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