home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / archives / k95source.tar.gz / k95source.tar / ckoftp.c < prev    next >
C/C++ Source or Header  |  2011-07-19  |  8KB  |  377 lines
  1. /* ckoftp.c
  2.  *
  3.  * TCP/IP interface DLL between C-Kermit and FTP PC/TCP
  4.  *
  5.  */
  6.  
  7. /*
  8.   Author: Jeffrey Altman (jaltman@secure-endpoints.com)
  9.             Secure Endpoints Inc., New York City
  10.  
  11.   Copyright (C) 1985, 2004, Trustees of Columbia University in the City of New
  12.   York.
  13. */
  14.  
  15. /* PCTCP include file */
  16. #define INCL_DOSEXCEPTIONS
  17. #include <pctcp.h>
  18.  
  19. /* BSD include files  */
  20. #include <sys/socket.h>
  21. #include <netinet/in.h>
  22. #include <net\if.h>
  23. #include <netdb.h>
  24.  
  25. #ifndef __IBMC__
  26. #include <stddef.h>
  27. #include <memory.h>
  28. #endif
  29.  
  30. #define CK_DLL
  31. #include "ckotcp.h"
  32.  
  33. int ENTRY ck_sockinit(void)
  34. {
  35.   /* no sock_init() in ftp pc/tcp */
  36.   return 0;
  37. }
  38.  
  39. /* socket calls */
  40.  
  41. int ENTRY ck_connect(int socket, struct ck_sockaddr *name, int namelen)
  42. {
  43.   struct sockaddr_in addr;
  44.  
  45.   memset(&addr, 0, sizeof(addr));
  46.   addr.sin_port        = ((struct ck_sockaddr_in *) name) -> sin_port;
  47.   addr.sin_family      = ((struct ck_sockaddr_in *) name) -> sin_family;
  48.   addr.sin_addr.s_addr = ((struct ck_sockaddr_in *) name) -> sin_addr.s_addr;
  49.  
  50.   return connect(socket, (struct sockaddr *) &addr, sizeof(addr));
  51. }
  52.  
  53. int ENTRY ck_bind(int socket, struct ck_sockaddr *name, int namelen)
  54. {
  55.   struct sockaddr_in addr;
  56.  
  57.   memset(&addr, 0, sizeof(addr));
  58.   addr.sin_port        = ((struct ck_sockaddr_in *) name) -> sin_port;
  59.   addr.sin_family      = ((struct ck_sockaddr_in *) name) -> sin_family;
  60.   addr.sin_addr.s_addr = ((struct ck_sockaddr_in *) name) -> sin_addr.s_addr;
  61.  
  62.   return bind(socket, (struct sockaddr *) &addr, sizeof(addr));
  63. }
  64.  
  65. int ENTRY ck_listen(int socket, int backlog)
  66. {
  67.     return listen( socket, backlog );
  68. }
  69.  
  70. int ENTRY ck_accept(int socket, struct ck_sockaddr *name, int * namelen)
  71. {
  72.   struct sockaddr_in addr;
  73.   int rc = 0 ;
  74.   short len = sizeof(addr);
  75.  
  76.   memset(&addr, 0, sizeof(addr));
  77.   addr.sin_port        = ((struct ck_sockaddr_in *) name) -> sin_port;
  78.   addr.sin_family      = ((struct ck_sockaddr_in *) name) -> sin_family;
  79.   addr.sin_addr.s_addr = ((struct ck_sockaddr_in *) name) -> sin_addr.s_addr;
  80.  
  81.   rc = accept(socket, (struct sockaddr *) &addr, &len);
  82.   *namelen = len ;
  83.   ((struct ck_sockaddr_in *) name) -> sin_port = addr.sin_port ;
  84.   ((struct ck_sockaddr_in *) name) -> sin_family = addr.sin_family ;
  85.   ((struct ck_sockaddr_in *) name) -> sin_addr.s_addr = addr.sin_addr.s_addr;
  86.  
  87.   return rc ;
  88. }
  89.  
  90. int ENTRY ck_ioctl(int socket, int cmd, long *data)
  91. {
  92.     long dat = *data ;
  93.     int rc = 0 ;
  94.  
  95.     switch (cmd)
  96.     {
  97.       case CK_FIONREAD:
  98.           cmd = FIONREAD;
  99.           break;
  100.       case CK_FIONBIO:
  101.           cmd = FIONBIO;
  102.           break;
  103.       case CK_SIOCATMARK:
  104.           cmd = SIOCATMARK;
  105.           break;
  106.       default:
  107.           return -1;
  108.     }
  109.  
  110.     rc =  ioctl(socket, cmd, (char *)&dat);
  111.     *data = dat ;
  112.     return rc;
  113. }
  114.  
  115. int ENTRY ck_recv(int socket, char *buffer, int length, int flags)
  116. {
  117.   return recv(socket, buffer, length,flags);
  118. }
  119.  
  120. int ENTRY ck_select(int *fds, int read, int write, int except, long timeout)
  121. {
  122.   /* Warning: if the called select is 16-bit but the calling code is
  123.    * 32-bit, only one fd can be pointed to by fds! However, calling
  124.    * with one "read" socket is the only use of select() in
  125.    * C-Kermit. Might change in the future, so this must be checked. */
  126.  
  127.   int rc ;
  128.   ULONG nestings ;  /* MustComplete sections */
  129.  
  130.   fd_set rfds;
  131.   struct timeval tv;
  132.   int socket = *fds;
  133.  
  134.   if ((read + write + except) != 1)
  135.     return -1;
  136.  
  137.   FD_ZERO(&rfds);
  138.   FD_SET(socket, &rfds);
  139.   tv.tv_sec = tv.tv_usec = 0L;
  140.  
  141.   if (timeout < 1000)
  142.     tv.tv_usec = (long) timeout * 1000L;
  143.   else
  144.     tv.tv_sec = timeout / 1000L ;
  145.  
  146.   rc =  (read ? select(FD_SETSIZE, &rfds, NULL, NULL, &tv) : 1) &&
  147.         (write ? select(FD_SETSIZE, NULL, &rfds, NULL, &tv) : 1) &&
  148.         (except ? select(FD_SETSIZE, NULL, NULL, &rfds, &tv) : 1) &&
  149.             FD_ISSET(socket, &rfds);
  150.     return rc ;
  151. }
  152.  
  153. int ENTRY ck_send(int socket, char *buffer, int length, int flags)
  154. {
  155.   return send(socket, buffer, length,flags);
  156. }
  157.  
  158. int ENTRY ck_setsockopt(int socket, int level, int optname,
  159.                   char *optvalue, int optlength)
  160. {
  161.     int rc=0;
  162.     short  optname16;
  163.     char * optvalue16;
  164.     short  optlength16;
  165.  
  166.     short  optval16;
  167.  
  168.     if (level == CK_SOL_SOCKET)
  169.         level = SOL_SOCKET;
  170.     else
  171.         return -1;
  172.  
  173.     switch ( optname )
  174.     {
  175.     case CK_SO_OOBINLINE:
  176.         optname16 = SO_OOBINLINE ;
  177.         optval16 = (short)*((int *)optvalue);
  178.         rc = setsockopt(socket, level, optname16, &optval16, optlength);
  179.         break;
  180.     case CK_SO_REUSEADDR:
  181.         optname16 = SO_REUSEADDR ;
  182.         break;
  183.     case CK_SO_LINGER:
  184.         optname16 = SO_LINGER ;
  185.         break;
  186.     case CK_SO_KEEPALIVE:
  187.         optname16 = SO_KEEPALIVE ;
  188.         break;
  189.     case CK_SO_SNDBUF:
  190.         optname16 = SO_SNDBUF ;
  191.         break;
  192.     case CK_SO_RCVBUF:
  193.         optname16 = SO_RCVBUF ;
  194.         break;
  195.     default:
  196.         return -1;
  197.     }
  198.  
  199.   return rc;
  200. }
  201.  
  202. int ENTRY ck_getsockopt(int socket, int level, int optname,
  203.                   char *optvalue, int * optlength)
  204. {
  205.     short len = *optlength ;
  206.     int rc = 0 ;
  207.  
  208.   if (level == CK_SOL_SOCKET)
  209.     level = SOL_SOCKET;
  210.   else
  211.     return -1;
  212.  
  213.    switch ( optname )
  214.    {
  215.    case CK_SO_OOBINLINE:
  216.       optname = SO_OOBINLINE ;
  217.       break;
  218.    case CK_SO_REUSEADDR:
  219.       optname = SO_REUSEADDR ;
  220.       break;
  221.    case CK_SO_LINGER:
  222.       optname = SO_LINGER ;
  223.       break;
  224.    case CK_SO_KEEPALIVE:
  225.       optname = SO_KEEPALIVE ;
  226.       break;
  227.    case CK_SO_SNDBUF:
  228.       optname = SO_SNDBUF ;
  229.       break;
  230.    case CK_SO_RCVBUF:
  231.       optname = SO_RCVBUF ;
  232.       break;
  233.    default:
  234.       return -1;
  235.    }
  236.  
  237.   rc = getsockopt(socket, level, optname, optvalue, &len);
  238.     *optlength = len ;
  239.     return rc ;
  240. }
  241.  
  242. int ENTRY ck_socket(int domain, int type, int protocol)
  243. {
  244.   if (domain == CK_AF_INET)
  245.     domain = AF_INET;
  246.   else
  247.     return -1;
  248.  
  249.   if (type == CK_SOCK_STREAM)
  250.     type = SOCK_STREAM;
  251.   else
  252.     return -1;
  253.  
  254.   if (protocol != 0)
  255.     return -1;
  256.  
  257.   return socket(domain, type, protocol);
  258. }
  259.  
  260. int ENTRY ck_soclose(int socket)
  261. {
  262.   return closesocket(socket);
  263. }
  264.  
  265. /* utility calls */
  266.  
  267. struct ck_hostent * ENTRY ck_gethostbyname(char *name)
  268. {
  269.   struct hostent *host = gethostbyname(name);
  270.   static struct ck_hostent ckhost;
  271.  
  272.   if (host == NULL)
  273.     return NULL;
  274.  
  275.   ckhost.h_name     = host -> h_name;
  276.   ckhost.h_aliases  = NULL;
  277.   ckhost.h_addrtype = host -> h_addrtype;
  278.   ckhost.h_length   = host -> h_length;
  279.   ckhost.h_addr_list  = host -> h_addr_list;
  280.  
  281.   return &ckhost;
  282. }
  283.  
  284. struct ck_servent * ENTRY ck_getservbyname(char *name, char *protocol)
  285. {
  286.   struct servent *serv = getservbyname(name, protocol);
  287.   static struct ck_servent ckserv;
  288.  
  289.   if (serv == NULL)
  290.     return NULL;
  291.  
  292.   ckserv.s_name    = serv -> s_name;
  293.   ckserv.s_aliases = NULL;
  294.   ckserv.s_port    = serv -> s_port;
  295.   ckserv.s_proto   = serv -> s_proto;
  296.  
  297.   return &ckserv;
  298. }
  299.  
  300. struct ck_hostent * ENTRY ck_gethostbyaddr(char *addr, int len, int net)
  301. {
  302.   struct hostent *host = gethostbyaddr(addr, len, net);
  303.   static struct ck_hostent ckhost;
  304.  
  305.   if (host == NULL)
  306.     return NULL;
  307.  
  308.   ckhost.h_name     = host -> h_name;
  309.   ckhost.h_aliases  = NULL;
  310.   ckhost.h_addrtype = host -> h_addrtype;
  311.   ckhost.h_length   = host -> h_length;
  312.   ckhost.h_addr_list  = host -> h_addr_list;
  313.  
  314.   return &ckhost;
  315. }
  316.  
  317. struct ck_servent * ENTRY ck_getservbyport(int port, char *name)
  318. {
  319.   struct servent *serv = getservbyport(port, name);
  320.   static struct ck_servent ckserv;
  321.  
  322.   if (serv == NULL)
  323.     return NULL;
  324.  
  325.   ckserv.s_name    = serv -> s_name;
  326.   ckserv.s_aliases = NULL;
  327.   ckserv.s_port    = serv -> s_port;
  328.   ckserv.s_proto   = serv -> s_proto;
  329.  
  330.   return &ckserv;
  331. }
  332.  
  333. unsigned long ENTRY ck_inet_addr(char *cp)
  334. {
  335.   return inet_addr(cp);
  336. }
  337.  
  338. char * ENTRY ck_inet_ntoa(struct ck_in_addr in)
  339. {
  340.   struct in_addr addr;
  341.  
  342.   addr.s_addr = in.s_addr;
  343.  
  344.   return inet_ntoa(addr);
  345. }
  346.  
  347. int ENTRY ck_getpeername( int socket, struct ck_sockaddr * name, int * namelen )
  348. {
  349.     int rc ;
  350.     short len = (short) *namelen ;
  351.  
  352.     rc = getpeername( socket, (struct sockaddr *) name, &len ) ;
  353.     *namelen = len ;
  354.     return rc;
  355. }
  356.  
  357. int ENTRY ck_getsockname( int socket, struct ck_sockaddr * name, int * namelen )
  358. {
  359.     int rc ;
  360.     short len = (short) *namelen ;
  361.  
  362.     rc = getsockname( socket, (struct sockaddr *) name, &len ) ;
  363.     *namelen = len ;
  364.     return rc;
  365. }
  366.  
  367. int ENTRY ck_gethostname( char * buf, int len )
  368. {
  369.     int rc ;
  370.     short slen = (short) len ;
  371.  
  372.     rc = gethostname( buf, slen ) ;
  373.     return rc;
  374. }
  375.  
  376. /* end of ckotcp.c */
  377.