home *** CD-ROM | disk | FTP | other *** search
/ Chip 1999 September / CHIPCD_9_99.iso / software / serwery_www / sambar / _setup.1 / netutils.c < prev    next >
C/C++ Source or Header  |  1998-01-12  |  10KB  |  457 lines
  1. /*
  2. ** NETUTILS
  3. **
  4. **      HTTP Wrapper for some basic Network Utilities
  5. **
  6. **        Confidential Property of Tod Sambar
  7. **        (c) Copyright Tod Sambar 1997
  8. **        All rights reserved.
  9. **
  10. **
  11. ** Public Functions:
  12. **
  13. **        netutils_init
  14. **        ipname_lookup
  15. **        whois_lookup
  16. **        finger_lookup
  17. **
  18. **
  19. ** History:
  20. ** Chg#    Date    Description                                                Resp
  21. ** ----    -------    -------------------------------------------------------    ----
  22. **         2FEB97    Created                                                    sambar
  23. */
  24.  
  25. #include    <stdio.h>
  26. #include    <memory.h>
  27. #include    <string.h>
  28. #include    <stdlib.h>
  29. #include    <winsock.h>
  30. #include    <direct.h>
  31. #include    <errno.h>
  32. #include    <netutils.h>
  33.  
  34. /*
  35. ** WHOIS defines
  36. */
  37. #define WHOIS_PORT        43
  38. #define WHOIS_SERVER    "198.41.0.5"        /* rs.internic.net */
  39.  
  40. /*
  41. ** Network Utility RPC Commands
  42. */
  43. typedef struct netutils__rpcs
  44. {
  45.     SA_CHAR        *name;
  46.     SA_RPCPARAM    *params;
  47.     SA_INT        numparams;
  48.     SA_INT        auth;
  49.     SA_VOID        *func;
  50.     SA_CHAR        *descr;
  51. } NETUTILS__RPCS;
  52.  
  53. static SA_RPCPARAM        ipnamep [] =
  54. {
  55.     { "ipaddr",        1,    "IP Address to lookup." }
  56. };
  57. static SA_RPCPARAM        whoisp [] =
  58. {
  59.     { "sitename",    1,    "Site name to lookup." }
  60. };
  61. static SA_RPCPARAM        fingerp [] =
  62. {
  63.     { "user",        0,    "User name to lookup (may be NULL)." },
  64.     { "host",        1,    "Site to lookup user on (must have finger daemon)." }
  65. };
  66.  
  67. static NETUTILS__RPCS     netutils_rpcs [] =
  68. {
  69.     { "ipname",        ipnamep,    sizeof(ipnamep) / sizeof(SA_RPCPARAM),
  70.       SA_AUTHORIZATION_ALL,    (SA_VOID *)ipname_lookup,
  71.       "Lookup the DNS name associated with an IP address." },
  72.     { "whois",        whoisp,        sizeof(ipnamep) / sizeof(SA_RPCPARAM),
  73.       SA_AUTHORIZATION_ALL,    (SA_VOID *)whois_lookup,
  74.       "Perform a whois lookup given a network domain name." },
  75.     { "finger",        fingerp,        sizeof(fingerp) / sizeof(SA_RPCPARAM),
  76.       SA_AUTHORIZATION_ALL,    (SA_VOID *)finger_lookup,
  77.       "Perform a finger lookup given a user and host." }
  78. };
  79.  
  80. /*
  81. **  NETUTILS_INIT
  82. **
  83. **    Initialize the Network Utilities.
  84. **
  85. **  Parameters:
  86. **    sactx        Sambar Server context
  87. **
  88. **  Returns:
  89. **    SA_SUCCEED | SA_FAIL
  90. */
  91. SA_RETCODE SA_PUBLIC
  92. netutils_init(sactx)
  93. SA_CTX        *sactx;
  94. {
  95.     int            i;
  96.  
  97.     /* Register the Network Uitlities RPCs with the application            */
  98.     for (i = 0; i < sizeof(netutils_rpcs) / sizeof(NETUTILS__RPCS); i++)
  99.     {
  100.         if (sa_cmd_init(sactx, netutils_rpcs[i].name, 
  101.             netutils_rpcs[i].params, netutils_rpcs[i].numparams,
  102.             netutils_rpcs[i].auth, netutils_rpcs[i].descr, 
  103.             (SA_RPCFUNC)netutils_rpcs[i].func) != SA_SUCCEED)
  104.         {
  105.             sa_log(sactx, "Unable to initialize Network Utility RPCs");
  106.             return (SA_FAIL);
  107.         }
  108.     } 
  109.  
  110.     sa_log(sactx, "Network Utilities Initialized");
  111.  
  112.     return (SA_SUCCEED);
  113. }
  114.  
  115. /*
  116. **  IPNAME_LOOKUP
  117. **
  118. **    Get the host name associated with an IP address.
  119. **
  120. **  Parameters:
  121. **    sactx        Sambar Server context
  122. **    saconn        Sambar Server connection
  123. **    saparams    RPC Parameters
  124. **    infop        Error parameters
  125. **
  126. **  Returns:
  127. **    SA_SUCCEED | SA_FAIL
  128. */
  129. SA_RETCODE SA_PUBLIC
  130. ipname_lookup(sactx, saconn, saparams, infop)
  131. SA_CTX        *sactx;
  132. SA_CONN        *saconn;
  133. SA_PARAMS    *saparams;
  134. SA_INT        *infop;
  135. {
  136.     unsigned long    addr;
  137.     SA_INT            datalen;
  138.     SA_CHAR            *data;
  139.     struct hostent    *hent;
  140.  
  141.     /* Get the ip address to lookup                                        */
  142.     if ((sa_param(sactx, saparams, "ipaddr", &data, &datalen) != SA_SUCCEED) ||
  143.         (datalen == 0))
  144.     {
  145.         *infop = SA_E_INVALIDDATA;
  146.         return (SA_FAIL);
  147.     }
  148.  
  149.     addr = (int)inet_addr((char *)data);
  150.     if (addr == -1)
  151.     {
  152.         *infop = SA_E_INVALIDDATA;
  153.         return (SA_FAIL);
  154.     }
  155.  
  156.     hent = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
  157.     if (hent != NULL)
  158.     {
  159.         if (sa_conn_send(saconn, hent->h_name, SA_NULLTERM) != SA_SUCCEED)
  160.             return (SA_FAIL);
  161.     }
  162.     else
  163.     {
  164.         if (sa_conn_send(saconn, "unknown", SA_NULLTERM) != SA_SUCCEED)
  165.             return (SA_FAIL);
  166.     }
  167.  
  168.     return (SA_SUCCEED);
  169. }
  170.  
  171. /*
  172. **  WHOIS_LOOKUP
  173. **
  174. **    Perform a whois search.
  175. **
  176. **  Parameters:
  177. **    sactx        Sambar Server context
  178. **    saconn        Sambar Server connection
  179. **    saparams    RPC Parameters
  180. **    infop        Error parameters
  181. **
  182. **  Returns:
  183. **    SA_SUCCEED | SA_FAIL
  184. */
  185. SA_RETCODE SA_PUBLIC
  186. whois_lookup(sactx, saconn, saparams, infop)
  187. SA_CTX        *sactx;
  188. SA_CONN        *saconn;
  189. SA_PARAMS    *saparams;
  190. SA_INT        *infop;
  191. {
  192.     SA_INT                buflen;
  193.     SA_INT                datalen;
  194.     SA_BOOL                finished;
  195.     SOCKET                sock;
  196.     unsigned long        addr;
  197.     SA_CHAR                *data;
  198.     struct sockaddr_in    sin;
  199.     struct hostent        *hent;
  200.     SA_CHAR                buffer[1024];
  201.  
  202.     /* Get the site name                                                */
  203.     if ((sa_param(sactx, saparams, "sitename", &data, &datalen) != SA_SUCCEED)
  204.         || (datalen == 0))
  205.     {
  206.         *infop = SA_E_INVALIDDATA;
  207.         return (SA_FAIL);
  208.     }
  209.  
  210.     /* Get the WHOIS server address for the query                        */
  211.     addr = (int)inet_addr((char *)WHOIS_SERVER);
  212.     if (addr == -1)
  213.     {
  214.         *infop = SA_E_INVALIDDATA;
  215.         return (SA_FAIL);
  216.     }
  217.  
  218.     hent = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
  219.     if (hent == NULL)
  220.     {
  221.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  222.             SA_NULLTERM) != SA_SUCCEED)
  223.         {
  224.             return (SA_FAIL);
  225.         }
  226.  
  227.         return (SA_SUCCEED);
  228.     }
  229.  
  230.     /* Create a socket                                                     */
  231.     sock = socket(hent->h_addrtype, SOCK_STREAM, 0);
  232.     if (sock == INVALID_SOCKET)
  233.     {
  234.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  235.             SA_NULLTERM) != SA_SUCCEED)
  236.         {
  237.             return (SA_FAIL);
  238.         }
  239.  
  240.         return (SA_SUCCEED);
  241.     }
  242.  
  243.     /* Connect to the WHOIS server                                        */
  244.     sin.sin_family = AF_INET;
  245.     sin.sin_port = htons((u_short)WHOIS_PORT);
  246.     memcpy(&sin.sin_addr, hent->h_addr, hent->h_length);
  247.  
  248.     /* Now, connect to that WHOIS server                                */
  249.     if (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) 
  250.     {
  251.         closesocket(sock);
  252.  
  253.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  254.             SA_NULLTERM) != SA_SUCCEED)
  255.         {
  256.             return (SA_FAIL);
  257.         }
  258.  
  259.         return (SA_SUCCEED);
  260.     }
  261.  
  262.     /* Send the request.                                                */
  263.     sprintf(buffer, "%s\r\n", data);
  264.     buflen = strlen(buffer);
  265.  
  266.     if (send(sock, buffer, buflen, 0) != buflen)
  267.     {
  268.         closesocket(sock);
  269.  
  270.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  271.             SA_NULLTERM) != SA_SUCCEED)
  272.         {
  273.             return (SA_FAIL);
  274.         }
  275.  
  276.         return (SA_SUCCEED);
  277.     }
  278.  
  279.     /* Receive the response.                                            */
  280.     finished = 0;
  281.     while (!finished)
  282.     {
  283.         buflen = recv(sock, buffer, 1024, 0);
  284.         if ((buflen < 0) && (errno == EINTR))
  285.             continue;
  286.  
  287.         if (buflen == SOCKET_ERROR)
  288.         {
  289.             closesocket(sock);
  290.             return (SA_FAIL);
  291.         }
  292.  
  293.         if (buflen > 0)
  294.         {
  295.             if (sa_conn_send(saconn, buffer, buflen) != SA_SUCCEED)
  296.             {
  297.                 closesocket(sock);
  298.                 return (SA_FAIL);
  299.             }
  300.         }
  301.         else
  302.         {
  303.             finished = 1;
  304.         }
  305.     }
  306.  
  307.     closesocket(sock);
  308.  
  309.     if (!finished)
  310.     {
  311.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  312.             SA_NULLTERM) != SA_SUCCEED)
  313.         {
  314.             return (SA_FAIL);
  315.         }
  316.     }
  317.  
  318.     return (SA_SUCCEED);
  319. }
  320.  
  321. /*
  322. **  FINGER_LOOKUP
  323. **
  324. **    Perform a 'finger' search.
  325. **
  326. **  Parameters:
  327. **    sactx        Sambar Server context
  328. **    saconn        Sambar Server connection
  329. **    saparams    RPC Parameters
  330. **    infop        Error parameters
  331. **
  332. **  Returns:
  333. **    SA_SUCCEED | SA_FAIL
  334. */
  335. SA_RETCODE SA_PUBLIC
  336. finger_lookup(sactx, saconn, saparams, infop)
  337. SA_CTX        *sactx;
  338. SA_CONN        *saconn;
  339. SA_PARAMS    *saparams;
  340. SA_INT        *infop;
  341. {
  342.     SA_INT                buflen;
  343.     SA_INT                userlen;
  344.     SA_INT                hostlen;
  345.     SA_BOOL                finished;
  346.     SOCKET                sock;
  347.     SA_CHAR                *host;
  348.     SA_CHAR                *user;
  349.     struct sockaddr_in    sin;
  350.     struct hostent        *hent;
  351.     SA_CHAR                buffer[1024];
  352.  
  353.     /* Get the host where the finger server is running                    */
  354.     if ((sa_param(sactx, saparams, "host", &host, &hostlen) != SA_SUCCEED)
  355.         || (hostlen == 0))
  356.     {
  357.         *infop = SA_E_INVALIDDATA;
  358.         return (SA_FAIL);
  359.     }
  360.  
  361.     (void)sa_param(sactx, saparams, "user", &user, &userlen);
  362.  
  363.     /* Get the finger server address                                */
  364.     hent = gethostbyname(host);
  365.     if (hent == NULL)
  366.     {
  367.         sprintf(buffer, "Unable to locate the specified host: '%s'", host);
  368.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  369.             return (SA_FAIL);
  370.  
  371.         return (SA_SUCCEED);
  372.     }
  373.  
  374.     /* Open a socket                                                     */
  375.     sock = socket(PF_INET, SOCK_STREAM, 0);
  376.     if (sock == INVALID_SOCKET)
  377.     {
  378.         if (sa_conn_send(saconn, "Unable to create a new TCP/IP socket.", 
  379.             SA_NULLTERM) != SA_SUCCEED)
  380.         {
  381.             return (SA_FAIL);
  382.         }
  383.  
  384.         return (SA_SUCCEED);
  385.     }
  386.  
  387.     /* Connect to the finger server                                        */
  388.     sin.sin_family = AF_INET;
  389.     sin.sin_port = htons((u_short)IPPORT_FINGER);
  390.     memcpy(&sin.sin_addr, hent->h_addr, hent->h_length);
  391.  
  392.     /* Now, connect to that WHOIS server                                */
  393.     if (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) 
  394.     {
  395.         closesocket(sock);
  396.         sprintf(buffer, "Unable to connect to the host: '%s'", host);
  397.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  398.             return (SA_FAIL);
  399.  
  400.         return (SA_SUCCEED);
  401.     }
  402.  
  403.     /* Send the request.                                                */
  404.     sprintf(buffer, "%s\r\n", userlen > 0 ? user : "");
  405.     buflen = strlen(buffer);
  406.  
  407.     if (send(sock, buffer, buflen, 0) != buflen)
  408.     {
  409.         closesocket(sock);
  410.  
  411.         sprintf(buffer, "Failure connecting to finger daemon at: '%s'", host);
  412.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  413.             return (SA_FAIL);
  414.  
  415.         return (SA_SUCCEED);
  416.     }
  417.  
  418.     /* Receive the response.                                            */
  419.     finished = 0;
  420.     while (!finished)
  421.     {
  422.         buflen = recv(sock, buffer, 1024, 0);
  423.         if ((buflen < 0) && (errno == EINTR))
  424.             continue;
  425.  
  426.         if (buflen == SOCKET_ERROR)
  427.         {
  428.             closesocket(sock);
  429.             return (SA_FAIL);
  430.         }
  431.  
  432.         if (buflen > 0)
  433.         {
  434.             if (sa_conn_send(saconn, buffer, buflen) != SA_SUCCEED)
  435.             {
  436.                 closesocket(sock);
  437.                 return (SA_FAIL);
  438.             }
  439.         }
  440.         else
  441.         {
  442.             finished = 1;
  443.         }
  444.     }
  445.  
  446.     closesocket(sock);
  447.  
  448.     if (!finished)
  449.     {
  450.         sprintf(buffer, "Finger daemon at host '%s' is not available.", host);
  451.         if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  452.             return (SA_FAIL);
  453.     }
  454.  
  455.     return (SA_SUCCEED);
  456. }
  457.