Initial commit

_rs232/ic_emul_0.2/ic.bat

@@ -0,0 +1 @@
+ic.exe com5

_rs232/ic_emul_0.2/ic_cmds.c

@@ -0,0 +1,578 @@
+#ifdef __WIN32
+#include <winsock2.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#endif
+
+#include "ic_comm.h"
+#include "ic_cmds.h"
+#include "uart.h"
+#include "log.h"
+
+#ifdef __WIN32
+//Winsock shit
+WORD wVersionRequested;
+WSADATA wsaData;
+#else
+typedef int SOCKET;
+#define INVALID_SOCKET -1
+#define SOCKET_ERROR   -1
+#define closesocket close
+#endif
+
+//vars
+SOCKET sockets[SOCKET_MAX];
+
+
+
+//Init
+int init(char *sname, int baud)
+{
+  int i;
+
+  for(i=0; i<SOCKET_MAX; ++i)
+    sockets[i]=0;
+
+  if(uart_init(sname, baud) < 0) return -1;
+
+#ifdef __WIN32
+  //Init winsock
+  wVersionRequested = MAKEWORD(2,2);
+  WSAStartup(wVersionRequested, &wsaData);
+#endif  
+
+  return 0;
+}
+
+
+
+//Process
+void process(void)
+{
+  unsigned char cmd;
+
+  while(1)
+  {
+    //read command
+    uart_read(&cmd,1);
+
+    switch(cmd)
+    {
+      case IC_CMD_NOP:     cmd_nop();     break;
+      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 #%02x!",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);
+}
+
+
+//silently reply \0 for (re)sync purposes
+void cmd_nop(void)
+{
+  unsigned char p=0;
+  uart_write(&p,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?
+#ifdef __WIN32
+    loc_addr.sin_addr.S_un.S_addr=htonl(params[1] | (params[2]<<8) | (params[3]<<16) | (params[4]<<24));
+#else
+    loc_addr.sin_addr.s_addr=htonl(params[1] | (params[2]<<8) | (params[3]<<16) | (params[4]<<24));
+#endif
+    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?
+#ifdef __WIN32
+    rm_addr.sin_addr.S_un.S_addr=htonl(params[4] | (params[3]<<8) | (params[2]<<16) | (params[1]<<24));
+#else
+    rm_addr.sin_addr.s_addr=(params[1] | (params[2]<<8) | (params[3]<<16) | (params[4]<<24));
+#endif
+    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)
+{
+  logerr("CMD_LISTEN not implemented yet.");
+}
+
+
+
+void cmd_accept(void)
+{
+  logerr("CMD_ACCEPT not implemented yet.");
+}
+
+
+
+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;
+
+  //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_("Host %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)
+{
+  logerr("CMD_GETHOSTBYADDR not implemented yet.");
+}
+
+
+
+
+
+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)
+{
+  logerr("CMD_SENDTO not implemented yet.");
+}
+
+
+
+void cmd_recvfrom(void)
+{
+  logerr("CMD_RECVFROM not implemented yet.");
+}
+
+
+

_rs232/ic_emul_0.2/ic_cmds.h

@@ -0,0 +1,28 @@
+
+
+#define SOCKET_MAX 20  //max sockets
+#define MAX_SELECT 20  //max total sockets for select
+
+int init(char *sname, int baud);
+void process(void);
+
+
+void cmd_nop(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_0.2/ic_comm.h

@@ -0,0 +1,27 @@
+
+
+#define IC_CMD_NOP		0x00
+#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_0.2/ic_main.c

@@ -0,0 +1,70 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "ic_comm.h"
+#include "ic_cmds.h"
+#include "log.h"
+
+int debug=0;
+
+void usage(void)
+{
+#ifdef __WIN32
+  printf("Usage: ic.exe COMx [-b baudrate] [-q] [-q]\n\n");
+#else
+  printf("Usage: ic /dev/ttyUSBx [-b baudrate] [-q] [-q]\n\n");
+#endif
+  printf("Supported baud rates: 115200 (default), 57600, 38400,\n");
+  printf("                      19200, 9600, 4800, 2400, 1200\n");
+  printf("Use single -q for quiet mode,\n");
+  printf("double -q for complete silence.\n");
+}
+
+
+int main(int argc, char *argv[])
+{
+  char *sname=NULL,*p;
+  int i, baud=115200, q=0;
+
+  for (i = 1; i < argc; i++)
+  {
+    p = argv[i];
+    if (*p == '-')
+    {
+      if (strcmp(p, "-b") == 0) baud = atoi(argv[++i]);
+      else if (strcmp(p, "-q") == 0) q++;
+      else if (strcmp(p, "-d") == 0) debug=1;
+    }
+    else if (!sname) sname = p;
+         else
+         {
+           usage();
+           return -1;
+         }
+  }
+
+  if(!sname)
+  {
+    usage();
+    return -1;
+  }
+
+  loginit(q);
+
+  if(init(sname, baud) < 0)
+  {
+    logerr("Init error.");
+    return -2;
+  }
+
+  if(q<2)
+  {
+    printf("ZX-Spectrum Internet Controller Emulator v0.2.\n");
+    printf("Serial device used: %s at %d baud.\n", sname, baud);
+  }
+
+  process();
+  return 0;
+}
+

_rs232/ic_emul_0.2/log.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+int loglvl=0;
+
+void loginit(int lvl)
+{
+  loglvl=lvl;
+}
+
+void log_(const char *fmt, ...)
+{
+  if(loglvl>0)
+    return;
+#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(loglvl>1)
+    return;
+#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_0.2/log.h

@@ -0,0 +1,7 @@
+
+
+void loginit(int lvl);
+void log_(const char *fmt, ...);
+void logerr(const char *fmt, ...);
+
+

_rs232/ic_emul_0.2/make.bat

@@ -0,0 +1,12 @@
+@echo off
+
+set TOOLS_PATH=D:\proj\zx\floppy-disk-ripper\_tools
+
+set GCC_PATH=%TOOLS_PATH%\mingw\bin;%TOOLS_PATH%\mingw\msys\1.0\bin
+set PATH=%GCC_PATH%;%PATH%
+
+gcc -Wall -Wno-pointer-sign -c ic_main.c -o ic_main.o
+gcc -Wall -Wno-pointer-sign -c ic_cmds.c -o ic_cmds.o 
+gcc -Wall -Wno-pointer-sign -c log.c -o log.o
+gcc -Wall -Wno-pointer-sign -c uart_win.c -o uart.o
+gcc ic_main.o ic_cmds.o log.o uart.o  -lws2_32 -o ic.exe

_rs232/ic_emul_0.2/make.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+gcc -Wall -Wno-pointer-sign -c ic_main.c -o ic_main.o
+gcc -Wall -Wno-pointer-sign -c ic_cmds.c -o ic_cmds.o
+gcc -Wall -Wno-pointer-sign -c log.c -o log.o
+gcc -Wall -Wno-pointer-sign -c uart_lin.c -o uart.o
+
+gcc ic_main.o ic_cmds.o log.o uart.o  -o ic

_rs232/ic_emul_0.2/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_0.2/uart.h

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

_rs232/ic_emul_0.2/uart_lin.c

@@ -0,0 +1,91 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <stdio.h>
+#include <strings.h>
+#include <unistd.h>
+
+#include "uart.h"
+
+#define BAUD_ERROR -1U
+int fd;
+extern int debug;
+
+
+static tcflag_t get_baud(int baud)
+{
+  switch(baud)
+  {
+    case 115200: return B115200;
+    case 57600:  return B57600;
+    case 38400:  return B38400;
+    case 19200:  return B19200;
+    case 9600:   return B9600;
+    case 4800:   return B4800;
+    case 2400:   return B2400;
+    case 1200:   return B1200;
+    default:     return BAUD_ERROR;
+  }
+}
+
+
+//init uart
+int uart_init(char *sname, int baud)
+{
+  struct termios /*otio,*/ ntio;
+  tcflag_t BAUD;
+
+  //check/get baud rate
+  BAUD = get_baud(baud);
+  if(BAUD==BAUD_ERROR) return -1;
+
+  //open tty
+  fd = open(sname, O_RDWR | O_NOCTTY);
+  if(fd<0) return -1;
+
+  //save current port settings
+  //tcgetattr(fd,&otio);
+
+  //set config
+  bzero(&ntio, sizeof(ntio));
+  ntio.c_cflag = BAUD |     //baud rate
+                 CS8 |      //8n1
+                 CLOCAL |   //local connection, no modem control
+                 CREAD;     //enable receiving characters
+  ntio.c_iflag = IGNPAR;    //ignore bytes with parity errors
+  ntio.c_oflag = 0;         //raw output
+  ntio.c_lflag = 0;         //non-canonical input
+
+  ntio.c_cc[VMIN] = 1;      //wait for 1 byte minimum
+
+  //flush and apply new settings
+  tcflush(fd, TCIFLUSH);
+  tcsetattr(fd,TCSANOW,&ntio);
+  return 0;
+}
+
+
+//read bytes
+void uart_read(char *buf, int len)
+{
+  unsigned long s=0;
+
+  while(s<len)
+  {
+    s+=read(fd,&buf[s],len-s);
+  }
+  if(debug){printf("read: ");for(s=0;s<len;s++) printf("%02x ",(unsigned char)buf[s]); printf("\n");}
+}
+
+//write bytes
+void uart_write(char *buf, int len)
+{
+  int s;
+
+  if(debug){printf("write: ");for(s=0;s<len;s++) printf("%02x ",(unsigned char)buf[s]); printf("\n");}
+  write(fd,buf,len);
+}
+
+
+

_rs232/ic_emul_0.2/uart_win.c

@@ -0,0 +1,106 @@
+#include <windows.h>
+#include <stdio.h>
+
+HANDLE port;
+DCB dcb;
+COMMTIMEOUTS touts;
+extern int debug;
+
+#define BAUD_ERROR -1U
+
+
+static DWORD get_baud(int baud)
+{
+  switch(baud)
+  {
+    case 115200: return CBR_115200;
+    case 57600:  return CBR_57600;
+    case 38400:  return CBR_38400;
+    case 19200:  return CBR_19200;
+    case 9600:   return CBR_9600;
+    case 4800:   return CBR_4800;
+    case 2400:   return CBR_2400;
+    case 1200:   return CBR_1200;
+    default:     return BAUD_ERROR;
+  }
+}
+
+
+
+
+
+//init uart
+int uart_init(char *sname, int baud)
+{
+  char buf[16], *p;
+  DWORD CBR;
+
+  //fix COMx name to \\.\COMx
+  if(strncasecmp(sname,"com",3)==0 && strlen(sname)<7)
+  {
+    sprintf(buf,"\\\\.\\%s",sname);
+    p=buf;
+  }
+  else
+  {
+    p=sname;
+  }
+
+  //check/get baud rate
+  CBR = get_baud(baud);
+  if(CBR==BAUD_ERROR) return -1;
+
+  //open serial line
+  port = CreateFile(p, GENERIC_READ | GENERIC_WRITE,
+      FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, NULL);
+  if (port==INVALID_HANDLE_VALUE) return -1;
+
+  //set config
+  if (GetCommState(port, &dcb))
+  {
+     dcb.BaudRate = CBR; //CBR_57600; //CBR_115200;
+     dcb.ByteSize = 8; dcb.Parity = 0; dcb.StopBits = 0;
+     dcb.fAbortOnError = 0;
+     SetCommState(port, &dcb);
+  }
+
+  //set timeouts
+  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 bytes
+void uart_read(char *buf, int len)
+{
+  unsigned long nread=0,s;
+
+  for(s=0; s<len;)
+  {
+    ReadFile(port, &buf[s], len-s, &nread, NULL);
+    s+=nread;
+  }
+  if(debug){printf("read: ");for(s=0;s<len;s++) printf("%02x ",(unsigned char)buf[s]); printf("\n");}
+}
+
+
+//write bytes
+void uart_write(char *buf, int len)
+{
+  unsigned long nread=0,s;
+
+  if(debug){printf("write: ");for(s=0;s<len;s++) printf("%02x ",(unsigned char)buf[s]); printf("\n");}
+  WriteFile(port, buf, len, &nread, NULL);
+}
+