/* * This DLL contains the user interface for the serial driver. * a dialog box to configure the specified COMM port * an interface to the control panel (??) * functions to load and save default configuration * * Eventually the 32 bit comm port driver could be moved into here * and interfaced to KERNEL32 using the WIN95 or WINNT comm driver interface. * This way, different driver DLLS could be written to support other * serial interfaces, such as X.25, etc. * * Basic structure copied from COMCTL32 code. * * Copyright 2000 Mike McCormack * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "config.h" #include "wine/port.h" #include <string.h> #include <stdarg.h> #include <stdio.h> #include "windef.h" #include "winbase.h" #include "winreg.h" #include "wingdi.h" #include "winuser.h" #include "wine/debug.h" #include "serialui.h" #include "winerror.h" WINE_DEFAULT_DEBUG_CHANNEL(comm); HMODULE SERIALUI_hModule = 0; /*********************************************************************** * DllMain [Internal] Initializes the internal 'SERIALUI.DLL'. * * PARAMS * hinstDLL [I] handle to the DLL's instance * fdwReason [I] * lpvReserved [I] reserved, must be NULL * * RETURNS * Success: TRUE * Failure: FALSE */ BOOL WINAPI DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) { TRACE("%p,%lx,%p\n", hinstDLL, fdwReason, lpvReserved); switch (fdwReason) { case DLL_PROCESS_ATTACH: DisableThreadLibraryCalls(hinstDLL); SERIALUI_hModule = hinstDLL; break; case DLL_PROCESS_DETACH: break; } return TRUE; } /*********************************************************************** * EnumPropPages (SERIALUI.2) * * Called by the device manager to add prop sheets in Control Panel ??? * Pointed to in Win98 registry by * \System\CurrentControlSet\Services\Class\ports\0000\EnumPropPages = * "serialui.dll,EnumPropPages" */ typedef LPVOID LPDEVICE_INFO; typedef LPVOID LPFNADDPROPSHEETPAGE; BOOL WINAPI SERIALUI_EnumPropPages(LPDEVICE_INFO pdi, LPFNADDPROPSHEETPAGE pfnAdd, LPARAM lParam ) { FIXME("(%p %p %lx)\n",pdi,pfnAdd,lParam); return FALSE; } /* * These data structures are convert from values used in fields of a DCB * to strings used in the CommConfigDialog. */ typedef struct tagPARAM2STRDATA { DWORD val; CONST CHAR *name; } PARAM2STRDATA, *LPPARAM2STRDATA; typedef struct tagPARAM2STR { DWORD dwSize; LPPARAM2STRDATA data; } PARAM2STR, *LPPARAM2STR; typedef const LPPARAM2STR LPCPARAM2STR; #define SERIALUI_TABLESIZE(x) ((sizeof (x))/(sizeof (x[0]))) static PARAM2STRDATA SERIALUI_Baud2StrData[]={ {110, "110"}, {300, "300"}, {600, "600"}, {1200, "1200"}, {2400, "2400"}, {4800, "4800"}, {9600, "9600"}, {14400, "14400"}, {19200, "19200"}, {38400L, "38400"}, {56000L, "56000"}, {57600L, "57600"}, {115200L, "115200"}, {128000L, "128000"}, {256000L, "256000"} }; static PARAM2STR SERIALUI_Baud2Str={ SERIALUI_TABLESIZE(SERIALUI_Baud2StrData),SERIALUI_Baud2StrData }; static PARAM2STRDATA SERIALUI_Parity2StrData[]={ {NOPARITY,"None"}, {ODDPARITY,"Odd"}, {EVENPARITY,"Even"}, {MARKPARITY,"Mark"}, {SPACEPARITY,"Space"} }; static PARAM2STR SERIALUI_Parity2Str={ SERIALUI_TABLESIZE(SERIALUI_Parity2StrData),SERIALUI_Parity2StrData }; static PARAM2STRDATA SERIALUI_Stop2StrData[]={ {ONESTOPBIT,"1"}, {ONE5STOPBITS,"1.5"}, {TWOSTOPBITS,"2"} }; static PARAM2STR SERIALUI_Stop2Str={ SERIALUI_TABLESIZE(SERIALUI_Stop2StrData),SERIALUI_Stop2StrData }; static PARAM2STRDATA SERIALUI_Data2StrData[]={ {5,"5"}, {6,"6"}, {7,"7"}, {8, "8"}, {16,"16"} }; static PARAM2STR SERIALUI_Data2Str={ SERIALUI_TABLESIZE(SERIALUI_Data2StrData),SERIALUI_Data2StrData }; static PARAM2STRDATA SERIALUI_Flow2StrData[]={ {0,"None"}, {1,"Hardware (RTS/CTS)"}, {2,"Software (XON/XOFF)"} }; static PARAM2STR SERIALUI_Flow2Str={ SERIALUI_TABLESIZE(SERIALUI_Flow2StrData),SERIALUI_Flow2StrData }; /* * Add all the fields to a combo box and highlight the current value */ static void SERIALUI_AddConfItems(HWND hDlg, DWORD id, LPCPARAM2STR table, DWORD dwVal) { int i,n; HWND hControl = GetDlgItem(hDlg,id); if(!hControl) return; for(i=0; i<table->dwSize; i++) { n = SendMessageA(hControl, CB_ADDSTRING, 0L, (LPARAM)table->data[i].name); if(dwVal == table->data[i].val) { SendMessageA(hControl, CB_SETCURSEL, (WPARAM)n, (LPARAM)0); } } } /* * Get the current sellection of the given combo box and set a DCB field to * the value matching that selection. */ static BOOL SERIALUI_GetConfItems(HWND hDlg, DWORD id, LPCPARAM2STR table, LPDWORD lpdwVal) { DWORD i; CHAR lpEntry[20]; HWND hControl = GetDlgItem(hDlg,id); if( (!hControl) || (!lpdwVal)) { TRACE("Couldn't get window handle for item %lx\n",id); return FALSE; } if(!GetWindowTextA(hControl, &lpEntry[0], sizeof(lpEntry))) { TRACE("Couldn't get window text for item %lx\n",id); return FALSE; } /* TRACE("%ld contains %s\n",id, lpEntry); */ for(i=0; i<table->dwSize; i++) { if(!lstrcmpA(table->data[i].name,lpEntry)) { *lpdwVal = table->data[i].val; return TRUE; } } return FALSE; } /* * Both the enumerated values CBR_XXXX and integer baud rates are valid * dcb.BaudRate. This code is to convert back and forth between CBR_ style * and integers. The dialog box uses integer values. */ static DWORD SERIALUI_BaudConvertTable[] = { CBR_110, 110, CBR_300, 300, CBR_600, 600, CBR_1200, 1200, CBR_2400, 2400, CBR_4800, 4800, CBR_9600, 9600, CBR_14400, 14400, CBR_19200, 19200, CBR_38400, 38400, CBR_56000, 56000, CBR_57600, 57600, CBR_115200, 115200, CBR_128000, 128000, CBR_256000, 256000 }; static BOOL SERIALUI_MakeBaudDword(LPDWORD lpdwBaudRate) { int i; for(i=0; i<(sizeof(SERIALUI_BaudConvertTable)/sizeof(DWORD)); i+=2) { if(*lpdwBaudRate == SERIALUI_BaudConvertTable[i]) { *lpdwBaudRate = SERIALUI_BaudConvertTable[i+1]; return TRUE; } } return FALSE; } static BOOL SERIALUI_MakeBaudEnum(LPDWORD lpdwBaudRate) { int i; for(i=0; i<(sizeof(SERIALUI_BaudConvertTable)/sizeof(DWORD)); i+=2) { if(*lpdwBaudRate == SERIALUI_BaudConvertTable[i+1]) { *lpdwBaudRate = SERIALUI_BaudConvertTable[i]; return TRUE; } } return FALSE; } typedef struct tagSERIALUI_DialogInfo { LPCSTR lpszDevice; LPCOMMCONFIG lpCommConfig; BOOL bConvert; /* baud rate was converted to a DWORD */ DWORD dwFlowControl; /* old flow control */ } SERIALUI_DialogInfo; static void SERIALUI_DCBToDialogInfo(HWND hDlg, SERIALUI_DialogInfo *info) { DWORD dwBaudRate, dwStopBits, dwParity, dwByteSize, dwFlowControl; LPDCB lpdcb = &info->lpCommConfig->dcb; /* pass integer pointers to SERIALUI_ dialog config fns */ dwBaudRate = lpdcb->BaudRate; dwStopBits = lpdcb->StopBits; dwParity = lpdcb->Parity; dwByteSize = lpdcb->ByteSize; /* map flow control state, if it looks normal */ if((lpdcb->fRtsControl == RTS_CONTROL_HANDSHAKE) || (lpdcb->fOutxCtsFlow == TRUE)) { dwFlowControl = 1; } else if(lpdcb->fOutX || lpdcb->fInX) { dwFlowControl = 2; } else { dwFlowControl = 0; } info->bConvert = SERIALUI_MakeBaudDword(&dwBaudRate); SERIALUI_AddConfItems( hDlg, IDC_BAUD, &SERIALUI_Baud2Str ,dwBaudRate); SERIALUI_AddConfItems( hDlg, IDC_STOP, &SERIALUI_Stop2Str ,dwStopBits); SERIALUI_AddConfItems( hDlg, IDC_PARITY, &SERIALUI_Parity2Str ,dwParity); SERIALUI_AddConfItems( hDlg, IDC_DATA, &SERIALUI_Data2Str ,dwByteSize); SERIALUI_AddConfItems( hDlg, IDC_FLOW, &SERIALUI_Flow2Str, dwFlowControl ); info->dwFlowControl = dwFlowControl; } static void SERIALUI_DialogInfoToDCB(HWND hDlg, SERIALUI_DialogInfo *info) { DWORD dwBaudRate, dwStopBits, dwParity, dwByteSize, dwFlowControl; LPDCB lpdcb = &info->lpCommConfig->dcb; SERIALUI_GetConfItems( hDlg, IDC_BAUD, &SERIALUI_Baud2Str, &dwBaudRate); SERIALUI_GetConfItems( hDlg, IDC_STOP, &SERIALUI_Stop2Str, &dwStopBits); SERIALUI_GetConfItems( hDlg, IDC_PARITY, &SERIALUI_Parity2Str, &dwParity); SERIALUI_GetConfItems( hDlg, IDC_DATA, &SERIALUI_Data2Str, &dwByteSize); SERIALUI_GetConfItems( hDlg, IDC_FLOW, &SERIALUI_Flow2Str, &dwFlowControl ); TRACE("baud=%ld stop=%ld parity=%ld data=%ld flow=%ld\n", dwBaudRate, dwStopBits, dwParity, dwByteSize, dwFlowControl); lpdcb->BaudRate = dwBaudRate; lpdcb->StopBits = dwStopBits; lpdcb->Parity = dwParity; lpdcb->ByteSize = dwByteSize; /* try not to change flow control if the user didn't change it */ if(info->dwFlowControl != dwFlowControl) { switch(dwFlowControl) { case 0: lpdcb->fOutxCtsFlow = FALSE; lpdcb->fOutxDsrFlow = FALSE; lpdcb->fDtrControl = DTR_CONTROL_DISABLE; lpdcb->fOutX = FALSE; lpdcb->fInX = FALSE; lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break; case 1: /* CTS/RTS */ lpdcb->fOutxCtsFlow = TRUE; lpdcb->fOutxDsrFlow = FALSE; lpdcb->fDtrControl = DTR_CONTROL_DISABLE; lpdcb->fOutX = FALSE; lpdcb->fInX = FALSE; lpdcb->fRtsControl = RTS_CONTROL_HANDSHAKE; break; case 2: lpdcb->fOutxCtsFlow = FALSE; lpdcb->fOutxDsrFlow = FALSE; lpdcb->fDtrControl = DTR_CONTROL_DISABLE; lpdcb->fOutX = TRUE; lpdcb->fInX = TRUE; lpdcb->fRtsControl = RTS_CONTROL_DISABLE; break; } } if(info->bConvert) SERIALUI_MakeBaudEnum(&lpdcb->BaudRate); } /*********************************************************************** * SERIALUI_ConfigDialogProc * * Shows a dialog for configuring a COMM port */ INT_PTR CALLBACK SERIALUI_ConfigDialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { CHAR szTitle[30]; SERIALUI_DialogInfo *info; switch (uMsg) { case WM_INITDIALOG: info = (SERIALUI_DialogInfo*) lParam; if(!info) return FALSE; SetWindowLongA(hWnd, DWL_USER, lParam); snprintf(szTitle, sizeof(szTitle), "Settings for %s", info->lpszDevice); SetWindowTextA(hWnd, szTitle); SERIALUI_DCBToDialogInfo(hWnd, info); return TRUE; case WM_COMMAND: { WORD wID = LOWORD(wParam); info = (SERIALUI_DialogInfo *) GetWindowLongA(hWnd, DWL_USER); if(!info) EndDialog(hWnd,0); switch (wID) { case IDOK: SERIALUI_DialogInfoToDCB(hWnd,info); EndDialog(hWnd,1); return TRUE; case IDCANCEL: EndDialog(hWnd,0); return TRUE; /* test code for Get/SetDefaultCommConfig begins */ case ID_GETDEFAULT: { DWORD r,dwConfSize = sizeof (COMMCONFIG); r = GetDefaultCommConfigA(info->lpszDevice, info->lpCommConfig, &dwConfSize); if(!r) MessageBoxA(hWnd,"Failed","GetDefaultCommConfig",MB_OK); } SERIALUI_DCBToDialogInfo(hWnd, info); break; case ID_SETDEFAULT: { DWORD r; SERIALUI_DialogInfoToDCB(hWnd,info); r = SetDefaultCommConfigA(info->lpszDevice, info->lpCommConfig, sizeof (COMMCONFIG)); if(!r) MessageBoxA(hWnd,"Failed","GetDefaultCommConfig",MB_OK); } break; /* test code for Get/SetDefaultCommConfig ends */ } } default: return FALSE; } } /*********************************************************************** * drvCommConfigDialog (SERIALUI.3) * * Used by Win9x KERNEL to show a dialog for configuring a COMM port. */ BOOL WINAPI SERIALUI_CommConfigDialog( LPCSTR lpszName, HWND hWndParent, LPCOMMCONFIG lpCommConfig ) { SERIALUI_DialogInfo info; info.lpCommConfig = lpCommConfig; info.lpszDevice = lpszName; info.bConvert = FALSE; info.dwFlowControl = 0; if(!lpCommConfig) return FALSE; return DialogBoxParamA(SERIALUI_hModule, MAKEINTRESOURCEA(IDD_SERIALUICONFIG), hWndParent, SERIALUI_ConfigDialogProc, (LPARAM)&info); } static LPCSTR lpszCommKey = "System\\CurrentControlSet\\Services\\Class\\Ports"; static LPCSTR lpszDCB = "DCB"; /*********************************************************************** * drvSetDefaultCommConfig (SERIALUI.4) * * Used by Win98 KERNEL to set the default config for a COMM port * FIXME: uses the wrong registry key... should use a digit, not * the comm port name. */ BOOL WINAPI SERIALUI_SetDefaultCommConfig( LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, DWORD dwSize ) { HKEY hKeyReg=0, hKeyPort=0; CHAR szKeyName[100]; DWORD r,dwDCBSize; TRACE("%p %p %lx\n",lpszDevice,lpCommConfig,dwSize); if(!lpCommConfig) return FALSE; if(dwSize < sizeof (COMMCONFIG)) return FALSE; r = RegConnectRegistryA(NULL, HKEY_LOCAL_MACHINE, &hKeyReg); if(r != ERROR_SUCCESS) return FALSE; snprintf(szKeyName, sizeof(szKeyName), "%s\\%s", lpszCommKey ,lpszDevice); r = RegCreateKeyA(hKeyReg, szKeyName, &hKeyPort); if(r == ERROR_SUCCESS) { dwDCBSize = sizeof (DCB); r = RegSetValueExA( hKeyPort, lpszDCB, 0, REG_BINARY, (LPSTR)&lpCommConfig->dcb,dwDCBSize); TRACE("write key r=%ld\n",r); RegCloseKey(hKeyPort); } RegCloseKey(hKeyReg); return (r==ERROR_SUCCESS); } /*********************************************************************** * drvGetDefaultCommConfig (SERIALUI.5) * * Used by Win9x KERNEL to get the default config for a COMM port * FIXME: uses the wrong registry key... should use a digit, not * the comm port name. */ BOOL WINAPI SERIALUI_GetDefaultCommConfig( LPCSTR lpszDevice, LPCOMMCONFIG lpCommConfig, LPDWORD lpdwSize ) { HKEY hKeyReg, hKeyPort; CHAR szKeyName[100]; DWORD r,dwSize,dwType; TRACE("%p %p %p\n",lpszDevice,lpCommConfig,lpdwSize); if(!lpCommConfig) return FALSE; if(!lpdwSize) return FALSE; if(*lpdwSize < sizeof (COMMCONFIG)) return FALSE; *lpdwSize = sizeof (COMMCONFIG); memset(lpCommConfig, 0 , sizeof (COMMCONFIG)); lpCommConfig->dwSize = sizeof (COMMCONFIG); lpCommConfig->wVersion = 1; r = RegConnectRegistryA(NULL, HKEY_LOCAL_MACHINE, &hKeyReg); if(r != ERROR_SUCCESS) return FALSE; snprintf(szKeyName, sizeof(szKeyName), "%s\\%s", lpszCommKey ,lpszDevice); r = RegOpenKeyA(hKeyReg, szKeyName, &hKeyPort); if(r == ERROR_SUCCESS) { dwSize = sizeof (DCB); dwType = 0; r = RegQueryValueExA( hKeyPort, lpszDCB, NULL, &dwType, (LPSTR)&lpCommConfig->dcb,&dwSize); if ((r==ERROR_SUCCESS) && (dwType != REG_BINARY)) r = 1; if ((r==ERROR_SUCCESS) && (dwSize != sizeof(DCB))) r = 1; RegCloseKey(hKeyPort); } else { /* FIXME: default to a hardcoded commconfig */ lpCommConfig->dcb.DCBlength = sizeof(DCB); lpCommConfig->dcb.BaudRate = 9600; lpCommConfig->dcb.fBinary = TRUE; lpCommConfig->dcb.fParity = FALSE; lpCommConfig->dcb.ByteSize = 8; lpCommConfig->dcb.Parity = NOPARITY; lpCommConfig->dcb.StopBits = ONESTOPBIT; return TRUE; } RegCloseKey(hKeyReg); return (r==ERROR_SUCCESS); }