home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / old / ckermit5a190 / ckoibm.c < prev    next >
C/C++ Source or Header  |  2020-01-01  |  4KB  |  216 lines

  1. /* ckotcp.c
  2.  *
  3.  * TCP/IP interface DLL between C-Kermit and IBM TCP/IP
  4.  *
  5.  * Author:  Kai-Uwe Rommel <rommel@ars.muc.de>
  6.  * Created: Wed May 25 1994
  7.  */
  8.  
  9. #include <stdlib.h>
  10. #include <memory.h>
  11. #include <sys/types.h>
  12.  
  13. #ifdef __IBMC__
  14. #define off_t _dummy_off_t  /* avoid warning */
  15. #include <types.h>
  16. #undef off_t
  17. #else
  18. #define far _far
  19. #define cdecl _cdecl
  20. #include <types.h>
  21. #endif
  22.  
  23. #ifdef __TYPES_32H
  24. #define FDPTR                                  /* TCP/IP 2.0 */
  25. #define PACKED
  26. #else
  27. #define FDPTR (short * _Seg16)                 /* TCP/IP 1.2.1 */
  28. #define PACKED _Packed
  29. #endif
  30.  
  31. #include <netinet/in.h>
  32. #include <netdb.h>
  33. #include <sys/ioctl.h>
  34. #include <sys/socket.h>
  35.  
  36. #define BSD_SELECT
  37. #include <sys/time.h>
  38. #include <sys/select.h>
  39.  
  40. #define CK_DLL
  41. #include "ckotcp.h"
  42.  
  43. int ENTRY ck_sockinit(void)
  44. {
  45.   return sock_init();
  46. }
  47.  
  48. /* socket calls */
  49.  
  50. int ENTRY ck_connect(int socket, struct ck_sockaddr *name, int namelen)
  51.   struct sockaddr_in addr;
  52.  
  53.   memset(&addr, 0, sizeof(addr));
  54.   addr.sin_port        = ((struct ck_sockaddr_in *) name) -> sin_port;
  55.   addr.sin_family      = ((struct ck_sockaddr_in *) name) -> sin_family;
  56.   addr.sin_addr.s_addr = ((struct ck_sockaddr_in *) name) -> sin_addr.s_addr;
  57.  
  58.   return connect(socket, (struct sockaddr *) &addr, sizeof(addr)); 
  59. }
  60.  
  61. int ENTRY ck_ioctl(int socket, int cmd, char *data, int length)
  62. {
  63.   switch (cmd)
  64.   {
  65.   case CK_FIONREAD:
  66.     cmd = FIONREAD;
  67.     break;
  68.   case CK_FIONBIO:
  69.     cmd = FIONBIO;
  70.     break;
  71.   default:
  72.     return -1;
  73.   }
  74.  
  75.   return ioctl(socket, cmd, data, length); 
  76. }
  77.  
  78. int ENTRY ck_recv(int socket, char *buffer, int length, int flags)
  79. {
  80.   if (flags != 0)
  81.     return -1;
  82.  
  83.   return recv(socket, buffer, length, flags); 
  84. }
  85.  
  86. int ENTRY ck_select(int *fds, int read, int write, int except, long timeout)
  87. {
  88.   /* Warning: if the called select is 16-bit but the calling code is
  89.    * 32-bit, only one fd can be pointed to by fds! However, calling
  90.    * with one "read" socket is the only use of select() in
  91.    * C-Kermit. Might change in the future, so this must be checked. */
  92.  
  93. #ifdef BSD_SELECT
  94.   fd_set rfds;
  95.   struct timeval tv;
  96.   int socket = *fds;
  97. #endif
  98.  
  99.   if (read != 1 && write != 0 && except != 0)
  100.     return -1;
  101.  
  102. #ifdef BSD_SELECT
  103.   FD_ZERO(&rfds);
  104.   FD_SET(socket, &rfds);
  105.   tv.tv_sec = tv.tv_usec = 0L;
  106.  
  107.   if (timeout < 1000)
  108.     tv.tv_usec = (long) timeout * 1000L;
  109.   else
  110.     tv.tv_sec = timeout;
  111.  
  112.   return select(FD_SETSIZE, &rfds, NULL, NULL, &tv) && FD_ISSET(socket, &rfds);
  113. #else
  114.   return select(FDPTR fds, read, write, except, timeout); 
  115. #endif
  116. }
  117.  
  118. int ENTRY ck_send(int socket, char *buffer, int length, int flags)
  119. {
  120.   if (flags != 0)
  121.     return -1;
  122.  
  123.   return send(socket, buffer, length, flags); 
  124. }
  125.  
  126. int ENTRY ck_setsockopt(int socket, int level, int optname, 
  127.           char *optvalue, int optlength)
  128. {
  129.   if (level == CK_SOL_SOCKET)
  130.     level = SOL_SOCKET;
  131.   else
  132.     return -1;
  133.  
  134.   if (optname == CK_SO_OOBINLINE)
  135.     optname = SO_OOBINLINE;
  136.   else
  137.     return -1;
  138.  
  139.   return setsockopt(socket, level, optname, optvalue, optlength); 
  140. }
  141.  
  142. int ENTRY ck_socket(int domain, int type, int protocol)
  143. {
  144.   if (domain == CK_AF_INET)
  145.     domain = AF_INET;
  146.   else
  147.     return -1;
  148.  
  149.   if (type == CK_SOCK_STREAM)
  150.     type = SOCK_STREAM;
  151.   else
  152.     return -1;
  153.  
  154.   if (protocol != 0)
  155.     return -1;
  156.  
  157.   return socket(domain, type, protocol); 
  158. }
  159.  
  160. int ENTRY ck_soclose(int socket)
  161. {
  162.   return soclose(socket); 
  163. }
  164.  
  165. /* utility calls */
  166.  
  167. struct ck_hostent * ENTRY ck_gethostbyname(char *name)
  168.   struct hostent *host = gethostbyname(name);
  169.   static struct ck_hostent ckhost;
  170.  
  171.   if (host == NULL)
  172.     return NULL;
  173.  
  174.   ckhost.h_name     = host -> h_name;
  175.   ckhost.h_aliases  = NULL;
  176.   ckhost.h_addrtype = host -> h_addrtype;
  177.   ckhost.h_length   = host -> h_length;
  178.   ckhost.h_address  = host -> h_addr;
  179.  
  180.   return &ckhost; 
  181. }
  182.  
  183. struct ck_servent * ENTRY ck_getservbyname(char *name, char *protocol)
  184. {
  185.   PACKED struct servent *serv = getservbyname(name, protocol);
  186.   static struct ck_servent ckserv;
  187.  
  188.   if (serv == NULL)
  189.     return NULL;
  190.  
  191.   ckserv.s_name    = serv -> s_name;
  192.   ckserv.s_aliases = NULL;
  193.   ckserv.s_port    = serv -> s_port;
  194.   ckserv.s_proto   = serv -> s_proto;
  195.  
  196.   return &ckserv; 
  197. }
  198.  
  199. unsigned long ENTRY ck_inet_addr(char *cp)
  200. {
  201.   return inet_addr(cp); 
  202. }
  203.  
  204. char * ENTRY ck_inet_ntoa(struct ck_in_addr in)
  205. {
  206.   struct in_addr addr;
  207.  
  208.   addr.s_addr = in.s_addr;
  209.  
  210.   return inet_ntoa(addr); 
  211. }
  212.  
  213. /* end of ckotcp.c */
  214.