home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 May / Pcwk5b98.iso / WEBSERVE / SAMBAR / DATA.1 / netutils.c < prev    next >
C/C++ Source or Header  |  1997-04-27  |  6KB  |  287 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. **
  17. **
  18. ** History:
  19. ** Chg#    Date    Description                                                Resp
  20. ** ----    -------    -------------------------------------------------------    ----
  21. **         2FEB97    Created                                                    sambar
  22. */
  23.  
  24. #include    <stdio.h>
  25. #include    <memory.h>
  26. #include    <string.h>
  27. #include    <stdlib.h>
  28. #include    <winsock.h>
  29. #include    <direct.h>
  30. #include    <errno.h>
  31. #include    <netutils.h>
  32.  
  33. /*
  34. ** WHOIS defines
  35. */
  36. #define WHOIS_PORT        43
  37. #define WHOIS_SERVER    "198.41.0.5"        /* rs.internic.net */
  38.  
  39. /*
  40. ** Network Utility RPC Commands
  41. */
  42. typedef struct netutils__rpcs
  43. {
  44.     SA_CHAR        *name;
  45.     SA_INT        auth;
  46.     SA_VOID        *func;
  47.     SA_CHAR        *descr;
  48. } NETUTILS__RPCS;
  49.  
  50. static NETUTILS__RPCS     netutils_rpcs [] =
  51. {
  52.     { "ipname",            SA_AUTHORIZATION_ALL,    (SA_VOID *)ipname_lookup,
  53.       "Lookup the DNS name associated with an IP address." },
  54.     { "whois",            SA_AUTHORIZATION_ALL,    (SA_VOID *)whois_lookup,
  55.       "Perform a whois lookup give a network domain name." }
  56. };
  57.  
  58. /*
  59. **  NETUTILS_INIT
  60. **
  61. **    Initialize the Network Utilities.
  62. **
  63. **  Parameters:
  64. **    sactx        Sambar Server context
  65. **
  66. **  Returns:
  67. **    SA_SUCCEED | SA_FAIL
  68. */
  69. SA_RETCODE SA_PUBLIC
  70. netutils_init(sactx)
  71. SA_CTX        *sactx;
  72. {
  73.     int            i;
  74.  
  75.     /* Register the Network Uitlities RPCs with the application            */
  76.     for (i = 0; i < sizeof(netutils_rpcs) / sizeof(NETUTILS__RPCS); i++)
  77.     {
  78.         if (sa_cmd_init(sactx, netutils_rpcs[i].name, netutils_rpcs[i].auth,
  79.             netutils_rpcs[i].descr, (SA_RPCFUNC)netutils_rpcs[i].func) 
  80.             != SA_SUCCEED)
  81.         {
  82.             sa_log(sactx, "Unable to initialize Network Utility RPCs");
  83.             return (SA_FAIL);
  84.         }
  85.     } 
  86.  
  87.     sa_log(sactx, "Network Utilities Initialized");
  88.  
  89.     return (SA_SUCCEED);
  90. }
  91.  
  92. /*
  93. **  IPNAME_LOOKUP
  94. **
  95. **    Get the host name associated with an IP address.
  96. **
  97. **  Parameters:
  98. **    sactx        Sambar Server context
  99. **    saconn        Sambar Server connection
  100. **    saparams    RPC Parameters
  101. **    infop        Error parameters
  102. **
  103. **  Returns:
  104. **    SA_SUCCEED | SA_FAIL
  105. */
  106. SA_RETCODE SA_PUBLIC
  107. ipname_lookup(sactx, saconn, saparams, infop)
  108. SA_CTX        *sactx;
  109. SA_CONN        *saconn;
  110. SA_PARAMS    *saparams;
  111. SA_INT        *infop;
  112. {
  113.     unsigned long    addr;
  114.     SA_INT            datalen;
  115.     SA_CHAR            *data;
  116.     struct hostent    *hent;
  117.  
  118.     /* Get the ip address to lookup                                        */
  119.     if ((sa_param(sactx, saparams, "ipaddr", &data, &datalen) != SA_SUCCEED) ||
  120.         (datalen == 0))
  121.     {
  122.         *infop = SA_E_INVALIDDATA;
  123.         return (SA_FAIL);
  124.     }
  125.  
  126.     addr = (int)inet_addr((char *)data);
  127.     if (addr == -1)
  128.     {
  129.         *infop = SA_E_INVALIDDATA;
  130.         return (SA_FAIL);
  131.     }
  132.  
  133.     hent = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
  134.     if (hent != NULL)
  135.     {
  136.         if (sa_conn_send(saconn, hent->h_name, SA_NULLTERM) != SA_SUCCEED)
  137.             return (SA_FAIL);
  138.     }
  139.     else
  140.     {
  141.         if (sa_conn_send(saconn, "unknown", SA_NULLTERM) != SA_SUCCEED)
  142.             return (SA_FAIL);
  143.     }
  144.  
  145.     return (SA_SUCCEED);
  146. }
  147.  
  148. /*
  149. **  WHOIS_LOOKUP
  150. **
  151. **    Perform a whois search.
  152. **
  153. **  Parameters:
  154. **    sactx        Sambar Server context
  155. **    saconn        Sambar Server connection
  156. **    saparams    RPC Parameters
  157. **    infop        Error parameters
  158. **
  159. **  Returns:
  160. **    SA_SUCCEED | SA_FAIL
  161. */
  162. SA_RETCODE SA_PUBLIC
  163. whois_lookup(sactx, saconn, saparams, infop)
  164. SA_CTX        *sactx;
  165. SA_CONN        *saconn;
  166. SA_PARAMS    *saparams;
  167. SA_INT        *infop;
  168. {
  169.     SA_INT                buflen;
  170.     SA_INT                datalen;
  171.     SA_BOOL                finished;
  172.     SOCKET                sock;
  173.     unsigned long        addr;
  174.     SA_CHAR                *data;
  175.     struct sockaddr_in    sin;
  176.     struct hostent        *hent;
  177.     SA_CHAR                buffer[1024];
  178.  
  179.     /* Get the site name                                                */
  180.     if ((sa_param(sactx, saparams, "sitename", &data, &datalen) != SA_SUCCEED)
  181.         || (datalen == 0))
  182.     {
  183.         *infop = SA_E_INVALIDDATA;
  184.         return (SA_FAIL);
  185.     }
  186.  
  187.     /* Get the WHOIS server address for the query                        */
  188.     addr = (int)inet_addr((char *)WHOIS_SERVER);
  189.     if (addr == -1)
  190.     {
  191.         *infop = SA_E_INVALIDDATA;
  192.         return (SA_FAIL);
  193.     }
  194.  
  195.     hent = gethostbyaddr((char *)&addr, sizeof(addr), AF_INET);
  196.     if (hent == NULL)
  197.     {
  198.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  199.             SA_NULLTERM) != SA_SUCCEED)
  200.         {
  201.             return (SA_FAIL);
  202.         }
  203.  
  204.         return (SA_SUCCEED);
  205.     }
  206.  
  207.     /* Create a socket                                                     */
  208.     sock = socket(hent->h_addrtype, SOCK_STREAM, 0);
  209.     if (sock == INVALID_SOCKET)
  210.     {
  211.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  212.             SA_NULLTERM) != SA_SUCCEED)
  213.         {
  214.             return (SA_FAIL);
  215.         }
  216.  
  217.         return (SA_SUCCEED);
  218.     }
  219.  
  220.     /* Connect to the WHOIS server                                        */
  221.     sin.sin_family = AF_INET;
  222.     sin.sin_port = htons((u_short)WHOIS_PORT);
  223.     memcpy(&sin.sin_addr, hent->h_addr, hent->h_length);
  224.  
  225.     /* Now, connect to that WHOIS server                                */
  226.     if (connect(sock, (struct sockaddr *)&sin, sizeof(sin)) < 0) 
  227.     {
  228.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  229.             SA_NULLTERM) != SA_SUCCEED)
  230.         {
  231.             return (SA_FAIL);
  232.         }
  233.  
  234.         return (SA_SUCCEED);
  235.     }
  236.  
  237.     /* Send the request.                                                */
  238.     sprintf(buffer, "%s\r\n", data);
  239.     buflen = strlen(buffer);
  240.  
  241.     if (send(sock, buffer, buflen, 0) != buflen)
  242.     {
  243.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  244.             SA_NULLTERM) != SA_SUCCEED)
  245.         {
  246.             return (SA_FAIL);
  247.         }
  248.  
  249.         return (SA_SUCCEED);
  250.     }
  251.  
  252.     /* Receive the response.                                            */
  253.     finished = 0;
  254.     while (!finished)
  255.     {
  256.         buflen = recv(sock, buffer, 1024, 0);
  257.         if ((buflen < 0) && (errno == EINTR))
  258.             continue;
  259.  
  260.         if (buflen == SOCKET_ERROR)
  261.             return (SA_FAIL);
  262.  
  263.         if (buflen > 0)
  264.         {
  265.             if (sa_conn_send(saconn, buffer, buflen) != SA_SUCCEED)
  266.                 return (SA_FAIL);
  267.         }
  268.         else
  269.         {
  270.             finished = 1;
  271.         }
  272.     }
  273.  
  274.     if (!finished)
  275.     {
  276.         if (sa_conn_send(saconn, "The WHOIS server is not available.", 
  277.             SA_NULLTERM) != SA_SUCCEED)
  278.         {
  279.             return (SA_FAIL);
  280.         }
  281.     }
  282.  
  283.     closesocket(sock);
  284.  
  285.     return (SA_SUCCEED);
  286. }
  287.