home *** CD-ROM | disk | FTP | other *** search
/ PC World 1999 November / PCWorld_1999-11_cd.bin / Komunik / Sambar / _setup.1 / general.c < prev    next >
C/C++ Source or Header  |  1999-03-30  |  6KB  |  281 lines
  1. /*
  2. ** GENERAL
  3. **
  4. **      HTTP Wrapper for General utility applications.
  5. **
  6. **        Confidential Property of Tod Sambar
  7. **        (c) Copyright Tod Sambar 1997
  8. **        All rights reserved.
  9. **
  10. **
  11. ** Public Functions:
  12. **
  13. **        page_count
  14. **
  15. **
  16. ** History:
  17. ** Chg#    Date    Description                                                Resp
  18. ** ----    -------    -------------------------------------------------------    ----
  19. **         10JUN97    Created                                                    sambar
  20. **         12JUL98    Added pragma-no cache to page counter                    sambar
  21. */
  22.  
  23. #include    <stdio.h>
  24. #include    <stdlib.h>
  25. #include    <memory.h>
  26. #include    <string.h>
  27. #include    <general.h>
  28.  
  29. /*
  30. ** General RPC Commands
  31. */
  32. typedef struct general__rpcs
  33. {
  34.     SA_CHAR            *name;
  35.     SA_RPCPARAM        *params;
  36.     SA_INT            numparams;
  37.     SA_INT            auth;
  38.     SA_VOID            *func;
  39.     SA_CHAR            *descr;
  40. } GENERAL__RPCS;
  41.  
  42. static SA_RPCPARAM    pagep [] =
  43. {
  44.     { "page",     1,    "Page associated with the row counter." },
  45.     { "style",     0,    "Page style: standard | plain" }
  46. };
  47.  
  48. static GENERAL__RPCS    general_rpcs [] =
  49. {
  50.     { "pagecount",    pagep,         sizeof(pagep)/sizeof(SA_RPCPARAM),
  51.       SA_AUTHORIZATION_ALL,        (SA_VOID *)page_count,
  52.       "Retrieve the number of hits for a page." }
  53. };
  54.  
  55.  
  56. /*
  57. **  GENERAL_INIT
  58. **
  59. **    Initialize the General Utility RPCS use by the Sambar Server plugins.
  60. **
  61. **
  62. **  Parameters:
  63. **    sactx        Sambar Server context
  64. **
  65. **  Returns:
  66. **    SA_SUCCEED | SA_FAIL
  67. */
  68. SA_RETCODE SA_PUBLIC
  69. general_init(sactx)
  70. SA_CTX        *sactx;
  71. {
  72.     int            i;
  73.  
  74.     /* Register the User RPCs with the server                            */
  75.     for (i = 0; i < sizeof(general_rpcs) / sizeof(GENERAL__RPCS); i++)
  76.     {
  77.         if (sa_cmd_init(sactx, general_rpcs[i].name, general_rpcs[i].params,
  78.             general_rpcs[i].numparams, general_rpcs[i].auth, 
  79.             general_rpcs[i].descr, general_rpcs[i].func) != SA_SUCCEED)
  80.         {
  81.             sa_log(sactx, "Unable to initialize General Utility RPCs");
  82.             return (SA_FAIL);
  83.         } 
  84.     }
  85.  
  86.     sa_log(sactx, "General Utilities Initialized");
  87.  
  88.     return (SA_SUCCEED);
  89. }
  90.  
  91. /*
  92. **  PAGE_COUNT
  93. **
  94. **    Retrieve the count associated with a page.
  95. **
  96. **  Parameters:
  97. **    sactx        Sambar Server context
  98. **    saconn        Sambar Server connection
  99. **    saparams    RPC Parameters
  100. **    infop        Error parameters
  101. **
  102. **  Returns:
  103. **    SA_SUCCEED | SA_FAIL
  104. */
  105. SA_RETCODE SA_PUBLIC
  106. page_count(sactx, saconn, saparams, infop)
  107. SA_CTX        *sactx;
  108. SA_CONN        *saconn;
  109. SA_PARAMS    *saparams;
  110. SA_INT        *infop;
  111. {
  112.     int            fh;
  113.     SA_INT        head;
  114.     SA_INT        datalen;
  115.       SA_INT         num, i, j;
  116.     SA_BOOL        plain;
  117.     SA_CHAR        *data;
  118.       SA_INT         count[INT_WIDTH + 1];
  119.     SA_CHAR     pagename[1024];
  120.     SA_CHAR        dirname[512];
  121.     SA_CHAR        buffer[256];
  122.  
  123.     plain = 0;
  124.     if (sa_param(sactx, saparams, "style", &data, &datalen) == SA_SUCCEED)
  125.     {
  126.         if ((datalen == 5) && (stricmp(data, "plain") == 0))
  127.             plain = 1;
  128.     }
  129.     
  130.     if (sa_param(sactx, saparams, "page", &data, &datalen) != SA_SUCCEED)
  131.     {
  132.         *infop = SA_E_INVALIDDATA;
  133.         sa_log(sactx, "page_count(): Expected parameter 'page'!");
  134.         return (SA_FAIL);
  135.     }
  136.     
  137.     if ((datalen == 0) || (datalen > 40))
  138.     {
  139.         *infop = SA_E_INVALIDDATA;
  140.         sa_log(sactx, "page_count(): 'page' field is NULL!");
  141.         return (SA_FAIL);
  142.     }
  143.  
  144.  
  145.     /*
  146.     ** Open the file with the current count.
  147.     ** The file must exist or we return 0.
  148.     */
  149.     if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_HOMEDIR, pagename,
  150.         900, &i) != SA_SUCCEED)
  151.     {
  152.         sa_log(sactx, "page_count(): Failure retrieving SA_CTXPROP_HOMEDIR!");
  153.         return (SA_FAIL);
  154.     }
  155.  
  156.     if (sa_ctx_props(sactx, SA_GET, SA_CTXPROP_APPLICDIR, dirname,
  157.         512, &j) != SA_SUCCEED)
  158.     {
  159.         sa_log(sactx, "page_count(): Failure retrieving SA_CTXPROP_APPLICDIR!");
  160.         return (SA_FAIL);
  161.     }
  162.  
  163.     sprintf(&pagename[i], "\\%s\\%s", j > 0 ? dirname : "tmp", data);
  164.  
  165.     num = 0;
  166.     if ((fh = _sopen(pagename, _O_RDWR, _SH_DENYNO, _S_IREAD|_S_IWRITE)) != -1)
  167.     {
  168.         if (_locking(fh, _LK_LOCK, 1) != -1)
  169.         {
  170.             buffer[0] = '\0';
  171.             _read(fh, buffer, INT_WIDTH);
  172.             num = atol(buffer) + 1;
  173.             lseek(fh, 0L, SEEK_SET);
  174.             sprintf(buffer, "%d\n", num);
  175.             _write(fh, buffer, strlen(buffer));
  176.             _locking(fh, _LK_UNLCK, 1);
  177.         }
  178.  
  179.         _close(fh);
  180.     }
  181.  
  182.     /* Convert the current count to an array of numbers. */
  183.     count[INT_WIDTH] = '\0';
  184.     for (i = 0; i < INT_WIDTH; ++i) 
  185.     {
  186.         j = num % 10;
  187.         count[INT_WIDTH - 1 - i] = j;
  188.         num /= 10;
  189.     }
  190.  
  191.     /* Send HTTP header */
  192.     if (sa_send_header(saconn, "HTTP/1.0 200 OK\r\n", SA_NULLTERM) 
  193.         != SA_SUCCEED)
  194.     {
  195.         return (SA_FAIL);
  196.     }
  197.  
  198.     if (sa_conn_send(saconn, "Expires: Thu, 01 Jan 1995 01:00:00:00 GMT\r\n", 
  199.         SA_NULLTERM) != SA_SUCCEED)
  200.     {
  201.         return (SA_FAIL);
  202.     }
  203.  
  204.     if (sa_conn_send(saconn, "Pragma: no-cache\r\n", SA_NULLTERM) != SA_SUCCEED)
  205.         return (SA_FAIL);
  206.  
  207.     /* MIME type is x bitmap */
  208.     if (sa_conn_send(saconn, "Content-Type: image/x-xbitmap\r\n\r\n", 
  209.         SA_NULLTERM) != SA_SUCCEED)
  210.     {
  211.         return (SA_FAIL);
  212.     }
  213.  
  214.     /* Strip leading zeros from the 'plain' display. */
  215.     head = 0;
  216.     if (plain)
  217.     {
  218.         while ((count[head] == 0) && (head < INT_WIDTH - 1))
  219.             head++;
  220.     }
  221.  
  222.        /* print the counter definitions */
  223.        sprintf(buffer, "#define counter_width %d\r\n", 
  224.         (INT_WIDTH - head) * COUNT_WIDTH);
  225.     if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  226.         return (SA_FAIL);
  227.  
  228.        sprintf(buffer, "#define counter_height %d\r\n", COUNT_HEIGHT);
  229.     if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  230.         return (SA_FAIL);
  231.  
  232.        /* print out the bitmap itself */
  233.     if (sa_conn_send(saconn, "static unsigned char counter_bits[] = {\r\n", 
  234.         SA_NULLTERM) != SA_SUCCEED)
  235.     {
  236.         return (SA_FAIL);
  237.     }
  238.  
  239.     if (plain)
  240.     {
  241.            for (i = 0; i < COUNT_HEIGHT; ++i) 
  242.         {
  243.             for (j = head; j < INT_WIDTH; ++j) 
  244.             {
  245.                    sprintf(buffer, "0x%02X, ", bitmap2[count[j]][i]);
  246.                 if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  247.                     return (SA_FAIL);
  248.             }
  249.         }
  250.     }
  251.     else
  252.     {
  253.            for (i = 0; i < COUNT_HEIGHT; ++i) 
  254.         {
  255.             for (j = 0; j < INT_WIDTH; ++j) 
  256.             {
  257.                    sprintf(buffer, "%s", bitmap[(count[j] * COUNT_HEIGHT) + i]);
  258.                 if (sa_conn_send(saconn, buffer, SA_NULLTERM) != SA_SUCCEED)
  259.                     return (SA_FAIL);
  260.     
  261.                    if (( i < COUNT_HEIGHT - 1) || (j < INT_WIDTH - 1)) 
  262.                 {
  263.                     if (sa_conn_send(saconn, ", ", SA_NULLTERM) != SA_SUCCEED)
  264.                         return (SA_FAIL);
  265.                 }
  266.             }
  267.         }
  268.  
  269.         if (sa_conn_send(saconn, "\r\n", SA_NULLTERM) != SA_SUCCEED)
  270.             return (SA_FAIL);
  271.     }
  272.  
  273.     if (sa_conn_send(saconn, "};\r\n", SA_NULLTERM) != SA_SUCCEED)
  274.         return (SA_FAIL);
  275.  
  276.     if (sa_conn_flush(saconn) != SA_SUCCEED)
  277.         return (SA_FAIL);
  278.  
  279.     return (SA_SUCCEED);
  280. }
  281.