home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 August / PCWorld_2001-08_cd.bin / Komunikace / sambar / _setup.1 / ntview.c < prev    next >
C/C++ Source or Header  |  2001-06-03  |  10KB  |  418 lines
  1. /*
  2. ** WINCTRL
  3. **
  4. **      This is the NT service controller the Sambar Server. 
  5. **
  6. **        Confidential Property of Tod Sambar
  7. **        (c) Copyright Tod Sambar 2001
  8. **        All rights reserved.
  9. **
  10. **
  11. ** Syntax:
  12. **
  13. **      controller
  14. */
  15.  
  16. #include    <windows.h>
  17. #include    <stdio.h>
  18. #include    <io.h>
  19. #include    <fcntl.h>
  20. #include    <sys/types.h>
  21. #include    <sys/stat.h>
  22. #include    <share.h>
  23. #include    <process.h>
  24. #include    <sambar.h>
  25. #include    <resource.h>
  26.  
  27. /*
  28. ** Local Defines
  29. */
  30. #define SERVER_ID         1001
  31. #define SERVER_MSG         WM_USER + 69
  32. #define NAME            "Sambar Server"
  33.  
  34. static int                LogCount = 0;
  35. static int                MainX = 20;
  36. static int                MainY = 80;
  37. static HWND                MainWindow = NULL;
  38. static HWND                MainList = NULL;
  39. static HWND                ClearButton = NULL;
  40. static HINSTANCE        MainInstance;
  41. static BOOL                ShellTray = FALSE;
  42. static BOOL                Showing = FALSE;
  43. static BOOL                CheckExisting = TRUE;
  44. static char                ConfigDir[256];
  45. static NOTIFYICONDATA    IconData;
  46. static HANDLE            hPipe = NULL;
  47.  
  48.  
  49. /*
  50. ** Local Prototypes
  51. */
  52. long __stdcall         WndProc(
  53.                     HWND         hWnd, 
  54.                     UINT         message, 
  55.                     WPARAM         wParam,
  56.                     LPARAM         lParam
  57.                     );
  58. void                WndShutdown(
  59.                     void
  60.                     );
  61. void                DisplayMenu(
  62.                     HWND         hWnd
  63.                     );
  64. BOOL                 DisplayLoglines(
  65.                     HWND         hWnd
  66.                     );
  67. void                 ShutdownServer(
  68.                     HWND         hWnd
  69.                     );
  70. void                 Logger(
  71.                     void         *argp
  72.                     );
  73.  
  74.  
  75. int     __stdcall
  76. WinMain(HINSTANCE Instance, HINSTANCE PrevInstance, LPSTR CmdLine, int CmdShow)
  77. {
  78.     unsigned long    thread;
  79.     MSG                message;
  80.     HWND            hWnd;
  81.     WNDCLASS        MainClass;
  82.     HICON            ServerIcon;
  83.  
  84.     /* Save the application Instance                                    */
  85.     MainInstance = Instance;
  86.  
  87.     /* If a Server is running, show it                                    */
  88.     if (CheckExisting)
  89.     {
  90.         hWnd = FindWindow(NAME, NULL);
  91.         if (hWnd)
  92.         {
  93.             if (IsIconic(hWnd))
  94.                 ShowWindow(hWnd, SW_RESTORE);
  95.  
  96.             SetForegroundWindow(hWnd);
  97.             return (0);
  98.         } 
  99.     }
  100.  
  101.     SetErrorMode(SEM_FAILCRITICALERRORS |
  102.                  SEM_NOGPFAULTERRORBOX |
  103.                  SEM_NOOPENFILEERRORBOX);
  104.  
  105.     /* Create the tray Icon resource                                    */
  106.     ServerIcon = LoadIcon(Instance, "SERVER_ICON");
  107.  
  108.     /* Create a window class                                            */
  109.     MainClass.style =             CS_HREDRAW | CS_VREDRAW;
  110.     MainClass.lpfnWndProc =        WndProc;
  111.     MainClass.cbClsExtra =         0;
  112.     MainClass.cbWndExtra =         0;
  113.     MainClass.hInstance =         Instance;
  114.     MainClass.hIcon =             ServerIcon;
  115.     MainClass.hCursor =         LoadCursor(NULL, IDC_ARROW);
  116.     MainClass.hbrBackground =     GetStockObject(LTGRAY_BRUSH);
  117.     MainClass.lpszMenuName =     NULL;
  118.     MainClass.lpszClassName =     NAME;
  119.  
  120.     if (!RegisterClass(&MainClass))
  121.         return (0);
  122.  
  123.     if (!WaitNamedPipe("\\\\.\\pipe\\SambarServer", NMPWAIT_USE_DEFAULT_WAIT))
  124.     {
  125.         MessageBox(NULL, "Failure connecting to Sambar Server NT Service.",
  126.             NAME, MB_OK | MB_ICONSTOP);
  127.         return 0;
  128.     }
  129.  
  130.     hPipe = CreateFile("\\\\.\\pipe\\SambarServer", GENERIC_READ, 0, NULL,
  131.         OPEN_EXISTING, 0, NULL);
  132.     if (hPipe == INVALID_HANDLE_VALUE)
  133.     {
  134.         MessageBox(NULL, "Failure connecting to Sambar Server NT Service.",
  135.             NAME, MB_OK | MB_ICONSTOP);
  136.         return 0;
  137.     }
  138.  
  139.     /* Create the main window                                            */
  140.     MainWindow = CreateWindowEx(WS_EX_OVERLAPPEDWINDOW, NAME, NAME, 
  141.         (WS_THICKFRAME | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX),
  142.         CW_USEDEFAULT, 0, 600, 360, NULL, NULL, Instance, NULL);
  143.  
  144.     if (!MainWindow)
  145.     {
  146.         CloseHandle(hPipe);
  147.         return (0);
  148.     }
  149.  
  150.     /*
  151.     ** Display the header.
  152.     */
  153.     hWnd = CreateWindow("STATIC", "Header1", WS_CHILD | WS_VISIBLE,
  154.         20, 15, 300, 20, MainWindow, NULL, Instance, NULL);
  155.     SetWindowText(hWnd, "Sambar Server NT Monitor");
  156.  
  157.     /*
  158.     ** Put the buttons in.
  159.     */
  160.     ClearButton = CreateWindow("BUTTON", "Clear", WS_CHILD | WS_VISIBLE, 
  161.         MainX, MainY - 30, 50, 25, MainWindow, NULL, Instance, NULL);
  162.     SetWindowText(ClearButton, "Clear");
  163.     if (!ClearButton)
  164.     {
  165.         MessageBox(NULL, "Failure creating clear button.", 
  166.             NAME, MB_OK | MB_ICONSTOP );
  167.         CloseHandle(hPipe);
  168.         return (0);
  169.     }
  170.  
  171.     /* Create a list box for the log display                            */
  172.     MainList = CreateWindow("LISTBOX", NULL, 
  173.                     WS_CHILD|WS_BORDER|WS_VISIBLE|WS_VSCROLL|WS_HSCROLL, 
  174.                     MainX, MainY, 550, 280, MainWindow, (HMENU)1000, 
  175.                     Instance, NULL);
  176.  
  177.     if (!MainList)
  178.     {
  179.         MessageBox(NULL, "Failure creating list box.", 
  180.             NAME, MB_OK | MB_ICONSTOP );
  181.         CloseHandle(hPipe);
  182.         return (0);
  183.     }
  184.  
  185.     SendMessage(MainList, LB_SETHORIZONTALEXTENT, 2048, 0L);
  186.  
  187.     /* Start the log thread.                                            */
  188.     thread = _beginthread(Logger, 0, (void *)NULL);
  189.     if (thread == -1)
  190.         return (0);
  191.  
  192.     /* Add tray icon to system tray                                        */
  193.     IconData.cbSize             = sizeof(NOTIFYICONDATA);
  194.     IconData.hWnd                 = MainWindow;
  195.     IconData.uID                 = SERVER_ID;
  196.     IconData.uFlags             = NIF_MESSAGE | NIF_ICON | NIF_TIP;
  197.     IconData.uCallbackMessage    = SERVER_MSG;
  198.     IconData.hIcon                = ServerIcon;
  199.     strcpy(IconData.szTip, "Sambar Server Controller is Active");
  200.  
  201.     /* Win95 and NT4.0 only                                                */
  202.     if (!Shell_NotifyIcon(NIM_ADD, &IconData))
  203.     {
  204.         ShowWindow(MainWindow, CmdShow);
  205.         UpdateWindow(MainWindow);
  206.     }
  207.     else
  208.     {
  209.         ShellTray = TRUE;
  210.         ShowWindow(MainWindow, Showing ? SW_SHOW : SW_HIDE);
  211.     }
  212.  
  213.     atexit(WndShutdown);
  214.  
  215.     /* Message loop                                                        */
  216.     while (GetMessage(&message, NULL, 0, 0))
  217.         DispatchMessage(&message);
  218.  
  219.     Shell_NotifyIcon(NIM_DELETE, &IconData);
  220.     UnregisterClass(NAME, Instance);
  221.     if (hPipe != NULL)
  222.         CloseHandle(hPipe);
  223.  
  224.     return (message.wParam);
  225. }
  226.  
  227. void WndShutdown()
  228. {
  229.     Shell_NotifyIcon(NIM_DELETE, &IconData);
  230. }
  231.  
  232. long __stdcall 
  233. WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  234. {
  235.     int    hi;
  236.     int    lo;
  237.     RECT    rect;
  238.  
  239.     switch (message) 
  240.     {
  241.     case SERVER_MSG:
  242.         if ((wParam == SERVER_ID) && (lParam == WM_RBUTTONDOWN))
  243.         {
  244.             DisplayMenu(hWnd);
  245.         }
  246.         else if ((wParam == SERVER_ID) && (lParam == WM_LBUTTONDBLCLK))
  247.         {
  248.             Showing = TRUE;
  249.             ShowWindow(hWnd, SW_SHOW);
  250.         }
  251.         break;
  252.  
  253.     case WM_CLOSE:
  254.         if (ShellTray)
  255.         {
  256.             ShowWindow(MainWindow, SW_HIDE);
  257.             Showing = FALSE;
  258.         }
  259.         else
  260.         {
  261.             return DefWindowProc(hWnd, message, wParam, lParam);
  262.         }
  263.         break;
  264.  
  265.     case WM_COMMAND:
  266.         if ((HWND)lParam == ClearButton)
  267.         {
  268.             /* Clear the list box                                        */
  269.             LogCount = 1;
  270.             SendMessage(MainList, LB_RESETCONTENT, 0, 0);
  271.         }
  272.         else
  273.         {
  274.             /* Unhandled message                                        */
  275.             return DefWindowProc(hWnd, message, wParam, lParam);
  276.         }
  277.         break;
  278.  
  279.     case WM_SIZE:
  280.         hi = HIWORD(lParam);
  281.         lo = LOWORD(lParam);
  282.         GetClientRect(MainList, &rect);
  283.         if ((LOWORD(lParam) - 40 == rect.right) &&
  284.             (HIWORD(lParam) - 90 == rect.bottom))
  285.         {
  286.             return 0;
  287.         }
  288.  
  289.         /* Adjust the log box's window                                    */
  290.         MoveWindow(MainList, MainX, MainY, LOWORD(lParam) - 40, 
  291.             HIWORD(lParam) - 90, TRUE);
  292.         break;
  293.  
  294.     case WM_DESTROY:
  295.         /* Shutdown the main window                                        */
  296.         PostQuitMessage(0);
  297.         break;
  298.  
  299.     default:
  300.         /* Unhandled Messages end up here (DefWindowProc)                */
  301.         return DefWindowProc(hWnd, message, wParam, lParam);
  302.     }
  303.  
  304.     return(0);
  305. }
  306.  
  307. void
  308. DisplayMenu(HWND hWnd)
  309. {
  310.     HMENU     MenuHnd;
  311.     POINT     MousePos;
  312.     int     ScreenWidth;
  313.     int     ScreenHeight;
  314.     int     SelItem;
  315.  
  316.     MenuHnd = CreatePopupMenu();
  317.     AppendMenu(MenuHnd, MF_ENABLED, 1, "Open");
  318.     AppendMenu(MenuHnd, MF_SEPARATOR, 0, NULL);
  319.     AppendMenu(MenuHnd, MF_ENABLED, 2, "Shutdown");
  320.  
  321.     //Get Mouse Pos
  322.     GetCursorPos(&MousePos);
  323.  
  324.     //Get Screen Metrics
  325.     ScreenWidth = GetSystemMetrics(SM_CXSCREEN);
  326.     ScreenHeight = GetSystemMetrics(SM_CYSCREEN);
  327.  
  328.     SetForegroundWindow(MainWindow);
  329.  
  330.     //Handle the different possible task bar locations
  331.     if ((MousePos.x >= (ScreenWidth / 2)) && (MousePos.y >= (ScreenHeight / 2)))
  332.     {
  333.         //Bottom or Right
  334.         SelItem = TrackPopupMenu(MenuHnd,
  335.             TPM_BOTTOMALIGN | TPM_RIGHTALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON,
  336.             MousePos.x, ScreenHeight, 0, MainWindow, NULL);
  337.     }
  338.     else if (MousePos.y < (ScreenHeight / 2)) 
  339.     {
  340.         //Top
  341.         SelItem = TrackPopupMenu(MenuHnd,
  342.             TPM_TOPALIGN | TPM_RIGHTALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON,
  343.             MousePos.x, MousePos.y, 0, MainWindow, NULL);
  344.     }
  345.     else 
  346.     {
  347.         //Left
  348.         SelItem = TrackPopupMenu(MenuHnd,
  349.             TPM_BOTTOMALIGN | TPM_LEFTALIGN | TPM_RETURNCMD | TPM_LEFTBUTTON,
  350.             MousePos.x, ScreenHeight, 0, MainWindow, NULL);
  351.     }
  352.  
  353.     SetForegroundWindow(MainWindow);
  354.     DestroyMenu(MenuHnd);
  355.  
  356.     switch (SelItem)
  357.     {
  358.     case 1:
  359.         Showing = TRUE;
  360.         ShowWindow(MainWindow, SW_SHOW);
  361.         break;
  362.     case 2:
  363.         ShutdownServer(MainWindow);
  364.         break;
  365.     default:
  366.         break;
  367.     }
  368. }
  369.  
  370. void
  371. ShutdownServer(HWND MainWindow)
  372. {
  373.     int Answer;
  374.  
  375.     Answer = MessageBox(MainWindow, 
  376.         "Are you sure you want to shutdown the Sambar Server Controller?",
  377.         NAME, MB_YESNO | MB_ICONQUESTION);
  378.  
  379.     // If they do destroy the main window and let the the rest fall in place...
  380.     if (Answer == IDYES)
  381.         DestroyWindow(MainWindow);
  382. }
  383.  
  384. void Logger(void *argp)
  385. {
  386.     int        n;
  387.     int        read;
  388.     int        done;
  389.     char    buffer[1024];
  390.  
  391.     done = 0;
  392.     while (!done)
  393.     {
  394.         /* Read failure, close/shutdown */
  395.         if (!ReadFile(hPipe, buffer, 1000, &read, NULL))
  396.         {
  397.             // NT Server shutdown, quit now.
  398.             DestroyWindow(MainWindow);
  399.             PostQuitMessage(0);
  400.             CloseHandle(hPipe);
  401.             hPipe = NULL;
  402.             exit(0);
  403.         }
  404.  
  405.         LogCount++;
  406.         if (LogCount > 200)
  407.         {
  408.             LogCount = 1;
  409.             SendMessage(MainList, LB_RESETCONTENT, 0, 0);
  410.         }
  411.  
  412.         buffer[read] = '\0';
  413.         SendMessage(MainList, LB_ADDSTRING, 0, (LPARAM)(LPSTR)buffer);
  414.         n = SendMessage(MainList, LB_GETCOUNT, 0, 0);
  415.         SendMessage(MainList, LB_SETCURSEL, (unsigned int)n - 1, 0);
  416.     }
  417. }
  418.