/*
 * udptcp_win.c — UDP<->TCP converter for Windows
 *
 * Compile: gcc udptcp_win.c -o udptcp_win.exe -lws2_32 -lshell32
 *
 * Framing over TCP: [uint16_be length][payload]
 *
 * Run directly:
 *   udptcp_win.exe --u2t --listen <udp-port> --host <h> --port <p> [--verbose]
 *   udptcp_win.exe --t2u --listen <tcp-port> --host <h> --port <p> [--verbose]
 *
 * Windows service:
 *   udptcp_win.exe --install --u2t --listen 6666 --host example.com --port 6666
 *   udptcp_win.exe --uninstall
 *   sc start udptcp
 *   sc stop  udptcp
 *
 * Startup parameters are embedded in the service ImagePath in the registry:
 *   HKLM\SYSTEM\CurrentControlSet\Services\udptcp\ImagePath
 * Log file (service mode): same directory as the exe, udptcp_win.log
 */

#define _WIN32_WINNT 0x0600   /* Vista+ for inet_ntop / getaddrinfo */
/* Note: do NOT define WIN32_LEAN_AND_MEAN — it implies NOSERVICE */
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#include <winsvc.h>
#include <shellapi.h>
#ifdef _MSC_VER
#  pragma comment(lib, "ws2_32.lib")
#  pragma comment(lib, "shell32.lib")
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <ctype.h>

#define SERVICE_NAME "udptcp"
#define MAX_PKT      65507

static int    g_verbose    = 0;
static HANDLE g_stop_event = NULL;  /* manual-reset event; set by svc_ctrl to signal stop */

static int should_stop(void) {
    return g_stop_event &&
           WaitForSingleObject(g_stop_event, 0) == WAIT_OBJECT_0;
}

static void interruptible_sleep(DWORD ms) {
    if (g_stop_event) WaitForSingleObject(g_stop_event, ms);
    else              Sleep(ms);
}

/* ================================================================
 * Logging  (stdout/stderr; service mode redirects these to a file)
 * ================================================================ */
static void ts_str(char *buf, size_t n) {
    SYSTEMTIME st; GetLocalTime(&st);
    snprintf(buf, n, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
        st.wYear, st.wMonth, st.wDay,
        st.wHour, st.wMinute, st.wSecond, st.wMilliseconds);
}

#define LOG(fmt, ...) do { \
    char _ts[40]; ts_str(_ts, sizeof(_ts)); \
    printf("[%s] " fmt "\n", _ts, ##__VA_ARGS__); \
    fflush(stdout); \
} while(0)

#define ERR(fmt, ...) do { \
    char _ts[40]; ts_str(_ts, sizeof(_ts)); \
    fprintf(stderr, "[%s] ERR " fmt "\n", _ts, ##__VA_ARGS__); \
    fflush(stderr); \
} while(0)

static const char *wsa_err(void) {
    static char buf[32];
    snprintf(buf, sizeof(buf), "WSA#%d", WSAGetLastError());
    return buf;
}

static void hexdump(const char *label, const unsigned char *data, int len) {
    char _ts[40]; ts_str(_ts, sizeof(_ts));
    printf("[%s] %s (%d bytes)\n", _ts, label, len);
    for (int i = 0; i < len; i += 16) {
        printf("  %04x  ", i);
        for (int j = 0; j < 16; j++) {
            if (i+j < len) printf("%02x ", data[i+j]); else printf("   ");
            if (j == 7) printf(" ");
        }
        printf(" |");
        for (int j = 0; j < 16 && i+j < len; j++)
            putchar(isprint((unsigned char)data[i+j]) ? data[i+j] : '.');
        printf("|\n");
    }
    fflush(stdout);
}

/* ================================================================
 * I/O helpers
 * ================================================================ */
static int write_all(SOCKET fd, const void *buf, int n) {
    const char *p = (const char *)buf;
    while (n > 0) {
        int w = send(fd, p, n, 0);
        if (w == SOCKET_ERROR) return -1;
        p += w; n -= w;
    }
    return 0;
}

static int read_exact(SOCKET fd, void *buf, int n) {
    char *p = (char *)buf;
    while (n > 0) {
        int r = recv(fd, p, n, 0);
        if (r <= 0) return -1;
        p += r; n -= r;
    }
    return 0;
}

/* ================================================================
 * Framing: [uint16_be len][payload]
 * ================================================================ */
static int send_framed(SOCKET tcp_fd, const void *data, uint16_t len) {
    uint8_t hdr[2] = { (uint8_t)(len >> 8), (uint8_t)(len & 0xff) };
    if (write_all(tcp_fd, hdr, 2) < 0) return -1;
    return write_all(tcp_fd, data, (int)len);
}

static int recv_framed(SOCKET tcp_fd, void *buf, int bufsz) {
    uint8_t hdr[2];
    if (read_exact(tcp_fd, hdr, 2) < 0) return -1;
    uint16_t len = ((uint16_t)hdr[0] << 8) | hdr[1];
    if (len == 0 || (int)len > bufsz) { ERR("bad frame len %u", len); return -1; }
    if (read_exact(tcp_fd, buf, (int)len) < 0) return -1;
    return (int)len;
}

/* ================================================================
 * Network helpers
 * ================================================================ */
static void addr_str(struct sockaddr_storage *ss, char *buf, size_t n) {
    char ip[INET6_ADDRSTRLEN] = {0};
    int  port = 0;
    if (ss->ss_family == AF_INET) {
        struct sockaddr_in *s = (struct sockaddr_in *)ss;
        inet_ntop(AF_INET,  &s->sin_addr,  ip, sizeof(ip));
        port = ntohs(s->sin_port);
    } else {
        struct sockaddr_in6 *s = (struct sockaddr_in6 *)ss;
        inet_ntop(AF_INET6, &s->sin6_addr, ip, sizeof(ip));
        port = ntohs(s->sin6_port);
    }
    snprintf(buf, n, "%s:%d", ip, port);
}

/* DNS resolve with exponential-backoff retry: 1 2 4 8 16 s */
static struct addrinfo *resolve_retry(const char *host, const char *port,
                                      int socktype, int retries) {
    struct addrinfo hints, *res;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_UNSPEC;
    hints.ai_socktype = socktype;
    for (int i = 0; i <= retries; i++) {
        if (i > 0) {
            DWORD d = (DWORD)(1u << (i < 5 ? i - 1 : 4));
            ERR("DNS retry %s:%s in %lus (%d/%d)", host, port, (unsigned long)d, i, retries);
            interruptible_sleep(d * 1000);
            if (should_stop()) return NULL;
        }
        int rc = getaddrinfo(host, port, &hints, &res);
        if (rc == 0) return res;
        ERR("getaddrinfo %s:%s: %s", host, port, gai_strerror(rc));
    }
    return NULL;
}

static SOCKET tcp_connect_to(const char *host, const char *port) {
    struct addrinfo *res = resolve_retry(host, port, SOCK_STREAM, 5);
    if (!res) return INVALID_SOCKET;
    SOCKET fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    if (fd == INVALID_SOCKET ||
        connect(fd, res->ai_addr, (int)res->ai_addrlen) == SOCKET_ERROR) {
        ERR("tcp_connect %s:%s: %s", host, port, wsa_err());
        if (fd != INVALID_SOCKET) closesocket(fd);
        freeaddrinfo(res); return INVALID_SOCKET;
    }
    freeaddrinfo(res);
    return fd;
}

static SOCKET udp_socket_to(const char *host, const char *port,
                             struct sockaddr_storage *dst, int *dstlen) {
    struct addrinfo *res = resolve_retry(host, port, SOCK_DGRAM, 3);
    if (!res) return INVALID_SOCKET;
    SOCKET fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    if (fd == INVALID_SOCKET) {
        ERR("udp socket: %s", wsa_err()); freeaddrinfo(res); return INVALID_SOCKET;
    }
    memcpy(dst, res->ai_addr, res->ai_addrlen);
    *dstlen = (int)res->ai_addrlen;
    freeaddrinfo(res);
    return fd;
}

/* ================================================================
 * U2T: UDP listen -> TCP forward
 * ================================================================ */

struct u2t_session {
    struct sockaddr_storage udp_src;
    int                     udp_srclen;
    char                    key[64];
    SOCKET                  tcp_fd;
    SOCKET                  udp_fd;   /* shared listen socket for sendto back */
    volatile LONG           alive;
    struct u2t_session     *next;
};

struct u2t_map {
    struct u2t_session *head;
    CRITICAL_SECTION    lock;
    SOCKET              udp_fd;
    const char         *fwd_host;
    const char         *fwd_port;
};

struct u2t_backflow_arg {
    struct u2t_session *sess;
    struct u2t_map     *map;
};

static DWORD WINAPI u2t_backflow(LPVOID arg) {
    struct u2t_backflow_arg *a = (struct u2t_backflow_arg *)arg;
    struct u2t_session *s = a->sess;
    struct u2t_map     *m = a->map;
    free(a);

    uint8_t buf[MAX_PKT];
    int n;
    while ((n = recv_framed(s->tcp_fd, buf, sizeof(buf))) > 0) {
        if (g_verbose) hexdump("TCP->UDP(back)", buf, n);
        sendto(s->udp_fd, (const char *)buf, n, 0,
               (struct sockaddr *)&s->udp_src, s->udp_srclen);
    }

    LOG("  [%s] session closed", s->key);
    InterlockedExchange(&s->alive, 0);

    EnterCriticalSection(&m->lock);
    struct u2t_session **pp = &m->head;
    while (*pp && *pp != s) pp = &(*pp)->next;
    if (*pp) *pp = s->next;
    LeaveCriticalSection(&m->lock);

    closesocket(s->tcp_fd);
    free(s);
    return 0;
}

static struct u2t_session *u2t_get_session(struct u2t_map *map,
    struct sockaddr_storage *src, int srclen) {

    char key[64];
    addr_str(src, key, sizeof(key));

    EnterCriticalSection(&map->lock);
    struct u2t_session *s;
    for (s = map->head; s; s = s->next)
        if (s->udp_srclen == srclen &&
            memcmp(&s->udp_src, src, srclen) == 0 &&
            InterlockedCompareExchange(&s->alive, 0, 0) != 0) {
            LeaveCriticalSection(&map->lock);
            return s;
        }
    LeaveCriticalSection(&map->lock);

    /* TCP connect outside the lock so other sessions aren't blocked */
    SOCKET tcp_fd = tcp_connect_to(map->fwd_host, map->fwd_port);
    if (tcp_fd == INVALID_SOCKET) return NULL;

    s = (struct u2t_session *)calloc(1, sizeof(*s));
    memcpy(&s->udp_src, src, srclen);
    s->udp_srclen = srclen;
    strncpy(s->key, key, sizeof(s->key) - 1);
    s->tcp_fd = tcp_fd;
    s->udp_fd = map->udp_fd;
    InterlockedExchange(&s->alive, 1);

    EnterCriticalSection(&map->lock);
    struct u2t_session *existing;
    for (existing = map->head; existing; existing = existing->next)
        if (existing->udp_srclen == srclen &&
            memcmp(&existing->udp_src, src, srclen) == 0 &&
            InterlockedCompareExchange(&existing->alive, 0, 0) != 0) {
            LeaveCriticalSection(&map->lock);
            closesocket(tcp_fd); free(s);
            return existing;
        }
    s->next   = map->head;
    map->head = s;
    LeaveCriticalSection(&map->lock);

    LOG("  new session [%s] -> TCP %s:%s", key, map->fwd_host, map->fwd_port);

    struct u2t_backflow_arg *ba = (struct u2t_backflow_arg *)malloc(sizeof(*ba));
    ba->sess = s; ba->map = map;
    HANDLE h = CreateThread(NULL, 0, u2t_backflow, ba, 0, NULL);
    if (h) CloseHandle(h);
    return s;
}

static void run_u2t(const char *lport, const char *fwd_host, const char *fwd_port) {
    struct addrinfo hints, *res;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_INET;
    hints.ai_socktype = SOCK_DGRAM;
    hints.ai_flags    = AI_PASSIVE;
    if (getaddrinfo(NULL, lport, &hints, &res) != 0) {
        ERR("getaddrinfo udp :%s: %s", lport, wsa_err()); return;
    }
    SOCKET udp_fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    if (udp_fd == INVALID_SOCKET) { ERR("udp socket: %s", wsa_err()); return; }
    int opt = 1;
    setsockopt(udp_fd, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
    if (bind(udp_fd, res->ai_addr, (int)res->ai_addrlen) == SOCKET_ERROR) {
        ERR("udp bind: %s", wsa_err()); closesocket(udp_fd); return;
    }
    freeaddrinfo(res);

    LOG("[U2T] UDP 0.0.0.0:%s  ->  TCP %s:%s", lport, fwd_host, fwd_port);

    /* 1-second recv timeout so the loop can check should_stop() */
    DWORD rcvtmo = 1000;
    setsockopt(udp_fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&rcvtmo, sizeof(rcvtmo));

    struct u2t_map map;
    map.head     = NULL;
    map.udp_fd   = udp_fd;
    map.fwd_host = fwd_host;
    map.fwd_port = fwd_port;
    InitializeCriticalSection(&map.lock);

    uint8_t buf[MAX_PKT];
    for (;;) {
        if (should_stop()) break;
        struct sockaddr_storage src;
        int srclen = sizeof(src);
        int n = recvfrom(udp_fd, (char *)buf, sizeof(buf), 0,
                         (struct sockaddr *)&src, &srclen);
        if (n == SOCKET_ERROR) {
            if (WSAGetLastError() == WSAETIMEDOUT) continue;
            ERR("recvfrom: %s", wsa_err());
            if (should_stop()) break;
            continue;
        }

        struct u2t_session *sess = u2t_get_session(&map, &src, srclen);
        if (!sess) continue;

        if (g_verbose) hexdump("UDP->TCP", buf, n);
        if (send_framed(sess->tcp_fd, buf, (uint16_t)n) < 0) {
            ERR("send_framed [%s]: %s", sess->key, wsa_err());
            InterlockedExchange(&sess->alive, 0);
        }
    }
    closesocket(udp_fd);
}

/* ================================================================
 * T2U: TCP listen -> UDP forward
 * ================================================================ */

struct t2u_conn {
    SOCKET                  tcp_fd;
    SOCKET                  udp_fd;
    struct sockaddr_storage udp_dst;
    int                     udp_dstlen;
    char                    peer[64];
    volatile LONG           alive;
};

static DWORD WINAPI t2u_udp_reader(LPVOID arg) {
    struct t2u_conn *c = (struct t2u_conn *)arg;
    uint8_t buf[MAX_PKT];
    while (InterlockedCompareExchange(&c->alive, 0, 0) != 0) {
        struct sockaddr_storage from;
        int fromlen = sizeof(from);
        int n = recvfrom(c->udp_fd, (char *)buf, sizeof(buf), 0,
                         (struct sockaddr *)&from, &fromlen);
        if (n == SOCKET_ERROR) break;
        if (g_verbose) hexdump("UDP->TCP(back)", buf, n);
        if (send_framed(c->tcp_fd, buf, (uint16_t)n) < 0) break;
    }
    return 0;
}

static DWORD WINAPI t2u_handle(LPVOID arg) {
    struct t2u_conn *c = (struct t2u_conn *)arg;

    HANDLE h = CreateThread(NULL, 0, t2u_udp_reader, c, 0, NULL);
    if (h) CloseHandle(h);

    uint8_t buf[MAX_PKT];
    int n;
    while ((n = recv_framed(c->tcp_fd, buf, sizeof(buf))) > 0) {
        if (g_verbose) hexdump("TCP->UDP", buf, n);
        sendto(c->udp_fd, (const char *)buf, n, 0,
               (struct sockaddr *)&c->udp_dst, c->udp_dstlen);
    }

    InterlockedExchange(&c->alive, 0);
    shutdown(c->tcp_fd, SD_BOTH);
    LOG("  [%s] closed", c->peer);
    closesocket(c->tcp_fd);
    closesocket(c->udp_fd);
    free(c);
    return 0;
}

static void run_t2u(const char *lport, const char *fwd_host, const char *fwd_port) {
    struct addrinfo hints, *res;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family   = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_flags    = AI_PASSIVE;
    if (getaddrinfo(NULL, lport, &hints, &res) != 0) {
        ERR("getaddrinfo tcp :%s: %s", lport, wsa_err()); return;
    }
    SOCKET srv = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
    if (srv == INVALID_SOCKET) { ERR("socket: %s", wsa_err()); return; }
    int opt = 1;
    setsockopt(srv, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt));
    if (bind(srv, res->ai_addr, (int)res->ai_addrlen) == SOCKET_ERROR) {
        ERR("bind: %s", wsa_err()); closesocket(srv); return;
    }
    freeaddrinfo(res);
    if (listen(srv, 128) == SOCKET_ERROR) { ERR("listen: %s", wsa_err()); return; }

    LOG("[T2U] TCP 0.0.0.0:%s  ->  UDP %s:%s", lport, fwd_host, fwd_port);

    for (;;) {
        if (should_stop()) break;
        /* 1-second select so we can check should_stop() without blocking forever */
        fd_set fds;
        FD_ZERO(&fds);
        FD_SET(srv, &fds);
        struct timeval tv = {1, 0};
        if (select(0, &fds, NULL, NULL, &tv) <= 0) continue;

        struct sockaddr_storage peer;
        int plen = sizeof(peer);
        SOCKET tcp_fd = accept(srv, (struct sockaddr *)&peer, &plen);
        if (tcp_fd == INVALID_SOCKET) { ERR("accept: %s", wsa_err()); continue; }

        struct t2u_conn *c = (struct t2u_conn *)calloc(1, sizeof(*c));
        c->tcp_fd = tcp_fd;
        InterlockedExchange(&c->alive, 1);
        addr_str(&peer, c->peer, sizeof(c->peer));

        c->udp_fd = udp_socket_to(fwd_host, fwd_port, &c->udp_dst, &c->udp_dstlen);
        if (c->udp_fd == INVALID_SOCKET) { closesocket(tcp_fd); free(c); continue; }

        if (connect(c->udp_fd, (struct sockaddr *)&c->udp_dst, c->udp_dstlen) == SOCKET_ERROR) {
            ERR("udp connect: %s", wsa_err());
            closesocket(c->udp_fd); closesocket(tcp_fd); free(c); continue;
        }

        LOG("[T2U] TCP [%s]  ->  UDP %s:%s", c->peer, fwd_host, fwd_port);

        HANDLE h = CreateThread(NULL, 0, t2u_handle, c, 0, NULL);
        if (h) CloseHandle(h);
    }
    closesocket(srv);
}

/* ================================================================
 * UAC / admin helpers  (pattern from wholeton_login.c)
 * ================================================================ */

/* CheckTokenMembership: works even when UAC is disabled */
static int is_admin(void) {
    BOOL result = FALSE;
    PSID admins = NULL;
    SID_IDENTIFIER_AUTHORITY nt = SECURITY_NT_AUTHORITY;
    if (AllocateAndInitializeSid(&nt, 2,
            SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS,
            0, 0, 0, 0, 0, 0, &admins)) {
        CheckTokenMembership(NULL, admins, &result);
        FreeSid(admins);
    }
    return result;
}

/* extract args portion from GetCommandLineW(), skip exe token */
static const wchar_t *cmdline_args_only(void) {
    const wchar_t *p = GetCommandLineW();
    if (!p) return L"";
    while (*p == L' ') p++;
    if (*p == L'"') { p++; while (*p && *p != L'"') p++; if (*p) p++; }
    else            { while (*p && *p != L' ') p++; }
    while (*p == L' ') p++;
    return p;
}

/* re-launch elevated via UAC; uses wide-char GetCommandLineW so Unicode paths are safe */
static void relaunch_as_admin(void) {
    wchar_t exe[MAX_PATH];
    GetModuleFileNameW(NULL, exe, MAX_PATH);

    SHELLEXECUTEINFOW sei;
    memset(&sei, 0, sizeof(sei));
    sei.cbSize       = sizeof(sei);
    sei.fMask        = SEE_MASK_NOCLOSEPROCESS;
    sei.lpVerb       = L"runas";
    sei.lpFile       = exe;
    sei.lpParameters = cmdline_args_only();
    sei.nShow        = SW_SHOWNORMAL;

    if (ShellExecuteExW(&sei)) {
        WaitForSingleObject(sei.hProcess, INFINITE);
        CloseHandle(sei.hProcess);
    } else {
        DWORD e = GetLastError();
        if (e == ERROR_CANCELLED) fprintf(stderr, "UAC cancelled.\n");
        else                      fprintf(stderr, "ShellExecuteEx failed: %lu\n", e);
    }
}

/* ================================================================
 * Windows Service
 * ================================================================ */

static int         g_mode_u2t    = 0;
static const char *g_listen_port = NULL;
static const char *g_fwd_host    = NULL;
static const char *g_fwd_port    = NULL;

static SERVICE_STATUS        g_svc_status;
static SERVICE_STATUS_HANDLE g_svc_handle;

static void svc_report(DWORD state) {
    g_svc_status.dwCurrentState = state;
    SetServiceStatus(g_svc_handle, &g_svc_status);
}

static VOID WINAPI svc_ctrl(DWORD ctrl) {
    if (ctrl == SERVICE_CONTROL_STOP || ctrl == SERVICE_CONTROL_SHUTDOWN) {
        svc_report(SERVICE_STOP_PENDING);
        if (g_stop_event) SetEvent(g_stop_event);   /* wake run_u2t / run_t2u loops */
    }
}

static VOID WINAPI svc_main(DWORD argc, LPSTR *argv) {
    (void)argc; (void)argv;

    g_svc_handle = RegisterServiceCtrlHandlerA(SERVICE_NAME, svc_ctrl);
    if (!g_svc_handle) return;

    g_stop_event = CreateEvent(NULL, TRUE, FALSE, NULL); /* manual-reset */

    memset(&g_svc_status, 0, sizeof(g_svc_status));
    g_svc_status.dwServiceType      = SERVICE_WIN32_OWN_PROCESS;
    g_svc_status.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN;
    svc_report(SERVICE_RUNNING);

    /* append log next to the exe (no freopen — keeps stdout available for debugging) */
    char logpath[MAX_PATH];
    GetModuleFileNameA(NULL, logpath, MAX_PATH);
    char *dot = strrchr(logpath, '.');
    if (dot) strcpy(dot, ".log"); else strcat(logpath, ".log");
    FILE *lf = fopen(logpath, "a");
    /* redirect both handles to the log file */
    if (lf) { freopen(logpath, "a", stdout); freopen(logpath, "a", stderr); fclose(lf); }

    WSADATA wsa;
    WSAStartup(MAKEWORD(2, 2), &wsa);

    if (g_mode_u2t) run_u2t(g_listen_port, g_fwd_host, g_fwd_port);
    else            run_t2u(g_listen_port, g_fwd_host, g_fwd_port);

    WSACleanup();
    CloseHandle(g_stop_event);
    g_stop_event = NULL;
    svc_report(SERVICE_STOPPED);
}

/* Build service ImagePath: "exe" + all argv[] except --install */
static void svc_install(int argc, char *argv[]) {
    char exe[MAX_PATH];
    GetModuleFileNameA(NULL, exe, MAX_PATH);

    char cmdline[4096];
    snprintf(cmdline, sizeof(cmdline), "\"%s\"", exe);
    for (int i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "--install")) continue;
        size_t rem = sizeof(cmdline) - strlen(cmdline) - 1;
        strncat(cmdline, " ", rem);
        rem--;
        if (strchr(argv[i], ' ')) {
            strncat(cmdline, "\"", rem); rem--;
            strncat(cmdline, argv[i], rem); rem -= strlen(argv[i]);
            strncat(cmdline, "\"", rem);
        } else {
            strncat(cmdline, argv[i], rem);
        }
    }

    SC_HANDLE scm = OpenSCManagerA(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
    if (!scm) {
        fprintf(stderr, "OpenSCManager failed: %lu (run as Administrator)\n", GetLastError());
        return;
    }

    SC_HANDLE svc = CreateServiceA(
        scm,
        SERVICE_NAME,                   /* service name (internal) */
        "UDP<->TCP Converter",          /* display name */
        SERVICE_ALL_ACCESS,
        SERVICE_WIN32_OWN_PROCESS,
        SERVICE_AUTO_START,             /* start on boot */
        SERVICE_ERROR_NORMAL,
        cmdline,                        /* ImagePath with embedded args */
        NULL, NULL, NULL, NULL, NULL);

    if (!svc) {
        DWORD e = GetLastError();
        if (e == ERROR_SERVICE_EXISTS)
            fprintf(stderr, "Service '%s' already exists — run --uninstall first.\n", SERVICE_NAME);
        else
            fprintf(stderr, "CreateService failed: %lu\n", e);
    } else {
        SERVICE_DESCRIPTIONA desc = { (LPSTR)"UDP<->TCP framing converter with DNS retry" };
        ChangeServiceConfig2A(svc, SERVICE_CONFIG_DESCRIPTION, &desc);

        printf("Service '%s' installed.\n", SERVICE_NAME);
        printf("ImagePath : %s\n", cmdline);
        printf("Log file  : (exe dir)\\udptcp_win.log\n");

        /* start the service immediately after install */
        if (StartServiceA(svc, 0, NULL))
            printf("Service started.\n");
        else
            fprintf(stderr, "StartService failed: %lu\n", GetLastError());

        CloseServiceHandle(svc);
    }
    CloseServiceHandle(scm);
}

static void svc_uninstall(void) {
    SC_HANDLE scm = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
    if (!scm) {
        fprintf(stderr, "OpenSCManager failed: %lu (run as Administrator)\n", GetLastError());
        return;
    }
    SC_HANDLE svc = OpenServiceA(scm, SERVICE_NAME,
                                 SERVICE_STOP | DELETE | SERVICE_QUERY_STATUS);
    if (!svc) {
        fprintf(stderr, "Service '%s' not found: %lu\n", SERVICE_NAME, GetLastError());
        CloseServiceHandle(scm); return;
    }

    /* stop the service and wait for it to reach STOPPED */
    SERVICE_STATUS st;
    if (ControlService(svc, SERVICE_CONTROL_STOP, &st)) {
        for (int i = 0; i < 30; i++) {
            Sleep(500);
            if (!QueryServiceStatus(svc, &st)) break;
            if (st.dwCurrentState == SERVICE_STOPPED) break;
        }
    }

    if (DeleteService(svc))
        printf("Service '%s' deleted.\n", SERVICE_NAME);
    else
        fprintf(stderr, "DeleteService failed: %lu\n", GetLastError());

    CloseServiceHandle(svc);
    CloseServiceHandle(scm);

    /* delete the log file */
    char logpath[MAX_PATH];
    GetModuleFileNameA(NULL, logpath, MAX_PATH);
    char *dot = strrchr(logpath, '.');
    if (dot) strcpy(dot, ".log"); else strcat(logpath, ".log");
    if (DeleteFileA(logpath))
        printf("Log file deleted: %s\n", logpath);

    printf("Uninstall complete.\n");
}

/* ================================================================
 * main
 * ================================================================ */
static void usage(const char *p) {
    printf(
        "Usage:\n"
        "  %s --u2t --listen <udp-port> --host <h> --port <p> [--verbose]\n"
        "  %s --t2u --listen <tcp-port> --host <h> --port <p> [--verbose]\n"
        "  %s --install --u2t --listen <udp-port> --host <h> --port <p>\n"
        "  %s --uninstall\n"
        "\n"
        "Options:\n"
        "  --u2t        UDP listen -> TCP forward\n"
        "  --t2u        TCP listen -> UDP forward\n"
        "  --listen     local port to bind\n"
        "  --host       remote host — IP or domain name (DNS retry on failure)\n"
        "  --port       remote port\n"
        "  --verbose    hex+ascii dump of every payload\n"
        "  --install    install as Windows service (requires Administrator)\n"
        "  --uninstall  remove Windows service   (requires Administrator)\n"
        "\n"
        "Service notes:\n"
        "  Parameters are stored in the registry ImagePath — no separate config needed.\n"
        "  Log: <exe directory>\\udptcp_win.log\n"
        "  sc start %s  /  sc stop %s\n"
        "\n"
        "Framing: [uint16_be length][payload]  preserves UDP datagram boundaries\n",
        p, p, p, p, SERVICE_NAME, SERVICE_NAME);
    exit(0);
}

int main(int argc, char *argv[]) {
    SetConsoleOutputCP(CP_UTF8);
    SetConsoleCP(CP_UTF8);

    /* handle --install / --uninstall before WSAStartup */
    for (int i = 1; i < argc; i++) {
        if (!strcmp(argv[i], "--install") || !strcmp(argv[i], "--uninstall")) {
            if (!is_admin()) {
                printf("Administrator required — requesting UAC elevation...\n");
                relaunch_as_admin();
                return 0;
            }
        }
        if (!strcmp(argv[i], "--install")) {
            svc_install(argc, argv);
            printf("\nPress any key to exit...\n"); getchar();
            return 0;
        }
        if (!strcmp(argv[i], "--uninstall")) {
            svc_uninstall();
            printf("\nPress any key to exit...\n"); getchar();
            return 0;
        }
        if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h")) usage(argv[0]);
    }

    int mode_u2t = 0, mode_t2u = 0;
    const char *listen_port = NULL, *fwd_host = NULL, *fwd_port = NULL;

    for (int i = 1; i < argc; i++) {
        if      (!strcmp(argv[i], "--u2t"))                   mode_u2t    = 1;
        else if (!strcmp(argv[i], "--t2u"))                   mode_t2u    = 1;
        else if (!strcmp(argv[i], "--verbose"))               g_verbose   = 1;
        else if (!strcmp(argv[i], "--listen") && i+1 < argc) listen_port = argv[++i];
        else if (!strcmp(argv[i], "--host")   && i+1 < argc) fwd_host    = argv[++i];
        else if (!strcmp(argv[i], "--port")   && i+1 < argc) fwd_port    = argv[++i];
        else { fprintf(stderr, "unknown arg: %s\n", argv[i]); return 1; }
    }

    if ((mode_u2t + mode_t2u) != 1) {
        fputs("specify exactly one of --u2t / --t2u\n", stderr); return 1;
    }
    if (!listen_port || !fwd_host || !fwd_port) {
        fputs("--listen, --host, --port required\n", stderr); return 1;
    }

    /* save for svc_main (called by SCM dispatcher in a separate thread) */
    g_mode_u2t    = mode_u2t;
    g_listen_port = listen_port;
    g_fwd_host    = fwd_host;
    g_fwd_port    = fwd_port;

    /*
     * Try to connect to SCM as a service.
     * If started from a console, ERROR_FAILED_SERVICE_CONTROLLER_CONNECT is
     * returned immediately and we fall through to run as a normal process.
     */
    SERVICE_TABLE_ENTRYA svc_table[] = {
        { (LPSTR)SERVICE_NAME, svc_main },
        { NULL, NULL }
    };
    if (!StartServiceCtrlDispatcherA(svc_table)) {
        if (GetLastError() != ERROR_FAILED_SERVICE_CONTROLLER_CONNECT) {
            fprintf(stderr, "StartServiceCtrlDispatcher: %lu\n", GetLastError());
            return 1;
        }
        /* console mode */
        WSADATA wsa;
        if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
            fprintf(stderr, "WSAStartup failed\n"); return 1;
        }
        if (mode_u2t) run_u2t(listen_port, fwd_host, fwd_port);
        else          run_t2u(listen_port, fwd_host, fwd_port);
        WSACleanup();
    }
    return 0;
}