home *** CD-ROM | disk | FTP | other *** search
/ Borland Programmer's Resource / Borland_Programmers_Resource_CD_1995.iso / winsock / twnsck10 / commands.c next >
Encoding:
C/C++ Source or Header  |  1995-05-19  |  13.9 KB  |  669 lines
  1. /*
  2.  *  TwinSock - "Troy's Windows Sockets"
  3.  *
  4.  *  Copyright (C) 1994  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 GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <sys/types.h>
  23. #include <netinet/in.h>
  24. #include <netdb.h>
  25. #include <errno.h>
  26. #include <sys/socket.h>
  27. #include "twinsock.h"
  28. #include "tx.h"
  29. #include "wserror.h"
  30.  
  31. struct
  32. {
  33.     int    iErrnoHost;
  34.     int    iErrnoDos;
  35. } error_mappings[] =
  36. {
  37.     { 0,        0        },
  38.     { EINTR,    WSAEINTR    },
  39.     { EBADF,    WSAEBADF    },
  40.     { EINVAL,    WSAEINVAL    },
  41.     { EMFILE,    WSAEMFILE    },
  42.     { EWOULDBLOCK,    WSAEWOULDBLOCK    },
  43.     { EINPROGRESS,    WSAEINPROGRESS    },
  44.     { EALREADY,    WSAEALREADY    },
  45.     { ENOTSOCK,    WSAENOTSOCK    },
  46.     { EDESTADDRREQ,    WSAEDESTADDRREQ },
  47.     { EMSGSIZE,    WSAEMSGSIZE    },
  48.     { EPROTOTYPE,    WSAEPROTOTYPE    },
  49.     { ENOPROTOOPT,    WSAENOPROTOOPT    },
  50.     { EPROTONOSUPPORT, WSAEPROTONOSUPPORT },
  51.     { ESOCKTNOSUPPORT, WSAESOCKTNOSUPPORT },
  52.     { EOPNOTSUPP,    WSAEOPNOTSUPP    },
  53.     { EPFNOSUPPORT,    WSAEPFNOSUPPORT },
  54.     { EAFNOSUPPORT, WSAEAFNOSUPPORT },
  55.     { EADDRINUSE,    WSAEADDRINUSE    },
  56.     { EADDRNOTAVAIL,WSAEADDRNOTAVAIL },
  57.     { ENETDOWN,    WSAENETDOWN    },
  58.     { ENETUNREACH,    WSAENETUNREACH    },
  59.     { ENETRESET,    WSAENETRESET    },
  60.     { ECONNABORTED,    WSAECONNABORTED    },
  61.     { ECONNRESET,    WSAECONNRESET    },
  62.     { ENOBUFS,    WSAENOBUFS    },
  63.     { EISCONN,    WSAEISCONN    },
  64.     { ENOTCONN,    WSAENOTCONN    },
  65.     { ESHUTDOWN,    WSAESHUTDOWN    },
  66.     { ETOOMANYREFS,    WSAETOOMANYREFS    },
  67.     { ETIMEDOUT,    WSAETIMEDOUT    },
  68.     { ECONNREFUSED,    WSAECONNREFUSED    },
  69.     { ELOOP,    WSAELOOP,    },
  70.     { ENAMETOOLONG,    WSAENAMETOOLONG    },
  71.     { EHOSTDOWN,    WSAEHOSTDOWN    },
  72.     { EHOSTUNREACH,    WSAEHOSTUNREACH    },
  73.     { -1,        -1        }
  74. }, h_error_mappings[] =
  75. { 
  76.     { 0,        0        },
  77.     { HOST_NOT_FOUND, WSAHOST_NOT_FOUND },
  78.     { TRY_AGAIN,    WSATRY_AGAIN    },
  79.     { NO_RECOVERY,    WSANO_RECOVERY    },
  80.     { NO_DATA,    WSANO_DATA    },
  81.     { -1,        -1        }
  82. };
  83.  
  84. /* some functions to allow us to copy integer data
  85.  * to and from unaligned addresses
  86.  */
  87.  
  88. static short
  89. ToShort(char *pchData)
  90. {
  91.     short    n;
  92.  
  93.     memcpy(&n, pchData, sizeof(short));
  94.     return n;
  95. }
  96.  
  97. static long
  98. ToLong(char *pchData)
  99. {
  100.     long n;
  101.  
  102.     memcpy(&n, pchData, sizeof(long));
  103.     return n;
  104. }
  105.  
  106. static void
  107. FromShort(char *pchData, short n)
  108. {
  109.     memcpy(pchData, &n, sizeof(short));
  110. }
  111.  
  112. static void
  113. FromLong(char *pchData, long n)
  114. {
  115.     memcpy(pchData, &n, sizeof(long));
  116. }
  117.  
  118. static int
  119. GetIntVal(struct func_arg *pfa)
  120. {
  121.     switch(pfa->at)
  122.     {
  123.     case AT_Int16:
  124.     case AT_Int16Ptr:
  125.         return ToShort(pfa->pvData);
  126.  
  127.     case AT_Int32:
  128.     case AT_Int32Ptr:
  129.         return ToLong(pfa->pvData);
  130.     }
  131. }
  132.  
  133. void
  134. SetIntVal(struct func_arg *pfa, int iVal)
  135. {
  136.     switch(pfa->at)
  137.     {
  138.     case AT_Int16:
  139.     case AT_Int16Ptr:
  140.         FromShort(pfa->pvData,(short) iVal);
  141.         return;
  142.  
  143.     case AT_Int32:
  144.     case AT_Int32Ptr:
  145.         FromLong(pfa->pvData, iVal);
  146.         return;
  147.     }
  148. };
  149.  
  150. struct sockaddr *
  151. ConvertSA(struct func_arg *pfa, struct sockaddr_in *sin)
  152. {
  153.     memcpy(sin, pfa->pvData, sizeof(*sin));
  154.     sin->sin_family = ntohs(sin->sin_family);
  155.     return (struct sockaddr *) sin;
  156. }
  157.  
  158. int
  159. MapError(int iError)
  160. {
  161.     int    i;
  162.  
  163.     for (i = 0; error_mappings[i].iErrnoHost != -1; i++)
  164.     {
  165.         if (error_mappings[i].iErrnoHost == iError)
  166.             return error_mappings[i].iErrnoDos;
  167.     }
  168.     return WSAEFAULT;
  169. }
  170.  
  171. int
  172. MapHError(int iError)
  173. {
  174.     int    i;
  175.  
  176.     for (i = 0; h_error_mappings[i].iErrnoHost != -1; i++)
  177.     {
  178.         if (h_error_mappings[i].iErrnoHost == iError)
  179.             return h_error_mappings[i].iErrnoDos;
  180.     }
  181.     return WSAEFAULT;
  182. }
  183.  
  184. int
  185. CopyString(void *pvData, char *pchString, int iMax)
  186. {
  187.     char    *pchData;
  188.     int    iLen;
  189.  
  190.     pchData = (char *) pvData;
  191.     iLen = strlen(pchString);
  192.     if (iLen + 1 > iMax - 1)
  193.         return 0;
  194.     strcpy(pchData,    pchString);
  195.     return iLen + 1;
  196. }
  197.  
  198. void
  199. CopyHostEnt(void *pvData, struct hostent *phe)
  200. {
  201.     int    iLocation;
  202.     char    *pchData;
  203.     int    i;
  204.  
  205.     pchData = (char *) pvData;
  206.     FromShort(pchData, htons(phe->h_addrtype));
  207.     FromShort(pchData + sizeof(short), htons(phe->h_length));
  208.     for (i = 0; phe->h_addr_list[i]; i++);
  209.     FromShort(pchData + sizeof(short) * 2, htons(i));
  210.     iLocation = sizeof(short) * 3;
  211.     for (i = 0; phe->h_addr_list[i]; i++)
  212.     {
  213.         memcpy(pchData + iLocation, phe->h_addr_list[i], 4);
  214.         iLocation += 4;
  215.     }
  216.     iLocation += CopyString(pchData + iLocation,
  217.                 phe->h_name,
  218.                 MAX_HOST_ENT - iLocation);
  219.     for (i = 0; phe->h_aliases[i]; i++)
  220.     {
  221.         iLocation += CopyString(pchData + iLocation,
  222.                     phe->h_aliases[i],
  223.                     MAX_HOST_ENT - iLocation);
  224.     }
  225.     pchData[iLocation] = 0;
  226. }
  227.  
  228. void
  229. CopyNetEnt(void *pvData, struct netent *pne)
  230. {
  231.     int    iLocation;
  232.     char    *pchData;
  233.     int    i;
  234.  
  235.     pchData = (char *) pvData;
  236.     FromShort(pchData, htons(pne->n_addrtype));
  237.     FromLong(pchData + sizeof(short), pne->n_net);
  238.     iLocation = sizeof(short) + sizeof(long);
  239.     iLocation += CopyString(pchData + iLocation,
  240.                 pne->n_name,
  241.                 MAX_HOST_ENT - iLocation);
  242.     for (i = 0; pne->n_aliases[i]; i++)
  243.     {
  244.         iLocation += CopyString(pchData + iLocation,
  245.                     pne->n_aliases[i],
  246.                     MAX_HOST_ENT - iLocation);
  247.     }
  248.     pchData[iLocation] = 0;
  249. }
  250.  
  251. void
  252. CopyServEnt(void *pvData, struct servent *pse)
  253. {
  254.     int    iLocation;
  255.     char    *pchData;
  256.     int    i;
  257.  
  258.     pchData = (char *) pvData;
  259.     FromShort(pchData, pse->s_port); /* No htons - already in network order */
  260.     iLocation = sizeof(short);
  261.     iLocation += CopyString(pchData + iLocation,
  262.                 pse->s_proto,
  263.                 MAX_HOST_ENT - iLocation);
  264.     iLocation += CopyString(pchData + iLocation,
  265.                 pse->s_name,
  266.                 MAX_HOST_ENT - iLocation);
  267.     for (i = 0; pse->s_aliases[i]; i++)
  268.     {
  269.         iLocation += CopyString(pchData + iLocation,
  270.                     pse->s_aliases[i],
  271.                     MAX_HOST_ENT - iLocation);
  272.     }
  273.     pchData[iLocation] = 0;
  274. }
  275.  
  276. void
  277. CopyProtoEnt(void *pvData, struct protoent *ppe)
  278. {
  279.     int    iLocation;
  280.     char    *pchData;
  281.     int    i;
  282.  
  283.     pchData = (char *) pvData;
  284.     FromShort(pchData, htons(ppe->p_proto));
  285.     iLocation = sizeof(short);
  286.     iLocation += CopyString(pchData + iLocation,
  287.                 ppe->p_name,
  288.                 MAX_HOST_ENT - iLocation);
  289.     for (i = 0; ppe->p_aliases[i]; i++)
  290.     {
  291.         iLocation += CopyString(pchData + iLocation,
  292.                     ppe->p_aliases[i],
  293.                     MAX_HOST_ENT - iLocation);
  294.     }
  295.     pchData[iLocation] = 0;
  296. }
  297.  
  298. void
  299. SwapSockOptIn(    struct func_arg *pfa,
  300.         int    iOpt)
  301. {
  302.     int    iValue;
  303.     char    *pchData;
  304.  
  305.     pchData = (char *) pfa->pvData;
  306.     if (iOpt == SO_LINGER)
  307.     {
  308.         FromShort(pchData, ntohs(ToShort(pchData)));
  309.         FromShort(pchData + sizeof(short),
  310.                 ntohs(ToShort(pchData + sizeof(short))));
  311.     }
  312.     else
  313.     {
  314.         FromLong(pchData, ntohl(ToLong(pchData)));
  315.     }
  316. }
  317.  
  318. void
  319. SwapSockOptOut(    struct func_arg *pfa,
  320.         int    iOpt)
  321. {
  322.     int    iValue;
  323.     char    *pchData;
  324.  
  325.     pchData = (char *) pfa->pvData;
  326.     if (iOpt == SO_LINGER)
  327.     {
  328.         FromShort(pchData, htons(ToShort(pchData)));
  329.         FromShort(pchData + sizeof(short),
  330.                 htons(ToShort(pchData + sizeof(short))));
  331.     }
  332.     else
  333.     {
  334.         FromLong(pchData, htonl(ToLong(pchData)));
  335.     }
  336. }
  337.  
  338. void
  339. ResponseReceived(struct tx_request *ptxr_)
  340. {
  341.     enum Functions ft;
  342.     short    nArgs;
  343.     short    nLen;
  344.     short    id;
  345.     int    iLen;
  346.     int    iValue;
  347.     int    iSocket;
  348.     int    nOptVal;
  349.     short    nError;
  350.     struct    tx_request *ptxr;
  351.     struct    func_arg *pfaArgs;
  352.     struct    func_arg faResult;
  353.     struct    sockaddr_in sin;
  354.     char    *pchData;
  355.     int    i;
  356.     int    iErrorSent;
  357.     int    iOffset;
  358.     struct    hostent *phe;
  359.     struct    netent *pne;
  360.     struct    servent *pse;
  361.     struct    protoent *ppe;
  362.  
  363.     nLen = ntohs(ptxr_->nLen);
  364.     ptxr = (struct tx_request *) malloc(nLen);
  365.     memcpy(ptxr, ptxr_, nLen);
  366.     ft = (enum Functions) ntohs(ptxr->iType);
  367.     nArgs = ntohs(ptxr->nArgs);
  368.  
  369.     pfaArgs = (struct func_arg *) malloc(sizeof(struct func_arg) * nArgs);
  370.     pchData = ptxr->pchData;
  371.     for (i = 0; i < nArgs; i++)
  372.     {
  373.         pfaArgs[i].at = (enum arg_type) ntohs(ToShort(pchData));
  374.         pchData += sizeof(short);
  375.         pfaArgs[i].iLen = ntohs(ToShort(pchData));
  376.         pchData += sizeof(short);
  377.         pfaArgs[i].pvData = pchData;
  378.         pchData += pfaArgs[i].iLen;
  379.     }
  380.     faResult.at = (enum arg_type) ntohs(ToShort(pchData));
  381.     pchData += sizeof(short);
  382.     faResult.iLen = ntohs(ToShort(pchData));
  383.     pchData += sizeof(short);
  384.     faResult.pvData = pchData;
  385.  
  386.     iErrorSent = 0;
  387.     errno = 0;
  388.     h_errno = 0;
  389.  
  390.     switch(ft)
  391.     {
  392.     case FN_IOCtl:
  393.     case FN_Accept:
  394.     case FN_Select:
  395.     case FN_Data:
  396.         ptxr->nError = htons(WSAEOPNOTSUPP);
  397.         ptxr->nLen = htons(sizeof(short) * 5);
  398.         PacketTransmitData(ptxr, sizeof(short) * 5, -1);
  399.         iErrorSent = 1;
  400.         break;
  401.  
  402.     case FN_Send:
  403.         SetIntVal(&faResult,
  404.             send(GetIntVal(&pfaArgs[0]),
  405.                  pfaArgs[1].pvData,
  406.                  GetIntVal(&pfaArgs[2]),
  407.                  GetIntVal(&pfaArgs[3])));
  408.         break;
  409.  
  410.     case FN_SendTo:
  411.         SetIntVal(&faResult,
  412.             sendto(GetIntVal(&pfaArgs[0]),
  413.                    pfaArgs[1].pvData,
  414.                    GetIntVal(&pfaArgs[2]),
  415.                    GetIntVal(&pfaArgs[3]),
  416.                    ConvertSA(&pfaArgs[4], &sin),
  417.                    GetIntVal(&pfaArgs[5])));
  418.         break;
  419.  
  420.     case FN_Bind:
  421.         SetIntVal(&faResult,
  422.             bind(GetIntVal(&pfaArgs[0]),
  423.                  ConvertSA(&pfaArgs[1], &sin),
  424.                  GetIntVal(&pfaArgs[2])));
  425.         break;
  426.  
  427.     case FN_Connect:
  428.         iSocket = GetIntVal(&pfaArgs[0]);
  429.         iValue = connect(iSocket,
  430.                 ConvertSA(&pfaArgs[1], &sin),
  431.                 GetIntVal(&pfaArgs[2]));
  432.         SetIntVal(&faResult, iValue);
  433.         if (iValue != -1)
  434.             BumpLargestFD(iSocket);
  435.         break;
  436.  
  437.     case FN_Close:
  438.         SetIntVal(&faResult,
  439.             close(GetIntVal(&pfaArgs[0])));
  440.         FlushStream(GetIntVal(&pfaArgs[0]));
  441.         SetClosed(GetIntVal(&pfaArgs[0]));
  442.         break;
  443.  
  444.     case FN_Shutdown:
  445.         SetIntVal(&faResult,
  446.             shutdown(GetIntVal(&pfaArgs[0]),
  447.                  GetIntVal(&pfaArgs[1])));
  448.         if (GetIntVal(&pfaArgs[1]) != 1)
  449.             SetClosed(GetIntVal(&pfaArgs[0]));
  450.         break;
  451.  
  452.     case FN_Listen:
  453.         iSocket = GetIntVal(&pfaArgs[0]);
  454.         iValue = listen(iSocket,
  455.                 GetIntVal(&pfaArgs[1]));
  456.         SetIntVal(&faResult, iValue);
  457.         if (iValue != -1)
  458.         {
  459.             BumpLargestFD(iSocket);
  460.             SetListener(iSocket);
  461.         }
  462.         break;
  463.  
  464.     case FN_Socket:
  465.         iSocket = socket(GetIntVal(&pfaArgs[0]),
  466.                 GetIntVal(&pfaArgs[1]),
  467.                 GetIntVal(&pfaArgs[2]));
  468.         SetIntVal(&faResult,iSocket);
  469.         if (iSocket != -1)
  470.         {
  471.             BumpLargestFD(iSocket);
  472.             nOptVal = 1;
  473.             iLen = sizeof(nOptVal);
  474.             setsockopt(iSocket,
  475.                     SOL_SOCKET,
  476.                     SO_OOBINLINE,
  477.                     (char *) &nOptVal,
  478.                     &iLen);
  479.             errno = 0;
  480.         }
  481.         break;
  482.  
  483.     case FN_GetPeerName:
  484.         iLen = GetIntVal(&pfaArgs[2]);
  485.         iValue = getpeername(GetIntVal(&pfaArgs[0]),
  486.                      (struct sockaddr *) pfaArgs[1].pvData,
  487.                      &iLen);
  488.         if (iValue != -1)
  489.         {
  490.             SetIntVal(&faResult, iValue);
  491.             SetIntVal(&pfaArgs[2], iValue);
  492.             iValue = ((struct sockaddr *) pfaArgs[1].pvData)->
  493.                         sa_family;
  494.             iValue = htons((short) iValue);
  495.             ((struct sockaddr *) pfaArgs[1].pvData)->sa_family =
  496.                         (short) iValue;
  497.         }
  498.         break;
  499.  
  500.     case FN_GetSockName:
  501.         iLen = GetIntVal(&pfaArgs[2]);
  502.         iValue = getsockname(GetIntVal(&pfaArgs[0]),
  503.                      (struct sockaddr *) pfaArgs[1].pvData,
  504.                      &iLen);
  505.         if (iValue != -1)
  506.         {
  507.             SetIntVal(&faResult, iValue);
  508.             SetIntVal(&pfaArgs[2], iValue);
  509.             iValue = ((struct sockaddr *) pfaArgs[1].pvData)->
  510.                         sa_family;
  511.             iValue = htons((short) iValue);
  512.             ((struct sockaddr *) pfaArgs[1].pvData)->sa_family =
  513.                         (short) iValue;
  514.         }
  515.         break;
  516.  
  517.     case FN_GetSockOpt:
  518.         iLen = GetIntVal(&pfaArgs[4]);
  519.         iValue = getsockopt(    GetIntVal(&pfaArgs[0]),
  520.                     GetIntVal(&pfaArgs[1]),
  521.                     GetIntVal(&pfaArgs[2]),
  522.                     (char *) pfaArgs[3].pvData,
  523.                     &iLen);
  524.         if (iValue != -1)
  525.         {
  526.             SwapSockOptOut(&pfaArgs[3],
  527.                     GetIntVal(&pfaArgs[2]));
  528.             SetIntVal(&pfaArgs[4], iLen);
  529.         }
  530.         SetIntVal(&faResult, iValue);
  531.         break;
  532.  
  533.     case FN_SetSockOpt:
  534.         iLen = GetIntVal(&pfaArgs[4]);
  535.         SwapSockOptIn(&pfaArgs[3],
  536.                 GetIntVal(&pfaArgs[2]));
  537.         iValue = setsockopt(    GetIntVal(&pfaArgs[0]),
  538.                     SOL_SOCKET,
  539.                     GetIntVal(&pfaArgs[2]),
  540.                     (char *) pfaArgs[3].pvData,
  541.                     &iLen);
  542.         SwapSockOptOut(&pfaArgs[3],
  543.                 GetIntVal(&pfaArgs[2]));
  544.         SetIntVal(&faResult, iValue);
  545.         break;
  546.  
  547.     case FN_GetHostName:
  548.         SetIntVal(&faResult,
  549.             gethostname((char *) pfaArgs[0].pvData,
  550.                     GetIntVal(&pfaArgs[1])));
  551.         break;
  552.  
  553.     case FN_HostByAddr:
  554.         phe = gethostbyaddr((char *) pfaArgs[0].pvData,
  555.                     GetIntVal(&pfaArgs[1]),
  556.                     GetIntVal(&pfaArgs[2]));
  557.         if (phe)
  558.         {
  559.             h_errno = 0;
  560.             CopyHostEnt(faResult.pvData, phe);
  561.         }
  562.         break;
  563.  
  564.     case FN_HostByName:
  565.         phe = gethostbyname((char *) pfaArgs[0].pvData);
  566.         if (phe)
  567.         {
  568.             h_errno = 0;
  569.             CopyHostEnt(faResult.pvData, phe);
  570.         }
  571.         else if (!h_errno)
  572.         {
  573.             h_errno = TRY_AGAIN;
  574.         }
  575.         break;
  576.  
  577.     case FN_ServByPort:
  578.         pse = getservbyport(GetIntVal(&pfaArgs[0]),
  579.                     (char *) pfaArgs[1].pvData);
  580.         if (pse)
  581.         {
  582.             h_errno = 0;
  583.             CopyServEnt(faResult.pvData, pse);
  584.         }
  585.         else
  586.         {
  587.             h_errno = NO_DATA;
  588.         }
  589.         break;
  590.  
  591.     case FN_ServByName:
  592.         pse = getservbyname((char *) pfaArgs[0].pvData,
  593.                     (char *) pfaArgs[1].pvData);
  594.         if (pse)
  595.         {
  596.             h_errno = 0;
  597.             CopyServEnt(faResult.pvData, pse);
  598.         }
  599.         else
  600.         {
  601.             h_errno = NO_DATA;
  602.         }
  603.         break;
  604.  
  605.     case FN_ProtoByNumber:
  606.         ppe = getprotobynumber(GetIntVal(&pfaArgs[0]));
  607.         if (ppe)
  608.         {
  609.             h_errno = 0;
  610.             CopyProtoEnt(faResult.pvData, ppe);
  611.         }
  612.         else
  613.         {
  614.             h_errno = NO_DATA;
  615.         }
  616.         break;
  617.  
  618.     case FN_ProtoByName:
  619.         ppe = getprotobyname((char *) pfaArgs[0].pvData);
  620.         if (ppe)
  621.         {
  622.             h_errno = 0;
  623.             CopyProtoEnt(faResult.pvData, ppe);
  624.         }
  625.         else
  626.         {
  627.             h_errno = NO_DATA;
  628.         }
  629.         break;
  630.     }
  631.     if (!iErrorSent)
  632.     {
  633.         if (ft >= FN_HostByAddr || ft <= FN_ProtoByName)
  634.             ptxr->nError = htons(MapHError(h_errno));
  635.         else
  636.             ptxr->nError = htons(MapError(errno));
  637.         PacketTransmitData(ptxr, nLen, -1);
  638.     }
  639.     free(ptxr);
  640.     free(pfaArgs);
  641. }
  642.  
  643. void
  644. SendSocketData(int iSocket,
  645.         void    *pvData,
  646.         int    iLen,
  647.         struct sockaddr_in *psa,
  648.         int    iAddrLen,
  649.         enum function_type ft)
  650. {
  651.     struct    tx_request *ptxr;
  652.     int    iDataLen;
  653.     struct    sockaddr_in sa;
  654.  
  655.     iDataLen = sizeof(struct sockaddr_in) + iLen;
  656.     sa = *psa;
  657.     sa.sin_family = htons(sa.sin_family);
  658.     ptxr = (struct tx_request *) malloc(sizeof(short) * 5 + iDataLen);
  659.     ptxr->nLen = htons(iDataLen + sizeof(short) * 5);
  660.     ptxr->id = htons(iSocket);
  661.     ptxr->nArgs = 0;
  662.     ptxr->nError = 0;
  663.     ptxr->iType = htons(ft);
  664.     memcpy(ptxr->pchData, &sa, sizeof(sa));
  665.     memcpy(ptxr->pchData + sizeof(sa), pvData, iLen);
  666.     PacketTransmitData(ptxr, sizeof(short) * 5 + iDataLen, iSocket);
  667.     free(ptxr);
  668. }
  669.