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