Initial commit

_rs232/ic_emul/ic.bat

@@ -0,0 +1 @@
+ic_115200.exe COM5

_rs232/ic_emul/ic_cmds.c

@@ -0,0 +1,546 @@
+#include <winsock2.h>
+
+#include "ic_comm.h"
+#include "ic_cmds.h"
+#include "uart.h"
+#include "log.h"
+
+//Winsock shit
+WORD wVersionRequested;
+WSADATA wsaData;
+
+
+//vars
+SOCKET sockets[SOCKET_MAX];
+
+
+
+//Init
+int init(char *comport)
+{
+  int i;
+
+  for(i=0; i<SOCKET_MAX; ++i)
+    sockets[i]=0;
+
+  if(uart_init(comport) < 0) return -1;
+
+  //Init winsock
+  wVersionRequested = MAKEWORD(2,2);
+  WSAStartup(wVersionRequested, &wsaData);
+  
+
+  return 0;
+}
+
+
+
+//Process
+void process(void)
+{
+  unsigned char cmd;
+
+  while(1)
+  {
+    //read command
+    uart_read(&cmd,1);
+
+    switch(cmd)
+    {
+      case IC_CMD_SOCKET:  cmd_socket();  break;
+      case IC_CMD_BIND:    cmd_bind();    break;
+      case IC_CMD_CONNECT: cmd_connect(); break;
+      case IC_CMD_LISTEN:  cmd_listen();  break;
+      case IC_CMD_ACCEPT:  cmd_accept();  break;
+      case IC_CMD_CLOSE:   cmd_close();   break;
+      case IC_CMD_SELECT:  cmd_select();  break;
+                          
+      case IC_CMD_GETHOSTBYNAME: cmd_gethostbyname(); break;
+      case IC_CMD_GETHOSTBYADDR: cmd_gethostbyaddr(); break;
+                          
+      case IC_CMD_SEND:     cmd_send();     break;
+      case IC_CMD_RECV:     cmd_recv();     break;
+      case IC_CMD_SENDTO:   cmd_sendto();   break;
+      case IC_CMD_RECVFROM: cmd_recvfrom(); break;
+
+      default:
+        logerr("Wrong command #%2x!",cmd);
+    }
+  }
+
+
+}
+
+
+
+
+
+
+
+
+
+void cmd_res_fail(void)
+{
+  unsigned char t=IC_CMD_RES_FAIL;
+  uart_write(&t,1);
+}
+
+void cmd_res_ok(void)
+{
+  unsigned char t=IC_CMD_RES_OK;
+  uart_write(&t,1);
+}
+
+
+
+
+
+void cmd_socket(void)
+{
+  unsigned char params[10];
+  SOCKET tsock;
+  int i;
+
+  //get params
+  uart_read(params,3);
+  //find free socket
+  for(i=0; i<SOCKET_MAX; ++i)
+    if(sockets[i]==0) break;
+
+  if(i==SOCKET_MAX)
+  { //not found, result=fail
+    cmd_res_fail();
+    logerr("CMD_SOCKET: No free sockets.");
+  }
+  else
+  { //found, create real socket
+    tsock=socket((int)params[0],(int)params[1],(int)params[2]);
+
+    if(tsock==INVALID_SOCKET)
+    { //socket() fail
+      cmd_res_fail();
+      logerr("socket() failed.");
+    }
+    else
+    { //socket created
+      sockets[i]=tsock;
+      params[0]=IC_CMD_RES_OK;	//res=ok
+      params[1]=i;		//fd
+      uart_write(params,2);
+      log_("Socket created, id=%i.",i);
+    }
+  }
+}
+
+
+
+
+
+void cmd_bind(void)
+{
+  unsigned char params[10];
+  unsigned char fd;
+  struct sockaddr_in loc_addr;
+
+  //get params
+  uart_read(params,7);
+  fd=params[0];
+  if(fd>=SOCKET_MAX || sockets[fd]==0)
+  { //wrong fd
+    cmd_res_fail();
+    logerr("CMD_BIND: Wrong socket descriptor, id=%i.",fd);
+  }
+  else
+  { //correct fd
+    loc_addr.sin_family = AF_INET; //fix in proto?
+    loc_addr.sin_addr.S_un.S_addr=htonl(params[1] | (params[2]<<8) | (params[3]<<16) | (params[4]<<24));
+    loc_addr.sin_port=htons(params[5] | (params[6]<<8));
+    if(bind(sockets[fd], (struct sockaddr *)&loc_addr, sizeof(loc_addr)) == 0)
+    { //bind ok
+      cmd_res_ok();
+      log_("Socket id=%i binded to %u.%u.%u.%u:%u.",fd,params[1],params[2],params[3],params[4], params[5] | (params[6]<<8));
+    }
+    else
+    { //bind error
+      cmd_res_fail();
+      logerr("bind() error.");
+    }
+  }
+}
+
+
+void cmd_connect(void)
+{
+  unsigned char params[10];
+  unsigned char fd;
+  struct sockaddr_in rm_addr;
+
+  //get params
+  uart_read(params,7);
+  fd=params[0];
+  if(fd>=SOCKET_MAX || sockets[fd]==0)
+  { //wrong fd
+    cmd_res_fail();
+    logerr("CMD_CONNECT: Wrong socket descriptor, id=%i.",fd);
+  }
+  else
+  { //correct fd
+    rm_addr.sin_family = AF_INET; //fix in proto?
+    rm_addr.sin_addr.S_un.S_addr=htonl(params[4] | (params[3]<<8) | (params[2]<<16) | (params[1]<<24));
+    rm_addr.sin_port=htons(params[5] | (params[6]<<8));
+    if(connect(sockets[fd], (struct sockaddr *)&rm_addr, sizeof(rm_addr)) == 0)
+    { //connect ok
+      cmd_res_ok();
+      log_("Socket id=%i connected to %u.%u.%u.%u:%u.",fd,params[1],params[2],params[3],params[4], params[5] | (params[6]<<8));
+    }
+    else
+    { //connect error
+      cmd_res_fail();
+      logerr("connect() error.");
+    }
+  }
+}
+
+
+
+void cmd_listen(void)
+{
+
+}
+
+
+
+void cmd_accept(void)
+{
+
+}
+
+
+
+void cmd_close(void)
+{
+  unsigned char fd;
+
+  //get params
+  uart_read(&fd,1);
+  if(fd>=SOCKET_MAX || sockets[fd]==0)
+  { //wrong fd
+    cmd_res_fail();
+    logerr("CMD_CLOSE: Wrong socket descriptor, id=%i.",fd);
+  }
+  else
+  { //correct fd
+    closesocket(sockets[fd]);
+    sockets[fd]=0;
+    cmd_res_ok();
+    log_("Close socket, id=%i.",fd);
+  }
+}
+
+
+
+void cmd_select(void)
+{
+  unsigned char params[MAX_SELECT],tlen[3];
+  fd_set fdrd;
+  fd_set fdwr;
+  fd_set fdexc;
+  struct timeval tout={0,0};
+  int n,nr,nw,ne,i,p;
+
+  //get nums & timeout
+  uart_read(params,3);
+  nr=params[0];
+  nw=params[1];
+  ne=params[2];
+  n=nr+ne+nw;
+
+  if(n>MAX_SELECT || nr>MAX_SELECT || nw>MAX_SELECT || ne>MAX_SELECT)
+  { //too much sockets! error...
+    while(n>0)
+    {
+      nr=(n>MAX_SELECT) ? MAX_SELECT : n;
+      uart_read(params,nr);
+      n-=nr;
+    }
+    cmd_res_fail();
+    logerr("CMD_SELECT: Too much sockets.");
+    return;
+  }
+  else
+  { //ok, get fds
+    uart_read(params,n);
+    FD_ZERO(&fdrd);
+    FD_ZERO(&fdwr); 
+    FD_ZERO(&fdexc); 
+
+    //fill fd_set
+    if(nr)
+    {
+      for(i=0;i<nr;++i)
+      {
+        if(sockets[params[i]]==0)
+        {
+          cmd_res_fail();
+          logerr("CMD_SELECT: Wrong socket.");
+          return;
+        }
+        FD_SET(sockets[params[i]], &fdrd);
+      }
+    }
+
+    if(nw)
+    {
+      for(i=0;i<nw;++i)
+      {
+        if(sockets[params[i+nr]]==0)
+        {
+          cmd_res_fail();
+          logerr("CMD_SELECT: Wrong socket.");
+          return;
+        }
+        FD_SET(sockets[params[i+nr]], &fdwr);
+      }
+    }
+
+    if(ne)
+    {
+      for(i=0;i<ne;++i)
+      {
+        if(sockets[params[i+nr+nw]]==0)
+        {
+          cmd_res_fail();
+          logerr("CMD_SELECT: Wrong socket.");
+          return;
+        }
+        FD_SET(sockets[params[i+nr+nw]], &fdexc);
+      }
+    }
+
+    n=select(FD_SETSIZE, &fdrd, &fdwr, &fdexc, &tout);
+
+    if(n==0)
+    { //no data on any socket
+      params[0]=IC_CMD_RES_OK;
+      params[1]=0;
+      params[2]=0;
+      params[3]=0;
+      uart_write(params,4);
+      log_("CMD_SELECT: No data.");
+    }
+    else if(n==SOCKET_ERROR)
+    { //socket error?????
+      cmd_res_fail();
+      logerr("CMD_SELECT: socket error (closed?).");
+    }
+    else
+    { //some sockets signalled
+      //check all
+      p=0;
+        for(n=0,i=0;i<nr;++i)
+          if(FD_ISSET(sockets[params[i]], &fdrd))
+            params[p++]=params[i];
+        tlen[0]=n;
+
+        for(n=0,i=0;i<nw;++i)
+          if(FD_ISSET(sockets[params[i+nr]], &fdrd))
+            params[p++]=params[i+nr];
+        tlen[1]=n;
+
+        for(n=0,i=0;i<nr;++i)
+          if(FD_ISSET(sockets[params[i]], &fdrd))
+            params[p++]=params[i];
+        tlen[2]=n;
+
+      uart_write(tlen,3);
+      if(p) uart_write(params,p);
+      log_("CMD_SELECT: %i sockets signalled.",p);
+    }
+
+  }
+}
+
+
+
+
+
+
+void cmd_gethostbyname(void)
+{
+  struct hostent *remoteHost;
+  unsigned char params[10];
+  unsigned char *buf;
+  unsigned short len,sent;
+
+  //get params
+  uart_read(params,2);
+  len=params[0] + 256*params[1];
+  buf=(unsigned char*)malloc(len+1);
+    
+  if(buf)
+  { //mem ok
+    uart_read(buf,len);
+    buf[len]=0;
+    remoteHost = gethostbyname(buf);
+    if(remoteHost==NULL)
+    {
+      cmd_res_fail();
+      logerr("CMD_GETHOSTBYNAME: gethostbyname(%s) failed.",buf);
+    }
+    else
+    {
+      cmd_res_ok();
+      memcpy(params,remoteHost->h_addr_list[0],4);
+      uart_write(params,4);
+      log_("CMD_GETHOSTBYNAME: %s resolved to %d.%d.%d.%d.",buf,
+          params[0],params[1],params[2],params[3]);
+    }
+    free(buf);
+  }
+  else
+  {
+    cmd_res_fail();
+    logerr("CMD_GETHOSTBYNAME: malloc() failed.");
+  }
+}
+
+
+
+void cmd_gethostbyaddr(void)
+{
+
+}
+
+
+
+
+
+void cmd_send(void)
+{
+  unsigned char params[10];
+  unsigned char fd;
+  unsigned char *buf;
+  unsigned short len,sent;
+
+  //get params
+  uart_read(params,4);
+  fd=params[0];
+  if(fd>=SOCKET_MAX || sockets[fd]==0)
+  { //wrong fd
+    cmd_res_fail();
+    logerr("CMD_SEND: Wrong socket descriptor, id=%i.",fd);
+  }
+  else
+  { //correct fd
+    len=params[1] + 256*params[2];
+    buf=(unsigned char*)malloc(len);
+    
+    if(buf)
+    { //mem ok
+      cmd_res_ok();
+      //get data and send it to real socket
+      uart_read(buf,len);
+      sent=send(sockets[fd],buf,len,0);
+      //report real sent/error
+      params[0]=sent & 0xff; params[1]=(sent>>8) & 0xff;
+      uart_write(params,2);
+
+      free(buf);
+      log_("Socket id=%i send %u bytes.",fd,len);
+    }
+    else
+    { //no mem
+      cmd_res_fail();
+      logerr("CMD_SEND: no memory.");
+    }
+  }
+
+}
+
+
+
+void cmd_recv(void)
+{
+  unsigned char params[10];
+  unsigned char fd;
+  unsigned char *buf;
+  unsigned short len,reallen;
+  fd_set fdset;
+  struct timeval tout={0,0};
+  int n;
+
+  //get params
+  uart_read(params,4);
+  fd=params[0];
+  if(fd>=SOCKET_MAX || sockets[fd]==0)
+  { //wrong fd
+    cmd_res_fail();
+    logerr("CMD_RECV: Wrong socket descriptor, id=%i.",fd);
+  }
+  else
+  { //correct fd
+    len=params[1] + 256*params[2];
+    buf=(unsigned char*)malloc(len+3);
+    
+    if(buf)
+    { //mem ok
+      FD_ZERO(&fdset); FD_SET(sockets[fd], &fdset);
+      n=select(FD_SETSIZE, &fdset, NULL, NULL, &tout);
+
+      if(n==0)
+      { //timeout, no data, socket ok
+        buf[0]=IC_CMD_RES_OK;
+        buf[1]=0;
+        buf[2]=0;
+        uart_write(buf,3);
+        log_("Socket id=%i recv 0 bytes.",fd);
+      }
+      else if(n==SOCKET_ERROR)
+      { //socket error
+        cmd_res_fail();
+        logerr("CMD_RECV: socket error (closed?), id=%i.",fd);
+      }
+      else
+      { //data present, read
+        reallen=recv(sockets[fd],buf+3,len,0);
+        if(reallen==0)
+        { //socket closed
+          cmd_res_fail();
+          log_("CMD_RECV: socket closed, id=%i.",fd);
+        }
+        else
+        {
+          //report real sent/error
+          buf[0]=IC_CMD_RES_OK;
+          buf[1]=reallen & 0xff; buf[2]=(reallen>>8) & 0xff;
+          uart_write(buf,reallen+3);
+          log_("Socket id=%i recv %u bytes.",fd,reallen);
+        }
+      }
+      free(buf);
+    }
+    else
+    { //no mem
+      cmd_res_fail();
+      logerr("CMD_RECV: no memory, id=%i.",fd);
+    }
+  }
+
+}
+
+
+
+void cmd_sendto(void)
+{
+
+}
+
+
+
+void cmd_recvfrom(void)
+{
+
+}
+
+
+

_rs232/ic_emul/ic_cmds.h

@@ -0,0 +1,27 @@
+
+
+#define SOCKET_MAX 20  //max sockets
+#define MAX_SELECT 20  //max total sockets for select
+
+int init(char *comport);
+void process(void);
+
+
+void cmd_socket(void);
+void cmd_bind(void);
+void cmd_connect(void);
+void cmd_listen(void);
+void cmd_accept(void);
+void cmd_close(void);
+void cmd_select(void);
+                          
+void cmd_gethostbyname(void);
+void cmd_gethostbyaddr(void);
+                          
+void cmd_send(void);
+void cmd_recv(void);
+void cmd_sendto(void);
+void cmd_recvfrom(void);
+
+
+

_rs232/ic_emul/ic_comm.h

@@ -0,0 +1,26 @@
+
+
+#define IC_CMD_SOCKET		0x01
+#define IC_CMD_BIND		0x02
+#define IC_CMD_CONNECT		0x03
+#define IC_CMD_LISTEN		0x04
+#define IC_CMD_ACCEPT		0x05
+#define IC_CMD_CLOSE		0x06
+#define IC_CMD_SELECT		0x07
+
+#define IC_CMD_GETHOSTBYNAME	0X20
+#define IC_CMD_GETHOSTBYADDR	0X21
+
+#define IC_CMD_SEND		0x10
+#define IC_CMD_RECV		0x11
+#define IC_CMD_SENDTO		0x18
+#define IC_CMD_RECVFROM		0x19
+
+#define IC_CMD_RES_OK		0x00
+#define IC_CMD_RES_FAIL		0xff
+
+
+
+
+
+

_rs232/ic_emul/ic_main.c

@@ -0,0 +1,30 @@
+#include <stdio.h>
+
+#include "ic_comm.h"
+#include "ic_cmds.h"
+#include "log.h"
+
+
+
+
+
+int main(int argc, char *argv[])
+{
+  if(argc<2)
+  {
+    log_("Usage: ic_emul.exe COMx");
+    return -1;
+  }
+
+  if(init(argv[1]) < 0)
+  {
+    logerr("Init error.");
+    return -2;
+  }
+
+  printf("ZX-Spectrum Internet Controller Emulator v0.1\n");
+  process();
+
+  return 0;
+}
+

_rs232/ic_emul/log.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+
+void log_(const char *fmt, ...)
+{
+#if 1
+  va_list ap;
+  char *msg=(char*)malloc(1024);
+
+  if(msg)
+  {
+    va_start(ap, fmt);
+    vsprintf(msg, fmt, ap);
+    printf("Log: %s\n",msg);
+    va_end(ap);
+    free(msg);
+  }
+#endif
+}
+
+
+
+void logerr(const char *fmt, ...)
+{
+#if 1
+  va_list ap;
+  char *msg=(char*)malloc(1024);
+
+  if(msg)
+  {
+    va_start(ap, fmt);
+    vsprintf(msg, fmt, ap);
+    printf("Error: %s\n",msg);
+    va_end(ap);
+    free(msg);
+  }
+#endif
+}

_rs232/ic_emul/log.h

@@ -0,0 +1,6 @@
+
+
+void log_(const char *fmt, ...);
+void logerr(const char *fmt, ...);
+
+

_rs232/ic_emul/make.bat

@@ -0,0 +1,12 @@
+@echo off
+
+set TOOLS_PATH=...
+
+set GCC_PATH=%TOOLS_PATH%\mingw\bin;%TOOLS_PATH%\mingw\msys\1.0\bin
+set PATH=%GCC_PATH%;%PATH%
+
+gcc -c ic_main.c -o ic_main.o
+gcc -c ic_cmds.c -o ic_cmds.o
+gcc -c log.c -o log.o
+gcc -c uart.c -o uart.o
+gcc ic_main.o ic_cmds.o log.o uart.o  -lws2_32 -o ic.exe

_rs232/ic_emul/proto.txt

@@ -0,0 +1,162 @@
+
+
+
+
+socket
+>	byte #01
+	byte address_family
+	byte type
+	byte protocol
+<	byte res (0=ok)
+<?	byte fd
+
+bind
+>	byte #02
+	byte fd
+	long my_addr
+	word port
+<	byte res (0=ok)
+
+connect
+>	byte #03
+	byte fd
+	long serv_addr
+	word port
+<	byte res (0=ok)
+
+
+listen
+>	byte #04
+	byte fd
+<	byte res (0=ok)?
+
+
+accept
+>	byte #05
+	byte fd
+<	byte res (0=ok)
+<???
+
+
+close
+>	byte #06
+	byte fd
+<	byte res (0=ok)
+
+
+select
+>	byte #07
+	byte fd_read_cnt
+	byte fd_write_cnt
+	byte fd_except_cnt
+	byte fd_read[fd_read_cnt]
+	byte fd_write[fd_write_cnt]
+	byte fd_exc[fd_exc_cnt]
+<	byte res (0=ok)
+<?	byte fd_read_sig
+<?	byte fd_write_sig
+<?	byte fd_except_sig
+<??	byte fd_read[fd_read_sig]
+<??	byte fd_write[fd_write_sig]
+<??	byte fd_exc[fd_exc_sig]
+
+
+
+gethostbyname
+>	byte #20
+>       word name_len
+>	ascii hostname
+<	byte res (0=ok)
+<?      long ip
+
+gethostbyaddr
+>	byte #21
+	long addr
+	byte type
+<	byte res (0=ok)
+<???
+
+
+
+
+send
+>	byte #10
+	byte fd
+	word buflen
+	byte flags
+<	byte res (0=ok)
+>?	byte buf[buflen]
+<?	word realsent (#ffff = error)
+
+
+
+recv
+>	byte #11
+	byte fd
+        word len
+	byte flags
+<	byte res (0=ok)
+>?	word reallen
+>??	byte buf[reallen]
+
+sendto
+>	byte #18
+	byte fd
+	word len
+	int flags
+	long to
+<	byte res (0=ok)
+>?	byte buf[len]
+<?	word realsent
+
+recvfrom
+>	byte #19
+	byte fd
+	word len
+<	byte res (0=ok)
+>?	word reallen
+>?	byte buf[reallen]
+	
+
+
+
+if_list
+
+if_config
+
+proxy_config
+
+soft_reset
+
+stats
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+ * Types
+ */
+#define SOCK_STREAM     1               /* stream socket */
+#define SOCK_DGRAM      2               /* datagram socket */
+#define SOCK_RAW        3               /* raw-protocol interface */
+
+
+/*
+ * Address families.
+ */
+#define AF_UNSPEC       0               /* unspecified */
+#define AF_INET         2               /* internetwork: UDP, TCP, etc. */
+#define AF_INET6        23              /* Internetwork Version 6 */
+
+
+

_rs232/ic_emul/uart.c

@@ -0,0 +1,63 @@
+#include <windows.h>
+
+HANDLE port;
+DCB dcb;
+COMMTIMEOUTS touts;
+
+
+
+//init uart
+int uart_init(char *comport)
+{
+  port = CreateFile(comport, GENERIC_READ | GENERIC_WRITE,
+      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
+  if (port==INVALID_HANDLE_VALUE) return -1;
+
+  if (GetCommState(port, &dcb))
+  {
+     dcb.BaudRate = CBR_115200;
+     dcb.ByteSize = 8; dcb.Parity = 0; dcb.StopBits = 0;
+     dcb.fAbortOnError = 0;
+     SetCommState(port, &dcb);
+  }
+
+  if (GetCommTimeouts(port, &touts))
+  {
+     touts.ReadIntervalTimeout = MAXDWORD;
+     touts.ReadTotalTimeoutMultiplier = MAXDWORD;
+     touts.ReadTotalTimeoutConstant = MAXDWORD;
+     touts.WriteTotalTimeoutMultiplier = MAXDWORD;
+     touts.WriteTotalTimeoutConstant = MAXDWORD;
+
+     SetCommTimeouts(port, &touts);
+  }
+
+//  PurgeComm(port, PURGE_RXCLEAR+PURGE_TXCLEAR);
+  return 0;
+}
+
+
+//read byte (can use int)
+void uart_read(char *buf, int len)
+{
+  unsigned long nread=0,s;
+
+  for(s=0; s<len;)
+  {
+    ReadFile(port, &buf[s], len, &nread, NULL);
+    s+=nread;
+  }
+}
+
+
+//write byte 2 usart
+void uart_write(char *buf, int len)
+{
+  unsigned long nread=0;
+
+  WriteFile(port, buf, len, &nread, NULL);
+}
+
+
+
+

_rs232/ic_emul/uart.h

@@ -0,0 +1,10 @@
+
+
+
+int uart_init(char *comport);
+void uart_read(char *buf, int len);
+void uart_write(char *buf, int len);
+
+
+
+