//--------------------------------------------------------------------------------- // Copyright 2015 by Joseph Forgione // This file is part of VCC (Virtual Color Computer). // // VCC (Virtual Color Computer) is free software: you can redistribute it and/or // modify it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, or any later // version. // // VCC (Virtual Color Computer) is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for // more details. You should have received a copy of the GNU General Public License // along with VCC (Virtual Color Computer). If not, see // . // //--------------------------------------------------------------------------------- // // This code is extracted from the standalone version of becker.dll with gui // deletions, changed external calls, and some variable name changes. // //--------------------------------------------------------------------------------- //#define USE_LOGGING #define _WINSOCK_DEPRECATED_NO_WARNINGS #include #include #include #include #include #include #include "becker.h" #define BUFFER_SIZE 512 #define TCP_RETRY_DELAY 500 #define STATS_PERIOD_MS 100 //------------------------------------------------------ // Error returns from SOCKET dw_open(...) //------------------------------------------------------ constexpr SOCKET SOCKET_RETRY = (SOCKET)-1; constexpr SOCKET SOCKET_FATAL = (SOCKET)-2; //------------------------------------------------------ // local functions //------------------------------------------------------ void dw_open(); void dw_close(); SOCKET dw_open(const char *, const char *); unsigned char dw_status(); unsigned char dw_read(); int dw_write(char); unsigned __stdcall dw_thread(void *); //------------------------------------------------------ // globals //------------------------------------------------------ static SOCKET dwSocket = 0; static bool dwEnabled = false; static HANDLE hDWTCPThread; // are we retrying tcp conn static bool retry = false; // circular buffer for socket io static char InBuffer[BUFFER_SIZE]; static int InReadPos = 0; static int InWritePos = 0; // hostname and port static char dwaddress[MAX_PATH] = {}; static char dwsport[16] = "65504"; static char curaddress[MAX_PATH] = {}; static char curport[16] = "65504"; // statistics static int BytesWrittenSince = 0; static int BytesReadSince = 0; static DWORD LastStats; static float ReadSpeed = 0; static float WriteSpeed = 0; //------------------------------------------------------ // Set becker server address and port // Should default to "127.0.0.1" and "65504" //------------------------------------------------------ int becker_sethost(const char *bufdwaddr, const char *bufdwport) { strcpy(dwaddress,bufdwaddr); strcpy(dwsport,bufdwport); if (strcmp(dwsport,curport) !=0 || (strcmp(dwaddress,curaddress) != 0)) dw_close(); return 0; } //------------------------------------------------------ // enable or disable becker port //------------------------------------------------------ void becker_enable(bool enable) { if (enable) { if (!dwEnabled) { // reset buffer pointers InReadPos = 0; InWritePos = 0; // start create thread to handle io HANDLE hEvent; unsigned threadID; hEvent = CreateEvent( nullptr, FALSE, FALSE, nullptr ) ; if (hEvent==nullptr) { DLOG_C("Cannot create DWTCPConnection thread!\n"); return; } // start it up... hDWTCPThread = (HANDLE)_beginthreadex ( nullptr, 0, &dw_thread, hEvent, 0, &threadID ); if (hDWTCPThread==nullptr) { DLOG_C("Cannot start DWTCPConnection thread!\n"); return; } dwEnabled = true; DLOG_C("DWTCPConnection thread started with id %d\n",threadID); } } else { dw_close(); dwEnabled = false; DLOG_C("DWTCPConnection has been disabled.\n"); } } //------------------------------------------------------ // write becker port //------------------------------------------------------ void becker_write(unsigned char data,unsigned short port) { if (port == 0x42) dw_write(data); return; } //------------------------------------------------------ // read becker port //------------------------------------------------------ unsigned char becker_read(unsigned short port) { switch (port) { // read status case 0x41: if (dw_status() != 0) return 2; else return 0; // read data case 0x42: return(dw_read()); } return 0; } //------------------------------------------------------ // get drivewire status for status line //------------------------------------------------------ void becker_status(char *DWStatus) { if (dwEnabled) { // calculate speed DWORD sinceCalc = GetTickCount() - LastStats; if (sinceCalc > STATS_PERIOD_MS) { LastStats += sinceCalc; ReadSpeed = 8.0f * (BytesReadSince / (1000.0f - sinceCalc)); WriteSpeed = 8.0f * (BytesWrittenSince / (1000.0f - sinceCalc)); BytesReadSince = 0; BytesWrittenSince = 0; } if (retry) { sprintf(DWStatus,"DW %s?", curaddress); } else if (dwSocket == 0) { sprintf(DWStatus,"DW ConError"); } else { sprintf(DWStatus,"DW OK R:%04.1f W:%04.1f", ReadSpeed , WriteSpeed); } } else { sprintf(DWStatus,""); } return; } //------------------------------------------------------ // Internal functions //------------------------------------------------------ // coco checks for data unsigned char dw_status( void ) { // check for input data waiting if (retry | (dwSocket == 0) | (InReadPos == InWritePos)) return 0; else return 1; } // coco reads a byte unsigned char dw_read( void ) { // increment buffer read pos, return next byte unsigned char dwdata = InBuffer[InReadPos]; InReadPos++; if (InReadPos == BUFFER_SIZE) InReadPos = 0; BytesReadSince++; return dwdata; } // coco writes a byte int dw_write( char dwdata) { // send the byte if we're connected if ((dwSocket != 0) & (!retry)) { int res = send(dwSocket, &dwdata, 1, 0); if (res != 1) { DLOG_C("dw_write socket error %d\n", WSAGetLastError()); closesocket(dwSocket); dwSocket = 0; } else { BytesWrittenSince++; } } else { DLOG_C("dw_write null socket\n"); } return 0; } void dw_close() { // close socket to cause io thread to die DLOG_C("dw_close\n"); if (dwSocket != 0) closesocket(dwSocket); dwSocket = 0; InReadPos = 0; InWritePos = 0; hDWTCPThread = nullptr; } // try to connect with DW server void dw_open( void ) { DLOG_C("dw_open %s:%d\n",dwaddress,dwsport); dwSocket = dw_open(dwaddress,dwsport); if (dwSocket == SOCKET_RETRY) { retry = true; dwSocket = 0; } else if (dwSocket == SOCKET_FATAL) { retry = false; dwSocket = 0; } } // Override for dw_open(void) replaces gethostbyname with getaddrinfo SOCKET dw_open(const char * server, const char * port) { struct addrinfo hints; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; struct addrinfo *result = nullptr; if (getaddrinfo(server, port, &hints, &result) != 0) return SOCKET_FATAL; SOCKET s = SOCKET_RETRY; for (auto p = result; p != nullptr; p = p->ai_next) { s = socket(p->ai_family, p->ai_socktype, p->ai_protocol); if (s == INVALID_SOCKET) { freeaddrinfo(result); return SOCKET_FATAL; } if (connect(s, p->ai_addr, p->ai_addrlen) != 0) { closesocket(s); s = SOCKET_RETRY; continue; } break; } freeaddrinfo(result); return s; } // TCP connection thread unsigned __stdcall dw_thread(void* /*Dummy*/) { DLOG_C("dw_thread %d\n",dwEnabled); WSADATA wsaData; int sz; int res; if (dwEnabled) { // Request Winsock version 2.2 if ((WSAStartup(0x202, &wsaData)) != 0) { DLOG_C("dw_thread winsock startup failed, exiting\n"); WSACleanup(); return 0; } } while(dwEnabled) { // get connected dw_open(); // keep trying... while ((dwSocket == 0) & dwEnabled) { dw_open(); // after 2 tries, sleep between attempts Sleep(TCP_RETRY_DELAY); } while ((dwSocket != 0) & dwEnabled) { // we have a connection, read as much as possible. if (InReadPos > InWritePos) sz = InReadPos - InWritePos; else sz = BUFFER_SIZE - InWritePos; // read the data res = recv(dwSocket,(char *)InBuffer + InWritePos, sz, 0); if (res < 1) { // no good, bail out closesocket(dwSocket); dwSocket = 0; } else { // good recv, inc ptr InWritePos += res; if (InWritePos == BUFFER_SIZE) InWritePos = 0; } } } // Not enabled - close socket if necessary if (dwSocket != 0) closesocket(dwSocket); dwSocket = 0; _endthreadex(0); return 0; }