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