home *** CD-ROM | disk | FTP | other *** search
/ PC World 2000 July / PCWorld_2000-07_cd.bin / Komunik / sambar / _SETUP.1 / winmain.c < prev    next >
C/C++ Source or Header  |  2000-03-15  |  16KB  |  647 lines
  1. /*
  2. ** WINMAIN
  3. **
  4. **      This is the main driver for the Windows driver of the Sambar
  5. **        Server. 
  6. **
  7. **        Confidential Property of Tod Sambar
  8. **        (c) Copyright Tod Sambar 1995-2000
  9. **        All rights reserved.
  10. **
  11. **
  12. ** Syntax:
  13. **
  14. **      server    [-bnst]
  15. **
  16. **            -b        Start a browser and load the home page.
  17. **            -n        Don't check for an existing server instance.
  18. **            -s        Show the GUI on startup.
  19. **            -t        Don't trace to GUI display when in icon tray 
  20. **                    (performance optimization).
  21. **
  22. **
  23. ** History:
  24. ** Chg#    Date    Description                                                Resp
  25. ** ----    -------    -------------------------------------------------------    ----
  26. **        9MAR97     Created                                                    sambar
  27. **        5NOV97     Simplified interface                                    sambar
  28. **        18FEB98    Added real-time log display.                            sambar
  29. */
  30.  
  31. #include    <windows.h>
  32. #include    <stdio.h>
  33. #include    <io.h>
  34. #include    <fcntl.h>
  35. #include    <sys/types.h>
  36. #include    <sys/stat.h>
  37. #include    <share.h>
  38. #include    <process.h>
  39. #include    <sambar.h>
  40. #include    <resource.h>
  41.  
  42. /*
  43. ** Local Defines
  44. */
  45. #define SERVER_ID     1001
  46. #define SERVER_MSG     WM_USER + 69
  47. #define NAME        "Sambar Server"
  48.  
  49. static int            LogCount = 0;
  50. static HWND            MainWindow = NULL;
  51. static HWND            MainList = NULL;
  52. static HWND            HideButton = NULL;
  53. static HWND            PauseButton = NULL;
  54. static HWND            ClearButton = NULL;
  55. static HWND            ConnStats = NULL;
  56. static HWND            HConnStats = NULL;
  57. static HWND            ThreadStats = NULL;
  58. static HINSTANCE    MainInstance;
  59. static BOOL            ShellTray = FALSE;
  60. static BOOL            Showing = FALSE;
  61. static BOOL            Paused = FALSE;
  62. static BOOL            AlwaysTrace = TRUE;
  63. static BOOL            StartBrowser = FALSE;
  64. static BOOL            CheckExisting = TRUE;
  65.  
  66.  
  67. /*
  68. ** Local Prototypes
  69. */
  70. long __stdcall         WndProc(
  71.                     HWND         hWnd, 
  72.                     UINT         message, 
  73.                     WPARAM         wParam,
  74.                     LPARAM         lParam
  75.                     );
  76. void                DisplayMenu(
  77.                     HWND         hWnd
  78.                     );
  79. void                RestartServer(
  80.                     HWND         hWnd
  81.                     );
  82. void                ShutdownServer(
  83.                     HWND         hWnd
  84.                     );
  85. BOOL                 DisplayLoglines(
  86.                     HWND         hWnd
  87.                     );
  88. void                 HTTPLog(
  89.                     SA_CTX         *ctx,
  90.                     SA_HTTPLOG    *httplog
  91.                     );
  92. void                 GetArgs(
  93.                     LPSTR         cmdline
  94.                     );
  95.  
  96. int     __stdcall
  97. WinMain(HINSTANCE Instance, HINSTANCE PrevInstance, LPSTR CmdLine, int CmdShow)
  98. {
  99.     unsigned long    thread;
  100.     SA_BOOL            ver3;
  101.     SA_BOOL            stopped;
  102.     SA_INT            count;
  103.     SA_CTX            *ctx;
  104.     DWORD            dwVersion;        // To hold return value from GetVersion
  105.     MSG                message;
  106.     HWND            hWnd;
  107.     WNDCLASS        MainClass;
  108.     HICON            ServerIcon;
  109.     NOTIFYICONDATA    IconData;
  110.     SA_INT            len;
  111.     SA_INT            port;
  112.     char            tmp[256];
  113.     char            name[256];
  114.     char            homedir[1024];
  115.     char            buffer[2048];
  116.  
  117.  
  118.     /* Save the application Instance                                    */
  119.     MainInstance = Instance;
  120.  
  121.     /* Process any command line arguments.                                */
  122.     GetArgs(CmdLine);
  123.  
  124.     /* If a Server is running, show it                                    */
  125.     if (CheckExisting)
  126.     {
  127.         hWnd = FindWindow(NAME, NULL);
  128.         if (hWnd)
  129.         {
  130.             if (IsIconic(hWnd))
  131.                 ShowWindow(hWnd, SW_RESTORE);
  132.  
  133.             SetForegroundWindow(hWnd);
  134.             return (0);
  135.         } 
  136.     }
  137.  
  138.     SetErrorMode(SEM_FAILCRITICALERRORS |
  139.                  SEM_NOGPFAULTERRORBOX |
  140.                  SEM_NOOPENFILEERRORBOX);
  141.  
  142.     /* Create the tray Icon resource                                    */
  143.     ServerIcon = LoadIcon(Instance, "SERVER_ICON");
  144.  
  145.     /* Create a window class                                            */
  146.     MainClass.style =             CS_HREDRAW | CS_VREDRAW;
  147.     MainClass.lpfnWndProc =        WndProc;
  148.     MainClass.cbClsExtra =         0;
  149.     MainClass.cbWndExtra =         0;
  150.     MainClass.hInstance =         Instance;
  151.     MainClass.hIcon =             ServerIcon;
  152.     MainClass.hCursor =         LoadCursor(NULL, IDC_ARROW);
  153.     MainClass.hbrBackground =     GetStockObject(LTGRAY_BRUSH);
  154.     MainClass.lpszMenuName =     NULL;
  155.     MainClass.lpszClassName =     NAME;
  156.  
  157.     if (!RegisterClass(&MainClass))
  158.         return (0);
  159.  
  160.     /* Determine if this is windows 3.51 -- change the window type        */
  161.     ver3 = 0;
  162.     dwVersion = GetVersion();
  163.     if (dwVersion < 0x80000000) 
  164.     {
  165.         if ((DWORD)(LOBYTE(LOWORD(dwVersion))) == 3)
  166.             ver3 = 1;
  167.     }
  168.  
  169.     /*
  170.     ** Start the Sambar Server.
  171.     ** On failure, the server will shutdown and destroy the MainWindow.
  172.     */
  173.     thread = _beginthread(sa_server, 0, (SA_VOID *)&MainWindow);
  174.     if (thread == -1)
  175.         return (0);
  176.  
  177.     /*
  178.     ** Wait for the server context to start up...
  179.     */
  180.     count = 0;
  181.     stopped = FALSE;
  182.     ctx = (SA_CTX *)NULL;
  183.     while ((!stopped) && (count < 20) && (ctx == (SA_CTX *)NULL))
  184.     {
  185.         if (sa_ctx_global(&ctx) != SA_SUCCEED)
  186.         {
  187.             Sleep(2000);
  188.  
  189.             /* Determine if the server has prematurely shut down        */
  190.             stopped = sa_stopped();
  191.         }
  192.  
  193.         count++;
  194.     }
  195.  
  196.     if (ctx == (SA_CTX *)NULL)
  197.     {
  198.         MessageBox(NULL, "Failure initializing server, see server.log", 
  199.             NAME, MB_OK | MB_ICONSTOP );
  200.         return (0);
  201.     }
  202.  
  203.     /* Create the main window                                            */
  204.     MainWindow = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, NAME, NAME,
  205.         (WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX),
  206.         CW_USEDEFAULT, 0, 600, 470, NULL, NULL, Instance, NULL);
  207.  
  208.     if (!MainWindow)
  209.     {
  210.         (SA_VOID)sa_shutdown(0);
  211.         return (0);
  212.     }
  213.  
  214.     /*
  215.     ** Display the Sambar Server machine/port
  216.     */
  217.     name[0] = '\0';
  218.     (SA_VOID)sa_ctx_props(ctx, SA_GET, SA_CTXPROP_SERVERSW, 
  219.         (SA_BYTE *)name, 255, &len);
  220.     hWnd = CreateWindow("STATIC", "Version", WS_CHILD | WS_VISIBLE, 
  221.         20, 15, 300, 20, MainWindow, NULL, Instance, NULL);
  222.     SetWindowText(hWnd, name);
  223.  
  224.     (SA_VOID)sa_ctx_props(ctx, SA_GET, SA_CTXPROP_BUILDID, 
  225.         (SA_BYTE *)tmp, 255, &len);
  226.     wsprintf(buffer, "Build: %s", tmp);
  227.     hWnd = CreateWindow("STATIC", "Build", WS_CHILD | WS_VISIBLE, 
  228.         350, 15, 300, 20, MainWindow, NULL, Instance, NULL);
  229.     SetWindowText(hWnd, buffer);
  230.  
  231.     hWnd = CreateWindow("STATIC", "Company", WS_CHILD | WS_VISIBLE, 
  232.         20, 40, 300, 20, MainWindow, NULL, Instance, NULL);
  233.     SetWindowText(hWnd, "Sambar Technologies");
  234.  
  235.     hWnd = CreateWindow("STATIC", "Copyright", WS_CHILD | WS_VISIBLE, 
  236.         20, 60, 300, 20, MainWindow, NULL, Instance, NULL);
  237.     SetWindowText(hWnd, "Copyright Tod Sambar 1996-2000");
  238.  
  239.     hWnd = CreateWindow("STATIC", "Reserved", WS_CHILD | WS_VISIBLE, 
  240.         20, 80, 300, 20, MainWindow, NULL, Instance, NULL);
  241.     SetWindowText(hWnd, "All rights reserved.");
  242.  
  243.     /* Setup the "real-time" statistics windows...                        */
  244.     ThreadStats = CreateWindow("STATIC", "Threads", WS_CHILD | WS_VISIBLE, 
  245.         350, 40, 300, 20, MainWindow, NULL, Instance, NULL);
  246.     SetWindowText(ThreadStats, "Server Threads: 0");
  247.  
  248.     HConnStats = CreateWindow("STATIC", "HConnections", WS_CHILD | WS_VISIBLE, 
  249.         350, 60, 300, 20, MainWindow, NULL, Instance, NULL);
  250.     SetWindowText(HConnStats, "HTTP Connections: 0");
  251.  
  252.     ConnStats = CreateWindow("STATIC", "Connections", WS_CHILD | WS_VISIBLE, 
  253.         350, 80, 300, 20, MainWindow, NULL, Instance, NULL);
  254.     SetWindowText(ConnStats, "Network Connections: 0");
  255.  
  256.     name[0] = '\0';
  257.     (SA_VOID)sa_ctx_props(ctx, SA_GET, SA_CTXPROP_SERVERNAME, 
  258.         (SA_BYTE *)name, 255, &len);
  259.     tmp[0] = '\0';
  260.     (SA_VOID)sa_ctx_props(ctx, SA_GET, SA_CTXPROP_SERVERIP, 
  261.         (SA_BYTE *)tmp, 64, &len);
  262.     (SA_VOID)sa_ctx_props(ctx, SA_GET, SA_CTXPROP_SERVERPORT, 
  263.         (SA_BYTE *)&port, sizeof(SA_INT), &len);
  264.     homedir[0] = '\0';
  265.     (SA_VOID)sa_ctx_props(ctx, SA_GET, SA_CTXPROP_HOMEDIR, 
  266.         (SA_BYTE *)homedir, 1024, &len);
  267.  
  268.     hWnd = CreateWindow("STATIC", "Server", WS_CHILD | WS_VISIBLE, 
  269.         20, 105, 300, 20, MainWindow, NULL, Instance, NULL);
  270.     wsprintf(buffer, "Sambar Server  '%s:%d'", name, port);
  271.     SetWindowText(hWnd, buffer);
  272.  
  273.     hWnd = CreateWindow("STATIC", "ipaddress", WS_CHILD | WS_VISIBLE, 
  274.         20, 125, 300, 20, MainWindow, NULL, Instance, NULL);
  275.     wsprintf(buffer, "IP Address: %s", tmp);
  276.     SetWindowText(hWnd, buffer);
  277.  
  278.     hWnd = CreateWindow("STATIC", "homedir", WS_CHILD | WS_VISIBLE, 
  279.         20, 145, 300, 20, MainWindow, NULL, Instance, NULL);
  280.     wsprintf(buffer, "Server Dir: %s", homedir);
  281.     SetWindowText(hWnd, buffer);
  282.  
  283.     /* Create a list box for the log display                            */
  284.     MainList = CreateWindow("LISTBOX", NULL, 
  285.                     WS_CHILD|WS_BORDER|WS_VISIBLE|WS_VSCROLL|WS_HSCROLL, 
  286.                     20, 170, 550, 240, MainWindow, (HMENU)1000, 
  287.                     Instance, NULL);
  288.  
  289.     if (!MainList)
  290.     {
  291.         MessageBox(NULL, "Failure creating list box.", 
  292.             NAME, MB_OK | MB_ICONSTOP );
  293.         (SA_VOID)sa_shutdown(0);
  294.         return (0);
  295.     }
  296.  
  297.     SendMessage(MainList, LB_SETHORIZONTALEXTENT, 2048, 0L);
  298.  
  299.     /*
  300.     ** Put the buttons in.
  301.     */
  302.     ClearButton = CreateWindow("BUTTON", "Clear", WS_CHILD | WS_VISIBLE, 
  303.         20, 400, 50, 25, MainWindow, NULL, Instance, NULL);
  304.     SetWindowText(ClearButton, "Clear");
  305.     if (!ClearButton)
  306.     {
  307.         MessageBox(NULL, "Failure creating clear button.", 
  308.             NAME, MB_OK | MB_ICONSTOP );
  309.         (SA_VOID)sa_shutdown(0);
  310.         return (0);
  311.     }
  312.  
  313.     PauseButton = CreateWindow("BUTTON", "Pause", WS_CHILD | WS_VISIBLE, 
  314.         240, 400, 90, 25, MainWindow, NULL, Instance, NULL);
  315.     SetWindowText(PauseButton, "Pause");
  316.     if (!PauseButton)
  317.     {
  318.         MessageBox(NULL, "Failure creating pause button.", 
  319.             NAME, MB_OK | MB_ICONSTOP );
  320.         (SA_VOID)sa_shutdown(0);
  321.         return (0);
  322.     }
  323.  
  324.     HideButton = CreateWindow("BUTTON", "Hide", WS_CHILD | WS_VISIBLE, 
  325.         520, 400, 50, 25, MainWindow, NULL, Instance, NULL);
  326.     SetWindowText(HideButton, "Hide");
  327.     if (!HideButton)
  328.     {
  329.         MessageBox(NULL, "Failure creating hide button.", 
  330.             NAME, MB_OK | MB_ICONSTOP );
  331.         (SA_VOID)sa_shutdown(0);
  332.         return (0);
  333.     }
  334.  
  335.     /* Add tray icon to system tray                                        */
  336.     IconData.cbSize             = sizeof(NOTIFYICONDATA);
  337.     IconData.hWnd                 = MainWindow;
  338.     IconData.uID                 = SERVER_ID;
  339.     IconData.uFlags             = NIF_MESSAGE | NIF_ICON | NIF_TIP;
  340.     IconData.uCallbackMessage    = SERVER_MSG;
  341.     IconData.hIcon                = ServerIcon;
  342.     strcpy(IconData.szTip, "Sambar Server is Active");
  343.  
  344.     /* Win95 and NT4.0 only                                                */
  345.     if (!Shell_NotifyIcon(NIM_ADD, &IconData))
  346.     {
  347.         ShowWindow(MainWindow, CmdShow);
  348.         UpdateWindow(MainWindow);
  349.     }
  350.     else
  351.     {
  352.         ShellTray = TRUE;
  353.         ShowWindow(MainWindow, Showing ? SW_SHOW : SW_HIDE);
  354.     }
  355.  
  356.     /* Register the HTTP Log callback.                                    */
  357.     (SA_VOID)sa_ctx_props(ctx, SA_SET, SA_CTXPROP_HTTPLOGFUNC, 
  358.         (SA_BYTE *)HTTPLog, sizeof(SA_VOID *), (SA_INT *)NULL);
  359.  
  360.     /* Start the Web Browser to the home page                             */
  361.     if (StartBrowser)
  362.     {
  363.         if (port != 80)
  364.             wsprintf(buffer, "http://localhost:%d/", port);
  365.         else
  366.             strcpy(buffer, "http://localhost/");
  367.  
  368.         ShellExecute(GetTopWindow(NULL), "open", buffer, NULL, NULL, 
  369.             SW_SHOWNORMAL);
  370.     }
  371.  
  372.     /* Message loop                                                        */
  373.     while (GetMessage(&message, NULL, 0, 0))
  374.         DispatchMessage(&message);
  375.  
  376.     /* Shutdown the Sambar Server                                        */
  377.     (SA_VOID)sa_shutdown(0);
  378.  
  379.     Shell_NotifyIcon(NIM_DELETE, &IconData);
  380.     UnregisterClass(NAME, Instance);
  381.  
  382.     return (message.wParam);
  383. }
  384.  
  385. long __stdcall 
  386. WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  387. {
  388.     switch (message) 
  389.     {
  390.     case SERVER_MSG:
  391.         if ((wParam == SERVER_ID) && (lParam == WM_RBUTTONDOWN))
  392.         {
  393.             DisplayMenu(hWnd);
  394.         }
  395.         else if ((wParam == SERVER_ID) && (lParam == WM_LBUTTONDBLCLK))
  396.         {
  397.             Showing = TRUE;
  398.             ShowWindow(hWnd, SW_SHOW);
  399.         }
  400.         break;
  401.  
  402.     case WM_COMMAND:
  403.         if ((HWND)lParam == HideButton)
  404.         {
  405.             if (ShellTray)
  406.                 ShowWindow(MainWindow, SW_HIDE);
  407.             else
  408.                 ShowWindow(MainWindow, SW_MINIMIZE);
  409.  
  410.             LogCount = 1;
  411.             Showing = FALSE;
  412.             SendMessage(MainList, LB_RESETCONTENT, 0, 0);
  413.         }
  414.         else if ((HWND)lParam == PauseButton)
  415.         {
  416.             if (Paused)
  417.             {
  418.                 Paused = FALSE;
  419.                 sa_pause(TRUE);
  420.                 SetWindowText(PauseButton, "Pause");
  421.             }
  422.             else
  423.             {
  424.                 Paused = TRUE;
  425.                 sa_pause(FALSE);
  426.                 SetWindowText(PauseButton, "Un-Pause");
  427.             }
  428.         }
  429.         else if ((HWND)lParam == ClearButton)
  430.         {
  431.             /* Clear the list box                                        */
  432.             LogCount = 1;
  433.             SendMessage(MainList, LB_RESETCONTENT, 0, 0);
  434.         }
  435.         else
  436.         {
  437.             /* Unhandled message                                        */
  438.             DefWindowProc(hWnd, message, wParam, lParam);
  439.         }
  440.         break;
  441.  
  442.     case WM_DESTROY:
  443.         /* Shutdown the main window                                        */
  444.         PostQuitMessage(0);
  445.         break;
  446.  
  447.     default:
  448.         /* Unhandled Messages end up here (DefWindowProc)                */
  449.         return DefWindowProc(hWnd, message, wParam, lParam);
  450.     }
  451.  
  452.     return(0);
  453. }
  454.  
  455. void
  456. DisplayMenu(HWND hWnd)
  457. {
  458.     HMENU     MenuHnd;
  459.     POINT     MousePos;
  460.     int     ScreenWidth;
  461.     int     ScreenHeight;
  462.     int     SelItem;
  463.  
  464.     MenuHnd = CreatePopupMenu();
  465.     AppendMenu(MenuHnd, MF_ENABLED, 1, "Open");
  466.     AppendMenu(MenuHnd, MF_SEPARATOR, 0, NULL);
  467.     AppendMenu(MenuHnd, MF_ENABLED, 2, "Restart");
  468.     AppendMenu(MenuHnd, MF_ENABLED, 3, "Shutdown");
  469.  
  470.     //Get Mouse Pos
  471.     GetCursorPos(&MousePos);
  472.  
  473.     //Get Screen Metrics
  474.     ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
  475.     ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
  476.  
  477.     SetForegroundWindow(MainWindow);
  478.  
  479.     //Handle the different possible task bar locations
  480.     if ((MousePos.x >= (ScreenWidth / 2)) && (MousePos.y >= (ScreenHeight / 2)))
  481.     {
  482.         //Bottom or Right
  483.         SelItem = TrackPopupMenu(MenuHnd,
  484.             TPM_BOTTOMALIGN | TPM_RIGHTALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON,
  485.             MousePos.x, ScreenHeight, 0, MainWindow, NULL);
  486.     }
  487.     else if (MousePos.y < (ScreenHeight / 2)) 
  488.     {
  489.         //Top
  490.         SelItem = TrackPopupMenu(MenuHnd,
  491.             TPM_TOPALIGN | TPM_RIGHTALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON,
  492.             MousePos.x, MousePos.y, 0, MainWindow, NULL);
  493.     }
  494.     else 
  495.     {
  496.         //Left
  497.         SelItem = TrackPopupMenu(MenuHnd,
  498.             TPM_BOTTOMALIGN | TPM_LEFTALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON,
  499.             MousePos.x, ScreenHeight, 0, MainWindow, NULL);
  500.     }
  501.  
  502.     SetForegroundWindow(MainWindow);
  503.     DestroyMenu(MenuHnd);
  504.  
  505.     switch (SelItem)
  506.     {
  507.     case 1:
  508.         Showing = TRUE;
  509.         ShowWindow(MainWindow, SW_SHOW);
  510.         break;
  511.     case 2:
  512.         RestartServer(MainWindow);
  513.         break;
  514.     case 3:
  515.         ShutdownServer(MainWindow);
  516.         break;
  517.     default:
  518.         break;
  519.     }
  520. }
  521.  
  522. void
  523. ShutdownServer(HWND MainWindow)
  524. {
  525.     int Answer;
  526.  
  527.     Answer = MessageBox(MainWindow, 
  528.                 "Are you sure you want to shutdown the Sambar Server?",
  529.                 NAME, MB_YESNO | MB_ICONQUESTION);
  530.  
  531.     // If they do destroy the main window and let the the rest fall in place...
  532.     if (Answer == IDYES)
  533.         DestroyWindow(MainWindow);
  534. }
  535.  
  536. void
  537. RestartServer(HWND MainWindow)
  538. {
  539.     int Answer;
  540.  
  541.     Answer = MessageBox(MainWindow, 
  542.                 "Are you sure you want to restart the Sambar Server?",
  543.                 NAME, MB_YESNO | MB_ICONQUESTION);
  544.  
  545.     // If they do destroy the main window and let the the rest fall in place...
  546.     if (Answer == IDYES)
  547.         sa_shutdown(1);
  548. }
  549.  
  550.  
  551. void
  552. HTTPLog(SA_CTX *ctx, SA_HTTPLOG    *httplog)
  553. {
  554.     int        i;
  555.     int        n;
  556.     char    timestr[32];
  557.     char    str[2048];
  558.  
  559.     if (!MainList)
  560.         return;
  561.  
  562.     if ((!Showing) && (!AlwaysTrace))
  563.         return;
  564.  
  565.     LogCount++;
  566.     if (LogCount > 200)
  567.     {
  568.         LogCount = 1;
  569.         SendMessage(MainList, LB_RESETCONTENT, 0, 0);
  570.     }
  571.  
  572.     i = 0;
  573.     while ((httplog->timestamp[i] != '\0') && (httplog->timestamp[i] != ':'))
  574.         i++;
  575.  
  576.     n = 0;
  577.     while ((httplog->timestamp[i] != '\0') && 
  578.         (httplog->timestamp[i] != ' ') &&
  579.         (n < 16))
  580.     {
  581.         timestr[n] = httplog->timestamp[i];
  582.         n++;
  583.         i++;
  584.     }
  585.  
  586.     timestr[0] = '[';
  587.     timestr[n] = ']';
  588.     timestr[n+1] = '\0';
  589.  
  590.     sprintf(str, "[%s]  %s  %s  %ld  %s  %s    %ld", 
  591.         httplog->vhost, timestr, httplog->user, httplog->status, 
  592.         httplog->method, httplog->request, httplog->size);
  593.     SendMessage(MainList, LB_ADDSTRING, 0, (LPARAM)(LPSTR)str);
  594.     
  595.     n = SendMessage(MainList, LB_GETCOUNT, 0, 0);
  596.     SendMessage(MainList, LB_SETCURSEL, (unsigned int)n - 1, 0);
  597.  
  598.     sprintf(str, "Server Threads: %ld", httplog->threads);
  599.     SetWindowText(ThreadStats, str);
  600.     sprintf(str, "HTTP Connections: %ld", httplog->httpconns);
  601.     SetWindowText(HConnStats, str);
  602.     sprintf(str, "Network Connections: %ld", httplog->allconns);
  603.     SetWindowText(ConnStats, str);
  604.             
  605.     return;
  606. }
  607.  
  608. void
  609. GetArgs(LPSTR CmdLine)
  610. {
  611.     char    *p;
  612.  
  613.     if (CmdLine == NULL)
  614.         return;
  615.  
  616.     p = CmdLine;
  617.     while (*p != '\0')
  618.     {
  619.         switch ((int)*p)
  620.         {
  621.         case 'b':
  622.         case 'B':
  623.             StartBrowser = TRUE;
  624.             break;
  625.         case 'n':
  626.         case 'N':
  627.             CheckExisting = FALSE;
  628.             break;
  629.         case 's':
  630.         case 'S':
  631.             Showing = TRUE;
  632.             break;
  633.         case 't':
  634.         case 'T':
  635.             AlwaysTrace = FALSE;
  636.             break;
  637.         case '-':
  638.         default:
  639.             break;
  640.         }
  641.  
  642.         p++;
  643.     }
  644.  
  645.     return;
  646. }
  647.