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