home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / k95source / ckotcp.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. {
  52.   struct sockaddr_in addr;
  53.  
  54.   memset(&addr, 0, sizeof(addr));
  55.   addr.sin_port        = ((struct ck_sockaddr_in *) name) -> sin_port;
  56.   addr.sin_family      = ((struct ck_sockaddr_in *) name) -> sin_family;
  57.   addr.sin_addr.s_addr = ((struct ck_sockaddr_in *) name) -> sin_addr.s_addr;
  58.  
  59.   return connect(socket, (struct sockaddr *) &addr, sizeof(addr));
  60. }
  61.  
  62. int ENTRY ck_ioctl(int socket, int cmd, char *data, int length)
  63. {
  64.   switch (cmd)
  65.   {
  66.   case CK_FIONREAD:
  67.     cmd = FIONREAD;
  68.     break;
  69.   case CK_FIONBIO:
  70.     cmd = FIONBIO;
  71.     break;
  72.   default:
  73.     return -1;
  74.   }
  75.  
  76.   return ioctl(socket, cmd, data, length);
  77. }
  78.  
  79. int ENTRY ck_recv(int socket, char *buffer, int length, int flags)
  80. {
  81.   if (flags != 0)
  82.     return -1;
  83.  
  84.   return recv(socket, buffer, length, flags);
  85. }
  86.  
  87. int ENTRY ck_select(int *fds, int read, int write, int except, long timeout)
  88. {
  89.   /* Warning: if the called select is 16-bit but the calling code is
  90.    * 32-bit, only one fd can be pointed to by fds! However, calling
  91.    * with one "read" socket is the only use of select() in
  92.    * C-Kermit. Might change in the future, so this must be checked. */
  93.  
  94. #ifdef BSD_SELECT
  95.   fd_set rfds;
  96.   struct timeval tv;
  97.   int socket = *fds;
  98. #endif
  99.  
  100.   if (read != 1 && write != 0 && except != 0)
  101.     return -1;
  102.  
  103. #ifdef BSD_SELECT
  104.   FD_ZERO(&rfds);
  105.   FD_SET(socket, &rfds);
  106.   tv.tv_sec = tv.tv_usec = 0L;
  107.  
  108.   if (timeout < 1000)
  109.     tv.tv_usec = (long) timeout * 1000L;
  110.   else
  111.     tv.tv_sec = timeout;
  112.  
  113.   return select(FD_SETSIZE, &rfds, NULL, NULL, &tv) && FD_ISSET(socket, &rfds);
  114. #else
  115.   return select(FDPTR fds, read, write, except, timeout);
  116. #endif
  117. }
  118.  
  119. int ENTRY ck_send(int socket, char *buffer, int length, int flags)
  120. {
  121.   if (flags != 0)
  122.     return -1;
  123.  
  124.   return send(socket, buffer, length, flags);
  125. }
  126.  
  127. int ENTRY ck_setsockopt(int socket, int level, int optname,
  128.                   char *optvalue, int optlength)
  129. {
  130.   if (level == CK_SOL_SOCKET)
  131.     level = SOL_SOCKET;
  132.   else
  133.     return -1;
  134.  
  135.   if (optname == CK_SO_OOBINLINE)
  136.     optname = SO_OOBINLINE;
  137.   else
  138.     return -1;
  139.  
  140.   return setsockopt(socket, level, optname, optvalue, optlength);
  141. }
  142.  
  143. int ENTRY ck_socket(int domain, int type, int protocol)
  144. {
  145.   if (domain == CK_AF_INET)
  146.     domain = AF_INET;
  147.   else
  148.     return -1;
  149.  
  150.   if (type == CK_SOCK_STREAM)
  151.     type = SOCK_STREAM;
  152.   else
  153.     return -1;
  154.  
  155.   if (protocol != 0)
  156.     return -1;
  157.  
  158.   return socket(domain, type, protocol);
  159. }
  160.  
  161. int ENTRY ck_soclose(int socket)
  162. {
  163.   return soclose(socket);
  164. }
  165.  
  166. /* utility calls */
  167.  
  168. struct ck_hostent * ENTRY ck_gethostbyname(char *name)
  169. {
  170.   struct hostent *host = gethostbyname(name);
  171.   static struct ck_hostent ckhost;
  172.  
  173.   if (host == NULL)
  174.     return NULL;
  175.  
  176.   ckhost.h_name     = host -> h_name;
  177.   ckhost.h_aliases  = NULL;
  178.   ckhost.h_addrtype = host -> h_addrtype;
  179.   ckhost.h_length   = host -> h_length;
  180.   ckhost.h_address  = host -> h_addr;
  181.  
  182.   return &ckhost;
  183. }
  184.  
  185. struct ck_servent * ENTRY ck_getservbyname(char *name, char *protocol)
  186. {
  187.   PACKED struct servent *serv = getservbyname(name, protocol);
  188.   static struct ck_servent ckserv;
  189.  
  190.   if (serv == NULL)
  191.     return NULL;
  192.  
  193.   ckserv.s_name    = serv -> s_name;
  194.   ckserv.s_aliases = NULL;
  195.   ckserv.s_port    = serv -> s_port;
  196.   ckserv.s_proto   = serv -> s_proto;
  197.  
  198.   return &ckserv;
  199. }
  200.  
  201. unsigned long ENTRY ck_inet_addr(char *cp)
  202. {
  203.   return inet_addr(cp);
  204. }
  205.  
  206. char * ENTRY ck_inet_ntoa(struct ck_in_addr in)
  207. {
  208.   struct in_addr addr;
  209.  
  210.   addr.s_addr = in.s_addr;
  211.  
  212.   return inet_ntoa(addr);
  213. }
  214.  
  215. /* end of ckotcp.c */
  216.