home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 July / PCWorld_2000-07_cd.bin / Komunik / sambar / _SETUP.1 / search.c < prev    next >
C/C++ Source or Header  |  1998-03-09  |  12KB  |  521 lines
  1. /*
  2. ** SEARCH
  3. **
  4. **      This is a simple ISAPI search DLL that takes a set of words
  5. **           to search for in the "query" parameter, and displays all files
  6. **        that match the keywords.
  7. **
  8. **        Important!  The search occurs from the location of the search.dll
  9. **        and below.  The search.dll will only work properly if placed in
  10. **        the root of your documents directory.
  11. **
  12. **        Confidential Property of Tod Sambar
  13. **        (c) Copyright Tod Sambar 1998
  14. **        All rights reserved.
  15. **
  16. **
  17. ** History:
  18. ** Chg#    Date    Description                                                Resp
  19. ** ----    -------    -------------------------------------------------------    ----
  20. **        20MAR98    Created                                                    sambar
  21. */
  22.  
  23. #include <windows.h>
  24. #include <httpext.h>
  25. #include <string.h>
  26. #include <stdio.h>
  27. #include <stdarg.h>
  28.  
  29. /*
  30. ** Globals
  31. */
  32. #define PAGE_END        "<P><B>Done.</B>\n</BODY></HTML>\n"
  33. #define INVALID_FORMAT     "<B>Invalid search syntax.</B><P><I>search?query=foo&logic=AND</I>"
  34. #define NO_RESULTS         "<P><B>No results matching search request.</B>"
  35.  
  36. /*
  37. ** Local Prototypes
  38. */
  39. static DWORD          search_error(EXTENSION_CONTROL_BLOCK *pECB, CHAR *errorstr);
  40. static void          search_find(EXTENSION_CONTROL_BLOCK *pECB, 
  41.                         CHAR *docdir, CHAR *urldir, 
  42.                         CHAR kwords[10][256], int numkwords, int any, 
  43.                         int *nump);
  44. static short          search_match(CHAR *filename, CHAR kwords[10][256], 
  45.                         int numkwords, int any);
  46. static void         escape_to_ascii(CHAR *buf, int buflen);
  47. static short         get_param(CHAR *params, CHAR *arg, CHAR *buf, int buflen);
  48. static short         get_next(CHAR *head, CHAR *buffer, CHAR **tailp);
  49.  
  50.  
  51. /*
  52. **    GetExtensionVersion
  53. **
  54. **    ISAPI/Win32 API method to ensure compatibility with the Server.
  55. */
  56. BOOL WINAPI
  57. GetExtensionVersion(HSE_VERSION_INFO *pVer)
  58. {
  59.     pVer->dwExtensionVersion = MAKELONG(HSE_VERSION_MINOR, HSE_VERSION_MAJOR);
  60.  
  61.     lstrcpyn(pVer->lpszExtensionDesc, "Sambar Server ISAPI Search extension.",
  62.             HSE_MAX_EXT_DLL_NAME_LEN);
  63.  
  64.     return TRUE;
  65. } 
  66.  
  67. /*
  68. **    HttpExtensionProc
  69. **
  70. **     Called in response to the client request.
  71. **
  72. **  Format:
  73. **        search?query="<word1> <word2>... <wordN>"&logic="AND">
  74. **  or
  75. **        search?query="<word1> <word2>... <wordN>"&logic="OR">
  76. */
  77. DWORD WINAPI
  78. HttpExtensionProc(EXTENSION_CONTROL_BLOCK *pECB)
  79. {
  80.     int        any;
  81.     int        num;
  82.     int        numkwords;
  83.     int        found;
  84.     DWORD    buflen;
  85.     CHAR    *head;
  86.     CHAR    *params;
  87.     CHAR    tmp[256];
  88.     CHAR    kwords[10][256];
  89.     CHAR    buffer[2048];
  90.     CHAR    urldir[512];
  91.  
  92.     /* Get the GET/POST data                                            */
  93.     params = NULL;
  94.     if (!stricmp(pECB->lpszMethod, "GET")) 
  95.     {
  96.         /* Set the parameters list to the QUERY_STRING data                */
  97.         params = pECB->lpszQueryString;
  98.     }
  99.     else     /* POST */
  100.     {
  101.         /* Note: cbTotalBytes = cbAvailable    in the Sambar Server        */ 
  102.         if(pECB->cbTotalBytes > 0) 
  103.             params = pECB->lpbData;
  104.     }
  105.  
  106.     if (params == NULL)
  107.         return (search_error(pECB, INVALID_FORMAT));
  108.  
  109.     /* Get the "query" and "logic" parameters                            */
  110.     if (!get_param(params, "logic", tmp, 255))
  111.         return (search_error(pECB, INVALID_FORMAT));
  112.  
  113.     if (stricmp(tmp, "and"))
  114.         any = 1;
  115.     else
  116.         any = 0;
  117.  
  118.     if (!get_param(params, "query", tmp, 255))
  119.         return (search_error(pECB, INVALID_FORMAT));
  120.  
  121.     /* Parse the query into a list.                                        */
  122.     head = tmp;
  123.     numkwords = 0;
  124.     while ((numkwords < 10) && get_next(head, kwords[numkwords], &head))
  125.     {
  126.         _strupr(kwords[numkwords]);
  127.         numkwords++;
  128.     }
  129.  
  130.     wsprintf(buffer,
  131.              "Content-Type: text/html\r\n"
  132.              "\r\n"
  133.              "<head><title>Sambar ISAPI Search</title></head>\n"
  134.              "<body><h1>Sambar ISAPI Search</h1>\n"
  135.              "<hr><P>Keywords: %s</P>\n", tmp);
  136.  
  137.     buflen = lstrlen(buffer);
  138.  
  139.     if (!pECB->ServerSupportFunction(pECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER,
  140.         "200 OK", &buflen, (LPDWORD)buffer)) 
  141.     {
  142.         pECB->dwHttpStatusCode = 500;
  143.         return HSE_STATUS_ERROR;
  144.     }
  145.  
  146.     /*
  147.     ** Search for the keywords.
  148.     */
  149.     num = 0;
  150.  
  151.     /*
  152.     ** Get the document root to search from.
  153.     */
  154.     GetModuleFileName(GetModuleHandle("search.dll"), buffer, 1024);
  155.     buflen = strlen(buffer) - strlen("\\search.dll");
  156.     buffer[buflen] = '\0';
  157.  
  158.     /*
  159.     ** Get the URL path
  160.     */
  161.     buflen = 512;
  162.     if (!pECB->GetServerVariable(pECB->ConnID, "URL", urldir, &buflen))
  163.     {
  164.         buflen = lstrlen(NO_RESULTS);
  165.         pECB->WriteClient(pECB->ConnID, NO_RESULTS, &buflen, 0);
  166.         pECB->dwHttpStatusCode = 200;
  167.         return HSE_STATUS_SUCCESS;
  168.     }
  169.  
  170.     /* Strip off to the last "directory" symbol.                        */
  171.     found = 0;
  172.     buflen = strlen(urldir);
  173.     while ((!found) && (buflen > 0))
  174.     {
  175.         if ((urldir[buflen - 1] == '/') || (urldir[buflen - 1] == '/'))
  176.             found = 1;
  177.  
  178.         buflen--;
  179.     }
  180.  
  181.     urldir[buflen] = '\0';
  182.  
  183.     search_find(pECB, buffer, urldir, kwords, numkwords, any, &num);
  184.  
  185.     if (num == 0)
  186.     {
  187.         buflen = lstrlen(NO_RESULTS);
  188.         pECB->WriteClient(pECB->ConnID, NO_RESULTS, &buflen, 0);
  189.     }
  190.  
  191.     buflen = lstrlen(PAGE_END);
  192.     pECB->WriteClient(pECB->ConnID, PAGE_END, &buflen, 0);
  193.  
  194.     pECB->dwHttpStatusCode = 200;
  195.  
  196.     return HSE_STATUS_SUCCESS;
  197. }
  198.  
  199. /*
  200. ** search_find
  201. **
  202. **        Recursively search from the directory in which the search.dll
  203. **        is located and below returning files that match the query
  204. **        criteria.
  205. */
  206. static void
  207. search_find(EXTENSION_CONTROL_BLOCK *pECB, CHAR *docdir, CHAR *urldir, 
  208.              CHAR kwords[10][256], int numkwords, int any, int *nump)
  209. {
  210.     DWORD            buflen;
  211.     HANDLE            hFile;
  212.     WIN32_FIND_DATA    findData;
  213.     CHAR            buffer[2048];
  214.     CHAR            newurl[2048];
  215.  
  216.     /*
  217.     ** Loop through all the files from the root directory.                
  218.     */
  219.     sprintf(buffer, "%s\\*.htm", docdir);
  220.     hFile = FindFirstFile(buffer, &findData);
  221.     while (hFile != INVALID_HANDLE_VALUE)
  222.     {
  223.         /* Search file handle...                                        */
  224.         sprintf(buffer, "%s\\%s", docdir, findData.cFileName);
  225.         if (search_match(buffer, kwords, numkwords, any))
  226.         {
  227.             *nump = *nump + 1;
  228.             sprintf(buffer, "<A HREF=\"%s/%s\">%s/%s</A><BR>\n", 
  229.                 urldir, findData.cFileName, urldir, findData.cFileName);
  230.             buflen = lstrlen(buffer);
  231.             pECB->WriteClient(pECB->ConnID, buffer, &buflen, 0);
  232.         }
  233.  
  234.         if (!FindNextFile(hFile, &findData))
  235.             break;
  236.     }
  237.  
  238.     FindClose(hFile);
  239.     
  240.     sprintf(buffer, "%s\\*.html", docdir);
  241.     hFile = FindFirstFile(buffer, &findData);
  242.     while (hFile != INVALID_HANDLE_VALUE)
  243.     {
  244.         /* Search file handle...                                        */
  245.         sprintf(buffer, "%s\\%s", docdir, findData.cFileName);
  246.         if (search_match(buffer, kwords, numkwords, any))
  247.         {
  248.             *nump = *nump + 1;
  249.             sprintf(buffer, "<A HREF=\"%s/%s\">%s/%s</A><BR>\n", 
  250.                 urldir, findData.cFileName, urldir, findData.cFileName);
  251.             buflen = lstrlen(buffer);
  252.             pECB->WriteClient(pECB->ConnID, buffer, &buflen, 0);
  253.         }
  254.  
  255.         if (!FindNextFile(hFile, &findData))
  256.             break;
  257.     }
  258.  
  259.     FindClose(hFile);
  260.     
  261.     sprintf(buffer, "%s\\*.txt", docdir);
  262.     hFile = FindFirstFile(buffer, &findData);
  263.     while (hFile != INVALID_HANDLE_VALUE)
  264.     {
  265.         /* Search file handle...                                        */
  266.         sprintf(buffer, "%s\\%s", docdir, findData.cFileName);
  267.         if (search_match(buffer, kwords, numkwords, any))
  268.         {
  269.             *nump = *nump + 1;
  270.             sprintf(buffer, "<A HREF=\"%s/%s\">%s/%s</A><BR>\n", 
  271.                 urldir, findData.cFileName, urldir, findData.cFileName);
  272.             buflen = lstrlen(buffer);
  273.             pECB->WriteClient(pECB->ConnID, buffer, &buflen, 0);
  274.         }
  275.  
  276.         if (!FindNextFile(hFile, &findData))
  277.             break;
  278.     }
  279.  
  280.     FindClose(hFile);
  281.     
  282.     /*
  283.     ** Recurse the directory(s)
  284.     */
  285.     sprintf(buffer, "%s\\*.*", docdir);
  286.     hFile = FindFirstFile(buffer, &findData);
  287.     while (hFile != INVALID_HANDLE_VALUE)
  288.     {
  289.         if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
  290.             (strcmp(findData.cFileName, ".") != 0) && 
  291.             (strcmp(findData.cFileName, "..") != 0))
  292.         {
  293.             sprintf(buffer, "%s\\%s", docdir, findData.cFileName);
  294.             sprintf(newurl, "%s/%s", urldir, findData.cFileName);
  295.             search_find(pECB, buffer, newurl, kwords, numkwords, any, nump);
  296.         }
  297.  
  298.         if (!FindNextFile(hFile, &findData))
  299.             break;
  300.     }
  301.  
  302.     FindClose(hFile);
  303.     
  304.     return;
  305. }
  306.  
  307. /*
  308. ** search_match
  309. **
  310. **        Determine if the file matches the search criteria provided.
  311. */
  312. static short
  313. search_match(CHAR *filename, CHAR kwords[10][256], int numkwords, int any)
  314. {
  315.     int        i;
  316.     int        matched;
  317.     FILE    *hFile;
  318.     short    match[10];
  319.     CHAR    buffer[2048];
  320.  
  321.     hFile = fopen(filename, "r");
  322.     if (hFile == NULL)
  323.         return (0);
  324.  
  325.     matched = 0;
  326.     for (i = 0; i < numkwords; i++)
  327.         match[i] = 0;
  328.         
  329.     while (fgets(buffer, 2048, hFile) != NULL)
  330.     {
  331.         _strupr(buffer);
  332.  
  333.         /* Match found?                                                    */
  334.         for (i = 0; i < numkwords; i++)
  335.         {
  336.             if (strstr(buffer, kwords[i]) != NULL)
  337.             {
  338.                 if (any)
  339.                 {
  340.                     fclose(hFile);
  341.                     return (1);
  342.                 }
  343.             
  344.                 if (!match[i])
  345.                 {
  346.                     match[i] = 1;
  347.                     matched++;
  348.                 }
  349.             }
  350.         }
  351.  
  352.         /* All words matched...                                            */
  353.         if (matched == numkwords)
  354.         {
  355.             fclose(hFile);
  356.             return (1);
  357.         }
  358.     }
  359.  
  360.     fclose(hFile);
  361.  
  362.     return 0;
  363. }
  364.  
  365. /*
  366. ** search_error
  367. **
  368. **        Report a failure of the search interface.
  369. */
  370. static DWORD
  371. search_error(EXTENSION_CONTROL_BLOCK *pECB, CHAR *errorstr)
  372. {
  373.     DWORD    buflen;
  374.     CHAR    buffer[2048];
  375.  
  376.     /* Prepare the response header                                        */
  377.     wsprintf(buffer,
  378.              "Content-Type: text/html\r\n"
  379.              "\r\n"
  380.              "<head><title>Sambar ISAPI Search</title></head>\n"
  381.              "<body><h1>Sambar ISAPI Search</h1>\n"
  382.              "<hr><P>%s</P>\n"
  383.              "</body></html>\n", errorstr);
  384.  
  385.     buflen = lstrlen(buffer);
  386.  
  387.     if (!pECB->ServerSupportFunction(pECB->ConnID, HSE_REQ_SEND_RESPONSE_HEADER,
  388.         "200 OK", &buflen, (LPDWORD)buffer)) 
  389.     {
  390.         pECB->dwHttpStatusCode = 500;
  391.         return HSE_STATUS_ERROR;
  392.     }
  393.  
  394.     pECB->dwHttpStatusCode = 200;
  395.  
  396.     return HSE_STATUS_SUCCESS;
  397. }
  398.  
  399. /*
  400. **
  401. ** Parameter Processing...
  402. **
  403. */
  404.  
  405. static CHAR
  406. hex_to_ascii(CHAR *cval) 
  407. {
  408.     CHAR     c;
  409.  
  410.     c =  (cval[0] >= 'A' ? ((cval[0] & 0xDF) - 'A') + 10 : (cval[0] - '0'));
  411.     c *= 16;
  412.     c += (cval[1] >= 'A' ? ((cval[1] & 0xDF) - 'A') + 10 : (cval[1] - '0'));
  413.  
  414.     return c;
  415. }
  416.  
  417. static void 
  418. escape_to_ascii(CHAR *buf, int buflen) 
  419. {
  420.     int i, j;
  421.  
  422.     for (i = 0, j = 0; j < buflen; ++i, ++j)
  423.     {
  424.         if ((buf[i] = buf[j]) == '%' ) 
  425.         {
  426.             buf[i] = hex_to_ascii(&buf[j+1]);
  427.             j+=2;
  428.         }
  429.     }
  430.  
  431.     buf[i] = '\0';
  432. }
  433.  
  434. /*
  435. **    GET_PARAM
  436. **
  437. */
  438. static short
  439. get_param(CHAR *params, CHAR *arg, CHAR *buf, int buflen)
  440. {
  441.     int        i;
  442.     int        len;
  443.     CHAR     *head;
  444.     CHAR     *tail;
  445.  
  446.     /*
  447.     ** Find the value passed in by the client for some particular 
  448.     ** parameter within the query string. 
  449.     */
  450.     head = strstr(params, arg);
  451.     if (!head)
  452.         return (0);
  453.  
  454.     /* Increment past the equals sign...                                */
  455.     head += strlen(arg) + 1;
  456.   
  457.     /* Now determine the length of the value string.                    */
  458.     tail = strchr(head, '&');
  459.     if (tail)        
  460.         len = tail - head;
  461.     else    
  462.         len = strlen(head);
  463.  
  464.     /* Fail if we have zero lenght string.                                */
  465.     if ((len <= 0) || (len > buflen))
  466.         return (0);
  467.  
  468.     strncpy(buf, head, len);
  469.     buf[len] = '\0'; 
  470.  
  471.     /* 
  472.     ** Now replace "+" characters with " " characters and
  473.     ** "%xx" (hexadecemal) to the ASCII representation.
  474.     */
  475.     for (i = 0; i < len; i++)
  476.     {
  477.         if (buf[i] ==  '+')
  478.             buf[i] = ' ';
  479.     }
  480.  
  481.     escape_to_ascii(buf, len);
  482.  
  483.     return (1);
  484. }
  485.  
  486. static short
  487. get_next(CHAR *head, CHAR *buffer, CHAR **tailp)
  488. {
  489.     int        hlen;
  490.     int        blen;
  491.     CHAR    end;
  492.  
  493.     hlen = 0;
  494.     end = ' ';
  495.  
  496.     while (isspace(head[hlen]))
  497.         hlen++;
  498.  
  499.     if (head[hlen] == '\0')
  500.         return (0);
  501.  
  502.     if ((head[hlen] == '"') || (head[hlen] == '\''))
  503.     {
  504.         end = head[hlen];
  505.         hlen++;
  506.     }
  507.  
  508.     blen = 0;
  509.     while ((head[hlen] != '\0') && (head[hlen] != end))
  510.     {
  511.         buffer[blen] = head[hlen];
  512.         hlen++;
  513.         blen++;
  514.     }
  515.  
  516.     buffer[blen] = '\0';
  517.     *tailp = &head[hlen];
  518.  
  519.     return (1);
  520. }
  521.