home *** CD-ROM | disk | FTP | other *** search
/ What PC? 1996 April / WHAT_PC_APR_96.ISO / internet / twinsock / src / commands.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-24  |  21.5 KB  |  996 lines
  1. /*
  2.  *  TwinSock - "Troy's Windows Sockets"
  3.  *
  4.  *  Copyright (C) 1994-1995  Troy Rollo <troy@cbme.unsw.EDU.AU>
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the license in the file LICENSE.TXT included
  8.  *  with the TwinSock distribution.
  9.  *
  10.  *  This program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
  13.  */
  14.  
  15. #include <stdio.h>
  16. #include <sys/types.h>
  17. #include <netinet/in.h>
  18. #include <netdb.h>
  19. #include <errno.h>
  20. #include <sys/socket.h>
  21. #include "twinsock.h"
  22. #include "tx.h"
  23. #include "wserror.h"
  24.  
  25. #ifdef NEED_H_ERRNO
  26. extern int h_errno;
  27. #endif
  28. #ifdef NO_H_ERRNO
  29. #define h_errno errno
  30. #endif
  31.  
  32. #ifndef AF_UNSPEC
  33. #define    AF_UNSPEC    0
  34. #endif
  35. #ifndef AF_UNIX
  36. #define AF_UNIX        -1
  37. #endif
  38. #ifndef AF_INET
  39. #define AF_INET        -1
  40. #endif
  41. #ifndef AF_IMPLINK
  42. #define AF_IMPLINK      -1
  43. #endif
  44. #ifndef AF_PUP
  45. #define AF_PUP          -1
  46. #endif
  47. #ifndef AF_CHAOS
  48. #define AF_CHAOS        -1
  49. #endif
  50. #ifndef AF_NS
  51. #define AF_NS          -1
  52. #endif
  53. #ifndef AF_ISO
  54. #define AF_ISO          -1
  55. #endif
  56. #ifndef AF_ECMA
  57. #define AF_ECMA         -1
  58. #endif
  59. #ifndef AF_DATAKIT
  60. #define AF_DATAKIT      -1
  61. #endif
  62. #ifndef AF_CCITT
  63. #define AF_CCITT        -1
  64. #endif
  65. #ifndef AF_SNA
  66. #define AF_SNA          -1
  67. #endif
  68. #ifndef AF_DECnet
  69. #define AF_DECnet       -1
  70. #endif
  71. #ifndef AF_DLI
  72. #define AF_DLI          -1
  73. #endif
  74. #ifndef AF_LAT
  75. #define AF_LAT          -1
  76. #endif
  77. #ifndef AF_HYLINK
  78. #define AF_HYLINK       -1
  79. #endif
  80. #ifndef AF_APPLETALK
  81. #define AF_APPLETALK    -1
  82. #endif
  83. #ifndef AF_NETBIOS
  84. #define AF_NETBIOS    -1
  85. #endif
  86.  
  87. #define    rangeof(x)    (sizeof(x) / sizeof(x[0]))
  88.  
  89. static int HostSocketFamily[] =
  90. {
  91.     AF_UNSPEC,                    /* unspecified */
  92.     AF_UNIX,                    /* local to host (pipes, portals) */
  93.     AF_INET,                    /* internetwork: UDP, TCP, etc. */
  94.     AF_IMPLINK,                    /* arpanet imp addresses */
  95.     AF_PUP,                         /* pup protocols: e.g. BSP */
  96.     AF_CHAOS,                    /* mit CHAOS protocols */
  97.     AF_NS,                         /* NS, IPX and SPX */
  98.     AF_ISO,                         /* ISO protocols */
  99.     AF_ECMA,                    /* european computer manufacturers */
  100.     AF_DATAKIT,                    /* datakit protocols */
  101.     AF_CCITT,                    /* CCITT protocols, X.25 etc */
  102.     AF_SNA,                            /* IBM SNA */
  103.     AF_DECnet,                    /* DECnet */
  104.     AF_DLI,                            /* Direct data link interface */
  105.     AF_LAT,                            /* LAT */
  106.     AF_HYLINK,                    /* NSC Hyperchannel */
  107.     AF_APPLETALK,                    /* AppleTalk */
  108.     AF_NETBIOS                    /* NetBios-style addresses */
  109. };
  110.  
  111. static int HostSocketType[] =
  112. {
  113.     0,
  114.     SOCK_STREAM,
  115.     SOCK_DGRAM,
  116.     SOCK_RAW,
  117.         SOCK_RDM,
  118.     SOCK_SEQPACKET
  119. };
  120.  
  121. #ifndef IPPROTO_IP
  122. #define IPPROTO_IP 0
  123. #endif
  124. #ifndef IPPROTO_ICMP
  125. #define IPPROTO_ICMP 1
  126. #endif
  127. #ifndef IPPROTO_GGP
  128. #define IPPROTO_GGP 2
  129. #endif
  130. #ifndef IPPROTO_TCP
  131. #define IPPROTO_TCP 6
  132. #endif
  133. #ifndef IPPROTO_PUP
  134. #define IPPROTO_PUP 12
  135. #endif
  136. #ifndef IPPROTO_UDP
  137. #define IPPROTO_UDP 18
  138. #endif
  139. #ifndef IPPROTO_ND
  140. #define IPPROTO_ND 77
  141. #endif
  142.  
  143. static int HostSocketProtocol[] =
  144. {
  145.     IPPROTO_IP, IPPROTO_ICMP, IPPROTO_GGP, 3, 4,
  146.     5, IPPROTO_TCP, 7, 8, 9,
  147.     10, 11, IPPROTO_PUP, 13, 14, 15, 16, IPPROTO_UDP, 18, 19,
  148.     20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  149.     30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
  150.     40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
  151.     50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
  152.     60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
  153.     70, 71, 72, 73, 74, 75, 76, IPPROTO_ND, 78, 79
  154. };
  155.  
  156.  
  157. #ifndef SO_ACCEPTCONN
  158. #define    SO_ACCEPTCONN 0
  159. #endif
  160. #ifndef SO_USELOOPBACK
  161. #define    SO_USELOOPBACK 0
  162. #endif
  163.  
  164. static struct
  165. {
  166.  int iWindows;
  167.  int iHost;
  168. } HostSocketOption[] =
  169. {
  170.     { 0x0001,    SO_DEBUG    },
  171.     { 0x0002,    SO_ACCEPTCONN    },
  172.     { 0x0004,    SO_REUSEADDR    },
  173.     { 0x0008,    SO_KEEPALIVE    },
  174.     { 0x0010,    SO_DONTROUTE    },
  175.     { 0x0020,    SO_BROADCAST    },
  176.     { 0x0040,    SO_USELOOPBACK    },
  177.     { 0x0080,    SO_LINGER    },
  178.     { 0x0100,    SO_OOBINLINE    }
  179. };
  180.  
  181. static int
  182. GetFamily(int x)
  183. {
  184.     return (x < rangeof(HostSocketFamily)) ? HostSocketFamily[x] : x;
  185. }
  186.  
  187. static int
  188. RevFamily(int x)
  189. {
  190.     int i;
  191.  
  192.     for (i = 0; i < rangeof(HostSocketFamily); i++)
  193.     {
  194.         if (HostSocketFamily[i] == x)
  195.             return i;
  196.     }
  197.     return x;
  198. }
  199.  
  200. static int
  201. GetType(int x)
  202. {
  203.     return (x < rangeof(HostSocketType)) ? HostSocketType[x] : x;
  204. }
  205.  
  206. static int
  207. GetProtocol(int x)
  208. {
  209.     return (x < rangeof(HostSocketProtocol)) ? HostSocketProtocol[x] : x;
  210. }
  211.  
  212. static    int
  213. GetOption(int x)
  214. {
  215.     int    iOption = 0;
  216.     int    i;
  217.  
  218.     for (i = 0; i < rangeof(HostSocketOption); i++)
  219.     {
  220.         if (x & HostSocketOption[i].iWindows)
  221.             iOption |= HostSocketOption[i].iHost;
  222.     }
  223.     return iOption;
  224. }
  225.  
  226. extern void PacketTransmitData (void *pvData, int iDataLen, int iStream);
  227.  
  228. struct
  229. {
  230.     int    iErrnoHost;
  231.     int    iErrnoDos;
  232. } error_mappings[] =
  233. {
  234.     { 0,        0        },
  235.     { EINTR,    WSAEINTR    },
  236.     { EBADF,    WSAEBADF    },
  237.     { EINVAL,    WSAEINVAL    },
  238.     { EMFILE,    WSAEMFILE    },
  239.     { EWOULDBLOCK,    WSAEWOULDBLOCK    },
  240.     { EINPROGRESS,    WSAEINPROGRESS    },
  241.     { EALREADY,    WSAEALREADY    },
  242.     { ENOTSOCK,    WSAENOTSOCK    },
  243.     { EDESTADDRREQ,    WSAEDESTADDRREQ },
  244.     { EMSGSIZE,    WSAEMSGSIZE    },
  245.     { EPROTOTYPE,    WSAEPROTOTYPE    },
  246.     { ENOPROTOOPT,    WSAENOPROTOOPT    },
  247.     { EPROTONOSUPPORT, WSAEPROTONOSUPPORT },
  248.     { ESOCKTNOSUPPORT, WSAESOCKTNOSUPPORT },
  249.     { EOPNOTSUPP,    WSAEOPNOTSUPP    },
  250.     { EPFNOSUPPORT,    WSAEPFNOSUPPORT },
  251.     { EAFNOSUPPORT, WSAEAFNOSUPPORT },
  252.     { EADDRINUSE,    WSAEADDRINUSE    },
  253.     { EADDRNOTAVAIL,WSAEADDRNOTAVAIL },
  254.     { ENETDOWN,    WSAENETDOWN    },
  255.     { ENETUNREACH,    WSAENETUNREACH    },
  256.     { ENETRESET,    WSAENETRESET    },
  257.     { ECONNABORTED,    WSAECONNABORTED    },
  258.     { ECONNRESET,    WSAECONNRESET    },
  259.     { ENOBUFS,    WSAENOBUFS    },
  260.     { EISCONN,    WSAEISCONN    },
  261.     { ENOTCONN,    WSAENOTCONN    },
  262.     { ESHUTDOWN,    WSAESHUTDOWN    },
  263.     { ETOOMANYREFS,    WSAETOOMANYREFS    },
  264.     { ETIMEDOUT,    WSAETIMEDOUT    },
  265.     { ECONNREFUSED,    WSAECONNREFUSED    },
  266.     { ELOOP,    WSAELOOP,    },
  267.     { ENAMETOOLONG,    WSAENAMETOOLONG    },
  268.     { EHOSTDOWN,    WSAEHOSTDOWN    },
  269.     { EHOSTUNREACH,    WSAEHOSTUNREACH    },
  270.     { -1,        -1        }
  271. }, h_error_mappings[] =
  272. { 
  273.     { 0,        0        },
  274.     { HOST_NOT_FOUND, WSAHOST_NOT_FOUND },
  275.     { TRY_AGAIN,    WSATRY_AGAIN    },
  276.     { NO_RECOVERY,    WSANO_RECOVERY    },
  277.     { NO_DATA,    WSANO_DATA    },
  278.     { -1,        -1        }
  279. };
  280.  
  281. /* some functions to allow us to copy integer data
  282.  * to and from unaligned addresses
  283.  */
  284.  
  285. static unsigned short
  286. ToShort(char *pchData)
  287. {
  288.     short    n;
  289.  
  290.     memcpy(&n, pchData, sizeof(short));
  291.     return n;
  292. }
  293.  
  294. static long
  295. ToLong(char *pchData)
  296. {
  297.     long n;
  298.  
  299.     memcpy(&n, pchData, sizeof(long));
  300.     return n;
  301. }
  302.  
  303. static void
  304. FromShort(char *pchData, unsigned short n)
  305. {
  306.     memcpy(pchData, &n, sizeof(short));
  307. }
  308.  
  309. static void
  310. FromLong(char *pchData, long n)
  311. {
  312.     memcpy(pchData, &n, sizeof(long));
  313. }
  314.  
  315. static long
  316. GetIntVal(struct func_arg *pfa)
  317. {
  318.     switch(pfa->at)
  319.     {
  320.     case AT_Int16:
  321.     case AT_Int16Ptr:
  322.         return ntohs(ToShort(pfa->pvData));
  323.  
  324.     case AT_Int32:
  325.     case AT_Int32Ptr:
  326.         return ntohl(ToLong(pfa->pvData));
  327.     }
  328. }
  329.  
  330. void
  331. SetIntVal(struct func_arg *pfa, long iVal)
  332. {
  333.     switch(pfa->at)
  334.     {
  335.     case AT_Int16:
  336.     case AT_Int16Ptr:
  337.         FromShort(pfa->pvData,htons((short) iVal));
  338.         return;
  339.  
  340.     case AT_Int32:
  341.     case AT_Int32Ptr:
  342.         FromLong(pfa->pvData, htonl((short) iVal));
  343.         return;
  344.     }
  345. };
  346.  
  347. struct sockaddr *
  348. ConvertSA(struct func_arg *pfa, struct sockaddr_in *sin)
  349. {
  350.     u_short tmp;
  351.  
  352.     memcpy(sin, pfa->pvData, sizeof(*sin));
  353.     tmp = *(u_short *) sin;
  354.     *(u_short *) sin = 0;
  355.     sin->sin_family = GetFamily(ntohs(tmp));
  356.     return (struct sockaddr *) sin;
  357. }
  358.  
  359. int
  360. MapError(int iError)
  361. {
  362.     int    i;
  363.  
  364.     for (i = 0; error_mappings[i].iErrnoHost != -1; i++)
  365.     {
  366.         if (error_mappings[i].iErrnoHost == iError)
  367.             return error_mappings[i].iErrnoDos;
  368.     }
  369.     return WSAEFAULT;
  370. }
  371.  
  372. int
  373. MapHError(int iError)
  374. {
  375.     int    i;
  376.  
  377.     for (i = 0; h_error_mappings[i].iErrnoHost != -1; i++)
  378.     {
  379.         if (h_error_mappings[i].iErrnoHost == iError)
  380.             return h_error_mappings[i].iErrnoDos;
  381.     }
  382.     return WSAEFAULT;
  383. }
  384.  
  385. int
  386. CopyString(void *pvData, char *pchString, int iMax)
  387. {
  388.     char    *pchData;
  389.     int    iLen;
  390.  
  391.     pchData = (char *) pvData;
  392.     iLen = strlen(pchString);
  393.     if (iLen + 1 > iMax - 1)
  394.         return 0;
  395.     strcpy(pchData,    pchString);
  396.     return iLen + 1;
  397. }
  398.  
  399. void
  400. CopyHostEnt(void *pvData, struct hostent *phe)
  401. {
  402.     int    iLocation;
  403.     char    *pchData;
  404.     int    i;
  405.  
  406.     pchData = (char *) pvData;
  407.     FromShort(pchData, htons(phe->h_addrtype));
  408.     FromShort(pchData + sizeof(short), htons(phe->h_length));
  409.     for (i = 0; phe->h_addr_list[i]; i++);
  410.     FromShort(pchData + sizeof(short) * 2, htons(i));
  411.     iLocation = sizeof(short) * 3;
  412.     for (i = 0; phe->h_addr_list[i]; i++)
  413.     {
  414.         memcpy(pchData + iLocation, phe->h_addr_list[i], 4);
  415.         iLocation += 4;
  416.     }
  417.     iLocation += CopyString(pchData + iLocation,
  418.                 phe->h_name,
  419.                 MAX_HOST_ENT - iLocation);
  420.     for (i = 0; phe->h_aliases[i]; i++)
  421.     {
  422.         iLocation += CopyString(pchData + iLocation,
  423.                     phe->h_aliases[i],
  424.                     MAX_HOST_ENT - iLocation);
  425.     }
  426.     pchData[iLocation] = 0;
  427. }
  428.  
  429. void
  430. CopyNetEnt(void *pvData, struct netent *pne)
  431. {
  432.     int    iLocation;
  433.     char    *pchData;
  434.     int    i;
  435.  
  436.     pchData = (char *) pvData;
  437.     FromShort(pchData, htons(pne->n_addrtype));
  438.     FromLong(pchData + sizeof(short), pne->n_net);
  439.     iLocation = sizeof(short) + sizeof(long);
  440.     iLocation += CopyString(pchData + iLocation,
  441.                 pne->n_name,
  442.                 MAX_HOST_ENT - iLocation);
  443.     for (i = 0; pne->n_aliases[i]; i++)
  444.     {
  445.         iLocation += CopyString(pchData + iLocation,
  446.                     pne->n_aliases[i],
  447.                     MAX_HOST_ENT - iLocation);
  448.     }
  449.     pchData[iLocation] = 0;
  450. }
  451.  
  452. void
  453. CopyServEnt(void *pvData, struct servent *pse)
  454. {
  455.     int    iLocation;
  456.     char    *pchData;
  457.     int    i;
  458.  
  459.     pchData = (char *) pvData;
  460.     FromShort(pchData, pse->s_port); /* No htons - already in network order */
  461.     iLocation = sizeof(short);
  462.     iLocation += CopyString(pchData + iLocation,
  463.                 pse->s_proto,
  464.                 MAX_HOST_ENT - iLocation);
  465.     iLocation += CopyString(pchData + iLocation,
  466.                 pse->s_name,
  467.                 MAX_HOST_ENT - iLocation);
  468.     for (i = 0; pse->s_aliases[i]; i++)
  469.     {
  470.         iLocation += CopyString(pchData + iLocation,
  471.                     pse->s_aliases[i],
  472.                     MAX_HOST_ENT - iLocation);
  473.     }
  474.     pchData[iLocation] = 0;
  475. }
  476.  
  477. void
  478. CopyProtoEnt(void *pvData, struct protoent *ppe)
  479. {
  480.     int    iLocation;
  481.     char    *pchData;
  482.     int    i;
  483.  
  484.     pchData = (char *) pvData;
  485.     FromShort(pchData, htons(ppe->p_proto));
  486.     iLocation = sizeof(short);
  487.     iLocation += CopyString(pchData + iLocation,
  488.                 ppe->p_name,
  489.                 MAX_HOST_ENT - iLocation);
  490.     for (i = 0; ppe->p_aliases[i]; i++)
  491.     {
  492.         iLocation += CopyString(pchData + iLocation,
  493.                     ppe->p_aliases[i],
  494.                     MAX_HOST_ENT - iLocation);
  495.     }
  496.     pchData[iLocation] = 0;
  497. }
  498.  
  499. void
  500. SwapSockOptIn(    struct func_arg *pfa,
  501.         int    iOpt)
  502. {
  503.     int    iValue;
  504.     char    *pchData;
  505.  
  506.     pchData = (char *) pfa->pvData;
  507.     if (iOpt == SO_LINGER)
  508.     {
  509.         FromShort(pchData, ntohs(ToShort(pchData)));
  510.         FromShort(pchData + sizeof(short),
  511.                 ntohs(ToShort(pchData + sizeof(short))));
  512.     }
  513.     else
  514.     {
  515.         FromLong(pchData, ntohl(ToLong(pchData)));
  516.     }
  517. }
  518.  
  519. void
  520. SwapSockOptOut(    struct func_arg *pfa,
  521.         int    iOpt)
  522. {
  523.     int    iValue;
  524.     char    *pchData;
  525.  
  526.     pchData = (char *) pfa->pvData;
  527.     if (iOpt == SO_LINGER)
  528.     {
  529.         FromShort(pchData, htons(ToShort(pchData)));
  530.         FromShort(pchData + sizeof(short),
  531.                 htons(ToShort(pchData + sizeof(short))));
  532.     }
  533.     else
  534.     {
  535.         FromLong(pchData, htonl(ToLong(pchData)));
  536.     }
  537. }
  538.  
  539.  
  540. int
  541. CompressArg(    struct    tx_request *ptxr,
  542.         struct    func_arg *pfaArgs,
  543.         int    nArgs,
  544.         struct    func_arg *pfaResult,
  545.         int    iArg)
  546. {
  547.     struct    func_arg *pfaNow;
  548.     char    *pchNewData, *pchData;
  549.     int    i, j;
  550.     int    nLen;
  551.  
  552.     pchData = pchNewData = ptxr->pchData;
  553.     for (i = 0; i <= nArgs; i++)
  554.     {
  555.         if (i < nArgs)
  556.             pfaNow = pfaArgs + i;
  557.         else
  558.             pfaNow = pfaResult;
  559.         for (j = 0; j < pfaNow->iLen + 4; j++)
  560.             pchNewData[j] = pchData[j];
  561.         pchData += pfaNow->iLen + 4;
  562.         if (i == iArg)
  563.         {
  564.             pfaNow->iLen = 0;
  565.             *(short *) (pchNewData + 2) = 0;
  566.         }
  567.         pchNewData += pfaNow->iLen + 4;
  568.     }
  569.     nLen = pchNewData - ptxr->pchData + 10;
  570.     ptxr->nLen = htons((short) nLen);
  571.     return nLen;
  572. }
  573.  
  574.  
  575. void
  576. GetPortRange(    short    iInPort,
  577.         short    *piStartPort,
  578.         short    *piEndPort)
  579. {
  580.     char    achBuffer[1024];
  581.     char    achPort[20];
  582.     char    *pchComma;
  583.  
  584.     sprintf(achPort, "%d", (int) iInPort);
  585.     GetTwinSockSetting("Mappings",
  586.             achPort,
  587.             "",
  588.             achBuffer,
  589.             sizeof(achBuffer));
  590.     if (!*achBuffer || !(pchComma = (char *) strchr(achBuffer, ',')))
  591.     {
  592.         *piStartPort = *piEndPort = iInPort;
  593.         return;
  594.     }
  595.     *pchComma++ = 0;
  596.     *piStartPort = atoi(achBuffer);
  597.     *piEndPort = atoi(pchComma);
  598. }
  599.  
  600. void
  601. SendRemapMessage(    short    iFrom,
  602.             short    iTo)
  603. {
  604.     char    achBuffer[1024];
  605.     char    achPortDesc[50];
  606.     char    achPort[20];
  607.     struct    tx_request *ptxr;
  608.  
  609.     sprintf(achPortDesc, "Port %d", (int) iFrom);
  610.     sprintf(achPort, "%d", (int) iFrom);
  611.     GetTwinSockSetting("PortNames",
  612.             achPort,
  613.             achPortDesc,
  614.             achBuffer,
  615.             sizeof(achBuffer));
  616.     strcat(achBuffer, " remapped to ");
  617.     sprintf(achPortDesc, "Port %d", (int) iTo);
  618.     sprintf(achPort, "%d", (int) iTo);
  619.     GetTwinSockSetting("PortNames",
  620.             achPort,
  621.             achPortDesc,
  622.             achBuffer + strlen(achBuffer),
  623.             sizeof(achBuffer) - strlen(achBuffer));
  624.     ptxr = (struct tx_request *) malloc(11 + strlen(achBuffer));
  625.         ptxr->iType = htons(FN_Message);
  626.         ptxr->nArgs = 0;
  627.         ptxr->nLen = htons(11 + strlen(achBuffer));
  628.         ptxr->id = -1;
  629.         ptxr->nError = 0;
  630.     strcpy(ptxr->pchData, achBuffer);
  631.         PacketTransmitData(ptxr, 10 + strlen(achBuffer) + 1, -2);
  632.     free(ptxr);
  633. }
  634.  
  635. void
  636. ResponseReceived(struct tx_request *ptxr_)
  637. {
  638.     enum Functions ft;
  639.     short    nArgs;
  640.     short    nLen;
  641.     short    id;
  642.     short    iInPort;
  643.     short    iStartPort;
  644.     short    iEndPort;
  645.     short    iPort;
  646.     int    iLen;
  647.     int    iValue;
  648.     int    iSocket;
  649.     int    nOptName;
  650.     int    nOptVal;
  651.     short    nError;
  652.     struct    tx_request *ptxr;
  653.     struct    func_arg *pfaArgs;
  654.     struct    func_arg faResult;
  655.     struct    sockaddr_in sin;
  656.     char    *pchData;
  657.     int    i;
  658.     int    iErrorSent;
  659.     int    iOffset;
  660.     struct    hostent *phe;
  661.     struct    netent *pne;
  662.     struct    servent *pse;
  663.     struct    protoent *ppe;
  664.  
  665.     nLen = ntohs(ptxr_->nLen);
  666.     ptxr = (struct tx_request *) malloc(nLen);
  667.     memcpy(ptxr, ptxr_, nLen);
  668.     ft = (enum Functions) ntohs(ptxr->iType);
  669.     nArgs = ntohs(ptxr->nArgs);
  670.  
  671.     pfaArgs = (struct func_arg *) malloc(sizeof(struct func_arg) * nArgs);
  672.     pchData = ptxr->pchData;
  673.     for (i = 0; i < nArgs; i++)
  674.     {
  675.         pfaArgs[i].at = (enum arg_type) ntohs(ToShort(pchData));
  676.         pchData += sizeof(short);
  677.         pfaArgs[i].iLen = ntohs(ToShort(pchData));
  678.         pchData += sizeof(short);
  679.         pfaArgs[i].pvData = pchData;
  680.         pchData += pfaArgs[i].iLen;
  681.     }
  682.     faResult.at = (enum arg_type) ntohs(ToShort(pchData));
  683.     pchData += sizeof(short);
  684.     faResult.iLen = ntohs(ToShort(pchData));
  685.     pchData += sizeof(short);
  686.     faResult.pvData = pchData;
  687.  
  688.     iErrorSent = 0;
  689.     errno = 0;
  690.     h_errno = 0;
  691.  
  692.     switch(ft)
  693.     {
  694.     case FN_IOCtl:
  695.     case FN_Accept:
  696.     case FN_Select:
  697.     case FN_Data:
  698.         ptxr->nError = htons(WSAEOPNOTSUPP);
  699.         ptxr->nLen = htons(sizeof(short) * 5);
  700.         PacketTransmitData(ptxr, sizeof(short) * 5, -2);
  701.         iErrorSent = 1;
  702.         break;
  703.  
  704.     case FN_Send:
  705.         SetIntVal(&faResult,
  706.             send(GetIntVal(&pfaArgs[0]),
  707.                  pfaArgs[1].pvData,
  708.                  GetIntVal(&pfaArgs[2]),
  709.                  GetIntVal(&pfaArgs[3])));
  710.         nLen = CompressArg(ptxr, pfaArgs, nArgs, &faResult, 1);
  711.         break;
  712.  
  713.     case FN_SendTo:
  714.         SetIntVal(&faResult,
  715.             sendto(GetIntVal(&pfaArgs[0]),
  716.                    pfaArgs[1].pvData,
  717.                    GetIntVal(&pfaArgs[2]),
  718.                    GetIntVal(&pfaArgs[3]),
  719.                    ConvertSA(&pfaArgs[4], &sin),
  720.                    GetIntVal(&pfaArgs[5])));
  721.         nLen = CompressArg(ptxr, pfaArgs, nArgs, &faResult, 1);
  722.         break;
  723.  
  724.     case FN_Bind:
  725.         ConvertSA(&pfaArgs[1], &sin);
  726.         iInPort = ntohs(sin.sin_port);
  727.         GetPortRange(iInPort, &iStartPort, &iEndPort);
  728.         for (iPort = iStartPort; iPort <= iEndPort; iPort++)
  729.         {
  730.             errno = 0;
  731.             sin.sin_port = htons(iPort);
  732.             iValue = bind(GetIntVal(&pfaArgs[0]),
  733.                     (struct sockaddr *) &sin,
  734.                          GetIntVal(&pfaArgs[2]));
  735.             if (!iValue)
  736.             {
  737.                 if (iPort != iInPort)
  738.                     SendRemapMessage(iInPort, iPort);
  739.                 break;
  740.             }
  741.         }
  742.         SetIntVal(&faResult, iValue);
  743.         break;
  744.  
  745.     case FN_Connect:
  746.         iSocket = GetIntVal(&pfaArgs[0]);
  747.         iValue = connect(iSocket,
  748.                 ConvertSA(&pfaArgs[1], &sin),
  749.                 GetIntVal(&pfaArgs[2]));
  750.         SetIntVal(&faResult, iValue);
  751.         if (iValue != -1)
  752.             BumpLargestFD(iSocket);
  753.         break;
  754.  
  755.     case FN_Close:
  756.         SetIntVal(&faResult,
  757.             close(GetIntVal(&pfaArgs[0])));
  758.         FlushStream(GetIntVal(&pfaArgs[0]));
  759.         SetClosed(GetIntVal(&pfaArgs[0]));
  760.         break;
  761.  
  762.     case FN_Shutdown:
  763.         SetIntVal(&faResult,
  764.             shutdown(GetIntVal(&pfaArgs[0]),
  765.                  GetIntVal(&pfaArgs[1])));
  766.         if (GetIntVal(&pfaArgs[1]) != 1)
  767.             SetClosed(GetIntVal(&pfaArgs[0]));
  768.         break;
  769.  
  770.     case FN_Listen:
  771.         iSocket = GetIntVal(&pfaArgs[0]);
  772.         iValue = listen(iSocket,
  773.                 GetIntVal(&pfaArgs[1]));
  774.         SetIntVal(&faResult, iValue);
  775.         if (iValue != -1)
  776.         {
  777.             BumpLargestFD(iSocket);
  778.             SetListener(iSocket);
  779.         }
  780.         break;
  781.  
  782.     case FN_Socket:
  783.         iSocket = socket(GetFamily(GetIntVal(&pfaArgs[0])),
  784.                 GetType(GetIntVal(&pfaArgs[1])),
  785.                 GetProtocol(GetIntVal(&pfaArgs[2])));
  786.         SetIntVal(&faResult,iSocket);
  787.         if (iSocket != -1)
  788.         {
  789.             BumpLargestFD(iSocket);
  790.             nOptVal = 1;
  791.             iLen = sizeof(nOptVal);
  792.             setsockopt(iSocket,
  793.                     SOL_SOCKET,
  794.                     SO_OOBINLINE,
  795.                     (char *) &nOptVal,
  796.                     iLen);
  797.             errno = 0;
  798.         }
  799.         break;
  800.  
  801.     case FN_GetPeerName:
  802.         iLen = GetIntVal(&pfaArgs[2]);
  803.         iValue = getpeername(GetIntVal(&pfaArgs[0]),
  804.                      (struct sockaddr *) pfaArgs[1].pvData,
  805.                      &iLen);
  806.         if (iValue != -1)
  807.         {
  808.             SetIntVal(&faResult, iValue);
  809.             SetIntVal(&pfaArgs[2], iValue);
  810.             iValue = ((struct sockaddr *) pfaArgs[1].pvData)->
  811.                         sa_family;
  812.             iValue = RevFamily(iValue);
  813.             iValue = htons((short) iValue);
  814.             ((struct sockaddr *) pfaArgs[1].pvData)->sa_family =
  815.                         (short) iValue;
  816.         }
  817.         break;
  818.  
  819.     case FN_GetSockName:
  820.         iLen = GetIntVal(&pfaArgs[2]);
  821.         iValue = getsockname(GetIntVal(&pfaArgs[0]),
  822.                      (struct sockaddr *) pfaArgs[1].pvData,
  823.                      &iLen);
  824.         if (iValue != -1)
  825.         {
  826.             SetIntVal(&faResult, iValue);
  827.             SetIntVal(&pfaArgs[2], iValue);
  828.             iValue = ((struct sockaddr *) pfaArgs[1].pvData)->
  829.                         sa_family;
  830.             iValue = RevFamily(iValue);
  831.             iValue = htons((short) iValue);
  832.             ((struct sockaddr *) pfaArgs[1].pvData)->sa_family =
  833.                         (short) iValue;
  834.         }
  835.         break;
  836.  
  837.     case FN_GetSockOpt:
  838.         iLen = GetIntVal(&pfaArgs[4]);
  839.         nOptName = GetOption(GetIntVal(&pfaArgs[2]));
  840.         iValue = getsockopt(    GetIntVal(&pfaArgs[0]),
  841.                     GetIntVal(&pfaArgs[1]),
  842.                     nOptName,
  843.                     (char *) pfaArgs[3].pvData,
  844.                     &iLen);
  845.         if (iValue != -1)
  846.         {
  847.             SwapSockOptOut(&pfaArgs[3],
  848.                     nOptName);
  849.             SetIntVal(&pfaArgs[4], iLen);
  850.         }
  851.         SetIntVal(&faResult, iValue);
  852.         break;
  853.  
  854.     case FN_SetSockOpt:
  855.         iLen = GetIntVal(&pfaArgs[4]);
  856.         nOptName = GetOption(GetIntVal(&pfaArgs[2]));
  857.         SwapSockOptIn(&pfaArgs[3],
  858.                 nOptName);
  859.         iValue = setsockopt(    GetIntVal(&pfaArgs[0]),
  860.                     SOL_SOCKET,
  861.                     nOptName,
  862.                     (char *) pfaArgs[3].pvData,
  863.                     iLen);
  864.         SwapSockOptOut(&pfaArgs[3],
  865.                 nOptName);
  866.         SetIntVal(&faResult, iValue);
  867.         break;
  868.  
  869.     case FN_GetHostName:
  870.         SetIntVal(&faResult,
  871.             gethostname((char *) pfaArgs[0].pvData,
  872.                     GetIntVal(&pfaArgs[1])));
  873.         break;
  874.  
  875.     case FN_HostByAddr:
  876.         phe = gethostbyaddr((char *) pfaArgs[0].pvData,
  877.                     GetIntVal(&pfaArgs[1]),
  878.                     GetIntVal(&pfaArgs[2]));
  879.         if (phe)
  880.         {
  881.             h_errno = 0;
  882.             CopyHostEnt(faResult.pvData, phe);
  883.         }
  884.         break;
  885.  
  886.     case FN_HostByName:
  887.         phe = gethostbyname((char *) pfaArgs[0].pvData);
  888.         if (phe)
  889.         {
  890.             h_errno = 0;
  891.             CopyHostEnt(faResult.pvData, phe);
  892.         }
  893.         else if (!h_errno)
  894.         {
  895.             h_errno = TRY_AGAIN;
  896.         }
  897.         break;
  898.  
  899.     case FN_ServByPort:
  900.         if (pfaArgs[0].at == AT_Int16)
  901.             iValue = *(short *) pfaArgs[0].pvData;
  902.         else
  903.             iValue = *(long *) pfaArgs[0].pvData;
  904.         pse = getservbyport(iValue,
  905.                     (char *) pfaArgs[1].pvData);
  906.         if (pse)
  907.         {
  908.             h_errno = 0;
  909.             CopyServEnt(faResult.pvData, pse);
  910.         }
  911.         else
  912.         {
  913.             h_errno = NO_DATA;
  914.         }
  915.         break;
  916.  
  917.     case FN_ServByName:
  918.         pse = getservbyname((char *) pfaArgs[0].pvData,
  919.                     (char *) pfaArgs[1].pvData);
  920.         if (pse)
  921.         {
  922.             h_errno = 0;
  923.             CopyServEnt(faResult.pvData, pse);
  924.         }
  925.         else
  926.         {
  927.             h_errno = NO_DATA;
  928.         }
  929.         break;
  930.  
  931.     case FN_ProtoByNumber:
  932.         ppe = getprotobynumber(GetIntVal(&pfaArgs[0]));
  933.         if (ppe)
  934.         {
  935.             h_errno = 0;
  936.             CopyProtoEnt(faResult.pvData, ppe);
  937.         }
  938.         else
  939.         {
  940.             h_errno = NO_DATA;
  941.         }
  942.         break;
  943.  
  944.     case FN_ProtoByName:
  945.         ppe = getprotobyname((char *) pfaArgs[0].pvData);
  946.         if (ppe)
  947.         {
  948.             h_errno = 0;
  949.             CopyProtoEnt(faResult.pvData, ppe);
  950.         }
  951.         else
  952.         {
  953.             h_errno = NO_DATA;
  954.         }
  955.         break;
  956.     }
  957.     if (!iErrorSent)
  958.     {
  959.         if (ft >= FN_HostByAddr && ft <= FN_ProtoByName)
  960.             ptxr->nError = htons(MapHError(h_errno));
  961.         else
  962.             ptxr->nError = htons(MapError(errno));
  963.         PacketTransmitData(ptxr, nLen, -2);
  964.     }
  965.     free(ptxr);
  966.     free(pfaArgs);
  967. }
  968.  
  969. void
  970. SendSocketData(int iSocket,
  971.         void    *pvData,
  972.         int    iLen,
  973.         struct sockaddr_in *psa,
  974.         int    iAddrLen,
  975.         enum Functions ft)
  976. {
  977.     struct    tx_request *ptxr;
  978.     int    iDataLen;
  979.     struct    sockaddr_in sa;
  980.  
  981.     iDataLen = sizeof(struct sockaddr_in) + iLen;
  982.     sa = *psa;
  983.     sa.sin_family = htons(RevFamily(sa.sin_family));
  984.     ptxr = (struct tx_request *) malloc(sizeof(short) * 5 + iDataLen);
  985.     ptxr->nLen = htons(iDataLen + sizeof(short) * 5);
  986.     ptxr->id = htons(iSocket);
  987.     ptxr->nArgs = 0;
  988.     ptxr->nError = 0;
  989.     ptxr->iType = htons(ft);
  990.     memcpy(ptxr->pchData, &sa, sizeof(sa));
  991.     memcpy(ptxr->pchData + sizeof(sa), pvData, iLen);
  992.     PacketTransmitData(ptxr, sizeof(short) * 5 + iDataLen,
  993.         (ft == FN_Data) ? iSocket : -2);
  994.     free(ptxr);
  995. }
  996.