home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 35 Internet / 35-Internet.zip / ircd4652.zip / ircd-df-4.6.5-os2 / src / win32.c < prev    next >
C/C++ Source or Header  |  1997-12-28  |  13KB  |  526 lines
  1. /************************************************************************
  2.  *   IRC - Internet Relay Chat, win32.c
  3.  *   Copyright (C) 1996 Daniel Hazelbaker
  4.  *
  5.  *   This program is free software; you can redistribute it and/or modify
  6.  *   it under the terms of the GNU General Public License as published by
  7.  *   the Free Software Foundation; either version 1, or (at your option)
  8.  *   any later version.
  9.  *
  10.  *   This program is distributed in the hope that it will be useful,
  11.  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.  *   GNU General Public License for more details.
  14.  *
  15.  *   You should have received a copy of the GNU General Public License
  16.  *   along with this program; if not, write to the Free Software
  17.  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  */
  19.  
  20. #ifndef lint
  21. static char sccsid[] = "@(#)win32.c    ?.?? 10/21/96 (C) 1996 Daniel Hazelbaker";
  22. #endif
  23.  
  24. #define APPNAME "wIRCD"
  25.  
  26. // Windows Header Files:
  27. #include "common.h"
  28. #include <windows.h>
  29. #include <commctrl.h>
  30. #include <process.h>
  31. #include <stdio.h>
  32. #include <stdlib.h>
  33. #include <malloc.h>
  34. #include <memory.h>
  35. #include <io.h>
  36. #include <fcntl.h>
  37. #include "struct.h"
  38. #include "sys.h"
  39. #include <sys/types.h>
  40. #include <sys/stat.h>
  41. #include "h.h"
  42.  
  43. #include "resource.h"
  44. #include "CioFunc.h"
  45.  
  46.  
  47. BOOL              InitApplication(HINSTANCE);
  48. BOOL              InitInstance(HINSTANCE, int);
  49. LRESULT CALLBACK  FrameWndProc(HWND, UINT, WPARAM, LPARAM);
  50. LRESULT CALLBACK  About(HWND, UINT, WPARAM, LPARAM);
  51. LRESULT CALLBACK  Dlg_IrcdConf(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
  52. BOOL              DisplayString(HWND hWnd, char *InBuf, ...);
  53. void              LoadSetup(void);
  54. void              SaveSetup(void);
  55. int          SetDebugLevel(HWND hWnd, int NewLevel);
  56.  
  57. extern  void      SocketLoop(void *dummy), s_rehash(), do_dns_async(HANDLE id);
  58. extern  int       localdie(void), InitwIRCD(int argc, char *argv[]);
  59.  
  60.  
  61. HINSTANCE   hInst; // current instance
  62. char        szAppName[] = APPNAME; // The name of this application
  63. char        szTitle[]   = APPNAME; // The title bar text
  64. HWND        hwIRCDWnd=NULL, hCio=NULL;
  65. HANDLE      hMainThread = 0;
  66.  
  67.  
  68. /*
  69.  *  FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
  70.  *
  71.  *  PURPOSE: Entry point for the application.
  72.  *
  73.  *  COMMENTS:
  74.  *
  75.  *    This function initializes the application and processes the
  76.  *    message loop.
  77.  */
  78. int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
  79. {
  80.     MSG msg;
  81.     HANDLE hAccelTable;
  82.     int argc=1;
  83.     char *s, *argv[20], String[128];
  84.  
  85.     if (!hPrevInstance)
  86.         if (!InitApplication(hInstance))
  87.             return (FALSE);
  88.  
  89.     if (!InitInstance(hInstance, nCmdShow))
  90.         return (FALSE);
  91.  
  92.     argv[0] = "WIRCD.EXE";
  93.     if ( *(s = lpCmdLine) )
  94.         {
  95.         argv[argc++] = s;
  96.         while ( (s = strchr(s, ' ')) != NULL )
  97.             {
  98.             while ( *s == ' ' ) *s++ = 0;
  99.             argv[argc++] = s;
  100.             }
  101.         }
  102.     argv[argc] = NULL;
  103.     if ( InitwIRCD(argc, argv) != 1 )
  104.         return FALSE;
  105.  
  106.     wsprintf(String, "IRCD - %s", me.name);
  107.     SetWindowText(hwIRCDWnd, String);
  108.  
  109.     SetDebugLevel(hwIRCDWnd, debuglevel);
  110.  
  111.     hMainThread = (HANDLE)_beginthread(SocketLoop, 0, NULL);
  112.     hAccelTable = LoadAccelerators (hInstance, szAppName);
  113.  
  114.     LoadSetup();
  115.     atexit(SaveSetup);
  116.  
  117.     /* Say we are ready to recieve connections */
  118.     DisplayString(hCio, "%c%c%c%cwIRCD ready\r", 0, 0, 0, 0);
  119.  
  120.     /* Main message loop */
  121.     while (GetMessage(&msg, NULL, 0, 0))
  122.         {
  123.         if ( !TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
  124.             {
  125.             TranslateMessage(&msg);
  126.             DispatchMessage(&msg);
  127.             }
  128.         }
  129.  
  130.     return (msg.wParam);
  131.     lpCmdLine; /* This will prevent 'unused formal parameter' warnings */
  132. }
  133.  
  134.  
  135. /*
  136.  *  FUNCTION: InitApplication(HANDLE)
  137.  *
  138.  *  PURPOSE: Initializes window data and registers window class 
  139.  *
  140.  *  COMMENTS:
  141.  *
  142.  *       In this function, we initialize a window class by filling out a data
  143.  *       structure of type WNDCLASS and calling either RegisterClass or 
  144.  *       the internal MyRegisterClass.
  145.  */
  146. BOOL InitApplication(HINSTANCE hInstance)
  147. {
  148.     WNDCLASS  wc;
  149.  
  150.     // Fill in window class structure.
  151.     wc.style         = CS_HREDRAW | CS_VREDRAW;
  152.     wc.lpfnWndProc   = (WNDPROC)FrameWndProc;
  153.     wc.cbClsExtra    = 0;
  154.     wc.cbWndExtra    = 0;
  155.     wc.hInstance     = hInstance;
  156.     wc.hIcon         = LoadIcon (hInstance, APPNAME);
  157.     wc.hCursor       = LoadCursor(NULL, IDC_ARROW);
  158.     wc.hbrBackground = (HBRUSH)(COLOR_GRAYTEXT);
  159.     wc.lpszMenuName  = szAppName;
  160.     wc.lpszClassName = szAppName;
  161.  
  162.     if ( !RegisterClass(&wc) ) return 0;
  163.  
  164.     return 1;
  165. }
  166.  
  167.  
  168. /*
  169.  *   FUNCTION: InitInstance(HANDLE, int)
  170.  *
  171.  *   PURPOSE: Saves instance handle and creates main window 
  172.  *
  173.  *   COMMENTS:
  174.  *
  175.  *        In this function, we save the instance handle in a global variable and
  176.  *        create and display the main program window.
  177.  */
  178. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
  179. {
  180.     HWND hWnd;
  181.     WSADATA             WSAData;
  182.  
  183.     
  184.     if ( WSAStartup(MAKEWORD(1, 1), &WSAData) != 0 )
  185.     {
  186.         MessageBox(NULL, "wIRCD Init Error", "Unable to initialize WinSock DLL", MB_OK);
  187.         return FALSE;
  188.     }
  189.  
  190.     hInst = hInstance; /* Store instance handle in our global variable */
  191.     
  192.     if ( !Cio_Init(hInst) )
  193.     {
  194.         MessageBox(NULL, "wIRCD Init Error", "Couldn't Init CIO Library", MB_OK);
  195.         return FALSE;
  196.     }
  197.  
  198.     hWnd = CreateWindow(szAppName, szTitle, WS_OVERLAPPEDWINDOW,
  199.         CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
  200.         NULL, NULL, hInstance, NULL);
  201.  
  202.     if ( !hWnd )
  203.         return (FALSE);
  204.  
  205.     ShowWindow(hWnd, nCmdShow);
  206.     UpdateWindow(hwIRCDWnd = hWnd);
  207.  
  208.     return (TRUE);
  209. }
  210.  
  211.  
  212. /*
  213.  *  FUNCTION: FrameWndProc(HWND, unsigned, WORD, LONG)
  214.  *
  215.  *  PURPOSE:  Processes messages for the main window.
  216.  *
  217.  */
  218. LRESULT CALLBACK FrameWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
  219. {
  220.     int    wmId, wmEvent;
  221.  
  222.     switch (message)
  223.         {
  224.             case WM_CREATE:
  225.             hCio  = Cio_Create(hInst, hWnd, WS_VISIBLE, 0, 0, 300, 200);
  226.             DisplayString(hCio, "%c%c%c%cwIRCD loading\r", 0, 0, 0, 0);
  227.             return 0;
  228.  
  229.         case WM_COMMAND:
  230.             wmId    = LOWORD(wParam);
  231.             wmEvent = HIWORD(wParam);
  232.  
  233.             switch (wmId)
  234.                 {
  235.                 case IDM_ABOUT:
  236.                     DialogBox(hInst, "AboutBox", hWnd, (DLGPROC)About);
  237.                     break;
  238.  
  239.                 case IDM_IRCDCONF:
  240.                     DialogBox(hInst, "DLG_IRCDCONF", hWnd, (DLGPROC)Dlg_IrcdConf);
  241.                     break;
  242.  
  243.                 case IDM_REHASH:
  244.                     s_rehash();
  245.                     break;
  246.  
  247.                 case IDM_EXIT:
  248.                     if ( MessageBox(hWnd, "Are you sure?",
  249.                         "Terminate wIRCD",
  250.                         MB_ICONQUESTION | MB_YESNO) == IDNO )
  251.                         break;
  252.                     DestroyWindow(hWnd);
  253.                     break;
  254.  
  255.                 case IDM_DBGOFF:
  256.                 case IDM_DBGFATAL:
  257.                 case IDM_DBGERROR:
  258.                 case IDM_DBGNOTICE:
  259.                 case IDM_DBGDNS:
  260.                 case IDM_DBGINFO:
  261.                 case IDM_DBGNUM:
  262.                 case IDM_DBGSEND:
  263.                 case IDM_DBGDEBUG:
  264.                 case IDM_DBGMALLOC:
  265.                 case IDM_DBGLIST:
  266.                     SetDebugLevel(hWnd, wmId-IDM_DBGFATAL);
  267.                     break;
  268.  
  269.                 default:
  270.                     return (DefWindowProc(hWnd, message, wParam, lParam));
  271.                 }
  272.             break;
  273.  
  274.         case WM_CLOSE:
  275.             if ( MessageBox(hWnd, "Are you sure?", "Terminate wIRCD",
  276.                     MB_ICONQUESTION | MB_YESNO) == IDNO )
  277.                 break;
  278.             return (DefWindowProc(hWnd, message, wParam, lParam));
  279.  
  280.         case WM_DESTROY:
  281.             localdie();   /* Never returns */
  282.             PostQuitMessage(0);
  283.             break;
  284.  
  285.         case WM_SIZE:
  286.             SetWindowPos(hCio, NULL, 0, 0, LOWORD(lParam), HIWORD(lParam),
  287.                 SWP_NOZORDER);
  288.             /* Fallthrough to get the default handling too. */
  289.  
  290.         default:
  291.             return (DefWindowProc(hWnd, message, wParam, lParam));
  292.         }
  293.     return (0);
  294. }
  295.  
  296.  
  297. /*
  298.  *  FUNCTION: About(HWND, unsigned, WORD, LONG)
  299.  *
  300.  *  PURPOSE:  Processes messages for "About" dialog box
  301.  *         This version allows greater flexibility over the contents of the 'About' box,
  302.  *         by pulling out values from the 'Version' resource.
  303.  *
  304.  *  MESSAGES:
  305.  *
  306.  *    WM_INITDIALOG - initialize dialog box
  307.  *    WM_COMMAND    - Input received
  308.  *
  309.  */
  310. LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  311. {
  312.     switch (message)
  313.         {
  314.         case WM_INITDIALOG:
  315.             {
  316.             char    String[16384], **s = infotext;
  317.  
  318.             sprintf(String, "%s\n%s", version, creation);
  319.             SetDlgItemText(hDlg, IDC_VERSION, String);
  320.             String[0] = 0;
  321.             while ( *s )
  322.                 {
  323.                 strcat(String, *s++);
  324.                 if ( *s )
  325.                     strcat(String, "\r\n");
  326.                 }
  327.             SetDlgItemText(hDlg, IDC_INFOTEXT, String);
  328.  
  329.  
  330.             ShowWindow (hDlg, SW_SHOW);
  331.             return (TRUE);
  332.             }
  333.  
  334.         case WM_COMMAND:
  335.             if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
  336.                 {
  337.                 EndDialog(hDlg, TRUE);
  338.                 return (TRUE);
  339.                 }
  340.             break;
  341.         }
  342.     return FALSE;
  343. }
  344.  
  345.  
  346. /*
  347.  *  FUNCTION: Dlg_IrcdConf(HWND, unsigned, WORD, LONG)
  348.  *
  349.  *  PURPOSE:  Processes messages for "DLG_IRCDCONF" dialog box
  350.  *
  351.  */
  352. LRESULT CALLBACK Dlg_IrcdConf(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
  353. {
  354.     switch (message)
  355.     {
  356.         case WM_INITDIALOG:
  357.             {
  358.                 char  *Buffer = MyMalloc(65535);   /* Should be big enough */
  359.                 int   fd, Len;
  360.  
  361.                 if ( !Buffer )
  362.                 {
  363.                     MessageBox(hDlg, "Error: Could not allocate temporary buffer",
  364.                         "wIRCD Setup", MB_OK);
  365.                     EndDialog(hDlg, FALSE);
  366.                     return FALSE;
  367.                 }
  368.                 /* Open the ircd.conf file */
  369.                 fd = open(CONFIGFILE, _O_RDONLY | _O_BINARY);
  370.                 if ( fd == -1 )
  371.             {
  372.             MessageBox(hDlg, "Error: Could not open configuration file",
  373.                    "wIRCD Setup", MB_OK);
  374.             MyFree(Buffer);
  375.             EndDialog(hDlg, FALSE);
  376.             return FALSE;
  377.             }
  378.  
  379.                 Buffer[0] = 0;          /* Incase read() fails */
  380.                 Len = read(fd, Buffer, 65535);
  381.                 Buffer[Len] = 0;
  382.                 /* Set the text for the edit control to what was in the file */
  383.                 SendDlgItemMessage(hDlg, IDC_IRCDCONF, WM_SETTEXT, 0,
  384.                     (LPARAM)(LPCTSTR)Buffer);
  385.  
  386.                 close(fd);
  387.                 MyFree(Buffer);
  388.             }
  389.             return (TRUE);
  390.  
  391.         case WM_COMMAND:
  392.             if ( LOWORD(wParam) == IDOK )
  393.             {
  394.                 char  *Buffer = MyMalloc(65535);   /* Should be big enough */
  395.                 DWORD Len;
  396.                 int   fd;
  397.  
  398.                 if ( !Buffer )
  399.                 {
  400.                     MessageBox(hDlg, "Error: Could not allocate temporary buffer",
  401.                         "wIRCD Setup", MB_OK);
  402.                     return TRUE;
  403.                 }
  404.                 /* Open the ircd.conf file */
  405.                 fd = open(CONFIGFILE, _O_TRUNC|_O_CREAT|_O_RDWR|_O_BINARY,
  406.             S_IREAD|S_IWRITE);
  407.                 if ( fd == -1 )
  408.                 {
  409.                     MessageBox(hDlg, "Error: Could not open configuration file",
  410.                         "wIRCD Setup", MB_OK);
  411.                     MyFree(Buffer);
  412.                     return TRUE;
  413.                 }
  414.  
  415.                 /* Get the text from the edit control and save it to disk. */
  416.                 Len = SendDlgItemMessage(hDlg, IDC_IRCDCONF, WM_GETTEXT, 65535,
  417.                     (LPARAM)(LPCTSTR)Buffer);
  418.                 write(fd, Buffer, Len);
  419.  
  420.                 close(fd);
  421.                 MyFree(Buffer);
  422.  
  423.                 EndDialog(hDlg, TRUE);
  424.                 return TRUE;
  425.             }
  426.             if ( LOWORD(wParam) == IDCANCEL )
  427.             {
  428.                 EndDialog(hDlg, FALSE);
  429.                 return TRUE;
  430.             }
  431.             break;
  432.     }
  433.  
  434.     return FALSE;
  435. }
  436.  
  437.  
  438. int  DisplayString(HWND hWnd, char *InBuf, ...)
  439. {
  440.     CioWndInfo  *CWI;
  441.     va_list  argptr;
  442.     char    *Buffer=NULL, *Ptr=NULL;
  443.     DWORD    Len=0, TLen=0, Off=0, i=0;
  444.     BYTE     Red=0, Green=0, Blue=0;
  445.     BOOL     Bold = FALSE;
  446.  
  447.     if ( (Buffer = LocalAlloc(LPTR, 16384)) == NULL ) return FALSE;
  448.  
  449.     va_start(argptr, InBuf);
  450.     Len = vsprintf(Buffer, InBuf, argptr);
  451.     va_end(argptr);
  452.     if ( Len == 0 )
  453.     {
  454.         LocalFree(Buffer);
  455.         return FALSE;
  456.     }
  457.  
  458.     CWI = (CioWndInfo *)GetWindowLong(hWnd, GWL_USER);
  459.     for ( i = 0; i < Len; i++ )
  460.     {
  461.         if ( Buffer[i] == 0 )
  462.         {
  463.             i+=3;
  464.             continue;
  465.         }
  466.         if ( Buffer[i] == 0x02 )
  467.         {
  468.             if ( !Bold )
  469.             {
  470.                 Buffer[i] = 0;
  471.                 Cio_Puts(hWnd, Buffer+Off, i-Off);
  472.                 Red = CWI->FR;
  473.                 Green = CWI->FG;
  474.                 Blue = CWI->FB;
  475.  
  476.                 Off=i+1;
  477.                 Cio_PrintF(hWnd, "%c%c%c%c", 0, 255, 32, 32);
  478.                 Bold = 1;
  479.                 continue;
  480.             }
  481.             if ( Bold )
  482.             {
  483.                 Buffer[i] = 0;
  484.                 Cio_Puts(hWnd, Buffer+Off, i-Off);
  485.                 Off=i+1;
  486.                 Cio_PrintF(hWnd, "%c%c%c%c", 0, Red, Green, Blue);
  487.                 Bold = 0;
  488.                 continue;
  489.             }
  490.         }
  491.     }
  492.     Cio_Puts(hWnd, Buffer+Off, Len-Off);
  493.  
  494.     LocalFree(Buffer);
  495.     return TRUE;
  496. }
  497.  
  498.  
  499. void   LoadSetup(void)
  500. {
  501. }
  502.  
  503. void   SaveSetup(void)
  504. {
  505. }
  506.  
  507.  
  508. int    SetDebugLevel(HWND hWnd, int NewLevel)
  509. {
  510.     HMENU    hMenu = GetMenu(hWnd);
  511.  
  512.     if ( !hMenu || !(hMenu = GetSubMenu(hMenu, 1)) ||
  513.          !(hMenu = GetSubMenu(hMenu, 4)) )
  514.         return -1;
  515.  
  516.     CheckMenuItem(hMenu, IDM_DBGFATAL+debuglevel,
  517.         MF_BYCOMMAND | MF_UNCHECKED);
  518.     debuglevel = NewLevel;
  519.     CheckMenuItem(hMenu,IDM_DBGFATAL+debuglevel,
  520.         MF_BYCOMMAND | MF_CHECKED);
  521.  
  522.     return debuglevel;
  523. }
  524.  
  525.  
  526.