Bump version to 0.3.0

Refactor packet parsing.
Update to latest segatools.
Clean up codes.

CMakeLists.txt

@@ -8,7 +8,7 @@ ENDIF()
 SET(CMAKE_CXX_STANDARD 17)
 
 IF (NOT WIN32)
-	MESSAGE(FATAL_ERROR "This is not supposed to be run on non-Windows platforms!")
+    MESSAGE(FATAL_ERROR "This is not supposed to be run on non-Windows platforms!")
 ENDIF()
 
 
@@ -19,7 +19,8 @@ ELSE()
 ENDIF()
 
 ADD_EXECUTABLE(brokenithm 
-    src/main.cpp)
+    src/main.cpp
+    src/resources.rc)
 INCLUDE_DIRECTORIES(src)
 LINK_DIRECTORIES(${CMAKE_SOURCE_DIR})
 

segatools/aimeio/aimeio.c

@@ -26,7 +26,7 @@ static uint8_t aime_io_felica_id[8];
 static bool aime_io_aime_id_present;
 static bool aime_io_felica_id_present;
 
-struct IPCMemoryInfo
+struct aime_io_ipc_memory_info
 {
     uint8_t airIoStatus[6];
     uint8_t sliderIoStatus[32];
@@ -35,28 +35,31 @@ struct IPCMemoryInfo
     uint8_t serviceBtn;
     uint8_t coinInsertion;
     uint8_t cardRead;
+    uint8_t remoteCardRead;
+    uint8_t remoteCardType;
+    uint8_t remoteCardId[10];
 };
-typedef struct IPCMemoryInfo IPCMemoryInfo;
-static HANDLE FileMappingHandle;
-IPCMemoryInfo* FileMapping;
+typedef struct aime_io_ipc_memory_info aime_io_ipc_memory_info;
+static HANDLE aime_io_file_mapping_handle;
+aime_io_ipc_memory_info* aime_io_file_mapping;
 
-void initSharedMemory()
+void aime_io_init_shared_memory()
 {
-    if (FileMapping)
+    if (aime_io_file_mapping)
     {
         return;
     }
-    if ((FileMappingHandle = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, sizeof(IPCMemoryInfo), "Local\\BROKENITHM_SHARED_BUFFER")) == 0)
+    if ((aime_io_file_mapping_handle = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, sizeof(aime_io_ipc_memory_info), "Local\\BROKENITHM_SHARED_BUFFER")) == 0)
     {
         return;
     }
 
-    if ((FileMapping = (IPCMemoryInfo*)MapViewOfFile(FileMappingHandle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(IPCMemoryInfo))) == 0)
+    if ((aime_io_file_mapping = (aime_io_ipc_memory_info*)MapViewOfFile(aime_io_file_mapping_handle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(aime_io_ipc_memory_info))) == 0)
     {
         return;
     }
 
-    memset(FileMapping, 0, sizeof(IPCMemoryInfo));
+    memset(aime_io_file_mapping, 0, sizeof(aime_io_ipc_memory_info));
     SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_CONTINUOUS);
 }
 
@@ -196,19 +199,20 @@ static HRESULT aime_io_generate_felica(
     return S_OK;
 }
 
+uint16_t aime_io_get_api_version(void)
+{
+    return 0x0100;
+}
+
 HRESULT aime_io_init(void)
 {
     aime_io_config_read(&aime_io_cfg, L".\\segatools.ini");
 
-    initSharedMemory();
+    aime_io_init_shared_memory();
 
     return S_OK;
 }
 
-void aime_io_fini(void)
-{
-}
-
 HRESULT aime_io_nfc_poll(uint8_t unit_no)
 {
     bool sense;
@@ -223,11 +227,27 @@ HRESULT aime_io_nfc_poll(uint8_t unit_no)
     aime_io_aime_id_present = false;
     aime_io_felica_id_present = false;
 
+	/* First check remote card status, if there is one report it */
+
+	if (aime_io_file_mapping && aime_io_file_mapping->remoteCardRead) {
+		switch (aime_io_file_mapping->remoteCardType) {
+		case 0: // Aime
+			memcpy(aime_io_aime_id, aime_io_file_mapping->remoteCardId, 10);
+			aime_io_aime_id_present = true;
+			break;
+		case 1: // FeliCa
+			memcpy(aime_io_felica_id, aime_io_file_mapping->remoteCardId, 8);
+			aime_io_felica_id_present = true;
+			break;
+		}
+		return S_OK;
+	}
+
     /* Don't do anything more if the scan key is not held */
 
-    if (FileMapping && FileMapping->cardRead) {
+    if (aime_io_file_mapping && aime_io_file_mapping->cardRead) {
         sense = true;
-        FileMapping->cardRead = 0;
+        aime_io_file_mapping->cardRead = 0;
     } else {
         sense = GetAsyncKeyState(aime_io_cfg.vk_scan) & 0x8000;
     }

segatools/chuniio/chuniio.c

@@ -11,11 +11,12 @@ static unsigned int __stdcall chuni_io_slider_thread_proc(void *ctx);
 
 static bool chuni_io_coin;
 static uint16_t chuni_io_coins;
+static uint8_t chuni_io_hand_pos;
 static HANDLE chuni_io_slider_thread;
 static bool chuni_io_slider_stop_flag;
 static struct chuni_io_config chuni_io_cfg;
 
-struct IPCMemoryInfo
+struct chuni_io_ipc_memory_info
 {
     uint8_t airIoStatus[6];
     uint8_t sliderIoStatus[32];
@@ -24,36 +25,44 @@ struct IPCMemoryInfo
     uint8_t serviceBtn;
     uint8_t coinInsertion;
     uint8_t cardRead;
+    uint8_t remoteCardRead;
+    uint8_t remoteCardType;
+    uint8_t remoteCardId[10];
 };
-typedef struct IPCMemoryInfo IPCMemoryInfo;
-static HANDLE FileMappingHandle;
-IPCMemoryInfo* FileMapping;
+typedef struct chuni_io_ipc_memory_info chuni_io_ipc_memory_info;
+static HANDLE chuni_io_file_mapping_handle;
+chuni_io_ipc_memory_info* chuni_io_file_mapping;
 
-void initSharedMemory()
+void chuni_io_init_shared_memory()
 {
-    if (FileMapping)
+    if (chuni_io_file_mapping)
     {
         return;
     }
-    if ((FileMappingHandle = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, sizeof(IPCMemoryInfo), "Local\\BROKENITHM_SHARED_BUFFER")) == 0)
+    if ((chuni_io_file_mapping_handle = CreateFileMapping(INVALID_HANDLE_VALUE, 0, PAGE_READWRITE, 0, sizeof(chuni_io_ipc_memory_info), "Local\\BROKENITHM_SHARED_BUFFER")) == 0)
     {
         return;
     }
 
-    if ((FileMapping = (IPCMemoryInfo*)MapViewOfFile(FileMappingHandle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(IPCMemoryInfo))) == 0)
+    if ((chuni_io_file_mapping = (chuni_io_ipc_memory_info*)MapViewOfFile(chuni_io_file_mapping_handle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(chuni_io_ipc_memory_info))) == 0)
     {
         return;
     }
 
-    memset(FileMapping, 0, sizeof(IPCMemoryInfo));
+    memset(chuni_io_file_mapping, 0, sizeof(chuni_io_ipc_memory_info));
     SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_CONTINUOUS);
 }
 
+uint16_t chuni_io_get_api_version(void)
+{
+    return 0x0101;
+}
+
 HRESULT chuni_io_jvs_init(void)
 {
     chuni_io_config_load(&chuni_io_cfg, L".\\segatools.ini");
 
-    initSharedMemory();
+    chuni_io_init_shared_memory();
 
     return S_OK;
 }
@@ -64,9 +73,9 @@ void chuni_io_jvs_read_coin_counter(uint16_t *out)
         return;
     }
 
-    if (FileMapping && FileMapping->coinInsertion) {
+    if (chuni_io_file_mapping && chuni_io_file_mapping->coinInsertion) {
         chuni_io_coins++;
-        FileMapping->coinInsertion = 0;
+        chuni_io_file_mapping->coinInsertion = 0;
     } else {
         if (GetAsyncKeyState(chuni_io_cfg.vk_coin)) {
             if (!chuni_io_coin) {
@@ -85,24 +94,31 @@ void chuni_io_jvs_poll(uint8_t *opbtn, uint8_t *beams)
 {
     size_t i;
 
-    if ((FileMapping && FileMapping->testBtn) || GetAsyncKeyState(chuni_io_cfg.vk_test)) {
+    if ((chuni_io_file_mapping && chuni_io_file_mapping->testBtn) || GetAsyncKeyState(chuni_io_cfg.vk_test)) {
         *opbtn |= 0x01; /* Test */
     }
 
-    if ((FileMapping && FileMapping->serviceBtn) || GetAsyncKeyState(chuni_io_cfg.vk_service)) {
+    if ((chuni_io_file_mapping && chuni_io_file_mapping->serviceBtn) || GetAsyncKeyState(chuni_io_cfg.vk_service)) {
         *opbtn |= 0x02; /* Service */
     }
 
+    if (GetAsyncKeyState(chuni_io_cfg.vk_ir)) {
+        if (chuni_io_hand_pos < 6) {
+            chuni_io_hand_pos++;
+        }
+    } else {
+        if (chuni_io_hand_pos > 0) {
+            chuni_io_hand_pos--;
+        }
+    }
+
     for (i = 0 ; i < 6 ; i++) {
-        if (FileMapping && FileMapping->airIoStatus[i]) {
+        if ((chuni_io_file_mapping && chuni_io_file_mapping->airIoStatus[i]) || chuni_io_hand_pos > i) {
             *beams |= (1 << i);
         }
     }
 }
 
-void chuni_io_jvs_set_coin_blocker(bool open)
-{}
-
 HRESULT chuni_io_slider_init(void)
 {
     return S_OK;
@@ -139,22 +155,21 @@ void chuni_io_slider_stop(void)
 
 void chuni_io_slider_set_leds(const uint8_t *rgb)
 {
-    if (FileMapping)
-    {
-        memcpy(FileMapping->ledRgbData, rgb, 32 * 3);
+	if (chuni_io_file_mapping) {
+        memcpy(chuni_io_file_mapping->ledRgbData, rgb, 32 * 3);
     }
 }
 
 static unsigned int __stdcall chuni_io_slider_thread_proc(void *ctx)
 {
     chuni_io_slider_callback_t callback;
-    uint8_t pressure[32] = { 0 };
+    uint8_t pressure[32];
 
     callback = ctx;
 
     while (!chuni_io_slider_stop_flag) {
-        if (FileMapping) {
-            memcpy(pressure, FileMapping->sliderIoStatus, 32);
+        if (chuni_io_file_mapping) {
+            memcpy(pressure, chuni_io_file_mapping->sliderIoStatus, 32);
         }
 
         callback(pressure);

src/main.cpp

@@ -2,9 +2,13 @@
 #include <atomic>
 #include <thread>
 #include <unistd.h>
+#include <inttypes.h>
+#include <sys/time.h>
 
 #include "socket.h"
 #include "defer.h"
+#include "version.h"
+#include "struct.h"
 #include <windows.h>
 
 std::string remote_address;
@@ -12,23 +16,18 @@ uint16_t remote_port = 52468;
 uint16_t server_port = 52468;
 bool tcp_mode = false;
 
+size_t tcp_buffer_size = 96;
+size_t tcp_receive_threshold = 48;
+
 std::atomic_bool EXIT_FLAG {false}, CONNECTED {false};
 
-int setTimeout(SOCKET s, int timeout)
+void socketSetTimeout(SOCKET sHost, int timeout)
 {
-    int ret = -1;
-#ifdef _WIN32
-    ret = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(int));
-    ret = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(int));
-#else
-    struct timeval timeo = {timeout / 1000, (timeout % 1000) * 1000};
-    ret = setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, (const char*)&timeo, sizeof(timeo));
-    ret = setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeo, sizeof(timeo));
-#endif
-    return ret;
+    setsockopt(sHost, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof(int));
+    setsockopt(sHost, SOL_SOCKET, SO_RCVTIMEO, (char*)&timeout, sizeof(int));
 }
 
-int socket_bind(SOCKET sHost, long addr, uint16_t port)
+int socketBind(SOCKET sHost, long addr, uint16_t port)
 {
     sockaddr_in srcaddr = {};
     memset(&srcaddr, 0, sizeof(srcaddr));
@@ -38,86 +37,69 @@ int socket_bind(SOCKET sHost, long addr, uint16_t port)
     return bind(sHost, reinterpret_cast<sockaddr*>(&srcaddr), sizeof(srcaddr));
 }
 
-int udp_broadcast(SOCKET sHost, uint16_t port, const std::string &data)
+sockaddr_in makeBroadcastAddr(uint16_t port)
 {
     struct sockaddr_in addr = {};
     addr.sin_family = AF_INET;
     addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
     addr.sin_port = htons(port);
-    return sendto(sHost, data.data(), data.size(), 0, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
+    return addr;
 }
 
-int udp_send(SOCKET sHost, const std::string &dst_host, uint16_t dst_port, const std::string &data)
+sockaddr_in makeIPv4Addr(const std::string &host, uint16_t port)
 {
     struct sockaddr_in addr = {};
     addr.sin_family = AF_INET;
-    inet_pton(AF_INET, dst_host.data(), (struct in_addr *)&addr.sin_addr.s_addr);
-    addr.sin_port = htons(dst_port);
-    return sendto(sHost, data.data(), data.size(), 0, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr));
+    inet_pton(AF_INET, host.data(), (struct in_addr *)&addr.sin_addr.s_addr);
+    addr.sin_port = htons(port);
+    return addr;
 }
 
-void UDPLEDBroadcast(SOCKET sHost, const char* memory)
+int socketSendTo(SOCKET sHost, const sockaddr_in &addr, const std::string &data)
 {
-    static std::string previous_status;
-    static int skip_count = 0;
-    static std::string head = "\x63LED";
-    while(!EXIT_FLAG)
+    return sendto(sHost, data.data(), data.size(), 0, reinterpret_cast<const struct sockaddr*>(&addr), sizeof(addr));
+}
+
+std::string getTime(int type)
+{
+    time_t lt;
+    char tmpbuf[32], cMillis[7];
+    std::string format;
+    timeval tv;
+    gettimeofday(&tv, NULL);
+    snprintf(cMillis, 7, "%.6ld", (long)tv.tv_usec);
+    lt = time(NULL);
+    struct tm *local = localtime(&lt);
+    switch(type)
     {
-        if(!CONNECTED) {
-            Sleep(50);
-            continue;
-        }
-        std::string current_status;
-        current_status.assign(reinterpret_cast<const char*>(memory + 6 + 32), 32 * 3);
-        bool same = true;
-        if(!previous_status.empty())
-        {
-            for(int i = 0; i < 32 * 3; i++)
-            {
-                if(previous_status[i] != current_status[i])
-                {
-                    same = false;
-                    break;
-                }
-            }
-        }
-        else
-            same = false;
-        previous_status = current_status;
-        if(!same)
-        {
-            current_status.insert(0, head);
-            //if(udp_broadcast(sHost, server_port, current_status) < 0)
-            if(udp_send(sHost, remote_address, remote_port, current_status) < 0)
-            {
-                //std::cerr<<"cannot send broadcast: error " + std::to_string(GetLastError()) + "\n";
-                fprintf(stderr, "cannot send packet: error %lu\n", GetLastError());
-            }
-            skip_count = 0;
-        }
-        else
-        {
-            if(++skip_count > 50)
-            {
-                current_status.insert(0, head);
-                //if(udp_broadcast(sHost, server_port, current_status) < 0)
-                if(udp_send(sHost, remote_address, remote_port, current_status) < 0)
-                {
-                    //std::cerr<<"cannot send broadcast: error " + std::to_string(GetLastError()) + "\n";
-                    fprintf(stderr, "cannot send packet: error %lu\n", GetLastError());
-                }
-                skip_count = 0;
-            }
-        }
-        Sleep(10);
+    case 1:
+        format = "%Y%m%d-%H%M%S";
+        break;
+    case 2:
+        format = "%Y/%m/%d %a %H:%M:%S." + std::string(cMillis);
+        break;
+    case 3:
+        format = "%Y-%m-%d %H:%M:%S";
+        break;
     }
+    strftime(tmpbuf, 32, format.data(), local);
+    return std::string(tmpbuf);
 }
 
-void TCPLEDBroadcast(SOCKET sHost, const char* memory)
+template <typename... Args>
+void printErr(const char* format, Args... args)
+{
+    std::string time = "[" + getTime(2) + "] ";
+    fprintf(stderr, time.data());
+    fprintf(stderr, format, args...);
+}
+
+void threadLEDBroadcast(SOCKET sHost, const IPCMemoryInfo* memory)
 {
     static std::string previous_status;
     static int skip_count = 0;
     static std::string head = "\x63LED";
+    auto addr = makeIPv4Addr(remote_address, remote_port);
     while(!EXIT_FLAG)
     {
         if(!CONNECTED) {
@@ -125,18 +107,11 @@ void TCPLEDBroadcast(SOCKET sHost, const char* memory)
             continue;
         }
         std::string current_status;
-        current_status.assign(reinterpret_cast<const char*>(memory + 6 + 32), 32 * 3);
+        current_status.assign(reinterpret_cast<const char*>(memory->ledRgbData), sizeof(memory->ledRgbData));
         bool same = true;
         if(!previous_status.empty())
         {
-            for(int i = 0; i < 32 * 3; i++)
-            {
-                if(previous_status[i] != current_status[i])
-                {
-                    same = false;
-                    break;
-                }
-            }
+            same = (memcmp(previous_status.data(), current_status.data(), previous_status.size()) == 0);
         }
         else
             same = false;
@@ -144,43 +119,49 @@ void TCPLEDBroadcast(SOCKET sHost, const char* memory)
         if(!same)
         {
             current_status.insert(0, head);
-            if(send(sHost, current_status.data(), current_status.size(), 0) < 0)
+            if(socketSendTo(sHost, addr, current_status) < 0)
             {
-                fprintf(stderr, "cannot send packet: error %lu\n", GetLastError());
-                if(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
+                printErr("[Error] Cannot send packet: error %lu\n", GetLastError());
+                if(tcp_mode)
                 {
-                    continue;
-                }
-                else
-                {
-                    fprintf(stderr, "Device disconnected!");
-                    CONNECTED = false;
-                    EXIT_FLAG = true;
-                    break;
-                }
-            }
-            skip_count = 0;
-        }
-        else
-        {
-            if(++skip_count > 50)
-            {
-                current_status.insert(0, head);
-                if(udp_send(sHost, remote_address, remote_port, current_status) < 0)
-                {
-                    fprintf(stderr, "cannot send packet: error %lu\n", GetLastError());
                     if(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
                     {
                         continue;
                     }
                     else
                     {
-                        fprintf(stderr, "Device disconnected!\n");
+                        printErr("[INFO] Device disconnected!\n");
                         CONNECTED = false;
                         EXIT_FLAG = true;
                         break;
                     }
                 }
+            }
+            skip_count = 0;
+        }
+        else
+        {
+            if(++skip_count > 50)
+            {
+                current_status.insert(0, head);
+                if(socketSendTo(sHost, addr, current_status) < 0)
+                {
+                    printErr("[ERROR] Cannot send packet: error %lu\n", GetLastError());
+                    if(tcp_mode)
+                    {
+                        if(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
+                        {
+                            continue;
+                        }
+                        else
+                        {
+                            printErr("[INFO] Device disconnected!\n");
+                            CONNECTED = false;
+                            EXIT_FLAG = true;
+                            break;
+                        }
+                    }
+                }
                 skip_count = 0;
             }
         }
@@ -194,23 +175,22 @@ enum
     FUNCTION_CARD
 };
 
-std::tuple<std::string, uint16_t> getSocksAddress(const std::string &data)
+void getSocksAddress(const PacketConnect* pkt, std::string &address, uint16_t &port)
 {
     char cAddr[128] = {};
-    std::string retAddr, port_str = data.substr(1, 2);
-    int family = data[0];
-    uint16_t port = ntohs(*(short*)port_str.data());
+    std::string retAddr;
+    int family = pkt->addrType;
+    port = ntohs(pkt->port);
     switch(family)
     {
     case 1: //IPv4
-        inet_ntop(AF_INET, data.data() + 3, cAddr, 127);
+        inet_ntop(AF_INET, pkt->addr.addr4.addr, cAddr, 127);
         break;
     case 2: //IPv6
-        inet_ntop(AF_INET6, data.data() + 3, cAddr, 127);
+        inet_ntop(AF_INET6, pkt->addr.addr6, cAddr, 127);
         break;
     }
-    retAddr.assign(cAddr);
-    return std::make_tuple(retAddr, port);
+    address.assign(cAddr);
 }
 
 uint32_t last_input_packet_id = 0;
@@ -219,28 +199,107 @@ void updatePacketId(uint32_t newPacketId)
 {
     if(last_input_packet_id > newPacketId)
     {
-        fprintf(stderr, "[WARN] Packet #%zu came too late\n", newPacketId);
+        printErr("[WARN] Packet #%" PRIu32 " came too late\n", newPacketId);
     }
     else if(newPacketId > last_input_packet_id + 1)
     {
-        fprintf(stderr, "[WARN] Packets between #%zu and #%zu total %zu packet(s) are missing, probably too late or dropped\n", last_input_packet_id, newPacketId, newPacketId - last_input_packet_id - 1);
+        printErr("[WARN] Packets between #%" PRIu32 " and #%" PRIu32 " total %" PRIu32 " packet(s) are missing, probably too late or dropped\n", last_input_packet_id, newPacketId, newPacketId - last_input_packet_id - 1);
     }
     else if(newPacketId == last_input_packet_id)
     {
-        fprintf(stderr, "[WARN] Packet #%zu duplicated\n", newPacketId);
+        printErr("[WARN] Packet #%" PRIu32 " duplicated\n", newPacketId);
     }
     last_input_packet_id = newPacketId;
 }
 
-void InputReceive(SOCKET sHost, char *memory)
+template <typename... Args>
+void dprintf(const char* format, Args... args)
 {
-    constexpr size_t tcp_recv_buffer_size = 128;
-    char recv_buffer[tcp_recv_buffer_size];
+    fprintf(stderr, format, args...);
+}
+
+void dump(const void *ptr, size_t nbytes, bool hex_string = false)
+{
+    const uint8_t *bytes;
+    uint8_t c;
+    size_t i;
+    size_t j;
+
+    if (nbytes == 0) {
+        dprintf("\t--- Empty ---\n");
+    }
+
+    bytes = (const unsigned char*)ptr;
+
+    if (hex_string) {
+        for (i = 0 ; i < nbytes ; i++) {
+            dprintf("%02x", bytes[i]);
+        }
+        dprintf("\n");
+        return;
+    }
+
+    for (i = 0 ; i < nbytes ; i += 16) {
+        dprintf("    %08x:", (int) i);
+
+        for (j = 0 ; i + j < nbytes && j < 16 ; j++) {
+            dprintf(" %02x", bytes[i + j]);
+        }
+
+        while (j < 16) {
+            dprintf("   ");
+            j++;
+        }
+
+        dprintf(" ");
+
+        for (j = 0 ; i + j < nbytes && j < 16 ; j++) {
+            c = bytes[i + j];
+
+            if (c < 0x20 || c >= 0x7F) {
+                c = '.';
+            }
+
+            dprintf("%c", c);
+        }
+
+        dprintf("\n");
+    }
+
+    dprintf("\n");
+}
+
+enum
+{
+    CARD_AIME,
+    CARD_FELICA
+};
+
+void printCardInfo(uint8_t cardType, uint8_t *cardId)
+{
+    switch(cardType)
+    {
+    case CARD_AIME:
+        printErr("[INFO] Card Type: Aime\t\tID: ");
+        dump(cardId, 10, true);
+        break;
+    case CARD_FELICA:
+        printErr("[INFO] Card Type: FeliCa\tIDm: ");
+        dump(cardId, 8, true);
+        break;
+    }
+}
+
+void threadInputReceive(SOCKET sHost, IPCMemoryInfo *memory)
+{
+    char recv_buffer[tcp_buffer_size];
     char buffer[BUFSIZ];
     std::string remains;
+    auto addr = makeIPv4Addr(remote_address, remote_port);
     while(!EXIT_FLAG)
     {
         int recv_len, real_len;
+        size_t packet_len;
         uint32_t current_packet_id;
         if(!tcp_mode)
         {
@@ -254,6 +313,7 @@ void InputReceive(SOCKET sHost, char *memory)
             real_len = buffer[0];
             if(real_len > recv_len)
                 continue;
+            packet_len = real_len + 1;
         }
         else
         {
@@ -261,9 +321,9 @@ void InputReceive(SOCKET sHost, char *memory)
                 on TCP mode data is sent as stream, one recvfrom call may receive multiple packets
                 so we need to store the remaining data when real_len > recv_len
             **/
-            if(remains.size() < 48)
+            if(remains.size() < tcp_receive_threshold)
             {
-                if((recv_len = recv(sHost, recv_buffer, tcp_recv_buffer_size - 1, 0)) == -1)
+                if((recv_len = recv(sHost, recv_buffer, tcp_buffer_size - 1, 0)) == -1)
                     continue;
                 remains.append(recv_buffer, recv_len);
             }
@@ -272,77 +332,99 @@ void InputReceive(SOCKET sHost, char *memory)
             real_len = remains[0];
             if(real_len > data_left)
                 continue;
-            size_t data_copied = real_len + 1;
-            memcpy(buffer, remains.data(), data_copied);
-            remains.erase(0, data_copied);
+            packet_len = real_len + 1;
+            memcpy(buffer, remains.data(), packet_len);
+            remains.erase(0, packet_len);
         }
 
-        if(real_len >= 3 + 4 + 6 + 32 && buffer[1] == 'I' && buffer[2] == 'N' && buffer[3] == 'P')
+        if(packet_len >= sizeof(PacketInput) && buffer[1] == 'I' && buffer[2] == 'N' && buffer[3] == 'P')
         {
-            memcpy(memory, buffer + 4 + 4, 32 + 6);
-            if(real_len > 3 + 4 + 6 + 32)
-            {
-                memcpy(memory + 6 + 32 + 96, buffer + 4 + 4 + 6 + 32, real_len - (3 + 6 + 32 + 4));
-            }
-            current_packet_id = ntohl(*(uint32_t*)(buffer + 4));
+            PacketInput *pkt = reinterpret_cast<PacketInput*>(buffer);
+            memcpy(memory->airIoStatus, pkt->airIoStatus, sizeof(pkt->airIoStatus));
+            memcpy(memory->sliderIoStatus, pkt->sliderIoStatus, sizeof(pkt->sliderIoStatus));
+            memory->testBtn = pkt->testBtn;
+            memory->serviceBtn = pkt->serviceBtn;
+            current_packet_id = ntohl(pkt->packetId);
             updatePacketId(current_packet_id);
         }
-        else if(real_len >= 3 + 4 + 32 && buffer[1] == 'I' && buffer[2] == 'P' && buffer[3] == 'T') /// without air block
+        else if(packet_len >= sizeof(PacketInputNoAir) && buffer[1] == 'I' && buffer[2] == 'P' && buffer[3] == 'T') /// without air block
         {
-            memcpy(memory, buffer + 4, 32);
-            if(real_len > 3 + 4 + 32)
-            {
-                memcpy(memory + 6 + 32 + 96, buffer + 4 + 4 + 32, real_len - (3 + 32 + 4));
-            }
-            current_packet_id = ntohl(*(uint32_t*)(buffer + 4));
+            PacketInputNoAir *pkt = reinterpret_cast<PacketInputNoAir*>(buffer);
+            memcpy(memory->sliderIoStatus, pkt->sliderIoStatus, sizeof(pkt->sliderIoStatus));
+            memory->testBtn = pkt->testBtn;
+            memory->serviceBtn = pkt->serviceBtn;
+            current_packet_id = ntohl(pkt->packetId);
             updatePacketId(current_packet_id);
         }
-        else if(real_len >= 4 && buffer[1] == 'F' && buffer[2] == 'N' && buffer[3] == 'C')
+        else if(packet_len >= sizeof(PacketFunction) && buffer[1] == 'F' && buffer[2] == 'N' && buffer[3] == 'C')
         {
-            switch(buffer[4])
+            PacketFunction *pkt = reinterpret_cast<PacketFunction*>(buffer);
+            switch(pkt->funcBtn)
             {
             case FUNCTION_COIN:
-                *(memory + 6 + 32 + 96 + 2) = 1;
+                memory->coinInsertion = 1;
                 break;
             case FUNCTION_CARD:
-                *(memory + 6 + 32 + 96 + 3) = 1;
+                memory->cardRead = 1;
                 break;
             }
         }
-        else if(real_len >= 10 && buffer[1] == 'C' && buffer[2] == 'O' && buffer[3] == 'N')
+        else if(packet_len >= sizeof(PacketConnect) && buffer[1] == 'C' && buffer[2] == 'O' && buffer[3] == 'N')
         {
             last_input_packet_id = 0;
-            std::string data;
-            data.assign(buffer + 4, real_len - 3);
-            std::tie(remote_address, remote_port) = getSocksAddress(data);
-            //std::cout << "Device " << remote_address << ":" << remote_port << " connected." <<std::endl;
-            printf("Device %s:%d connected.\n", remote_address.data(), remote_port);
+            PacketConnect *pkt = reinterpret_cast<PacketConnect*>(buffer);
+            getSocksAddress(pkt, remote_address, remote_port);
+            printErr("[INFO] Device %s:%d connected.\n", remote_address.data(), remote_port);
             CONNECTED = true;
         }
-        else if(real_len >= 3 && buffer[1] == 'D' && buffer[2] == 'I' && buffer[3] == 'S')
+        else if(packet_len >= 4 && buffer[1] == 'D' && buffer[2] == 'I' && buffer[3] == 'S')
         {
             CONNECTED = false;
             if(tcp_mode)
             {
                 EXIT_FLAG = true;
-                printf("Device disconnected!\n");
+                printErr("[INFO] Device disconnected!\n");
                 break;
             }
             if(!remote_address.empty())
             {
-                printf("Device %s:%d disconnected.\n", remote_address.data(), remote_port);
-                //std::cout << "Device " << remote_address << ":" << remote_port << " disconnected." << std::endl;
+                printErr("[INFO] Device %s:%d disconnected.\n", remote_address.data(), remote_port);
                 remote_address.clear();
             }
         }
-        else if(real_len >= 11 && buffer[1] == 'P' && buffer[2] == 'I' && buffer[3] == 'N')
+        else if(packet_len >= sizeof(PacketPing) && buffer[1] == 'P' && buffer[2] == 'I' && buffer[3] == 'N')
         {
             if(!CONNECTED)
                 continue;
             std::string response;
             response.assign(buffer, 12);
             response.replace(2, 1, "O");
-            udp_send(sHost, remote_address, remote_port, response);
+            socketSendTo(sHost, addr, response);
+        }
+        else if(packet_len >= sizeof(PacketCard) && buffer[1] == 'C' && buffer[2] == 'R' && buffer[3] == 'D')
+        {
+            PacketCard *pkt = reinterpret_cast<PacketCard*>(buffer);
+            static uint8_t lastId[10] = {};
+            if(pkt->remoteCardRead)
+            {
+                if(memcmp(lastId, pkt->remoteCardId, 10))
+                {
+                    printErr("[INFO] Got remote card.\n");
+                    printCardInfo(pkt->remoteCardType, pkt->remoteCardId);
+                    memcpy(lastId, pkt->remoteCardId, 10);
+                }
+            }
+            else
+            {
+                if(memory->remoteCardRead)
+                {
+                    printErr("[INFO] Remote card removed.\n");
+                    memset(lastId, 0, 10);
+                }
+            }
+            memory->remoteCardRead = pkt->remoteCardRead;
+            memory->remoteCardType = pkt->remoteCardType;
+            memcpy(memory->remoteCardId, pkt->remoteCardId, 10);
         }
     }
 }
@@ -352,7 +434,7 @@ void printInfo()
     printf("=================================================\n");
     printf("=          Brokenithm-Evolved-Android:          =\n");
     printf("=     Brokenithm with full IO over network      =\n");
-    printf("=                v0.1 by XTindy                 =\n");
+    printf("=               " VERSION " by XTindy                =\n");
     printf("=              Original: esterTion              =\n");
     printf("=================================================\n\n");
 }
@@ -360,7 +442,7 @@ void printInfo()
 void checkArgs(int argc, char* argv[])
 {
     int opt;
-    while((opt = getopt(argc, argv, "p:T")) != -1)
+    while((opt = getopt(argc, argv, "p:Tr:")) != -1)
     {
         switch(opt)
         {
@@ -370,6 +452,10 @@ void checkArgs(int argc, char* argv[])
         case 'T':
             tcp_mode = true;
             break;
+        case 'r':
+            tcp_receive_threshold = atoi(optarg);
+            tcp_buffer_size = tcp_receive_threshold * 2;
+            break;
         }
     }
 }
@@ -384,7 +470,7 @@ int main(int argc, char* argv[])
     if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
     {
         //std::cerr << "WSA startup failed!\n";
-        fprintf(stderr, "WSA startup failed!\n");
+        printErr("[ERROR] WSA startup failed!\n");
         return -1;
     }
     const char *memFileName = "Local\\BROKENITHM_SHARED_BUFFER";
@@ -395,49 +481,48 @@ int main(int argc, char* argv[])
         if(hMapFile == NULL)
         {
             //std::cerr << "CreateFileMapping failed! Error " + std::to_string(GetLastError());
-            fprintf(stderr, "CreateFileMapping failed! error: %lu\n", GetLastError());
+            printErr("[ERROR] CreateFileMapping failed! error: %lu\n", GetLastError());
             return -1;
         }
     }
     defer(CloseHandle(hMapFile))
-    char *memory = reinterpret_cast<char*>(MapViewOfFileEx(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 1024, NULL));
+    IPCMemoryInfo *memory = reinterpret_cast<IPCMemoryInfo*>(MapViewOfFileEx(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 1024, NULL));
     if(memory == nullptr)
     {
         //std::cerr << "Cannot get view of memory map! Error " + std::to_string(GetLastError());
-        fprintf(stderr, "Cannot get view of memory map! error: %lu\n", GetLastError());
+        printErr("[ERROR] Cannot get view of memory map! error: %lu\n", GetLastError());
         return -1;
     }
     if(!tcp_mode)
     {
-        printf("Mode: UDP\n");
+        printErr("[INFO] Mode: UDP\n");
         SOCKET sHost = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
         defer(closesocket(sHost))
-        setTimeout(sHost, 2000);
-        int broadcastEnable = 1;
-        setsockopt(sHost, SOL_SOCKET, SO_BROADCAST, reinterpret_cast<char*>(&broadcastEnable), sizeof(broadcastEnable));
-        socket_bind(sHost, htonl(INADDR_ANY), server_port);
-        //std::cout << "Waiting for device on port " << server_port << "..." << std::endl;
-        printf("Waiting for device on port %d...\n", server_port);
-        auto LEDThread = std::thread(UDPLEDBroadcast, sHost, memory);
-        auto InputThread = std::thread(InputReceive, sHost, memory);
+        socketSetTimeout(sHost, 2000);
+        socketBind(sHost, htonl(INADDR_ANY), server_port);
+        printErr("[INFO] Waiting for device on port %d...\n", server_port);
+        auto LEDThread = std::thread(threadLEDBroadcast, sHost, memory);
+        auto InputThread = std::thread(threadInputReceive, sHost, memory);
         while(_getwch() != L'q');
-        //std::cout << "Exiting gracefully..." << std::endl;
-        printf("Exiting gracefully...\n");
+        printErr("[INFO] Exiting gracefully...\n");
+        last_input_packet_id = 0;
         EXIT_FLAG = true;
         LEDThread.join();
         InputThread.join();
     }
     else
     {
-        printf("Mode: TCP\n");
+        printErr("[INFO] Mode: TCP\n");
+        printErr("[INFO] TCP receive buffer size: %" PRIu32 "\n", tcp_buffer_size);
+        printErr("[INFO] TCP receive threshold: %" PRIu32 "\n", tcp_receive_threshold);
         SOCKET sHost = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
         defer(closesocket(sHost));
-        setTimeout(sHost, 50);
-        socket_bind(sHost, htonl(INADDR_ANY), server_port);
+        socketSetTimeout(sHost, 50);
+        socketBind(sHost, htonl(INADDR_ANY), server_port);
         listen(sHost, 10);
         while(true)
         {
-            printf("Waiting for device on port %d...\n", server_port);
+            printErr("[INFO] Waiting for device on port %d...\n", server_port);
             struct sockaddr_in user_socket = {};
             socklen_t sock_size = sizeof(struct sockaddr_in);
             SOCKET acc_socket = accept(sHost, (struct sockaddr *)&user_socket, &sock_size);
@@ -446,19 +531,18 @@ int main(int argc, char* argv[])
             const char* user_address = inet_ntop(AF_INET, &user_socket.sin_addr, buffer, 20);
             if(user_address != NULL)
             {
-                printf("Device %s:%d connected.\n", user_address, user_socket.sin_port);
+                printErr("[INFO] Device %s:%d connected.\n", user_address, user_socket.sin_port);
             }
             CONNECTED = true;
             EXIT_FLAG = false;
-            auto LEDThread = std::thread(TCPLEDBroadcast, acc_socket, memory);
-            auto InputThread = std::thread(InputReceive, acc_socket, memory);
-            while(_getwch() != L'q');
-            //std::cout << "Exiting gracefully..." << std::endl;
-            printf("Exiting gracefully...\n");
-            EXIT_FLAG = true;
-            CONNECTED = false;
+            auto LEDThread = std::thread(threadLEDBroadcast, acc_socket, memory);
+            auto InputThread = std::thread(threadInputReceive, acc_socket, memory);
             LEDThread.join();
             InputThread.join();
+            printErr("[INFO] Exiting gracefully...\n");
+            last_input_packet_id = 0;
+            EXIT_FLAG = true;
+            CONNECTED = false;
         }
     }
     return 0;

src/resources.rc

@@ -0,0 +1,36 @@
+//
+// Include the necessary resources
+//
+#include <winver.h>
+#include <ntdef.h>
+
+#include "version.h"
+
+#ifdef RC_INVOKED
+
+// ------- version info -------------------------------------------------------
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION             VERSION_MAJOR,VERSION_MINOR,VERSION_PATCH,0
+PRODUCTVERSION          VERSION_MAJOR,VERSION_MINOR,VERSION_PATCH,0
+BEGIN
+	BLOCK "StringFileInfo"
+	BEGIN
+		BLOCK "040904b0"
+        BEGIN
+		VALUE "Comments",         "Brokenithm-Evolved"
+		VALUE "FileDescription",  "Brokenithm-Evolved-Android Server"
+		VALUE "FileVersion",      VERSION
+		VALUE "InternalName",     "Brokenithm-Evolved-Android Server"
+		VALUE "LegalCopyright",   "(C)2021 XTindy"
+		VALUE "OriginalFilename", "brokenithm_server.exe"
+		VALUE "ProductName",      "Brokenithm-Evolved"
+		VALUE "ProductVersion",	  VERSION
+        END
+	END
+	BLOCK "VarFileInfo"
+	BEGIN
+		VALUE "Translation", 0x0409,1200
+	END
+END
+#endif

src/struct.h

@@ -0,0 +1,84 @@
+#ifndef STRUCT_H_INCLUDED
+#define STRUCT_H_INCLUDED
+
+#pragma pack(push)
+#pragma pack(1)
+
+struct IPCMemoryInfo
+{
+    uint8_t airIoStatus[6];
+    uint8_t sliderIoStatus[32];
+    uint8_t ledRgbData[32 * 3];
+    uint8_t testBtn;
+    uint8_t serviceBtn;
+    uint8_t coinInsertion;
+    uint8_t cardRead;
+    uint8_t remoteCardRead;
+    uint8_t remoteCardType;
+    uint8_t remoteCardId[10];
+};
+
+struct PacketInput
+{
+    uint8_t packetSize;
+    uint8_t packetName[3];
+    uint32_t packetId;
+    uint8_t airIoStatus[6];
+    uint8_t sliderIoStatus[32];
+    uint8_t testBtn;
+    uint8_t serviceBtn;
+};
+
+struct PacketInputNoAir
+{
+    uint8_t packetSize;
+    uint8_t packetName[3];
+    uint32_t packetId;
+    uint8_t sliderIoStatus[32];
+    uint8_t testBtn;
+    uint8_t serviceBtn;
+};
+
+struct PacketFunction
+{
+    uint8_t packetSize;
+    uint8_t packetName[3];
+    uint8_t funcBtn;
+};
+
+struct PacketConnect
+{
+    uint8_t packetSize;
+    uint8_t packetName[3];
+    uint8_t addrType;
+    uint16_t port;
+    union
+    {
+        struct
+        {
+            uint8_t addr[4];
+            uint8_t padding[12];
+        } addr4;
+        uint8_t addr6[16];
+    } addr;
+};
+
+struct PacketCard
+{
+    uint8_t packetSize;
+    uint8_t packetName[3];
+    uint8_t remoteCardRead;
+    uint8_t remoteCardType;
+    uint8_t remoteCardId[10];
+};
+
+struct PacketPing
+{
+    uint8_t packetSize;
+    uint8_t packetName[3];
+    uint64_t remotePingTime;
+};
+
+#pragma pack(pop)
+
+#endif // STRUCT_H_INCLUDED

src/version.h

@@ -0,0 +1,10 @@
+#ifndef VERSION_H_INCLUDED
+#define VERSION_H_INCLUDED
+
+#define VERSION "V0.3.0"
+
+#define VERSION_MAJOR 0
+#define VERSION_MINOR 3
+#define VERSION_PATCH 0
+
+#endif // VERSION_H_INCLUDED