feat: add smartcmd dedicated server

major bug: when connecting to the server a second time, it gets softlocked and keeps repeating ticking connection A\n in debug logs until it times out.
This commit is contained in:
pieeebot committed 2026-08-29 14:01:24 +03:00
1 parent a1541c590d
commit 4b962fcb21
146 files changed
+32837 -272

No files matched your search

+25
View File
@@ -0,0 +1,25 @@
This vendored component is based on the linenoise project idea/API.
Copyright (c) 2010-2014, Salvatore Sanfilippo <antirez at gmail dot com>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+652
View File
@@ -0,0 +1,652 @@
#include "linenoise.h"
#include <conio.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#define LINENOISE_MAX_LINE 4096
#define LINENOISE_MAX_PROMPT 128
typedef struct linenoiseHistory {
char **items;
int len;
int cap;
int maxLen;
} linenoiseHistory;
static linenoiseCompletionCallback *g_completionCallback = NULL;
static volatile LONG g_stopRequested = 0;
static linenoiseHistory g_history = { NULL, 0, 0, 128 };
/* Guards redraw/log interleaving so prompt and log lines do not overlap. */
static CRITICAL_SECTION g_ioLock;
static volatile LONG g_ioLockState = 0; /* 0=not init, 1=init in progress, 2=ready */
/* Snapshot of current editor line used to restore prompt after external output. */
static volatile LONG g_editorActive = 0;
static char g_editorPrompt[LINENOISE_MAX_PROMPT] = { 0 };
static char g_editorBuf[LINENOISE_MAX_LINE] = { 0 };
static int g_editorLen = 0;
static int g_editorPos = 0;
static int g_editorPrevLen = 0;
/**
* Lazily initialize the console I/O critical section.
* This avoids static init order issues and keeps startup cost minimal.
*/
static void linenoiseEnsureIoLockInit(void)
{
LONG state = InterlockedCompareExchange(&g_ioLockState, 0, 0);
if (state == 2)
return;
if (state == 0 && InterlockedCompareExchange(&g_ioLockState, 1, 0) == 0)
{
InitializeCriticalSection(&g_ioLock);
InterlockedExchange(&g_ioLockState, 2);
return;
}
while (InterlockedCompareExchange(&g_ioLockState, 0, 0) != 2)
{
Sleep(0);
}
}
static void linenoiseLockIo(void)
{
linenoiseEnsureIoLockInit();
EnterCriticalSection(&g_ioLock);
}
static void linenoiseUnlockIo(void)
{
LeaveCriticalSection(&g_ioLock);
}
/**
* Save current prompt/buffer/cursor state for later redraw.
* Called after each redraw while editor is active.
*/
static void linenoiseUpdateEditorState(const char *prompt, const char *buf, int len, int pos, int prevLen)
{
if (prompt == NULL)
prompt = "";
if (buf == NULL)
buf = "";
strncpy_s(g_editorPrompt, sizeof(g_editorPrompt), prompt, _TRUNCATE);
strncpy_s(g_editorBuf, sizeof(g_editorBuf), buf, _TRUNCATE);
g_editorLen = len;
g_editorPos = pos;
g_editorPrevLen = prevLen;
InterlockedExchange(&g_editorActive, 1);
}
static void linenoiseDeactivateEditorState(void)
{
InterlockedExchange(&g_editorActive, 0);
g_editorPrompt[0] = 0;
g_editorBuf[0] = 0;
g_editorLen = 0;
g_editorPos = 0;
g_editorPrevLen = 0;
}
static char *linenoiseStrdup(const char *src)
{
size_t n = strlen(src) + 1;
char *out = (char *)malloc(n);
if (out == NULL)
return NULL;
memcpy(out, src, n);
return out;
}
static void linenoiseEnsureHistoryCapacity(int wanted)
{
int newCap;
char **newItems;
if (wanted <= g_history.cap)
return;
newCap = g_history.cap == 0 ? 32 : g_history.cap;
while (newCap < wanted)
newCap *= 2;
newItems = (char **)realloc(g_history.items, sizeof(char *) * (size_t)newCap);
if (newItems == NULL)
return;
g_history.items = newItems;
g_history.cap = newCap;
}
static void linenoiseClearCompletions(linenoiseCompletions *lc)
{
size_t i = 0;
for (i = 0; i < lc->len; ++i)
{
free(lc->cvec[i]);
}
free(lc->cvec);
lc->cvec = NULL;
lc->len = 0;
}
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str)
{
char **newVec = (char **)realloc(lc->cvec, sizeof(char *) * (lc->len + 1));
if (newVec == NULL)
return;
lc->cvec = newVec;
lc->cvec[lc->len] = linenoiseStrdup(str);
if (lc->cvec[lc->len] == NULL)
return;
lc->len += 1;
}
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn)
{
g_completionCallback = fn;
}
void linenoiseFree(void *ptr)
{
free(ptr);
}
int linenoiseHistorySetMaxLen(int len)
{
if (len <= 0)
return 0;
g_history.maxLen = len;
while (g_history.len > g_history.maxLen)
{
free(g_history.items[0]);
memmove(g_history.items, g_history.items + 1, sizeof(char *) * (size_t)(g_history.len - 1));
g_history.len -= 1;
}
return 1;
}
int linenoiseHistoryAdd(const char *line)
{
if (line == NULL || line[0] == 0)
return 0;
if (g_history.len > 0)
{
const char *last = g_history.items[g_history.len - 1];
if (last != NULL && strcmp(last, line) == 0)
return 1;
}
linenoiseEnsureHistoryCapacity(g_history.len + 1);
if (g_history.cap <= g_history.len)
return 0;
g_history.items[g_history.len] = linenoiseStrdup(line);
if (g_history.items[g_history.len] == NULL)
return 0;
g_history.len += 1;
while (g_history.len > g_history.maxLen)
{
free(g_history.items[0]);
memmove(g_history.items, g_history.items + 1, sizeof(char *) * (size_t)(g_history.len - 1));
g_history.len -= 1;
}
return 1;
}
void linenoiseRequestStop(void)
{
InterlockedExchange(&g_stopRequested, 1);
}
void linenoiseResetStop(void)
{
InterlockedExchange(&g_stopRequested, 0);
}
static int linenoiseIsStopRequested(void)
{
return InterlockedCompareExchange(&g_stopRequested, 0, 0) != 0;
}
static void linenoiseWriteHint(const char *hint, size_t hintLen)
{
HANDLE stdoutHandle;
CONSOLE_SCREEN_BUFFER_INFO originalInfo;
int hasColorConsole = 0;
if (hint == NULL || hintLen == 0)
{
return;
}
stdoutHandle = GetStdHandle(STD_OUTPUT_HANDLE);
if (stdoutHandle != INVALID_HANDLE_VALUE && stdoutHandle != NULL)
{
if (GetConsoleScreenBufferInfo(stdoutHandle, &originalInfo))
{
hasColorConsole = 1;
/* Draw predictive tail in dim gray, then restore original console colors. */
SetConsoleTextAttribute(stdoutHandle, FOREGROUND_INTENSITY);
}
}
fwrite(hint, 1, hintLen, stdout);
if (hasColorConsole)
{
SetConsoleTextAttribute(stdoutHandle, originalInfo.wAttributes);
}
}
static int linenoiseStartsWithIgnoreCase(const char *full, const char *prefix)
{
while (*prefix != 0)
{
if (tolower((unsigned char)*full) != tolower((unsigned char)*prefix))
{
return 0;
}
++full;
++prefix;
}
return 1;
}
static size_t linenoiseBuildHint(const char *buf, char *hint, size_t hintSize)
{
linenoiseCompletions lc;
size_t inputLen = 0;
size_t i = 0;
if (hint == NULL || hintSize == 0)
{
return 0;
}
hint[0] = 0;
if (buf == NULL || buf[0] == 0 || g_completionCallback == NULL)
{
return 0;
}
lc.len = 0;
lc.cvec = NULL;
/* Reuse the completion callback and derive a "ghost text" suffix from the first extending match. */
g_completionCallback(buf, &lc);
inputLen = strlen(buf);
for (i = 0; i < lc.len; ++i)
{
const char *candidate = lc.cvec[i];
if (candidate == NULL)
{
continue;
}
if (strlen(candidate) <= inputLen)
{
continue;
}
if (!linenoiseStartsWithIgnoreCase(candidate, buf))
{
continue;
}
/* Keep only the part not yet typed by the user (rendered as hint text). */
strncpy_s(hint, hintSize, candidate + inputLen, _TRUNCATE);
break;
}
linenoiseClearCompletions(&lc);
return strlen(hint);
}
static void linenoiseRedrawUnsafe(const char *prompt, const char *buf, int len, int pos, int *prevLen)
{
int i;
char hint[LINENOISE_MAX_LINE] = {0};
int renderedLen = len;
/* Hint length contributes to the rendered width so stale tail characters can be cleared correctly. */
int hintLen = (int)linenoiseBuildHint(buf, hint, sizeof(hint));
if (hintLen > 0)
{
renderedLen += hintLen;
}
fputc('\r', stdout);
fputs(prompt, stdout);
if (len > 0)
{
fwrite(buf, 1, (size_t)len, stdout);
}
if (hintLen > 0)
{
linenoiseWriteHint(hint, (size_t)hintLen);
}
if (*prevLen > renderedLen)
{
for (i = renderedLen; i < *prevLen; ++i)
{
fputc(' ', stdout);
}
}
fputc('\r', stdout);
fputs(prompt, stdout);
if (pos > 0)
{
/* Cursor positioning reflects only real user input, not the ghost hint suffix. */
fwrite(buf, 1, (size_t)pos, stdout);
}
fflush(stdout);
*prevLen = renderedLen;
linenoiseUpdateEditorState(prompt, buf, len, pos, *prevLen);
}
static void linenoiseRedraw(const char *prompt, const char *buf, int len, int pos, int *prevLen)
{
linenoiseLockIo();
linenoiseRedrawUnsafe(prompt, buf, len, pos, prevLen);
linenoiseUnlockIo();
}
static int linenoiseStartsWith(const char *full, const char *prefix)
{
while (*prefix != 0)
{
if (*full != *prefix)
return 0;
++full;
++prefix;
}
return 1;
}
static int linenoiseComputeCommonPrefix(const linenoiseCompletions *lc, const char *seed, char *out, size_t outSize)
{
size_t commonLen = 0;
size_t i;
if (lc->len == 0 || outSize == 0)
return 0;
strncpy_s(out, outSize, lc->cvec[0], _TRUNCATE);
commonLen = strlen(out);
for (i = 1; i < lc->len; ++i)
{
const char *candidate = lc->cvec[i];
size_t j = 0;
while (j < commonLen && out[j] != 0 && candidate[j] != 0 && out[j] == candidate[j])
++j;
commonLen = j;
out[commonLen] = 0;
if (commonLen == 0)
break;
}
if (strlen(out) <= strlen(seed))
return 0;
return linenoiseStartsWith(out, seed);
}
static void linenoiseApplyCompletion(const char *prompt, char *buf, int *len, int *pos, int *prevLen)
{
linenoiseCompletions lc;
int i;
if (g_completionCallback == NULL)
{
Beep(750, 15);
return;
}
lc.len = 0;
lc.cvec = NULL;
g_completionCallback(buf, &lc);
if (lc.len == 0)
{
Beep(750, 15);
linenoiseClearCompletions(&lc);
return;
}
if (lc.len == 1)
{
strncpy_s(buf, LINENOISE_MAX_LINE, lc.cvec[0], _TRUNCATE);
*len = (int)strlen(buf);
*pos = *len;
linenoiseRedraw(prompt, buf, *len, *pos, prevLen);
linenoiseClearCompletions(&lc);
return;
}
{
char common[LINENOISE_MAX_LINE] = { 0 };
if (linenoiseComputeCommonPrefix(&lc, buf, common, sizeof(common)))
{
strncpy_s(buf, LINENOISE_MAX_LINE, common, _TRUNCATE);
*len = (int)strlen(buf);
*pos = *len;
linenoiseRedraw(prompt, buf, *len, *pos, prevLen);
}
}
linenoiseLockIo();
fputc('\n', stdout);
for (i = 0; i < (int)lc.len; ++i)
{
fputs(lc.cvec[i], stdout);
fputs(" ", stdout);
}
fputc('\n', stdout);
linenoiseRedrawUnsafe(prompt, buf, *len, *pos, prevLen);
linenoiseUnlockIo();
linenoiseClearCompletions(&lc);
}
char *linenoise(const char *prompt)
{
char buf[LINENOISE_MAX_LINE];
int len = 0;
int pos = 0;
int prevLen = 0;
int historyIndex = g_history.len;
if (prompt == NULL)
prompt = "";
buf[0] = 0;
linenoiseLockIo();
linenoiseUpdateEditorState(prompt, buf, len, pos, prevLen);
fputs(prompt, stdout);
fflush(stdout);
linenoiseUnlockIo();
while (!linenoiseIsStopRequested())
{
if (!_kbhit())
{
Sleep(10);
continue;
}
{
int c = _getwch();
if (c == 0 || c == 224)
{
int ext = _getwch();
if (ext == 72)
{
if (g_history.len > 0 && historyIndex > 0)
{
historyIndex -= 1;
strncpy_s(buf, sizeof(buf), g_history.items[historyIndex], _TRUNCATE);
len = (int)strlen(buf);
pos = len;
linenoiseRedraw(prompt, buf, len, pos, &prevLen);
}
}
else if (ext == 80)
{
if (g_history.len > 0 && historyIndex < g_history.len)
{
historyIndex += 1;
if (historyIndex == g_history.len)
buf[0] = 0;
else
strncpy_s(buf, sizeof(buf), g_history.items[historyIndex], _TRUNCATE);
len = (int)strlen(buf);
pos = len;
linenoiseRedraw(prompt, buf, len, pos, &prevLen);
}
}
else if (ext == 75)
{
if (pos > 0)
{
pos -= 1;
linenoiseRedraw(prompt, buf, len, pos, &prevLen);
}
}
else if (ext == 77)
{
if (pos < len)
{
pos += 1;
linenoiseRedraw(prompt, buf, len, pos, &prevLen);
}
}
continue;
}
if (c == 3)
{
linenoiseLockIo();
linenoiseDeactivateEditorState();
fputc('\n', stdout);
fflush(stdout);
linenoiseUnlockIo();
return NULL;
}
if (c == '\r' || c == '\n')
{
char *out;
linenoiseLockIo();
linenoiseDeactivateEditorState();
fputc('\n', stdout);
fflush(stdout);
linenoiseUnlockIo();
out = linenoiseStrdup(buf);
return out;
}
if (c == '\t')
{
linenoiseApplyCompletion(prompt, buf, &len, &pos, &prevLen);
continue;
}
if (c == 8)
{
if (pos > 0 && len > 0)
{
memmove(buf + pos - 1, buf + pos, (size_t)(len - pos + 1));
pos -= 1;
len -= 1;
linenoiseRedraw(prompt, buf, len, pos, &prevLen);
}
continue;
}
if (isprint((unsigned char)c) && len < LINENOISE_MAX_LINE - 1)
{
if (pos == len)
{
buf[pos++] = (char)c;
len += 1;
buf[len] = 0;
}
else
{
memmove(buf + pos + 1, buf + pos, (size_t)(len - pos + 1));
buf[pos] = (char)c;
pos += 1;
len += 1;
}
linenoiseRedraw(prompt, buf, len, pos, &prevLen);
}
}
}
linenoiseLockIo();
linenoiseDeactivateEditorState();
fputc('\n', stdout);
fflush(stdout);
linenoiseUnlockIo();
return NULL;
}
void linenoiseExternalWriteBegin(void)
{
int i;
int totalChars = 0;
/* Lock shared console state and clear current prompt area before external output. */
linenoiseLockIo();
if (InterlockedCompareExchange(&g_editorActive, 0, 0) == 0)
{
return;
}
totalChars = (int)strlen(g_editorPrompt) + g_editorPrevLen;
if (totalChars < 0)
{
totalChars = 0;
}
fputc('\r', stdout);
for (i = 0; i < totalChars; ++i)
{
fputc(' ', stdout);
}
fputc('\r', stdout);
fflush(stdout);
}
void linenoiseExternalWriteEnd(void)
{
/* Restore prompt line after external output has been printed. */
if (InterlockedCompareExchange(&g_editorActive, 0, 0) != 0)
{
int prevLen = g_editorPrevLen;
linenoiseRedrawUnsafe(g_editorPrompt, g_editorBuf, g_editorLen, g_editorPos, &prevLen);
g_editorPrevLen = prevLen;
}
linenoiseUnlockIo();
}
+37
View File
@@ -0,0 +1,37 @@
#ifndef VENDORED_LINENOISE_H
#define VENDORED_LINENOISE_H
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct linenoiseCompletions {
size_t len;
char **cvec;
} linenoiseCompletions;
typedef void(linenoiseCompletionCallback)(const char *buf, linenoiseCompletions *lc);
char *linenoise(const char *prompt);
void linenoiseFree(void *ptr);
void linenoiseSetCompletionCallback(linenoiseCompletionCallback *fn);
void linenoiseAddCompletion(linenoiseCompletions *lc, const char *str);
int linenoiseHistoryAdd(const char *line);
int linenoiseHistorySetMaxLen(int len);
void linenoiseRequestStop(void);
void linenoiseResetStop(void);
/* Wrap external stdout/stderr writes so active prompt can be cleared/restored safely. */
void linenoiseExternalWriteBegin(void);
void linenoiseExternalWriteEnd(void);
#ifdef __cplusplus
}
#endif
#endif