home *** CD-ROM | disk | FTP | other *** search
/ Chip 2000 February / CHIPCD_2_2000.iso / software / kamery / webcam / webcam32.exe / webcam32cgi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-12-09  |  4.2 KB  |  184 lines
  1. /*
  2.  
  3. File: client.c - Generic Unix flavor
  4. Project: WebCam32
  5. Author: Neil Kolban
  6. Date: 05/27/97
  7.  
  8. Function:
  9. This program is a CGI client which receives information from the Web Browser
  10. and attempts to communicate with the back-end server WebCam32 application 
  11. using sockets.
  12.  
  13. */
  14.  
  15. #include <errno.h>         /* errno extern                */
  16. #include <unistd.h>        /* gethostname()               */
  17. #include <fcntl.h>         /* File info                      */
  18. #include <sys/time.h>      /* Required for struct timeval */
  19. #include <sys/select.h>    /* Required for select()       */
  20. #include <sys/socket.h>    /* Sockets constants           */
  21. #include <netdb.h>
  22. #include <netinet/in.h>
  23.  
  24. #define WEBCAM_PORT    (8888)    /* Deafult Webcam32 port */
  25.  
  26. static char            *headerTEXT="Content-type: text/plain\n\n";
  27.  
  28.  
  29.  
  30. /*
  31.  
  32. Function: WaitForSocket
  33.  
  34. Inputs:
  35.  
  36. o fd - File descriptor on which to wait for data
  37.  
  38. o seconds - Number of seconds before read timeout.
  39.  
  40. */
  41. int WaitForSocket(int fd, int seconds)
  42. {
  43.     struct timeval timeout;
  44.     fd_set         readfds;
  45.     int            rc;
  46.  
  47.     timeout.tv_sec  = seconds;
  48.     timeout.tv_usec = 0;
  49.     FD_ZERO(&readfds);
  50.     FD_SET(fd, &readfds);
  51.  
  52.     rc = select(fd+1, &readfds, NULL, NULL, &timeout);
  53.     if (rc <= 0)
  54.     {
  55.         return(0);
  56.     }
  57.     return(1);
  58. }
  59.  
  60.  
  61. /*
  62.  
  63. Function: WriteHTML
  64.  
  65. Purpose:
  66.  
  67. Send HTML output to stdout (file descriptor 1)
  68.  
  69. */
  70. void WriteHTML(char *data, int length)
  71. {
  72.     write(1, data, length);
  73.     return;
  74. }
  75.  
  76. void WriteErrorText(char *errorMessage)
  77. {
  78.     WriteHTML(headerTEXT, strlen(headerTEXT));
  79.     WriteHTML(errorMessage, strlen(errorMessage));
  80.     return;
  81. }
  82.  
  83. int main(int args, char *argv[])
  84. {
  85.     int                   rc;
  86.     int                   servfd;
  87.     struct sockaddr_in    servsockaddr;
  88.     long                  address;
  89.     short                 port;
  90.     struct hostent        *he;
  91.     char                  hostname[256];
  92.     char                  buffer[64*1024];
  93.     char                  requestMessage[]="WEBCAM32CGI\n";
  94.     char                  *queryString;
  95.     char                  *ptr;
  96.     int                   i;
  97.  
  98.  
  99.  
  100.     /*setmode(fileno(stdout), O_BINARY); */
  101.  
  102.     queryString = (char *)getenv("QUERY_STRING");
  103.     if (queryString == NULL || strlen(queryString)==0)
  104.     {
  105.         rc = gethostname(hostname, sizeof(hostname));
  106.         if (rc == -1)
  107.         {
  108.             sprintf(buffer, 
  109.                 "Webcamcgi: Failed to gethostname(): %d\n", 
  110.                 errno);
  111.             WriteErrorText(buffer);
  112.             return(0);
  113.         }
  114.         port = WEBCAM_PORT;
  115.     }
  116.     else
  117.     {
  118.         ptr = queryString;
  119.         for (i=0; *ptr != ',' && *ptr != '\0'; i++, ptr++)
  120.         {
  121.             if (*ptr != ' ' && *ptr !='\t')
  122.             {
  123.                 hostname[i] = *ptr;
  124.             }
  125.         }
  126.         hostname[i]='\0';
  127.         if (*ptr == '\0')
  128.         {
  129.             port = WEBCAM_PORT;
  130.         }
  131.         else
  132.         {
  133.             port = atoi(ptr+1);
  134.         }
  135.     }
  136.  
  137.     
  138.  
  139.     servfd = socket(AF_INET, SOCK_STREAM, 0);
  140.     if (servfd < 0)
  141.     {
  142.         printf("Failed to socket()\n");
  143.         return(0);
  144.     }
  145.     
  146.     address = inet_addr(hostname);
  147.     if (address == INADDR_NONE)
  148.     {
  149.         he = gethostbyname(hostname);
  150.         if (he == 0)
  151.         {
  152.             sprintf(buffer, "Webcamcgi: Failed to gethostbyname(%s)", hostname);
  153.             WriteErrorText(buffer);
  154.             return(0);
  155.         }
  156.         address = *(long *)he->h_addr;
  157.     }
  158.     servsockaddr.sin_port = htons(port);
  159.     servsockaddr.sin_family = AF_INET;
  160.     servsockaddr.sin_addr.s_addr = address; 
  161.     rc = connect(servfd, 
  162.                  (struct sockaddr *)&servsockaddr, 
  163.                  sizeof(servsockaddr));
  164.     if (rc < 0)
  165.     {
  166.         return(0);
  167.     }
  168.     send(servfd, requestMessage, strlen(requestMessage), 0);
  169.     do
  170.     {
  171.         if (WaitForSocket(servfd, 20)==0)
  172.         {
  173.             break;
  174.         }
  175.         rc = recv(servfd, buffer, sizeof(buffer), 0);
  176.         if (rc > 0)
  177.         {
  178.             WriteHTML(buffer, rc);
  179.         }
  180.     } while(rc >0);
  181.     close(servfd);
  182.     return(0);
  183. }
  184. /* EOF */