diff options
Diffstat (limited to '')
27 files changed, 10647 insertions, 0 deletions
diff --git a/private/tapi/dev/sp/repeater/app/makefile b/private/tapi/dev/sp/repeater/app/makefile new file mode 100644 index 000000000..f1084966b --- /dev/null +++ b/private/tapi/dev/sp/repeater/app/makefile @@ -0,0 +1,29 @@ +!if "$(OS)" == "Windows_NT" + +!INCLUDE $(NTMAKEENV)\makefile.def + +!else + +############################################################################## +# +# Dialer.exe Make file +# +############################################################################## + +#Ok, we're doing a Win9x build. + +ROOT=..\..\..\..\.. + +VERSIONLIST=debug retail + +DEPENDNAME=depend.mk + +COMMONMKFILE=makefile.def + +IS_OEM=TRUE +IS_32 = TRUE + +!include $(ROOT)\dev\master.mk + +!endif + diff --git a/private/tapi/dev/sp/repeater/app/repapp.c b/private/tapi/dev/sp/repeater/app/repapp.c new file mode 100644 index 000000000..0c8f7a862 --- /dev/null +++ b/private/tapi/dev/sp/repeater/app/repapp.c @@ -0,0 +1,1093 @@ +////////////////////////////////////////////////////////////////////////////// +// +// +// +////////////////////////////////////////////////////////////////////////////// +#include <windows.h> +#include <stdio.h> +#include <commdlg.h> +#include "resource.h" +#include "..\new\logger.h" +////////////////////////////////////////////////////////////////////////////// +// PROTOTYPES +////////////////////////////////////////////////////////////////////////////// +static BOOL CreateMainWindow (int nCmdShow); + +static LRESULT CALLBACK MainWndProc (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam); +BOOL LogFileNameProc(); +BOOL DoStructKey(); +BOOL DoPostKey(); +BOOL DoPreKey(); +void WriteToListBox(LPSTR lpszText, ...); +BOOL ReadInLogFile(); +BOOL OpenLogFile(); +BOOL ReadKey(LPDWORD lpdwKey); + +////////////////////////////////////////////////////////////////////////////// +// GLOBALS +////////////////////////////////////////////////////////////////////////////// +HINSTANCE ghInstance; +HWND ghMainWnd; +HWND ghListWnd; +char gszLogFileName[MAX_PATH]; +HANDLE ghLogFile; + +LPSTR glpszFunctions[] = +{ + "TSPI_lineAccept", + "TSPI_lineAddToConference", + "TSPI_lineAgentSpecific", + "TSPI_lineAnswer", + "TSPI_lineBlindTransfer", + "TSPI_lineClose", + "TSPI_lineCloseCall", + "TSPI_lineCompleteCall", + "TSPI_lineCompleteTransfer", + "TSPI_lineConditionalMediaDetection", + "TSPI_lineDevSpecific", + "TSPI_lineDevSpecificFeature", + "TSPI_lineDial", + "TSPI_lineDrop", + "TSPI_lineForward", + "TSPI_lineGatherDigits", + "TSPI_lineGenerateDigits", + "TSPI_lineGenerateTone", + "TSPI_lineGetAddressCaps", + "TSPI_lineGetAddressID", + "TSPI_lineGetAddressStatus", + "TSPI_lineGetAgentActivityList", + "TSPI_lineGetAgentCaps", + "TSPI_lineGetAgentGroupList", + "TSPI_lineGetAgentStatus", + "TSPI_lineGetCallAddressID", + "TSPI_lineGetCallInfo", + "TSPI_lineGetCallStatus", + "TSPI_lineGetDevCaps", + "TSPI_lineGetDevConfig", + "TSPI_lineGetExtensionID", + "TSPI_lineGetIcon", + "TSPI_lineGetID", + "TSPI_lineGetLineDevStatus", + "TSPI_lineGetNumAddressIDs", + "TSPI_lineHold", + "TSPI_lineMakeCall", + "TSPI_lineMonitorDigits", + "TSPI_lineMonitorMedia", + "TSPI_lineMonitorTones", + "TSPI_lineNegotiateExtVersion", + "TSPI_lineNegotiateTSPIVersion", + "TSPI_lineOpen", + "TSPI_linePark", + "TSPI_linePickup", + "TSPI_linePrepareAddToConference", + "TSPI_lineRedirect", + "TSPI_lineReleaseUserUserInfo", + "TSPI_lineRemoveFromConference", + "TSPI_lineSecureCall", + "TSPI_lineSelectExtVersion", + "TSPI_lineSendUserUserInfo", + "TSPI_lineSetAgentActivity", + "TSPI_lineSetAgentGroup", + "TSPI_lineSetAgentState", + "TSPI_lineSetAppSpecific", + "TSPI_lineSetCallData", + "TSPI_lineSetCallParams", + "TSPI_lineSetCallQualityOfService", + "TSPI_lineSetCallTreatment", + "TSPI_lineSetCurrentLocation", + "TSPI_lineSetDefaultMediaDetection", + "TSPI_lineSetDevConfig", + "TSPI_lineSetLineDevStatus", + "TSPI_lineSetMediaControl", + "TSPI_lineSetMediaMode", + "TSPI_lineSetStatusMessages", + "TSPI_lineSetTerminal", + "TSPI_lineSetupConference", + "TSPI_lineSetupTransfer", + "TSPI_lineSwapHold", + "TSPI_lineUncompleteCall", + "TSPI_lineUnhold", + "TSPI_lineUnpark", + "TSPI_phoneClose", + "TSPI_phoneDevSpecific", + "TSPI_phoneGetButtonInfo", + "TSPI_phoneGetData", + "TSPI_phoneGetDevCaps", + "TSPI_phoneGetDisplay", + "TSPI_phoneGetExtensionID", + "TSPI_phoneGetGain", + "TSPI_phoneGetHookSwitch", + "TSPI_phoneGetIcon", + "TSPI_phoneGetID", + "TSPI_phoneGetLamp", + "TSPI_phoneGetRing", + "TSPI_phoneGetStatus", + "TSPI_phoneGetVolume", + "TSPI_phoneNegotiateExtVersion", + "TSPI_phoneNegotiateTSPIVersion", + "TSPI_phoneOpen", + "TSPI_phoneSelectExtVersion", + "TSPI_phoneSetButtonInfo", + "TSPI_phoneSetData", + "TSPI_phoneSetDisplay", + "TSPI_phoneSetGain", + "TSPI_phoneSetHookSwitch", + "TSPI_phoneSetLamp", + "TSPI_phoneSetRing", + "TSPI_phoneSetStatusMessages", + "TSPI_phoneSetVolume", + "TSPI_providerCreateLineDevice", + "TSPI_providerCreatePhoneDevice", + "TSPI_providerEnumDevices", + "TSPI_providerFreeDialogInstance", + "TSPI_providerGenericDialogData", + "TSPI_providerInit", + "TSPI_providerShutdown", + "TSPI_providerUIIdentify", + NULL +}; + +LPSTR glpszMessages[] = +{ + "LINE_ADDRESSSTATE", + "LINE_CALLINFO", + "LINE_CALLSTATE", + "LINE_CLOSE", + "LINE_DEVSPECIFIC", + "LINE_DEVSPECIFICFEATURE", + "LINE_GATHERDIGITS", + "LINE_GENERATE", + "LINE_LINEDEVSTATE", + "LINE_MONITORDIGITS", + "LINE_MONITORMEDIA", + "LINE_MONITORTONE", + "LINE_REPLY", + "LINE_REQUEST", + "PHONE_BUTTON", + "PHONE_CLOSE", + "PHONE_DEVSPECIFIC", + "PHONE_REPLY", + "PHONE_STATE", + "LINE_CREATE", + "PHONE_CREATE", + "LINE_AGENTSPECIFIC", + "LINE_AGENTSTATUS", + "LINE_APPNEWCALL", + "LINE_PROXYREQUEST", + "LINE_REMOVE", + "PHONE_REMOVE" +}; + +LPSTR glpszMessages500[] = +{ + "LINE_NEWCALL", + "LINE_CALLDEVSPECIFIC", + "LINE_CALLDEVSPECIFICFEATURE", + "LINE_CREATEDIALOGINSTANCE", + "LINE_SENDDIALOGINSTANCEDATA" +}; + + +////////////////////////////////////////////////////////////////////////////// +// +// WinMain() +// +////////////////////////////////////////////////////////////////////////////// + +int WINAPI WinMain (HINSTANCE hInstance, + HINSTANCE hPrevInstance, + LPSTR lpszCmdLine, + int nCmdShow) +{ + MSG msg; + + ghInstance = hInstance; + + if (!CreateMainWindow(nCmdShow)) + { + return 0; + } + + while (GetMessage(&msg, NULL, 0, 0)) + { + TranslateMessage(&msg); + DispatchMessage(&msg); + } + + return 1; +} + + +//***************************************************************************** +// CreateMainWindow() +//***************************************************************************** + +BOOL CreateMainWindow (int nCmdShow) +{ + WNDCLASS wc; + static char szClassName[] = "TapiClientWndClass"; + + wc.style = 0; + wc.lpfnWndProc = MainWndProc; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + wc.hInstance = ghInstance; + wc.hIcon = LoadIcon(NULL, IDI_APPLICATION); + wc.hCursor = LoadCursor(NULL, IDC_ARROW); + wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1); + wc.lpszMenuName = MAKEINTRESOURCE(IDR_REPAPPMENU); + wc.lpszClassName = szClassName; + + + if (!RegisterClass(&wc)) + { + return FALSE; + } + + ghMainWnd = CreateWindow(szClassName, + "Repeater Log App", + WS_OVERLAPPEDWINDOW, + 0, + 0, + GetSystemMetrics(SM_CXSCREEN)/2, + GetSystemMetrics(SM_CYSCREEN)/2, + NULL, + NULL, + ghInstance, + NULL); + + ghListWnd = CreateWindow("LISTBOX", + NULL, + WS_CHILD | WS_VISIBLE | WS_VSCROLL | LBS_USETABSTOPS, + 0, + 0, + 0, + 0, + ghMainWnd, + NULL, + ghInstance, + NULL); + + if (ghListWnd == NULL) + { + return FALSE; + } + + + if (ghMainWnd == NULL) + { + return FALSE; + } + + ShowWindow(ghMainWnd, nCmdShow); + UpdateWindow(ghMainWnd); + return TRUE; +} + + +//***************************************************************************** +// MainWndProc() +//***************************************************************************** + +LRESULT CALLBACK MainWndProc (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam) +{ + switch (uMsg) + { + + case WM_SIZE: + { + RECT rc; + + GetClientRect(hwnd, + &rc); + + MoveWindow(ghListWnd, + 0, 0, + rc.right, + rc.bottom, + TRUE); + + break; + } + case WM_COMMAND: + { + if (LOWORD(wParam) == ID_FILE_EXIT) + { + DestroyWindow(hwnd); + break; + } + + if (LOWORD(wParam) == ID_FILE_LOGFILENAME) + { + if (LogFileNameProc()) + { + SendMessage(ghListWnd, + LB_RESETCONTENT, + 0, + 0); + + ReadInLogFile(); + } + + break; + } + + return DefWindowProc(hwnd, uMsg, wParam, lParam); + } + case WM_DESTROY: + PostQuitMessage(0); + break; + + default: + return DefWindowProc(hwnd, uMsg, wParam, lParam); + } + return 0; +} + +BOOL LogFileNameProc() +{ + OPENFILENAME ofn; + BOOL bReturn; + + gszLogFileName[0] = '\0'; + + ofn.lStructSize = sizeof(ofn); + ofn.hwndOwner = ghMainWnd; + ofn.hInstance = ghInstance; + ofn.lpstrFilter = "Log Files\0*.log\0\0"; + ofn.lpstrCustomFilter = NULL; + ofn.nMaxCustFilter = 0; + ofn.nFilterIndex = 0; + ofn.lpstrFile = gszLogFileName; + ofn.nMaxFile = MAX_PATH; + ofn.lpstrFileTitle = NULL; + ofn.nMaxFileTitle = 0; + ofn.lpstrInitialDir = NULL; + ofn.lpstrTitle =NULL; + ofn.Flags = OFN_FILEMUSTEXIST; + ofn.nFileOffset = 0; + ofn.nFileExtension = 0; + ofn.lpstrDefExt = "LOG"; + ofn.lCustData = 0; + ofn.lpfnHook = NULL; + ofn.lpTemplateName = NULL; + + bReturn = GetOpenFileName(&ofn); + + return bReturn; +} + +BOOL ReadInLogFile() +{ + DWORD dwKey; + + if (!OpenLogFile()) + { + MessageBox(NULL, + "Couldn't open file", + NULL, + MB_OK); + + return FALSE; + } + + while (TRUE) + { + if (!ReadKey(&dwKey)) + { +// MessageBox(NULL, +// "Couldn't readkey", +// NULL, +// MB_OK); + break; + } + + else if (dwKey == DWPREKEY) + { + if (!DoPreKey()) + { +// MessageBox(NULL, +// "Couldn't do pre key", +// NULL, +// MB_OK); + + break; + } + } + + else if (dwKey == DWPOSTKEY) + { + if (!DoPostKey()) + { +// MessageBox(NULL, +// "Couldn't do post key", +// NULL, +// MB_OK); + + break; + } + } + + else if (dwKey == DWSTRCKEY) + { + if (!DoStructKey()) + { +// MessageBox(NULL, +// "Couldn't do struct key", +// NULL, +// MB_OK); + + break; + } + } + + else + { + MessageBox(NULL, + "Error reading in log file", + NULL, + MB_OK); + break; + } + } // while + + return TRUE; +} + +BOOL OpenLogFile() +{ + ghLogFile = CreateFile(gszLogFileName, + GENERIC_READ, + FILE_SHARE_READ, //0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (ghLogFile == INVALID_HANDLE_VALUE) + { + return FALSE; + } + + SetFilePointer(ghLogFile, + 0, + NULL, + FILE_BEGIN); + + return TRUE; +} + +BOOL ReadKey(LPDWORD lpdwKey) +{ + DWORD dwSize; + + if (!ReadFile(ghLogFile, + lpdwKey, + sizeof(DWORD), + &dwSize, + NULL)) + { + return FALSE; + } + + if (dwSize == 0) + { + return FALSE; + } + + SetFilePointer(ghLogFile, + 0-dwSize, + NULL, + FILE_CURRENT); + + return TRUE; +} + +BOOL DoPreKey() +{ + PREHEADER PreHeader; + DWORD dwSize; + + if (!ReadFile(ghLogFile, + &PreHeader, + sizeof(PreHeader), + &dwSize, + NULL)) + { + return FALSE; + } + + if (dwSize == 0) + { + return FALSE; + } + + + if (dwSize != sizeof(PreHeader)) + { + return FALSE; + } + + WriteToListBox("PreHeader - Time: %lu Type: %lu", + PreHeader.dwTime, + PreHeader.dwType); + + switch(PreHeader.dwType) + { + case LINEMSG: + { + LINEMSGSTRUCT LineMsg; + LPSTR lpszMsg; + + if (!ReadFile(ghLogFile, + &LineMsg, + sizeof(LineMsg), + &dwSize, + NULL)) + { + return FALSE; + } + + if (dwSize == 0) + { + return FALSE; + } + + if (LineMsg.dwMsg < 500) + { + lpszMsg = glpszMessages[LineMsg.dwMsg]; + } + else + { + lpszMsg = glpszMessages500[LineMsg.dwMsg-500]; + } + + WriteToListBox("\tLine Message: %s", + lpszMsg); + WriteToListBox("\t\thtLine: %lx, htCall: %lx", + LineMsg.htLine, + LineMsg.htCall); + WriteToListBox("\t\tdwParam1: %lx, dwParam2: %lx, dwParam3: %lx", + LineMsg.dw1, + LineMsg.dw2, + LineMsg.dw3); + + break; + } + + case PHONEMSG: + { + PHONEMSGSTRUCT PhoneMsg; + LPSTR lpszMsg; + + if (!ReadFile(ghLogFile, + &PhoneMsg, + sizeof(PhoneMsg), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + + if (PhoneMsg.dwMsg < 500) + { + lpszMsg = glpszMessages[PhoneMsg.dwMsg]; + } + else + { + lpszMsg = glpszMessages500[PhoneMsg.dwMsg-500]; + } + + + WriteToListBox("\tPhone Message: %s", + lpszMsg); + WriteToListBox("\t\thtPhone: %lx", + PhoneMsg.htPhone); + WriteToListBox("\t\tdwParam1: %lx, dwParam2: %lx, dwParam3: %lx", + PhoneMsg.dw1, + PhoneMsg.dw2, + PhoneMsg.dw3); + + break; + } + + case ASYNCMSG: + { + ASYNCSTRUCT AsyncMsg; + + if (!ReadFile(ghLogFile, + &AsyncMsg, + sizeof(AsyncMsg), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + + WriteToListBox("\tAsync Message - dwRequestID: %lx, lResult: %lx", + AsyncMsg.dwRequestID, + AsyncMsg.lResult); + + break; + } + + case SPFUNC1: + { + LOGSPFUNC1 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + break; + } + + case SPFUNC2: + { + LOGSPFUNC2 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + + break; + } + case SPFUNC3: + { + LOGSPFUNC3 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + + break; + } + + case SPFUNC4: + { + LOGSPFUNC4 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + + break; + } + + case SPFUNC5: + { + LOGSPFUNC5 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + WriteToListBox("\tParam5: %lx", + LogStruct.dwParam5); + + break; + } + + case SPFUNC6: + { + LOGSPFUNC6 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + WriteToListBox("\tParam5: %lx", + LogStruct.dwParam5); + WriteToListBox("\tParam6: %lx", + LogStruct.dwParam6); + + break; + } + + case SPFUNC7: + { + LOGSPFUNC7 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + WriteToListBox("\tParam5: %lx", + LogStruct.dwParam5); + WriteToListBox("\tParam6: %lx", + LogStruct.dwParam6); + WriteToListBox("\tParam7: %lx", + LogStruct.dwParam7); + + break; + } + + case SPFUNC8: + { + LOGSPFUNC8 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + WriteToListBox("\tParam5: %lx", + LogStruct.dwParam5); + WriteToListBox("\tParam6: %lx", + LogStruct.dwParam6); + WriteToListBox("\tParam7: %lx", + LogStruct.dwParam7); + WriteToListBox("\tParam8: %lx", + LogStruct.dwParam8); + + break; + } + + case SPFUNC9: + { + LOGSPFUNC9 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + WriteToListBox("\tParam5: %lx", + LogStruct.dwParam5); + WriteToListBox("\tParam6: %lx", + LogStruct.dwParam6); + WriteToListBox("\tParam7: %lx", + LogStruct.dwParam7); + WriteToListBox("\tParam8: %lx", + LogStruct.dwParam8); + WriteToListBox("\tParam9: %lx", + LogStruct.dwParam9); + + break; + } + + case SPFUNC12: + { + LOGSPFUNC12 LogStruct; + + if (!ReadFile(ghLogFile, + &LogStruct, + sizeof(LogStruct), + &dwSize, + NULL)) + { + return FALSE; + } + + if (dwSize == 0) + { + return FALSE; + } + + + WriteToListBox("\tFunction: %s", + glpszFunctions[LogStruct.dwSPFUNC]); + WriteToListBox("\tParam1: %lx", + LogStruct.dwParam1); + WriteToListBox("\tParam2: %lx", + LogStruct.dwParam2); + WriteToListBox("\tParam3: %lx", + LogStruct.dwParam3); + WriteToListBox("\tParam4: %lx", + LogStruct.dwParam4); + WriteToListBox("\tParam5: %lx", + LogStruct.dwParam5); + WriteToListBox("\tParam6: %lx", + LogStruct.dwParam6); + WriteToListBox("\tParam7: %lx", + LogStruct.dwParam7); + WriteToListBox("\tParam8: %lx", + LogStruct.dwParam8); + WriteToListBox("\tParam9: %lx", + LogStruct.dwParam9); + WriteToListBox("\tParam11: %lx", + LogStruct.dwParam10); + WriteToListBox("\tParam11: %lx", + LogStruct.dwParam11); + WriteToListBox("\tParam12: %lx", + LogStruct.dwParam12); + + break; + } + + } // switch + + return TRUE; + +} + +BOOL DoPostKey() +{ + POSTSTRUCT PostStruct; + DWORD dwSize; + + if (!ReadFile(ghLogFile, + &PostStruct, + sizeof(PostStruct), + &dwSize, + NULL)) + { + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + WriteToListBox("Post Struct - dwTime: %lu, lReturn: %lx", + PostStruct.dwTime, + PostStruct.lReturn); + + return TRUE; +} + +BOOL DoStructKey() +{ + STRUCTHEADER StructHeader; + DWORD dwSize; + LPVOID pBuffer; + + if (!ReadFile(ghLogFile, + &StructHeader, + sizeof(StructHeader), + &dwSize, + NULL)) + { + return FALSE; + } + + if (dwSize == 0) + { + return FALSE; + } + + + WriteToListBox("Struct Header - dwSize: %lu, dwID: %lx", + StructHeader.dwSize, + StructHeader.dwID); + + if (StructHeader.dwSize == 0) + { + return TRUE; + } + + pBuffer = GlobalAlloc(GPTR, StructHeader.dwSize); + + // read in structure, but don't do anything with it for now + if (!ReadFile(ghLogFile, + pBuffer, + StructHeader.dwSize, + &dwSize, + NULL)) + { + GlobalFree(pBuffer); + return FALSE; + } + if (dwSize == 0) + { + return FALSE; + } + + GlobalFree(pBuffer); + + return TRUE; +} + +void WriteToListBox(LPSTR lpszText, ...) +{ + char szBuffer[1024]; + va_list list; + + va_start(list,lpszText); + + vsprintf(szBuffer,lpszText,list); + + SendMessage(ghListWnd, + LB_ADDSTRING, + 0, + (LPARAM)szBuffer); +} + diff --git a/private/tapi/dev/sp/repeater/app/repapp.rc b/private/tapi/dev/sp/repeater/app/repapp.rc new file mode 100644 index 000000000..25619c74a --- /dev/null +++ b/private/tapi/dev/sp/repeater/app/repapp.rc @@ -0,0 +1,37 @@ +//Microsoft Developer Studio generated resource script. +// +#include "resource.h" + +///////////////////////////////////////////////////////////////////////////// +// +// Menu +// + +IDR_REPAPPMENU MENU DISCARDABLE +BEGIN + POPUP "&File" + BEGIN + MENUITEM "&Log File Name", ID_FILE_LOGFILENAME + MENUITEM SEPARATOR + MENUITEM "E&xit", ID_FILE_EXIT + END +END + + + +#if WINNT +#include <ntverp.h> +#else +#include <version.h> +#endif + + +#define VER_FILEDESCRIPTION_STR "Microsoft\256 Windows(TM) Telephony API Repeater Log File Reader" +#define VER_INTERNALNAME_STR "REPAPP" +#define VER_ORIGINALFILENAME_STR "REPAPP.EXE" +#define VER_LEGALCOPYRIGHT_STR "Copyright \251 Microsoft Corporation 1996. All Rights Reserved." + +#define VER_FILETYPE VFT_APP +#define VER_FILESUBTYPE VFT2_UNKNOWN + +#include <common.ver> diff --git a/private/tapi/dev/sp/repeater/app/resource.h b/private/tapi/dev/sp/repeater/app/resource.h new file mode 100644 index 000000000..7bd879f3b --- /dev/null +++ b/private/tapi/dev/sp/repeater/app/resource.h @@ -0,0 +1,22 @@ +#include <windows.h> +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by repapp.rc +// +#define IDD_LOGFILENAME 101 +#define IDR_REPAPPMENU 102 +#define IDC_LOGFILENAME 1000 +#define ID_FILE_LOGFILENAME 40001 +#define ID_FILE_EXIT 40002 +#define IDC_STATIC -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 103 +#define _APS_NEXT_COMMAND_VALUE 40003 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/private/tapi/dev/sp/repeater/app/sources b/private/tapi/dev/sp/repeater/app/sources new file mode 100644 index 000000000..24be8c8f2 --- /dev/null +++ b/private/tapi/dev/sp/repeater/app/sources @@ -0,0 +1,56 @@ +!IF 0 + +Copyright (c) 1989-1993 Microsoft Corporation + +Module Name: + + sources. + +Abstract: + + This file specifies the target component being built and the list of + sources files needed to build that component. Also specifies optional + compiler switches and libraries that are unique for the component being + built. + +Author: + + John Rogers (JohnRo) 25-Oct-1991 + +Notes: + + Commented description of this file is in \nt\public\oak\bin\sources.tpl + +Revision History: + +!ENDIF + + +MAJORCOMP=net +MINORCOMP=tapi + +TARGETNAME=repapp +TARGETPATH=$(BASEDIR)\public\sdk\lib +TARGETTYPE=PROGRAM + +TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \ + $(BASEDIR)\public\sdk\lib\*\shell32.lib \ + $(BASEDIR)\public\sdk\lib\*\tapi32l.lib \ + $(BASEDIR)\public\sdk\lib\*\comdlg32.lib + +INCLUDES=.;$(BASEDIR)\public\sdk\inc + +USE_CRTDLL=1 + +SOURCES=repapp.rc \ + repapp.c + +C_DEFINES=-DWINVER=0x0400 + +UMTYPE=windows + +UMENTRY=winmain + +!IFNDEF 386_WARNING_LEVEL +386_WARNING_LEVEL=/W3 +!ENDIF diff --git a/private/tapi/dev/sp/repeater/dirs b/private/tapi/dev/sp/repeater/dirs new file mode 100644 index 000000000..57bb36ac0 --- /dev/null +++ b/private/tapi/dev/sp/repeater/dirs @@ -0,0 +1,4 @@ +DIRS=\ + new \ + app \ + setup diff --git a/private/tapi/dev/sp/repeater/new/debug.c b/private/tapi/dev/sp/repeater/new/debug.c new file mode 100644 index 000000000..a5fc2c9b9 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/debug.c @@ -0,0 +1,180 @@ +// +// + +#if DBG + + +#include <windows.h> +#include <windowsx.h> +#include <stdio.h> +#include <stdarg.h> +#include <tapi.h> +#include "debug.h" + + + +extern const char far szINIfilename[]; + +DWORD gdwDebugLevel; + + +static char szNewBuff[256]; + + +DWORD RepeaterDebugLevel = 0; +static fRepeaterDebugLevelValid = FALSE; + +VOID +DbgPrt( + IN DWORD dwDbgLevel, + IN PUCHAR lpszFormat, + IN ... + ) +/*++ + +Routine Description: + + Formats the incoming debug message & calls DbgPrint + +Arguments: + + DbgLevel - level of message verboseness + + DbgMessage - printf-style format string, followed by appropriate + list of arguments + +Return Value: + + +--*/ + +{ + static char buf[128] = "Repeater: "; + + + if (!fRepeaterDebugLevelValid) + { +RepeaterDebugLevel = 0; +/* + RepeaterDebugLevel = GetPrivateProfileInt( "Debug", + "RepeaterDebugLevel", + 0, + szINIfilename ); +*/ + RepeaterDebugLevel = 99; + + if ( RepeaterDebugLevel > 0 ) + { + wsprintf( + &buf[10], + "RepeaterDebugLevel= %d\n\r", + RepeaterDebugLevel); + + OutputDebugString((LPSTR)buf); + + + fRepeaterDebugLevelValid = TRUE; + } + + } + + + // + // Is the message otherwise "low" enough to display? + // + if (dwDbgLevel <= RepeaterDebugLevel) + { + char buf[128] = "Repeater: "; + va_list ap; + + + va_start(ap, lpszFormat); + + wvsprintf (&buf[10], + lpszFormat, + ap + ); + + lstrcat (buf, "\n"); + + OutputDebugString(buf); + + va_end(ap); + } + + return; +} + + + + + + +//VOID +//DbgPrt( +// IN DWORD dwDbgLevel, +// IN PUCHAR lpszFormat, +// IN ... +// ) +///*++ +// +//Routine Description: +// +// Formats the incoming debug message & calls DbgPrint +// +//Arguments: +// +// DbgLevel - level of message verboseness +// +// DbgMessage - printf-style format string, followed by appropriate +// list of arguments +// +//Return Value: +// +// +//--*/ +//{ +// +// static BOOL fAlreadyGotIt = FALSE; +// static char buf[128] = "TAPI CPL: "; +//#define TEXT_START 10 +// +// if (!fAlreadyGotIt) +// { +// +// gdwDebugLevel = (DWORD) GetPrivateProfileInt( +// "Debug", +// "Repeater32DebugLevel", +// 0x0, +// "Telephon.ini" +// ); +// +// fAlreadyGotIt = TRUE; +// +// wsprintf(&buf[TEXT_START], "Repeater32DebugLevel=%d \r\n", gdwDebugLevel); +// OutputDebugStringA(buf); +// } +// +// +// if (dwDbgLevel <= gdwDebugLevel) +// { +// va_list ap; +// +// +// va_start(ap, lpszFormat); +// +// vsprintf (&buf[TEXT_START], +// lpszFormat, +// ap +// ); +// +// lstrcat (buf, "\n"); +// +// OutputDebugStringA (buf); +// +// va_end(ap); +// } +//} +// + +#endif diff --git a/private/tapi/dev/sp/repeater/new/debug.h b/private/tapi/dev/sp/repeater/new/debug.h new file mode 100644 index 000000000..11abf22ec --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/debug.h @@ -0,0 +1,25 @@ +#if DBG + + +#if !WIN32 +#define IN +#define PUCHAR char * +#endif + + + +#define DBGOUT(arg) DbgPrt arg + +extern VOID +DbgPrt( + IN DWORD dwDbgLevel, + IN PUCHAR DbgMessage, + IN ... + ); + +#else + +#define DBGOUT(arg) + +#endif + diff --git a/private/tapi/dev/sp/repeater/new/depend.mk b/private/tapi/dev/sp/repeater/new/depend.mk new file mode 100644 index 000000000..7f4b4291c --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/depend.mk @@ -0,0 +1,7 @@ +.\logger.obj: ..\logger.c ..\logger.h ..\debug.h + +.\Repeater.obj: ..\Repeater.c ..\Repeater.h ..\debug.h + +.\debug.obj: ..\debug.c ..\debug.h + +.\Repeater.res: ..\Repeater.rc diff --git a/private/tapi/dev/sp/repeater/new/logger.c b/private/tapi/dev/sp/repeater/new/logger.c new file mode 100644 index 000000000..1f145c143 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/logger.c @@ -0,0 +1,945 @@ +#define STRICT + +#include <windows.h> +#include <windowsx.h> +#include <tspi.h> +#ifndef WIN32 +#include <memory.h> +#endif +#include "logger.h" +#include "debug.h" + +#ifndef TCHAR +#define TCHAR char +#endif + +#if ! defined(TEXT) +#define TEXT(string) string +#endif + +#ifndef LPCWSTR +#define LPCWSTR LPCSTR +#endif + +extern BOOL gfTerminateNow; +DWORD gdwTotalBlocks; +DWORD gdwID = 0; +CHUNK gChunks[MAXCHUNKS]; + +typedef struct tagLOGSTRUCT +{ + int iSize; + struct tagLOGSTRUCT* pNext; + +} LOGSTRUCT, * PLOGSTRUCT; + + +#ifdef WIN32 +PLOGSTRUCT gpBegin = NULL, gpEnd = NULL; +CRITICAL_SECTION gcsLogging; +CRITICAL_SECTION gcsID; +#endif + +#ifdef WIN32 +HANDLE ghLogFile = NULL; +#else +HFILE ghLogFile = NULL; +#endif + +#ifndef MAX_PATH +#define MAX_PATH 260 +#endif + +#ifndef WIN32 +char gszFileName[MAX_PATH]; +#endif + +BOOL InitLogging(); +void WriteData(); +BOOL CopyIDToList(int iCount, LPVOID pBuffer); + + + + +//*************************************************************************** +//*************************************************************************** +//*************************************************************************** +#ifdef WIN32 + +DWORD WINAPI LoggingThread( LPVOID pThreadParm ) +{ + + DBGOUT((3, "Entering LoggingThread")); + + while ( !gfTerminateNow ) + { + + if (NULL != gpBegin) + { + WriteData(); + } + + Sleep(0); + + } + + DBGOUT((3, "Closing File Handle")); + + CloseHandle(ghLogFile); + + DBGOUT((3, "Exiting thread")); + + ExitThread(0); + return 0; +} +#endif //WIN32 + +#if 0 +#ifdef WIN32 +void CopyData(LPVOID pBuffer, int iCount) +{ + PLOGSTRUCT pNew; + + // if we have a lot of stuff to write, hold up here and + // wait until we've written a bunch + if (gdwTotalBlocks > MAXCHUNKS) + { + while (gdwTotalBlocks > MINCHUNKS) + { + Sleep(0); + } + } + + pNew = (PLOGSTRUCT)GlobalAlloc(GPTR, iCount+sizeof(LOGSTRUCT)); + + pNew->pNext = NULL; + pNew->iSize = iCount; + + memcpy(pNew+1, pBuffer, iCount); + + EnterCriticalSection(&gcsLogging); + if (gpBegin == NULL) + { + gpBegin = pNew; + } + else + { + gpEnd->pNext = pNew; + } + + gpEnd = pNew; + LeaveCriticalSection(&gcsLogging); + + gdwTotalBlocks++; + +} + +#else +void CopyData(LPVOID pBuffer, int iCount) +{ + OFSTRUCT ofstruct; + + ofstruct.cBytes = sizeof(ofstruct); + + ghLogFile = OpenFile(gszFileName, + &ofstruct, + OF_READWRITE); + + if (ghLogFile == HFILE_ERROR) + { + DBGOUT((3,"OpenFile failed")); + return; + } + + _llseek(ghLogFile, + 0, + 2); + + if (_lwrite(ghLogFile, + pBuffer, + iCount) == HFILE_ERROR) + { + char szbuf[128]; + + wsprintf(szbuf, "icount %d", iCount); + MessageBox(NULL, szbuf, NULL, MB_OK); + MessageBox(NULL, "writefile error", NULL, MB_OK); + } + + _lclose(ghLogFile); +} +#endif + +#endif // 0 + +#ifdef WIN32 +void WriteData() +{ + PLOGSTRUCT pHold; + DWORD dwNumBytes; + + while (gpBegin != NULL) + { + WriteFile(ghLogFile, + (LPCVOID)(gpBegin+1), + gpBegin->iSize, + &dwNumBytes, + NULL); + + if (dwNumBytes != (DWORD)(gpBegin->iSize)) + { + //bugbug do something + } + + EnterCriticalSection(&gcsLogging); + + pHold = gpBegin; + + gpBegin = gpBegin->pNext; + + LeaveCriticalSection(&gcsLogging); + + GlobalFree(pHold); + + gdwTotalBlocks--; + } + +} +#endif +#define SZFILEBASE "rep" +#define SZFILEEXT ".log" +#define SZREPEATERKEY "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Repeater" +#define SZLOGFILE "LogFileDirectory" +#define SZREPEATER "Repeater" +#define SZTELEPHONINI "telephon.ini" + +BOOL InitLogging() +{ + TCHAR szFileName[MAX_PATH]; + TCHAR szFilePath[MAX_PATH]; + int i = 0; +#ifdef WIN32 + HKEY hRepeaterKey; + DWORD dwSize; +#else + OFSTRUCT ofstruct; +#endif + + DBGOUT((3, "Entering InitLogging")); + +#ifdef WIN32 + RegOpenKeyEx(HKEY_LOCAL_MACHINE, + SZREPEATERKEY, + 0, + KEY_ALL_ACCESS, + &hRepeaterKey); + + dwSize = MAX_PATH; + RegQueryValueEx(hRepeaterKey, + SZLOGFILE, + NULL, + NULL, + szFilePath, + &dwSize); + + RegCloseKey(hRepeaterKey); +#else + GetPrivateProfileString(SZREPEATER, + SZLOGFILE, + "", + szFilePath, + MAX_PATH, + SZTELEPHONINI); +#endif + + + gdwTotalBlocks = 0; + + while (TRUE) + { +#ifdef WIN32 + HANDLE hFile; + WIN32_FIND_DATA FindData; + + wsprintf(szFileName, + "%s%s%d%s", + szFilePath, + SZFILEBASE, + i, + SZFILEEXT); + + /* + ghLogFile = CreateFile(szFileName, + GENERIC_WRITE, + 0, + NULL, + OPEN_EXISTING, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (ghLogFile == INVALID_HANDLE_VALUE) + { + break; + } + + CloseHandle(ghLogFile);*/ + + hFile = FindFirstFile(szFileName, + &FindData); + + if (hFile == INVALID_HANDLE_VALUE) + { + break; + } + + FindClose(hFile); + +// CloseHandle(hFile); + +#else + ofstruct.cBytes = sizeof(ofstruct); + + ghLogFile = OpenFile(szFileName, + &ofstruct, + OF_EXIST); + + if (ghLogFile == HFILE_ERROR) + { + break; + } + + _lclose(ghLogFile); +#endif + + i++; + } + +#ifdef WIN32 + + DBGOUT((3, "log file name is %s", szFileName)); + ghLogFile = CreateFile(szFileName, + GENERIC_WRITE, + FILE_SHARE_READ, //0, + NULL, + CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL, + NULL); + + if (ghLogFile == INVALID_HANDLE_VALUE) + { + DBGOUT((3, "InitLogging failed CreateFile")); + return FALSE; + } + +#else + + lstrcpy(gszFileName, szFileName); + + ofstruct.cBytes = sizeof(ofstruct); + + ghLogFile = OpenFile(gszFileName, + &ofstruct, + OF_CREATE); + + _lclose(ghLogFile); +/* + ofstruct.cBytes = sizeof(ofstruct); + + DBGOUT((3, szFileName)); + + ghLogFile = OpenFile(szFileName, + &ofstruct, + OF_CREATE | OF_READWRITE); + + if (ghLogFile == HFILE_ERROR) + { + DBGOUT((3, "InitLogging failed OpenFile")); + return FALSE; + }*/ +#endif + +#ifdef WIN32 + InitializeCriticalSection(&gcsLogging); + InitializeCriticalSection(&gcsID); + + gpBegin = NULL; + gpEnd = NULL; +#endif + + DBGOUT((3, "Exiting InitLogging")); + return TRUE; +} + + + +void WritePreHeader(DWORD dwID, DWORD dwType) +{ + return; +/* + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = dwType; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + */ +} + +void WriteStruct(DWORD dwID, + DWORD dwSize, + LPVOID lpBuf) +{ + STRUCTHEADER StructHeader; + + if (!lpBuf) + { + return; + } + + + StructHeader.dwKey = DWSTRCKEY; + StructHeader.dwSize = dwSize; + StructHeader.dwID = (DWORD)lpBuf; + + CopyData(dwID, (LPVOID)&StructHeader, sizeof(StructHeader)); + CopyData(dwID, lpBuf, (int)dwSize); +} + +void WritePostStruct(DWORD dwID, + LONG lResult) +{ + POSTSTRUCT PostStruct; + + PostStruct.dwKey = DWPOSTKEY; + PostStruct.dwTime = GetTickCount(); + PostStruct.lReturn = lResult; + + CopyData(dwID, (LPVOID)&PostStruct, sizeof(PostStruct)); +} + +void WriteLineMsgStruct(DWORD dwID, + HTAPILINE htLine, + HTAPICALL htCall, + DWORD dwMsg, + DWORD dw1, + DWORD dw2, + DWORD dw3) +{ + LINEMSGSTRUCT LineMsgStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = LINEMSG; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LineMsgStruct.dwMsg = dwMsg; + LineMsgStruct.htLine = htLine; + LineMsgStruct.htCall = htCall; + LineMsgStruct.dw1 = dw1; + LineMsgStruct.dw2 = dw2; + LineMsgStruct.dw3 = dw3; + + CopyData(dwID, (LPVOID)&LineMsgStruct, sizeof(LineMsgStruct)); +} + +void WritePhoneMsgStruct(DWORD dwID, + HTAPIPHONE htPhone, + DWORD dwMsg, + DWORD dw1, + DWORD dw2, + DWORD dw3) +{ + PHONEMSGSTRUCT PhoneMsgStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = PHONEMSG; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + PhoneMsgStruct.dwMsg = dwMsg; + PhoneMsgStruct.htPhone = htPhone; + PhoneMsgStruct.dw1 = dw1; + PhoneMsgStruct.dw2 = dw2; + PhoneMsgStruct.dw3 = dw3; + + CopyData(dwID, (LPVOID)&PhoneMsgStruct, sizeof(PhoneMsgStruct)); +} + +void WriteAsyncStruct(DWORD dwID, + DWORD dwRequestID, + LONG lResult) +{ + ASYNCSTRUCT AsyncStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = ASYNCMSG; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + AsyncStruct.dwRequestID = dwRequestID; + AsyncStruct.lResult = lResult; + + + CopyData(dwID, (LPVOID)&AsyncStruct, sizeof(AsyncStruct)); +} +void WriteLogStruct1(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1) +{ + LOGSPFUNC1 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC1; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void WriteLogStruct2(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2) +{ + LOGSPFUNC2 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC2; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void WriteLogStruct3(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3) +{ + LOGSPFUNC3 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC3; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + + +void WriteLogStruct4(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4) +{ + LOGSPFUNC4 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC4; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void WriteLogStruct5(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5) +{ + LOGSPFUNC5 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC5; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + LogStruct.dwParam5 = dwParam5; + + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void WriteLogStruct6(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6) +{ + LOGSPFUNC6 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC6; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + LogStruct.dwParam5 = dwParam5; + LogStruct.dwParam6 = dwParam6; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void WriteLogStruct7(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7) +{ + LOGSPFUNC7 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC7; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + LogStruct.dwParam5 = dwParam5; + LogStruct.dwParam6 = dwParam6; + LogStruct.dwParam7 = dwParam7; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + + +void WriteLogStruct8(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7, + DWORD dwParam8) +{ + LOGSPFUNC8 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC8; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + LogStruct.dwParam5 = dwParam5; + LogStruct.dwParam6 = dwParam6; + LogStruct.dwParam7 = dwParam7; + LogStruct.dwParam8 = dwParam8; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + + +void WriteLogStruct9(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7, + DWORD dwParam8, + DWORD dwParam9) +{ + LOGSPFUNC9 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC9; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + LogStruct.dwParam5 = dwParam5; + LogStruct.dwParam6 = dwParam6; + LogStruct.dwParam7 = dwParam7; + LogStruct.dwParam8 = dwParam8; + LogStruct.dwParam9 = dwParam9; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void WriteLogStruct12(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7, + DWORD dwParam8, + DWORD dwParam9, + DWORD dwParam10, + DWORD dwParam11, + DWORD dwParam12) +{ + LOGSPFUNC12 LogStruct; + PREHEADER PreHeader; + + PreHeader.dwKey = DWPREKEY; + PreHeader.dwTime = GetTickCount(); + PreHeader.dwType = SPFUNC12; + + CopyData(dwID, (LPVOID)&PreHeader, sizeof(PreHeader)); + + LogStruct.dwSPFUNC = dwSPFUNC; + LogStruct.dwParam1 = dwParam1; + LogStruct.dwParam2 = dwParam2; + LogStruct.dwParam3 = dwParam3; + LogStruct.dwParam4 = dwParam4; + LogStruct.dwParam5 = dwParam5; + LogStruct.dwParam6 = dwParam6; + LogStruct.dwParam7 = dwParam7; + LogStruct.dwParam8 = dwParam8; + LogStruct.dwParam9 = dwParam9; + LogStruct.dwParam10 = dwParam10; + LogStruct.dwParam11 = dwParam11; + LogStruct.dwParam12 = dwParam12; + + CopyData(dwID, (LPVOID)&LogStruct, sizeof(LogStruct)); +} + +void CopyData(DWORD dwID, LPVOID lpBuf, int dwSize) +{ + memcpy((LPBYTE)gChunks[dwID].pBuffer + gChunks[dwID].iStart, + lpBuf, + dwSize); + + gChunks[dwID].iStart += dwSize; +} + +BOOL GetChunkID(LPDWORD lpdwID) +{ +#ifdef WIN32 + EnterCriticalSection(&gcsID); +#endif + while (TRUE) + { + while (gdwID < MAXCHUNKS) + { + if (!gChunks[gdwID].bInUse) + { + goto gotid; + } + + gdwID++; + } + + gdwID = 0; +#ifdef WIN32 + Sleep(0); +#endif + } + +gotid: + + *lpdwID = gdwID; + gChunks[gdwID].bInUse = TRUE; + +#ifdef WIN32 + LeaveCriticalSection(&gcsID); +#endif + return TRUE; +} + +BOOL ReleaseID(DWORD dwID) +{ + CopyIDToList(gChunks[dwID].iStart, + gChunks[dwID].pBuffer); + +#ifdef WIN32 + GlobalFree(gChunks[dwID].pBuffer); +#else + GlobalFreePtr(gChunks[dwID].pBuffer); +#endif + gChunks[dwID].iStart = 0; + gChunks[dwID].pBuffer = NULL; + gChunks[dwID].bInUse = FALSE; + + return TRUE; +} + +#ifdef WIN32 +BOOL CopyIDToList(int iCount, LPVOID pBuffer) +{ + PLOGSTRUCT pNew; + + // if we have a lot of stuff to write, hold up here and + // wait until we've written a bunch + if (gdwTotalBlocks > MAXCHUNKS) + { + while (gdwTotalBlocks > MINCHUNKS) + { + Sleep(0); + } + } + + pNew = (PLOGSTRUCT)GlobalAlloc(GPTR, iCount+sizeof(LOGSTRUCT)); + + pNew->pNext = NULL; + pNew->iSize = iCount; + + memcpy(pNew+1, pBuffer, iCount); + + EnterCriticalSection(&gcsLogging); + if (gpBegin == NULL) + { + gpBegin = pNew; + } + else + { + gpEnd->pNext = pNew; + } + + gpEnd = pNew; + LeaveCriticalSection(&gcsLogging); + + gdwTotalBlocks++; + + return TRUE; +} +#else +BOOL CopyIDToList(int iCount, LPVOID pBuffer) +{ + OFSTRUCT ofstruct; + + ofstruct.cBytes = sizeof(ofstruct); + + ghLogFile = OpenFile(gszFileName, + &ofstruct, + OF_READWRITE); + + if (ghLogFile == HFILE_ERROR) + { + DBGOUT((3,"OpenFile failed")); + return FALSE; + } + + _llseek(ghLogFile, + 0, + 2); + + if (_lwrite(ghLogFile, + pBuffer, + iCount) == HFILE_ERROR) + { + DBGOUT((3, "_lwrite failed")); + } + + _lclose(ghLogFile); + + return TRUE; +} +#endif + +BOOL AllocChunk(DWORD dwID, DWORD dwSize) +{ + LPVOID pbuf; + + // ok, i messed up and forgot to alloc for structheader. + // so i'll just add the size of 4 struct headers to each + // alloc. what a hack - o - rama + dwSize += 4*sizeof(STRUCTHEADER); + +#ifdef WIN32 + pbuf = (LPVOID)GlobalAlloc(GPTR, dwSize); +#else + pbuf = (LPVOID)GlobalAllocPtr(GPTR, dwSize); +#endif + + if (!pbuf) + { + gChunks[dwID].pBuffer = NULL; + return FALSE; + } + +#ifdef WIN32 + memset(pbuf, 0, dwSize); +#else + memset(pbuf, 0, (int)dwSize); +#endif + gChunks[dwID].pBuffer = pbuf; + gChunks[dwID].bInUse = TRUE; + gChunks[dwID].iStart = 0; + + return TRUE; +} + diff --git a/private/tapi/dev/sp/repeater/new/logger.h b/private/tapi/dev/sp/repeater/new/logger.h new file mode 100644 index 000000000..60b8c850b --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/logger.h @@ -0,0 +1,317 @@ +#include <windows.h> +#include <tspi.h> + +DWORD WINAPI LoggingThread( LPVOID pThreadParm ); +// void CopyData(LPVOID pBuffer, int iCount); +void CopyData(DWORD dwID, LPVOID lpBuf, int dwSize); + + +#define MAXCHUNKS 5000 +#define MINCHUNKS 1000 + +// these are the preheader types + +#define LINEMSG 1 +#define PHONEMSG 2 +#define ASYNCMSG 3 +#define SPFUNC1 4 +#define SPFUNC2 5 +#define SPFUNC3 6 +#define SPFUNC4 7 +#define SPFUNC5 8 +#define SPFUNC6 9 +#define SPFUNC7 10 +#define SPFUNC8 11 +#define SPFUNC9 12 +#define SPFUNC12 13 + +#define MYFOURCC( ch0, ch1, ch2, ch3 ) \ + ( (DWORD)(BYTE)(ch0) | ( (DWORD)(BYTE)(ch1) << 8 ) | \ + ( (DWORD)(BYTE)(ch2) << 16 ) | ( (DWORD)(BYTE)(ch3) << 24 ) ) + +#define DWPREKEY MYFOURCC('P','R','E',' ') +#define DWPOSTKEY MYFOURCC('P','O','S','T') +#define DWSTRCKEY MYFOURCC('S','T','R','C') + +typedef struct tagCHUNK +{ + int iStart; + LPVOID pBuffer; + BOOL bInUse; +} CHUNK, * PCHUNK; + +typedef struct tagPREHEADER +{ + DWORD dwKey; // 'PRE ' + DWORD dwTime; + DWORD dwType; +} PREHEADER, * PPREHEADER; + +typedef struct tagPOSTSTRUCT +{ + DWORD dwKey; // 'POST' + DWORD dwTime; + LONG lReturn; +} POSTSTRUCT, * PPOSTSTRUCT; + +typedef struct tagSTRUCTHEADER +{ + DWORD dwKey; // 'STRC' + DWORD dwSize; + DWORD dwID; +} STRUCTHEADER, * PSTRUCTHEADER; + +typedef struct tagLINEMSGSTRUCT +{ + DWORD dwMsg; + HTAPILINE htLine; + HTAPICALL htCall; + DWORD dw1; + DWORD dw2; + DWORD dw3; + +} LINEMSGSTRUCT, * PLINEMSGSTRUCT; + + +typedef struct tagPHONEMSGSTRUCT +{ + DWORD dwMsg; + HTAPIPHONE htPhone; + DWORD dw1; + DWORD dw2; + DWORD dw3; + +} PHONEMSGSTRUCT, * PPHONEMSGSTRUCT; + + +typedef struct tagASYNCSTRUCT +{ + DWORD dwRequestID; + LONG lResult; + +} ASYNCSTRUCT, * PASYNCSTRUCT; + +typedef struct tagLOGSPFUNC1 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + +} LOGSPFUNC1, * PLOGSPFUNC1; + +typedef struct tagLOGSPFUNC2 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + +} LOGSPFUNC2, * PLOGSPFUNC2; + +typedef struct tagLOGSPFUNC3 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + +} LOGSPFUNC3, * PLOGSPFUNC3; + +typedef struct tagLOGSPFUNC4 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + +} LOGSPFUNC4, * PLOGSPFUNC4; + + +typedef struct tagLOGSPFUNC5 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + DWORD dwParam5; + +} LOGSPFUNC5, * PLOGSPFUNC5; + + +typedef struct tagLOGSPFUNC6 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + DWORD dwParam5; + DWORD dwParam6; + +} LOGSPFUNC6, * PLOGSPFUNC6; + + +typedef struct tagLOGSPFUNC7 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + DWORD dwParam5; + DWORD dwParam6; + DWORD dwParam7; + +} LOGSPFUNC7, * PLOGSPFUNC7; + + +typedef struct tagLOGSPFUNC8 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + DWORD dwParam5; + DWORD dwParam6; + DWORD dwParam7; + DWORD dwParam8; + +} LOGSPFUNC8, * PLOGSPFUNC8; + +typedef struct tagLOGSPFUNC9 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + DWORD dwParam5; + DWORD dwParam6; + DWORD dwParam7; + DWORD dwParam8; + DWORD dwParam9; + +} LOGSPFUNC9, * PLOGSPFUNC9; + +typedef struct tagLOGSPFUNC12 +{ + DWORD dwSPFUNC; + DWORD dwParam1; + DWORD dwParam2; + DWORD dwParam3; + DWORD dwParam4; + DWORD dwParam5; + DWORD dwParam6; + DWORD dwParam7; + DWORD dwParam8; + DWORD dwParam9; + DWORD dwParam10; + DWORD dwParam11; + DWORD dwParam12; + +} LOGSPFUNC12, * PLOGSPFUNC12; + +void WritePreHeader(DWORD dwID, DWORD dwType); +void WriteStruct(DWORD dwID, + DWORD dwSize, + LPVOID lpBuf); +void WritePostStruct(DWORD dwID, + LONG lReturn); +void WriteLineMsgStruct(DWORD dwID, + HTAPILINE htLine, + HTAPICALL htCall, + DWORD dwMsg, + DWORD dw1, + DWORD dw2, + DWORD dw3); +void WritePhoneMsgStruct(DWORD dwID, + HTAPIPHONE htPhone, + DWORD dwMsg, + DWORD dw1, + DWORD dw2, + DWORD dw3); +void WriteAsyncStruct(DWORD dwID, + DWORD, + LONG); +void WriteLogStruct1(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1); +void WriteLogStruct2(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2); +void WriteLogStruct3(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3); +void WriteLogStruct4(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4); +void WriteLogStruct5(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5); +void WriteLogStruct6(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6); +void WriteLogStruct7(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7); +void WriteLogStruct8(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7, + DWORD dwParam8); +void WriteLogStruct9(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7, + DWORD dwParam8, + DWORD dwParam9); +void WriteLogStruct12(DWORD dwID, + DWORD dwSPFUNC, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3, + DWORD dwParam4, + DWORD dwParam5, + DWORD dwParam6, + DWORD dwParam7, + DWORD dwParam8, + DWORD dwParam9, + DWORD dwParam10, + DWORD dwParam11, + DWORD dwParam12); +BOOL ReleaseID(DWORD dwID); +BOOL GetChunkID(LPDWORD lpdwID); +BOOL AllocChunk(DWORD dwID, DWORD dwSize); + diff --git a/private/tapi/dev/sp/repeater/new/makefile b/private/tapi/dev/sp/repeater/new/makefile new file mode 100644 index 000000000..7cc5b6412 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/makefile @@ -0,0 +1,29 @@ +!if "$(OS)" == "Windows_NT" + +!INCLUDE $(NTMAKEENV)\makefile.def + +!else + +############################################################################## +# +# tsp3216s.dll Make file +# +############################################################################## + +#Ok, we're doing a Win9x build. + +ROOT=..\..\..\..\.. + +VERSIONLIST=debug retail + +DEPENDNAME=depend.mk + +COMMONMKFILE=makefile.def + +IS_OEM=TRUE +IS_32 = TRUE + +!include $(ROOT)\dev\master.mk + +!endif + diff --git a/private/tapi/dev/sp/repeater/new/makefile.def b/private/tapi/dev/sp/repeater/new/makefile.def new file mode 100644 index 000000000..403b6f324 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/makefile.def @@ -0,0 +1,51 @@ +ROOT=..\..\..\..\..\.. + +IS_OEM=1 +IS_32 = TRUE +WANT_C932=1 +WIN32=1 + +BUILDDLL=1 +DLLENTRY=DllMain + + + +DEPENDNAME=..\depend.mk + +DRVNAME=Repeater +TARGETS=Repeater.tsp Repeater.sym + + +SRCDIR=.. + +SYMDIR=. + + +BUILD_COFF=1 + + + +L32EXE=Repeater.tsp # Name of exe. +L32DEF=..\Repeater.def # Our def file. +L32MAP=Repeater.map # Our map file. +L32SYM=Repeater.sym # Our sym file. +L32RES=Repeater.res # Resource file. +L32OBJS= Repeater.obj logger.obj debug.obj +L32LIBS= \ + $(DEVROOT)\lib\user32.lib \ + $(DEVROOT)\lib\kernel32.lib + + +L32FLAGS=$(L32FLAGS) -MAP -DEF:..\REPEATER.DEF + +!include $(ROOT)\dev\master.mk + + +INCLUDE=..\..\..\..\inc;$(ROOT)\win\thunk;$(ROOT)\win\core\inc;$(INCLUDE) + +#CFLAGS=$(CFLAGS) -DDONT_DECLARE_TSPI_FUNCTIONS=1 + +!IF "$(VERDIR)" == "debug" +CFLAGS = $(CFLAGS) -DDBG=1 +!endif + diff --git a/private/tapi/dev/sp/repeater/new/rep16.def b/private/tapi/dev/sp/repeater/new/rep16.def new file mode 100644 index 000000000..d0ab25f46 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/rep16.def @@ -0,0 +1,122 @@ +LIBRARY repeater +PROTMODE +CODE MOVEABLE DISCARDABLE +DATA PRELOAD + +EXPORTS + TSPI_lineAccept @500 + TSPI_lineAddToConference @501 + TSPI_lineAnswer @502 + TSPI_lineBlindTransfer @503 + TSPI_lineClose @504 + TSPI_lineCloseCall @505 + TSPI_lineCompleteCall @506 + TSPI_lineCompleteTransfer @507 + TSPI_lineConditionalMediaDetection @508 + TSPI_lineConfigDialog @509 + TSPI_lineDevSpecific @510 + TSPI_lineDevSpecificFeature @511 + TSPI_lineDial @512 + TSPI_lineDrop @513 + TSPI_lineForward @514 + TSPI_lineGatherDigits @515 + TSPI_lineGenerateDigits @516 + TSPI_lineGenerateTone @517 + TSPI_lineGetAddressCaps @518 + TSPI_lineGetAddressID @519 + TSPI_lineGetAddressStatus @520 + TSPI_lineGetCallAddressID @521 + TSPI_lineGetCallInfo @522 + TSPI_lineGetCallStatus @523 + TSPI_lineGetDevCaps @524 + TSPI_lineGetDevConfig @525 + TSPI_lineGetExtensionID @526 + TSPI_lineGetIcon @527 + TSPI_lineGetID @528 + TSPI_lineGetLineDevStatus @529 + TSPI_lineGetNumAddressIDs @530 + TSPI_lineHold @531 + TSPI_lineMakeCall @532 + TSPI_lineMonitorDigits @533 + TSPI_lineMonitorMedia @534 + TSPI_lineMonitorTones @535 + TSPI_lineNegotiateExtVersion @536 + TSPI_lineNegotiateTSPIVersion @537 + TSPI_lineOpen @538 + TSPI_linePark @539 + TSPI_linePickup @540 + TSPI_linePrepareAddToConference @541 + TSPI_lineRedirect @542 + TSPI_lineRemoveFromConference @543 + TSPI_lineSecureCall @544 + TSPI_lineSelectExtVersion @545 + TSPI_lineSendUserUserInfo @546 + TSPI_lineSetAppSpecific @547 + TSPI_lineSetCallParams @548 + TSPI_lineSetDefaultMediaDetection @549 + TSPI_lineSetDevConfig @550 + TSPI_lineSetMediaControl @551 + TSPI_lineSetMediaMode @552 + TSPI_lineSetStatusMessages @553 + TSPI_lineSetTerminal @554 + TSPI_lineSetupConference @555 + TSPI_lineSetupTransfer @556 + TSPI_lineSwapHold @557 + TSPI_lineUncompleteCall @558 + TSPI_lineUnhold @559 + TSPI_lineUnpark @560 + + TSPI_phoneClose @561 + TSPI_phoneConfigDialog @562 + TSPI_phoneDevSpecific @563 + TSPI_phoneGetButtonInfo @564 + TSPI_phoneGetData @565 + TSPI_phoneGetDevCaps @566 + TSPI_phoneGetDisplay @567 + TSPI_phoneGetExtensionID @568 + TSPI_phoneGetGain @569 + TSPI_phoneGetHookSwitch @570 + TSPI_phoneGetIcon @571 + TSPI_phoneGetID @572 + TSPI_phoneGetLamp @573 + TSPI_phoneGetRing @574 + TSPI_phoneGetStatus @575 + TSPI_phoneGetVolume @576 + TSPI_phoneNegotiateExtVersion @577 + TSPI_phoneNegotiateTSPIVersion @578 + TSPI_phoneOpen @579 + TSPI_phoneSelectExtVersion @580 + TSPI_phoneSetButtonInfo @581 + TSPI_phoneSetData @582 + TSPI_phoneSetDisplay @583 + TSPI_phoneSetGain @584 + TSPI_phoneSetHookSwitch @585 + TSPI_phoneSetLamp @586 + TSPI_phoneSetRing @587 + TSPI_phoneSetStatusMessages @588 + TSPI_phoneSetVolume @589 + + TSPI_providerConfig @590 + TSPI_providerInit @591 + TSPI_providerInstall @592 + TSPI_providerRemove @593 + TSPI_providerShutdown @594 + + TSPI_providerEnumDevices @595 + TSPI_lineDropOnClose @596 + TSPI_lineDropNoOwner @597 + TSPI_providerCreateLineDevice @598 + TSPI_providerCreatePhoneDevice @599 + TSPI_lineSetCurrentLocation @600 + TSPI_lineConfigDialogEdit @601 + TSPI_lineReleaseUserUserInfo @602 + +; TSPI_lineSetCallData @603 +; TSPI_lineSetCallQualityOfService @604 +; TSPI_lineSetCallTreatment @605 +; TSPI_lineSetLineDevStatus @606 +; TSPI_providerFreeDialogInstance @607 +; TSPI_providerGenericDialogData @608 +; TSPI_providerUIIdentify @609 + + diff --git a/private/tapi/dev/sp/repeater/new/rep16.mak b/private/tapi/dev/sp/repeater/new/rep16.mak new file mode 100644 index 000000000..ea96290a1 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/rep16.mak @@ -0,0 +1,80 @@ +##### DLL Macros ##### +DLLNAME = repeater +DLLSRCS = repeater.c logger.c debug.c +DLLOBJS = repeater.obj logger.obj debug.obj + +##### DLL Library Macros ##### +DLLLIBS = libw ldllcew ver +DLLMOD = -ALw -DDLL + +##### APP/DLL Include Macros ##### +DLLINCLS = + +##### APP/DLL Resource Macros ##### +APPRCFILES = +DLLRCFILES = + +##### DEBUG Version Built ##### +DEBUG = 1 + +##### Build Option Macros ##### +!if $(DEBUG) +DDEF = -DDEBUG -DDBG +CLOPT = -Zid -Od +MOPT = -Zi +LOPT = /CO /LI /MAP +!else +DDEF = +CLOPT = -Os +LOPT = +!endif + +##### General Macros ##### +DEF = + +##### Tool Macros ##### +CC = cl -nologo -c $(DLLMOD) -G2sw -Zp -W3 $(CLOPT) $(DDEF) $(DEF) +LINK = link /NOD /NOE $(LOPT) +RC = rc $(DDEF) $(DEF) +HC = hc + +##### Inference Rules ##### +.asm.obj: + $(ASM) $*.asm; + +.rc.res: + $(RC) -r $*.rc + +##### Main (default) Target ##### +goal: $(DLLNAME).tsp + +##### Dependents For Goal and Command Lines ##### +##### DLL Built Separately ##### +.c.obj : + $(CC) $(DLLSRCS) + + +$(DLLNAME).tsp: $(DLLOBJS) rep16.def + $(LINK) @<< + $(DLLOBJS), + $(DLLNAME).tsp, + $(DLLNAME).map, + $(DLLLIBS), + rep16.def +<< + implib $(DLLNAME).lib rep16.def + +# $(RC) -T $(DLLNAME).tsp +#!if $(DEBUG) +# cvpack -p $(DLLNAME).tsp +#!endif + +##### Dependents ##### +$(DLLOBJS): $(DLLINCLS) + +##### Clean Directory ##### +clean: + -del *.obj + -del *.tsp + -del *.map + -del *.sym diff --git a/private/tapi/dev/sp/repeater/new/repeater.c b/private/tapi/dev/sp/repeater/new/repeater.c new file mode 100644 index 000000000..bf0d84dcd --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/repeater.c @@ -0,0 +1,6251 @@ +#pragma warning(disable: 4087) + +#define STRICT +#define UNICODE + +#include <windows.h> +#include <windowsx.h> + +#ifndef WIN32 +#define TAPI_CURRENT_VERSION 0x00010004 +#endif + +#include <tapi.h> +#include <tspi.h> + +#include "tsp3216.h" + +#include "Repeater.h" +#include "logger.h" +#include "debug.h" + +#ifndef WIN32 +#define TCHAR char +#define TEXT(string) string +#define LPCWSTR LPCSTR +#endif + +#ifdef WIN32 +extern CRITICAL_SECTION gcsLogging; +extern CRITICAL_SECTION gcsID; +#endif + +#define TSPAPI PASCAL +typedef LONG (TSPAPI* TSPAPIPROC)(void); + +#if DBG +#define RepeaterDebugString(_x_) DbgPrt _x_ +#else +#define RepeaterDebugString(_x_) +#endif + +// globals + +HINSTANCE ghThisInst; +BOOL gfTerminateNow = FALSE; +BOOL gbStarted = FALSE; +DWORD dwPermanentProvider; +DWORD dwNumLines; +DWORD dwNumPhones; + +#ifdef WIN32 +DWORD gdwLoggingThreadID; +HANDLE ghLoggingThread; +#endif + +#if (TAPI_CURRENT_VERSION >= 0x00020000) +HDRVDIALOGINSTANCE gDlgInst; +#endif + +////////////////////////////////////////////////////// +HINSTANCE hProvider = NULL; +TSPAPIPROC FAR * lpfnProcAddress = NULL; + +#ifdef WIN32 +#define MYALLOC(x,y) ((x) = GlobalAlloc(GPTR, (y))) +#define MYFREE(x) GlobalFree(x) +#else +#define MYALLOC(x,y) ((x) = (LPVOID)MAKELONG(0, GlobalAlloc(GPTR, (y)))) +#define MYFREE(x) (GlobalFree((HGLOBAL)HIWORD(x))) + +#endif + + +LINEEVENT glpLineEventProc32; +PHONEEVENT glpPhoneEventProc32; + +ASYNC_COMPLETION glpAsyncCompletionProc32 = NULL; + +void InitLogging(); + +#ifndef WIN32 +const char far szIniFile[] = "telephon.INI"; +#endif + + +#define BOGUS_REQUEST_ID (0xfffffffd) + +#define NORMALCHUNK sizeof(PREHEADER) + sizeof(POSTSTRUCT) + +// all tspi function names +// since all functions are exported by name +char *gaszTSPIFuncNames[] = +{ + "TSPI_lineAccept", + "TSPI_lineAddToConference", + "TSPI_lineAgentSpecific", + "TSPI_lineAnswer", + "TSPI_lineBlindTransfer", + "TSPI_lineClose", + "TSPI_lineCloseCall", + "TSPI_lineCompleteCall", + "TSPI_lineCompleteTransfer", + "TSPI_lineConditionalMediaDetection", + "TSPI_lineDevSpecific", + "TSPI_lineDevSpecificFeature", + "TSPI_lineDial", + "TSPI_lineDrop", + "TSPI_lineForward", + "TSPI_lineGatherDigits", + "TSPI_lineGenerateDigits", + "TSPI_lineGenerateTone", + "TSPI_lineGetAddressCaps", + "TSPI_lineGetAddressID", + "TSPI_lineGetAddressStatus", + "TSPI_lineGetAgentActivityList", + "TSPI_lineGetAgentCaps", + "TSPI_lineGetAgentGroupList", + "TSPI_lineGetAgentStatus", + "TSPI_lineGetCallAddressID", + "TSPI_lineGetCallInfo", + "TSPI_lineGetCallStatus", + "TSPI_lineGetDevCaps", + "TSPI_lineGetDevConfig", + "TSPI_lineGetExtensionID", + "TSPI_lineGetIcon", + "TSPI_lineGetID", + "TSPI_lineGetLineDevStatus", + "TSPI_lineGetNumAddressIDs", + "TSPI_lineHold", + "TSPI_lineMakeCall", + "TSPI_lineMonitorDigits", + "TSPI_lineMonitorMedia", + "TSPI_lineMonitorTones", + "TSPI_lineNegotiateExtVersion", + "TSPI_lineNegotiateTSPIVersion", + "TSPI_lineOpen", + "TSPI_linePark", + "TSPI_linePickup", + "TSPI_linePrepareAddToConference", + "TSPI_lineRedirect", + "TSPI_lineReleaseUserUserInfo", + "TSPI_lineRemoveFromConference", + "TSPI_lineSecureCall", + "TSPI_lineSelectExtVersion", + "TSPI_lineSendUserUserInfo", + "TSPI_lineSetAgentActivity", + "TSPI_lineSetAgentGroup", + "TSPI_lineSetAgentState", + "TSPI_lineSetAppSpecific", + "TSPI_lineSetCallData", + "TSPI_lineSetCallParams", + "TSPI_lineSetCallQualityOfService", + "TSPI_lineSetCallTreatment", + "TSPI_lineSetCurrentLocation", + "TSPI_lineSetDefaultMediaDetection", + "TSPI_lineSetDevConfig", + "TSPI_lineSetLineDevStatus", + "TSPI_lineSetMediaControl", + "TSPI_lineSetMediaMode", + "TSPI_lineSetStatusMessages", + "TSPI_lineSetTerminal", + "TSPI_lineSetupConference", + "TSPI_lineSetupTransfer", + "TSPI_lineSwapHold", + "TSPI_lineUncompleteCall", + "TSPI_lineUnhold", + "TSPI_lineUnpark", + "TSPI_phoneClose", + "TSPI_phoneDevSpecific", + "TSPI_phoneGetButtonInfo", + "TSPI_phoneGetData", + "TSPI_phoneGetDevCaps", + "TSPI_phoneGetDisplay", + "TSPI_phoneGetExtensionID", + "TSPI_phoneGetGain", + "TSPI_phoneGetHookSwitch", + "TSPI_phoneGetIcon", + "TSPI_phoneGetID", + "TSPI_phoneGetLamp", + "TSPI_phoneGetRing", + "TSPI_phoneGetStatus", + "TSPI_phoneGetVolume", + "TSPI_phoneNegotiateExtVersion", + "TSPI_phoneNegotiateTSPIVersion", + "TSPI_phoneOpen", + "TSPI_phoneSelectExtVersion", + "TSPI_phoneSetButtonInfo", + "TSPI_phoneSetData", + "TSPI_phoneSetDisplay", + "TSPI_phoneSetGain", + "TSPI_phoneSetHookSwitch", + "TSPI_phoneSetLamp", + "TSPI_phoneSetRing", + "TSPI_phoneSetStatusMessages", + "TSPI_phoneSetVolume", + "TSPI_providerCreateLineDevice", + "TSPI_providerCreatePhoneDevice", + "TSPI_providerEnumDevices", + "TSPI_providerFreeDialogInstance", + "TSPI_providerGenericDialogData", + "TSPI_providerInit", + "TSPI_providerShutdown", + "TSPI_providerUIIdentify", + "TSPI_lineConfigDialog", + "TSPI_lineConfigDialogEdit", + "TSPI_phoneConfigDialog", + "TSPI_providerConfig" + "TSPI_lineDropOnClose", + "TSPI_lineDropNoOwner", + NULL +}; + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank1( + DWORD dwBlank1 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank1 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank2( + DWORD dwBlank1, + DWORD dwBlank2 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank2 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank3( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank3 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank4( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank4 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank5( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank5 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank6( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank6 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank7( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank7 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank8( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank8 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank9( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8, + DWORD dwBlank9 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank9 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank10( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8, + DWORD dwBlank9, + DWORD dwBlank10 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank10 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank11( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8, + DWORD dwBlank9, + DWORD dwBlank10, + DWORD dwBlank11 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank11 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_LineBlank12( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8, + DWORD dwBlank9, + DWORD dwBlank10, + DWORD dwBlank11, + DWORD dwBlank12 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_LineBlank12 - lResult=LINEERR_OPERATIONUNAVAIL")); + return LINEERR_OPERATIONUNAVAIL; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank1( + DWORD dwBlank1 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank1 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank2( + DWORD dwBlank1, + DWORD dwBlank2 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank2 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank3( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank3 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank4( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank4 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank5( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank5 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank6( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank6 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank7( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank7 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank8( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank8 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_PhoneBlank9( + DWORD dwBlank1, + DWORD dwBlank2, + DWORD dwBlank3, + DWORD dwBlank4, + DWORD dwBlank5, + DWORD dwBlank6, + DWORD dwBlank7, + DWORD dwBlank8, + DWORD dwBlank9 + ) +{ + RepeaterDebugString((2, "Entering/leaving TSPI_PhoneBlank9 - lResult=PHONEERR_OPERATIONUNAVAIL")); + return PHONEERR_OPERATIONUNAVAIL; +} + + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +// function definitions + +#ifdef DEBUG +VOID RepeaterOutputDebug(int level, LPSTR errString) + { + char outString[1024]; + + // if(level <= ???) + { + wsprintf(outString, "Repeater:(%d) %s\r\n", level, errString); + OutputDebugString(outString); + } + } +#endif + +VOID + InitializeSPs(VOID); + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +void StartMeUp( void ) +{ + + gbStarted = TRUE; + + MYALLOC(lpfnProcAddress, sizeof(gaszTSPIFuncNames)/sizeof(gaszTSPIFuncNames[0]) * sizeof(TSPAPIPROC)); + +#ifdef WIN32 + // + // Kick off the logging thread + // + InitLogging(); + + DBGOUT((3, "Entering StartMeUp")); + + ghLoggingThread = CreateThread( + NULL, + 0, + LoggingThread, + NULL, + 0, + &gdwLoggingThreadID + ); +#else + InitLogging(); +#endif + + InitializeSPs(); +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +VOID + InitializeSPs(VOID) +{ + TCHAR LibFileName[MAXBUFSIZE]; + TCHAR szBuffer[MAXBUFSIZE]; +#ifdef WIN32 + HKEY hKey; + DWORD dwSize, dwType; +#endif + + // under the telephony key, there should be a repeater key, + // that is exactly like the providers key. the repeater key + // should list the provider to actually be used. the provider + // key should list repeater as the only sp. + +#ifdef WIN32 + RegOpenKeyEx(HKEY_LOCAL_MACHINE, + TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony\\Repeater"), + 0, + KEY_QUERY_VALUE, + &hKey); +#endif + +#ifdef WIN32 + dwSize = MAXBUFSIZE; + dwType = REG_SZ; + RegQueryValueEx(hKey, + TEXT("ProviderFilename0"), + NULL, + &dwType, + (LPBYTE)LibFileName, + &dwSize); +#else + GetPrivateProfileString(TEXT("Repeater"), + TEXT("ProviderFilename0"), + TEXT(""), + LibFileName, + MAXBUFSIZE, + szIniFile); + +#endif + + DBGOUT((1, "Loading provider")); + + hProvider = LoadLibrary(LibFileName); + + if ( hProvider ) + { + DBGOUT((1, "LoadLibrary succeeded")); + +#ifdef WIN32 + + dwSize = sizeof(DWORD); + dwType = REG_DWORD; + + RegQueryValueEx(hKey, + TEXT("ProviderID0"), + NULL, + &dwType, + (LPBYTE)&dwPermanentProvider, + &dwSize); +#else + dwPermanentProvider= + GetPrivateProfileInt("Repeater", + TEXT("ProviderID0"), + 0, + szIniFile); + + // try to read NumPhones and NumLines from telephon.ini + // if the sp implements enumdevices, these numbers + // will get overwritten anyway + dwNumLines = GetPrivateProfileInt("Provider0", + "NumLines", + 0, + szIniFile); + + dwNumPhones = GetPrivateProfileInt("Provider0", + "NumPhones", + 0, + szIniFile); +#endif + } + + else + { + DBGOUT((1, " provider FAILED TO LOAD!")); + } + + + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +TSPAPIPROC GetProcAddressHashed(DWORD iFunction, UINT nNumParms) +{ + + static TSPAPIPROC DefaultLineTable[] = + { + (TSPAPIPROC)TSPI_LineBlank1, + (TSPAPIPROC)TSPI_LineBlank2, + (TSPAPIPROC)TSPI_LineBlank3, + (TSPAPIPROC)TSPI_LineBlank4, + (TSPAPIPROC)TSPI_LineBlank5, + (TSPAPIPROC)TSPI_LineBlank6, + (TSPAPIPROC)TSPI_LineBlank7, + (TSPAPIPROC)TSPI_LineBlank8, + (TSPAPIPROC)TSPI_LineBlank9, + (TSPAPIPROC)TSPI_LineBlank10, + (TSPAPIPROC)TSPI_LineBlank11, + (TSPAPIPROC)TSPI_LineBlank12 + }; + + static TSPAPIPROC DefaultPhoneTable[] = + { + (TSPAPIPROC)TSPI_PhoneBlank1, + (TSPAPIPROC)TSPI_PhoneBlank2, + (TSPAPIPROC)TSPI_PhoneBlank3, + (TSPAPIPROC)TSPI_PhoneBlank4, + (TSPAPIPROC)TSPI_PhoneBlank5, + (TSPAPIPROC)TSPI_PhoneBlank6, + (TSPAPIPROC)TSPI_PhoneBlank7, + (TSPAPIPROC)TSPI_PhoneBlank8, + (TSPAPIPROC)TSPI_PhoneBlank9, + }; + + TSPAPIPROC *pfn; + TSPAPIPROC *FunctionTable; + + + // + // Find out if it's a phone function or a line function + // + if ( + (iFunction >= SP_PHONECLOSE) + && + (iFunction <= SP_PHONESETVOLUME) + ) + { + // + // It's a phone function + // + FunctionTable = DefaultPhoneTable; + } + else + { + // + // It's a line function + // + FunctionTable = DefaultLineTable; + } + + if ( nNumParms > (sizeof(DefaultLineTable)/sizeof(TSPAPIPROC)) ) + { + DBGOUT((1, ">Num funcs function was requested!")); + return 0; + } + + // get the pointer to the function + pfn = &lpfnProcAddress[iFunction]; + + // have we already gotten the address? + if( NULL == *pfn ) + { + + // nope, call get proc address + DBGOUT((5, "%s address being gotten", gaszTSPIFuncNames[iFunction])); + + *pfn = (TSPAPIPROC)GetProcAddress(hProvider, + gaszTSPIFuncNames[iFunction]); + + // + // Did it fail? + // + if( NULL == *pfn ) + { + DBGOUT((1, "Getting address failed")); + *pfn = FunctionTable[ nNumParms - 1 ]; + } + } + + DBGOUT((1, "leaving getprocess address *pfn %lx", *pfn)); + + return *pfn; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +#ifdef WIN32 +void PASCAL LineEventProc( +#else +void CALLBACK __export LineEventProc( +#endif + HTAPILINE htLine, + HTAPICALL htCall, + DWORD dwMsg, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3 + ) +{ + + DWORD dwID; + + DBGOUT((1, "Line event callback")); + + + GetChunkID(&dwID); + AllocChunk(dwID, sizeof(PREHEADER) + sizeof(LINEMSGSTRUCT)); + + switch (dwMsg) + { + case LINE_NEWCALL: + case LINE_CALLSTATE: + case LINE_CALLDEVSPECIFIC: + case LINE_CALLDEVSPECIFICFEATURE: + case LINE_CALLINFO: + case LINE_GATHERDIGITS: + case LINE_GENERATE: + case LINE_MONITORDIGITS: + case LINE_MONITORMEDIA: + case LINE_MONITORTONE: + case LINE_ADDRESSSTATE: + case LINE_CLOSE: + case LINE_DEVSPECIFIC: + case LINE_DEVSPECIFICFEATURE: + case LINE_LINEDEVSTATE: + case LINE_CREATE: +#if (TAPI_CURRENT_VERSION >= 0x00020000) + case LINE_CREATEDIALOGINSTANCE: + case LINE_REMOVE: +#endif + break; + + } // end of switch (dwMsg) + + WritePreHeader(dwID, + LINEMSG); + + WriteLineMsgStruct(dwID, + htLine, + htCall, + dwMsg, + dwParam1, + dwParam2, + dwParam3); + + ReleaseID(dwID); + + (*glpLineEventProc32)(htLine, + htCall, + dwMsg, + dwParam1, + dwParam2, + dwParam3); + +} + +#ifdef WIN32 +void PASCAL +#else +void CALLBACK __export +#endif +PhoneEventProc( + HTAPIPHONE htPhone, + DWORD dwMsg, + DWORD dwParam1, + DWORD dwParam2, + DWORD dwParam3 + ) +{ + + DWORD dwID; + + DBGOUT((1, "Phone event callback")); + + GetChunkID(&dwID); + AllocChunk(dwID, sizeof(PREHEADER) + sizeof(PHONEMSGSTRUCT)); + + switch(dwMsg) + { + case PHONE_BUTTON: + case PHONE_CLOSE: + case PHONE_DEVSPECIFIC: + case PHONE_STATE: + case PHONE_CREATE: +#if (TAPI_CURRENT_VERSION >= 0x00020000) + case PHONE_REMOVE: +#endif + break; + } // end of switch(dwMsg) + + WritePreHeader(dwID, + PHONEMSG); + + WritePhoneMsgStruct(dwID, + htPhone, + dwMsg, + dwParam1, + dwParam2, + dwParam3); + + ReleaseID(dwID); + + (*glpPhoneEventProc32)(htPhone, + dwMsg, + dwParam1, + dwParam2, + dwParam3); + +} + + +#ifdef WIN32 +void CALLBACK //ASYNC_COMPLETION // PASCAL +#else +void CALLBACK __export +#endif +AsyncCompletionProc(DRV_REQUESTID dwRequestID, + LONG lResult) +{ + + DWORD dwID; + + DBGOUT((1, "Async completion callback")); + + GetChunkID(&dwID); + AllocChunk(dwID, sizeof(PREHEADER) + sizeof(ASYNCSTRUCT)); + + WritePreHeader(dwID, + ASYNCMSG); + + WriteAsyncStruct(dwID, + dwRequestID, + lResult); + + ReleaseID(dwID); + + (*glpAsyncCompletionProc32)( dwRequestID, lResult ); + +} + + + + +// +// -------------------- TSPIAPI TSPI_line functions --------------------------- +// + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineAccept(DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_lineAccept")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, + SP_LINEACCEPT, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpsUserUserInfo, + (DWORD)dwSize); + + WriteStruct(dwID, + dwSize, + (LPVOID)lpsUserUserInfo); + + lReturn = (* GetProcAddressHashed(SP_LINEACCEPT, 4))( + dwRequestID, + hdCall, + lpsUserUserInfo, + dwSize); + + WritePostStruct(dwID, + lReturn); + + ReleaseID(dwID); + + return lReturn; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineAddToConference( + DRV_REQUESTID dwRequestID, + HDRVCALL hdConfCall, + HDRVCALL hdConsultCall + ) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3)); + + RepeaterDebugString((2, "Entering TSPI_lineAddToConference")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINEADDTOCONFERENCE, + dwRequestID, + (DWORD)hdConfCall, + (DWORD)hdConsultCall); + + lReturn = (* GetProcAddressHashed(SP_LINEADDTOCONFERENCE,3))( + dwRequestID, + hdConfCall, + hdConsultCall); + + WritePostStruct(dwID, lReturn); + + ReleaseID(dwID); + + return lReturn; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineAnswer( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_lineAnswer")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEACCEPT, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpsUserUserInfo, + (DWORD)dwSize); + + WriteStruct(dwID, dwSize, (LPVOID)lpsUserUserInfo); + + lReturn = (* GetProcAddressHashed(SP_LINEANSWER, 4))( + dwRequestID, + hdCall, + lpsUserUserInfo, + dwSize); + + WritePostStruct(dwID, lReturn); + + ReleaseID(dwID); + + return lReturn; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineBlindTransfer( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCWSTR lpszDestAddress, + DWORD dwCountryCode) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + lstrlen(lpszDestAddress)); + + RepeaterDebugString((2, "Entering TSPI_lineBlindTransfer")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEBLINDTRANSFER, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpszDestAddress, + dwCountryCode); + + WriteStruct(dwID, lstrlen(lpszDestAddress), (LPVOID)lpszDestAddress); + + lReturn = (* GetProcAddressHashed(SP_LINEBLINDTRANSFER, 4))( + dwRequestID, + hdCall, + lpszDestAddress, + dwCountryCode + ); + + WritePostStruct(dwID, lReturn); + + ReleaseID(dwID); + + return lReturn; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineClose( + HDRVLINE hdLine + ) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1)); + + RepeaterDebugString((2, "Entering TSPI_lineClose")); + + WritePreHeader(dwID, SPFUNC1); + + WriteLogStruct1(dwID, SP_LINECLOSE, + (DWORD)hdLine); + + lReturn = (* GetProcAddressHashed(SP_LINECLOSE, 1))(hdLine); + + WritePostStruct(dwID, lReturn); + + ReleaseID(dwID); + + return lReturn; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineCloseCall( + HDRVCALL hdCall + ) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1)); + + + RepeaterDebugString((2, "Entering TSPI_lineCloseCall")); + + WritePreHeader(dwID, SPFUNC1); + + WriteLogStruct1(dwID, SP_LINECLOSECALL, + (DWORD)hdCall); + + lReturn = (* GetProcAddressHashed(SP_LINECLOSECALL, 1))(hdCall); + + WritePostStruct(dwID, lReturn); + + ReleaseID(dwID); + + return lReturn; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineCompleteCall( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPDWORD lpdwCompletionID, + DWORD dwCompletionMode, + DWORD dwMessageID + ) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(DWORD)); + + + RepeaterDebugString((2, "Entering TSPI_lineCompleteCall")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINECOMPLETECALL, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpdwCompletionID, + dwCompletionMode, + (DWORD)hdCall); + + lReturn = (* GetProcAddressHashed(SP_LINECOMPLETECALL, 5))( + dwRequestID, + hdCall, + lpdwCompletionID, + dwCompletionMode, + hdCall + ); + + WritePostStruct(dwID, lReturn); + + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwCompletionID); + + ReleaseID(dwID); + + return lReturn; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineCompleteTransfer( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + HDRVCALL hdConsultCall, + HTAPICALL htConfCall, + LPHDRVCALL lphdConfCall, + DWORD dwTransferMode + ) +{ + LONG lReturn; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + sizeof(MYHDRVCALL)); + + + RepeaterDebugString((2, "Entering TSPI_lineCompleteTransfer")); + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINECOMPLETETRANSFER, + dwRequestID, + (DWORD)hdCall, + (DWORD)hdConsultCall, + (DWORD)htConfCall, + (DWORD)lphdConfCall, + dwTransferMode); + + lReturn = (* GetProcAddressHashed(SP_LINECOMPLETETRANSFER, 6))( + dwRequestID, + hdCall, + hdConsultCall, + htConfCall, + lphdConfCall, + dwTransferMode + ); + + WritePostStruct(dwID, lReturn); + + if (lReturn >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdConfCall); + } + + + ReleaseID(dwID); + + return lReturn; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineConditionalMediaDetection( + HDRVLINE hdLine, + DWORD dwMediaModes, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + (lpCallParams ? lpCallParams->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineConditionalMediaDetection")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINECONDITIONALMEDIADETECTION, + (DWORD)hdLine, + dwMediaModes, + (DWORD)lpCallParams); + + if (lpCallParams) + { + WriteStruct(dwID, lpCallParams->dwTotalSize, + (LPVOID)lpCallParams); + } + + lResult = (* GetProcAddressHashed(SP_LINECONDITIONALMEDIADETECTION, 3))( + hdLine, + dwMediaModes, + lpCallParams); + + WritePostStruct(dwID, lResult); + + RepeaterDebugString((2, "Leaving TSPI_lineConditionalMediaDetection")); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineConfigDialog( + DWORD dwDeviceID, + HWND hwndOwner, + LPCWSTR lpszDeviceClass + ) +{ + + LONG lResult = 0; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + lstrlen(lpszDeviceClass)); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINECONFIGDIALOG, + dwDeviceID, +#ifdef WIN32 + (DWORD)hwndOwner, +#else + MAKELONG(hwndOwner, 0), +#endif + (DWORD)lpszDeviceClass); + + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + + lResult = + (* GetProcAddressHashed(SP_LINECONFIGDIALOG, 3))( + dwDeviceID, + hwndOwner, + lpszDeviceClass + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineConfigDialogEdit( + DWORD dwDeviceID, + HWND hwndOwner, + LPCWSTR lpszDeviceClass, + LPVOID const lpDeviceConfigIn, + DWORD dwSize, + LPVARSTRING lpDeviceConfigOut + ) +{ + LONG lResult; + DWORD dwID; + + RepeaterDebugString((2, "Entering TSPI_lineConfigDialogEdit")); + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC6) + + dwSize + + lstrlen(lpszDeviceClass) + + (lpDeviceConfigOut ? lpDeviceConfigOut->dwTotalSize : 0)); + + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINECONFIGDIALOGEDIT, + dwDeviceID, +#ifdef WIN32 + (DWORD)hwndOwner, +#else + (DWORD)MAKELONG(hwndOwner, 0), +#endif + (DWORD)lpszDeviceClass, + (DWORD)lpDeviceConfigIn, + dwSize, + (DWORD)lpDeviceConfigOut); + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + if (lpDeviceConfigIn) + { + WriteStruct(dwID, dwSize, + (LPVOID)lpDeviceConfigIn); + } + + lResult = (* GetProcAddressHashed(SP_LINECONFIGDIALOGEDIT, 6))( + dwDeviceID, + hwndOwner, + lpszDeviceClass, + lpDeviceConfigIn, + dwSize, + lpDeviceConfigOut); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpDeviceConfigOut) + { + WriteStruct(dwID, lpDeviceConfigOut->dwTotalSize, + (LPVOID)lpDeviceConfigOut); + } + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineDevSpecific( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD dwAddressID, + HDRVCALL hdCall, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + dwSize + dwSize); + + + RepeaterDebugString((2, "Entering TSPI_lineDevSpecific")); + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINEDEVSPECIFIC, + dwRequestID, + (DWORD)hdLine, + dwAddressID, + (DWORD)hdCall, + (DWORD)lpParams, + dwSize); + + WriteStruct(dwID, dwSize, + (LPVOID)lpParams); + + + lResult = (* GetProcAddressHashed(SP_LINEDEVSPECIFIC, 6))( + dwRequestID, + hdLine, + dwAddressID, + hdCall, + lpParams, + dwSize); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, dwSize, + (LPVOID)lpParams); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineDevSpecificFeature( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD dwFeature, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + dwSize + dwSize); + + RepeaterDebugString((2, "Entering TSPI_lineDevSpecificFeature")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEDEVSPECIFICFEATURE, + dwRequestID, + (DWORD)hdLine, + dwFeature, + (DWORD)lpParams, + dwSize); + + WriteStruct(dwID, dwSize, + (LPVOID)lpParams); + + lResult = (* GetProcAddressHashed(SP_LINEDEVSPECIFICFEATURE, 5))( + dwRequestID, + hdLine, + dwFeature, + lpParams, + dwSize); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, dwSize, + (LPVOID)lpParams); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineDial( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCWSTR lpszDestAddress, + DWORD dwCountryCode + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + lstrlen(lpszDestAddress)); + + RepeaterDebugString((2, "Entering TSPI_lineDial")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEDIAL, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpszDestAddress, + dwCountryCode); + + if (lpszDestAddress) + { + WriteStruct(dwID, lstrlen(lpszDestAddress), + (LPVOID)lpszDestAddress); + } + + lResult = (* GetProcAddressHashed(SP_LINEDIAL, 4))( + dwRequestID, + hdCall, + lpszDestAddress, + dwCountryCode + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineDrop( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_lineDrop")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEDROP, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpsUserUserInfo, + dwSize); + + WriteStruct(dwID, dwSize, + (LPVOID)lpsUserUserInfo); + + lResult = (* GetProcAddressHashed(SP_LINEDROP, 4))( + dwRequestID, + hdCall, + lpsUserUserInfo, + dwSize + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineDropOnClose( + HDRVCALL hdCall + ) +{ + + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1)); + + RepeaterDebugString((2, "Entering TSPI_lineDropOnClose")); + + WritePreHeader(dwID, SPFUNC1); + + WriteLogStruct1(dwID, SP_LINEDROPONCLOSE, + (DWORD)hdCall); + + lResult = (* GetProcAddressHashed(SP_LINEDROPONCLOSE, 1)) + (hdCall); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineDropNoOwner( + HDRVCALL hdCall + ) +{ + TSPAPIPROC pfn; + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1)); + + + RepeaterDebugString((2, "Entering TSPI_lineDropNoOwner")); + + + WritePreHeader(dwID, SPFUNC1); + + WriteLogStruct1(dwID, SP_LINEDROPNOOWNER, + (DWORD)hdCall); + + pfn = (TSPAPIPROC)GetProcAddressHashed(SP_LINEDROPNOOWNER, 1); + + + if (pfn != (TSPAPIPROC)TSPI_LineBlank1) + { + lResult = (*pfn)(hdCall); + } + else + { + RepeaterDebugString((4, " This SP does not export DROPNOOWNER, so we'll call LINEDROP")); + + lResult = (* GetProcAddressHashed(SP_LINEDROP, 4))( + (DWORD) BOGUS_REQUEST_ID, + (DWORD) hdCall, + (DWORD) NULL, + (DWORD) 0 + ); + + // + // Did we get an error back sync? + // + if ( + (lResult < 0) + && + (lResult != BOGUS_REQUEST_ID) + ) + { + // + // Yup. Return it. + // + } + else + { + // + // No, we got back the req id. Return success. + // + lResult = 0; + } + } + + RepeaterDebugString((3, "Leaving TSPI_lineDropNoOwner, return code=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineForward( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD bAllAddresses, + DWORD dwAddressID, + LPLINEFORWARDLIST const lpForwardList, + DWORD dwNumRingsNoAnswer, + HTAPICALL htConsultCall, + LPHDRVCALL lphdConsultCall, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC9) + + (lpForwardList ? lpForwardList->dwTotalSize : 0) + + (lpCallParams ? lpCallParams->dwTotalSize : 0) + + sizeof(HDRVCALL)); + + RepeaterDebugString((2, "Entering TSPI_lineForward")); + + WritePreHeader(dwID, SPFUNC9); + + WriteLogStruct9(dwID, SP_LINEFORWARD, + dwRequestID, + (DWORD)hdLine, + (DWORD)bAllAddresses, + dwAddressID, + (DWORD)lpForwardList, + (DWORD)dwNumRingsNoAnswer, + (DWORD)htConsultCall, + (DWORD)lphdConsultCall, + (DWORD)lpCallParams); + + if (lpForwardList) + { + WriteStruct(dwID, lpForwardList->dwTotalSize, + (LPVOID)lpForwardList); + } + + if (lpCallParams) + { + WriteStruct(dwID, lpCallParams->dwTotalSize, + (LPVOID)lpCallParams); + } + + lResult = (* GetProcAddressHashed(SP_LINEFORWARD, 9))( + dwRequestID, + (HDRVLINE)hdLine, + bAllAddresses, + dwAddressID, + lpForwardList, + dwNumRingsNoAnswer, + htConsultCall, + lphdConsultCall, + lpCallParams + ); + + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdConsultCall); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGatherDigits( + HDRVCALL hdCall, + DWORD dwEndToEndID, + DWORD dwDigitModes, +#ifdef WIN32 + LPWSTR lpsDigits, +#else + LPSTR lpsDigits, +#endif + DWORD dwNumDigits, + LPCWSTR lpszTerminationDigits, + DWORD dwFirstDigitTimeout, + DWORD dwInterDigitTimeout + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC8) + lstrlen(lpszTerminationDigits)); + + RepeaterDebugString((2, "Entering TSPI_lineGatherDigits")); + + WritePreHeader(dwID, SPFUNC8); + + WriteLogStruct8(dwID, SP_LINEGATHERDIGITS, + (DWORD)hdCall, + dwEndToEndID, + dwDigitModes, + (DWORD)lpsDigits, + dwNumDigits, + (DWORD)lpszTerminationDigits, + dwFirstDigitTimeout, + dwInterDigitTimeout); + + + // lpsDigits? + + if (lpszTerminationDigits) + { + WriteStruct(dwID, lstrlen(lpszTerminationDigits), + (LPVOID)lpszTerminationDigits); + } + + lResult = (* GetProcAddressHashed(SP_LINEGATHERDIGITS, 8))( + hdCall, + dwEndToEndID, + dwDigitModes, + lpsDigits, + dwNumDigits, + lpszTerminationDigits, + dwFirstDigitTimeout, + dwInterDigitTimeout); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGenerateDigits( + HDRVCALL hdCall, + DWORD dwEndToEndID, + DWORD dwDigitMode, + LPCWSTR lpszDigits, + DWORD dwDuration + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + lstrlen(lpszDigits)); + + RepeaterDebugString((2, "Entering TSPI_lineGenerateDigits")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEGENERATEDIGITS, + (DWORD)hdCall, + dwEndToEndID, + dwDigitMode, + (DWORD)lpszDigits, + dwDuration); + + if (lpszDigits) + { + WriteStruct(dwID, lstrlen(lpszDigits), + (LPVOID)lpszDigits); + } + + lResult = (* GetProcAddressHashed(SP_LINEGENERATEDIGITS, 5))( + hdCall, + dwEndToEndID, + dwDigitMode, + lpszDigits, + dwDuration ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGenerateTone( + HDRVCALL hdCall, + DWORD dwEndToEndID, + DWORD dwToneMode, + DWORD dwDuration, + DWORD dwNumTones, + LPLINEGENERATETONE const lpTones + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + dwNumTones * sizeof(LINEGENERATETONE)); + + RepeaterDebugString((2, "Entering TSPI_lineGenerateTone")); + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINEGENERATETONE, + (DWORD)hdCall, + dwEndToEndID, + dwToneMode, + dwDuration, + dwNumTones, + (DWORD)lpTones); + + WriteStruct(dwID, dwNumTones * sizeof(LINEGENERATETONE), + (LPVOID)lpTones); + + lResult = (* GetProcAddressHashed(SP_LINEGENERATETONE, 6))( + hdCall, + dwEndToEndID, + dwToneMode, + dwDuration, + dwNumTones, + lpTones ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetAddressCaps( + DWORD dwDeviceID, + DWORD dwAddressID, + DWORD dwTSPIVersion, + DWORD dwExtVersion, + LPLINEADDRESSCAPS lpAddressCaps + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC5) + + (lpAddressCaps ? lpAddressCaps->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineGetAddressCaps")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEGETADDRESSCAPS, + dwDeviceID, + dwAddressID, + dwTSPIVersion, + dwExtVersion, + (DWORD)lpAddressCaps); + + lResult = (* GetProcAddressHashed(SP_LINEGETADDRESSCAPS, 5))( + dwDeviceID, + dwAddressID, + dwTSPIVersion, + dwExtVersion, + lpAddressCaps + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpAddressCaps) + { + WriteStruct(dwID, lpAddressCaps->dwUsedSize, + (LPVOID)lpAddressCaps); + } + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetAddressID( + HDRVLINE hdLine, + LPDWORD lpdwAddressID, + DWORD dwAddressMode, + LPCWSTR lpsAddress, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + dwSize + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_lineGetAddressID")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEGETADDRESSID, + (DWORD)hdLine, + (DWORD)lpdwAddressID, + dwAddressMode, + (DWORD)lpsAddress, + dwSize); + + WriteStruct(dwID, dwSize, + (LPVOID)lpsAddress); + + lResult = + (* GetProcAddressHashed(SP_LINEGETADDRESSID, 5))( + hdLine, + lpdwAddressID, + dwAddressMode, + lpsAddress, + dwSize + ); + + RepeaterDebugString((2, "Leaving TSPI_lineGetAddressID")); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwAddressID); + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetAddressStatus( + HDRVLINE hdLine, + DWORD dwAddressID, + LPLINEADDRESSSTATUS lpAddressStatus + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + (lpAddressStatus ? lpAddressStatus->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineGetAddressStatus")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINEGETADDRESSSTATUS, + (DWORD)hdLine, + dwAddressID, + (DWORD)lpAddressStatus); + + lResult = (* GetProcAddressHashed(SP_LINEGETADDRESSSTATUS, 3))( + hdLine, + dwAddressID, + lpAddressStatus); + + RepeaterDebugString((2, "Leaving TSPI_lineGetAddressStatus")); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpAddressStatus) + { + WriteStruct(dwID, lpAddressStatus->dwUsedSize, + (LPVOID)lpAddressStatus); + } + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetCallAddressID( + HDRVCALL hdCall, + LPDWORD lpdwAddressID + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_lineGetCallAddressID")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEGETCALLADDRESSID, + (DWORD)hdCall, + (DWORD)lpdwAddressID); + + lResult = (* GetProcAddressHashed(SP_LINEGETCALLADDRESSID, 2))( + hdCall, + lpdwAddressID + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwAddressID); + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetCallInfo( + HDRVCALL hdCall, + LPLINECALLINFO lpCallInfo + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC2) + + (lpCallInfo? lpCallInfo->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineGetCallInfo")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEGETCALLINFO, + (DWORD)hdCall, + (DWORD)lpCallInfo); + + lResult = (* GetProcAddressHashed(SP_LINEGETCALLINFO, 2))( + hdCall, + lpCallInfo + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpCallInfo) + { + WriteStruct(dwID, lpCallInfo->dwUsedSize, + (LPVOID)lpCallInfo); + } + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetCallStatus( + HDRVCALL hdCall, + LPLINECALLSTATUS lpCallStatus + ) +{ + + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC2) + + (lpCallStatus ? lpCallStatus->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineGetCallStatus")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEGETCALLSTATUS, + (DWORD)hdCall, + (DWORD)lpCallStatus); + + + lResult = (* GetProcAddressHashed(SP_LINEGETCALLSTATUS, 2))( + hdCall, + lpCallStatus + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpCallStatus) + { + WriteStruct(dwID, lpCallStatus->dwUsedSize, + (LPVOID)lpCallStatus); + } + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetDevCaps( + DWORD dwDeviceID, + DWORD dwTSPIVersion, + DWORD dwExtVersion, + LPLINEDEVCAPS lpLineDevCaps + ) + { + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC4) + + (lpLineDevCaps ? lpLineDevCaps->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineGetDevCaps")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEGETDEVCAPS, + dwDeviceID, + dwTSPIVersion, + dwExtVersion, + (DWORD)lpLineDevCaps); + + lResult = + (* GetProcAddressHashed(SP_LINEGETDEVCAPS, 4))( + dwDeviceID, + dwTSPIVersion, + dwExtVersion, + lpLineDevCaps + ); + + DBGOUT((2, "Leaving TSPI_lineGetDevCaps retcode=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpLineDevCaps) + { + WriteStruct(dwID, lpLineDevCaps->dwUsedSize, + (LPVOID)lpLineDevCaps); + } + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetDevConfig( + DWORD dwDeviceID, + LPVARSTRING lpDeviceConfig, + LPCWSTR lpszDeviceClass + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + (lpDeviceConfig ? lpDeviceConfig->dwTotalSize : 0) + + lstrlen(lpszDeviceClass)); + + RepeaterDebugString((2, "Entering TSPI_lineGetDevConfig")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINEGETDEVCONFIG, + dwDeviceID, + (DWORD)lpDeviceConfig, + (DWORD)lpszDeviceClass); + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + lResult = + (* GetProcAddressHashed(SP_LINEGETDEVCONFIG, 3))( + dwDeviceID, + lpDeviceConfig, + lpszDeviceClass + ); + + DBGOUT((2, "Leaving TSPI_lineGetDevConfig retcode=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpDeviceConfig) + { + WriteStruct(dwID, lpDeviceConfig->dwUsedSize, + (LPVOID)lpDeviceConfig); + } + } + + ReleaseID(dwID); + + return lResult; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetExtensionID( + DWORD dwDeviceID, + DWORD dwTSPIVersion, + LPLINEEXTENSIONID lpExtensionID + ) +{ + + LONG lResult = 0; + DWORD dwID; + TSPAPIPROC lpfn; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(LINEEXTENSIONID)); + + RepeaterDebugString((2, "Entering TSPI_lineGetExtensionID")); + + lpfn = (TSPAPIPROC)GetProcAddressHashed(SP_LINEGETEXTENSIONID, 3); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINEGETEXTENSIONID, + dwDeviceID, + dwTSPIVersion, + (DWORD)lpExtensionID); + + if (lpfn != (TSPAPIPROC)TSPI_LineBlank3) + { + + lResult = + (* lpfn)( + dwDeviceID, + dwTSPIVersion, + lpExtensionID + ); + } + else + { + RepeaterDebugString((2, " SP does not support TSPI_lineGetExtensionID. (We'll fill in zeros.)")); + + lpExtensionID->dwExtensionID0 = 0; + lpExtensionID->dwExtensionID1 = 0; + lpExtensionID->dwExtensionID2 = 0; + lpExtensionID->dwExtensionID3 = 0; + } + + + + RepeaterDebugString((2, "Leaving TSPI_lineGetExtensionID retcode=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(LINEEXTENSIONID), + (LPVOID)lpExtensionID); + } + + ReleaseID(dwID); + + return lResult; +} + + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetIcon( + DWORD dwDeviceID, + LPCWSTR lpszDeviceClass, + LPHICON lphIcon + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + lstrlen(lpszDeviceClass) + + sizeof(HICON)); + + RepeaterDebugString((2, "Entering TSPI_lineGetIcon")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINEGETICON, + dwDeviceID, + (DWORD)lpszDeviceClass, + (DWORD)lphIcon); + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + lResult = + (* GetProcAddressHashed(SP_LINEGETICON, 3))( + dwDeviceID, + lpszDeviceClass, + lphIcon + ); + + DBGOUT((2, "Leaving TSPI_lineGetIcon retcode=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HICON), + (LPVOID)lphIcon); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetID( + HDRVLINE hdLine, + DWORD dwAddressID, + HDRVCALL hdCall, + DWORD dwSelect, + LPVARSTRING lpDeviceID, + LPCWSTR lpszDeviceClass +#if (TAPI_CURRENT_VERSION >= 0x00020000) + , + HANDLE hTargetProcess +#endif + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC7) + + lstrlen(lpszDeviceClass) + + (lpDeviceID ? lpDeviceID->dwTotalSize : 0)); + + + RepeaterDebugString((2, "Entering TSPI_lineGetID")); + + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + + WritePreHeader(dwID, SPFUNC7); + + WriteLogStruct7(dwID, SP_LINEGETID, + (DWORD)hdLine, + (DWORD)dwAddressID, + (DWORD)hdCall, + (DWORD)dwSelect, + (DWORD)lpDeviceID, + (DWORD)lpszDeviceClass, + (DWORD)hTargetProcess); +#else + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINEGETID, + (DWORD)hdLine, + (DWORD)dwAddressID, + (DWORD)hdCall, + (DWORD)dwSelect, + (DWORD)lpDeviceID, + (DWORD)lpszDeviceClass ); +#endif + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + lResult = (* GetProcAddressHashed(SP_LINEGETID, 7))( + hdLine, + dwAddressID, + hdCall, + dwSelect, + lpDeviceID, + lpszDeviceClass, + hTargetProcess); +#else + lResult = (* GetProcAddressHashed(SP_LINEGETID, 6))( + hdLine, + dwAddressID, + hdCall, + dwSelect, + lpDeviceID, + lpszDeviceClass); +#endif + + RepeaterDebugString((2, "Leaving TSPI_lineGetID - lResult=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpDeviceID) + { + WriteStruct(dwID, lpDeviceID->dwUsedSize, + (LPVOID)lpDeviceID); + } + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetLineDevStatus( + HDRVLINE hdLine, + LPLINEDEVSTATUS lpLineDevStatus + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC2) + + (lpLineDevStatus ? lpLineDevStatus->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineGetLineDevStatus")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEGETLINEDEVSTATUS, + (DWORD)hdLine, + (DWORD)lpLineDevStatus); + + lResult = (* GetProcAddressHashed(SP_LINEGETLINEDEVSTATUS, 2))( + hdLine, + lpLineDevStatus); + + RepeaterDebugString((2, "Leaving TSPI_lineGetLineDevStatus")); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpLineDevStatus) + { + WriteStruct(dwID, lpLineDevStatus->dwUsedSize, + (LPVOID)lpLineDevStatus); + } + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineGetNumAddressIDs( + HDRVLINE hdLine, + LPDWORD lpdwNumAddressIDs + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_lineGetNumAddressIDs")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEGETNUMADDRESSIDS, + (DWORD)hdLine, + (DWORD)lpdwNumAddressIDs); + + lResult = (* GetProcAddressHashed(SP_LINEGETNUMADDRESSIDS, 2))( + hdLine, + lpdwNumAddressIDs ); + + RepeaterDebugString((2, "Leaving TSPI_lineGetNumAddressIDs - returning 0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwNumAddressIDs); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineHold( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineHold")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEHOLD, + dwRequestID, + (DWORD)hdCall); + + lResult = (* GetProcAddressHashed(SP_LINEHOLD, 2))( + dwRequestID, + hdCall + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineMakeCall( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + HTAPICALL htCall, + LPHDRVCALL lphdCall, + LPCWSTR lpszDestAddress, + DWORD dwCountryCode, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC7) + + sizeof(HDRVCALL) + + lstrlen(lpszDestAddress) + + (lpCallParams?lpCallParams->dwTotalSize:0)); + + RepeaterDebugString((2, "Entering TSPI_lineMakeCall")); + + WritePreHeader(dwID, SPFUNC7); + + WriteLogStruct7(dwID, SP_LINEMAKECALL, + dwRequestID, + (DWORD)hdLine, + (DWORD)htCall, + (DWORD)lphdCall, + (DWORD)lpszDestAddress, + dwCountryCode, + (DWORD)lpCallParams); + + if (lpszDestAddress) + { + WriteStruct(dwID, lstrlen(lpszDestAddress), + (LPVOID)lpszDestAddress); + } + + if (lpCallParams) + { + WriteStruct(dwID, lpCallParams->dwTotalSize, + (LPVOID)lpCallParams); + } + + lResult = (* GetProcAddressHashed(SP_LINEMAKECALL, 7)) + ( + dwRequestID, + hdLine, + htCall, + lphdCall, + lpszDestAddress, + dwCountryCode, + lpCallParams + ); + + + RepeaterDebugString((2, "Leaving TSPI_lineMakeCall - returning 0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdCall); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineMonitorDigits( + HDRVCALL hdCall, + DWORD dwDigitModes + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineMonitorDigits")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEMONITORDIGITS, + (DWORD)hdCall, + dwDigitModes); + + lResult = (* GetProcAddressHashed(SP_LINEMONITORDIGITS, 2))( + hdCall, + dwDigitModes + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineMonitorMedia( + HDRVCALL hdCall, + DWORD dwMediaModes + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineMonitorMedia")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEMONITORMEDIA, + (DWORD)hdCall, + dwMediaModes); + + lResult = (* GetProcAddressHashed(SP_LINEMONITORMEDIA, 2))( + hdCall, + dwMediaModes + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineMonitorTones( + HDRVCALL hdCall, + DWORD dwToneListID, + LPLINEMONITORTONE const lpToneList, + DWORD dwNumEntries + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwNumEntries * sizeof(LINEMONITORTONE)); + + RepeaterDebugString((2, "Entering TSPI_lineMonitorTones")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEMONITORTONES, + (DWORD)hdCall, + dwToneListID, + (DWORD)lpToneList, + dwNumEntries); + + WriteStruct(dwID, sizeof(LINEMONITORTONE) * dwNumEntries, + (LPVOID)lpToneList); + + lResult = (* GetProcAddressHashed(SP_LINEMONITORTONES, 4))( + hdCall, + dwToneListID, + lpToneList, + dwNumEntries + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineNegotiateExtVersion( + DWORD dwDeviceID, + DWORD dwTSPIVersion, + DWORD dwLowVersion, + DWORD dwHighVersion, + LPDWORD lpdwExtVersion + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_lineNegotiateExtVersion")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINENEGOTIATEEXTVERSION, + dwDeviceID, + dwTSPIVersion, + dwLowVersion, + dwHighVersion, + (DWORD)lpdwExtVersion); + + lResult = + (* GetProcAddressHashed(SP_LINENEGOTIATEEXTVERSION, 5))( + dwDeviceID, + dwTSPIVersion, + dwLowVersion, + dwHighVersion, + lpdwExtVersion + ); + + + DBGOUT((2, "Leaving TSPI_lineNegotiateExeVersion retcode=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwExtVersion); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineNegotiateTSPIVersion( + DWORD dwDeviceID, + DWORD dwLowVersion, + DWORD dwHighVersion, + LPDWORD lpdwTSPIVersion + ) +{ + LONG lResult = 0; + DWORD dwID; + + if (!gbStarted) + { + StartMeUp(); + } + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + sizeof(DWORD)); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINENEGOTIATETSPIVERSION, + dwDeviceID, + dwLowVersion, + dwHighVersion, + (DWORD)lpdwTSPIVersion); + + RepeaterDebugString((2, "Entering TSPI_lineNegotiateTSPIVersion")); + + /// bugbugbug!! call the *(&(^$ function + + lResult = (* GetProcAddressHashed(SP_LINENEGOTIATETSPIVERSION, 4))( + dwDeviceID, + dwLowVersion, + dwHighVersion, + lpdwTSPIVersion); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwTSPIVersion); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineOpen( + DWORD dwDeviceID, + HTAPILINE htLine, + LPHDRVLINE lphdLine, + DWORD dwTSPIVersion, + LINEEVENT lpfnEventProc + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(HDRVLINE)); + + RepeaterDebugString((2, "Entering TSPI_lineOpen")); + + glpLineEventProc32 = lpfnEventProc; + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEOPEN, + dwDeviceID, + (DWORD)htLine, + (DWORD)lphdLine, + dwTSPIVersion, + (DWORD)lpfnEventProc); + + lResult = + (* GetProcAddressHashed(SP_LINEOPEN, 5))( + dwDeviceID, + htLine, + lphdLine, + dwTSPIVersion, + LineEventProc + ); + + DBGOUT((2, "Leaving TSPI_lineOpen retcode=0x%08lx", lResult)); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVLINE), + (LPVOID)lphdLine); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_linePark( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + DWORD dwParkMode, + LPCWSTR lpszDirAddress, + LPVARSTRING lpNonDirAddress + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC5) + + lstrlen(lpszDirAddress) + + (lpNonDirAddress ? lpNonDirAddress->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_linePark")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEPARK, + dwRequestID, + (DWORD)hdCall, + dwParkMode, + (DWORD)lpszDirAddress, + (DWORD)lpNonDirAddress); + + if (dwParkMode & LINEPARKMODE_DIRECTED) + { + if (lpszDirAddress) + { + WriteStruct(dwID, lstrlen(lpszDirAddress), + (LPVOID)lpszDirAddress); + } + } + + lResult = + (* GetProcAddressHashed(SP_LINEPARK, 5))( + dwRequestID, + hdCall, + dwParkMode, + lpszDirAddress, + lpNonDirAddress); + + WritePostStruct(dwID, lResult); + + if ((lResult >= 0) && (dwParkMode & LINEPARKMODE_NONDIRECTED)) + { + if (lpNonDirAddress) + { + WriteStruct(dwID, lpNonDirAddress->dwUsedSize, + (LPVOID)lpNonDirAddress); + } + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_linePickup( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD dwAddressID, + HTAPICALL htCall, + LPHDRVCALL lphdCall, + LPCWSTR lpszDestAddress, + LPCWSTR lpszGroupID + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC7) + + lstrlen(lpszDestAddress) + + lstrlen(lpszGroupID) + + sizeof(HDRVCALL)); + + RepeaterDebugString((2, "Entering TSPI_linePickup")); + + WritePreHeader(dwID, SPFUNC7); + + WriteLogStruct7(dwID, SP_LINEPICKUP, + dwRequestID, + (DWORD)hdLine, + (DWORD)dwAddressID, + (DWORD)htCall, + (DWORD)lphdCall, + (DWORD)lpszDestAddress, + (DWORD)lpszGroupID); + + if (lpszDestAddress) + { + WriteStruct(dwID, lstrlen(lpszDestAddress), + (LPVOID)lpszDestAddress); + } + + if (lpszGroupID) + { + WriteStruct(dwID, lstrlen(lpszGroupID), + (LPVOID)lpszGroupID); + } + + lResult = + (* GetProcAddressHashed(SP_LINEPICKUP, 7))( + dwRequestID, + hdLine, + dwAddressID, + htCall, + lphdCall, + lpszDestAddress, + lpszGroupID); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdCall); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_linePrepareAddToConference( + DRV_REQUESTID dwRequestID, + HDRVCALL hdConfCall, + HTAPICALL htConsultCall, + LPHDRVCALL lphdConsultCall, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC5) + + (lpCallParams?lpCallParams->dwTotalSize:0) + + sizeof(HDRVCALL)); + + RepeaterDebugString((2, "Entering TSPI_linePrepareAddToConference")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINEPREPAREADDTOCONFERENCE, + dwRequestID, + (DWORD)hdConfCall, + (DWORD)htConsultCall, + (DWORD)lphdConsultCall, + (DWORD)lpCallParams); + + if (lpCallParams) + { + WriteStruct(dwID, lpCallParams->dwTotalSize, + (LPVOID)lpCallParams); + } + + lResult = (* GetProcAddressHashed(SP_LINEPREPAREADDTOCONFERENCE, + 5))( + dwRequestID, + hdConfCall, + htConsultCall, + lphdConsultCall, + lpCallParams); + + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdConsultCall); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineRedirect( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCWSTR lpszDestAddress, + DWORD dwCountryCode + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC4) + + lstrlen(lpszDestAddress)); + + RepeaterDebugString((2, "Entering TSPI_lineRedirect")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINEREDIRECT, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpszDestAddress, + dwCountryCode); + + if (lpszDestAddress) + { + WriteStruct(dwID, lstrlen(lpszDestAddress), + (LPVOID)lpszDestAddress); + } + + lResult = (* GetProcAddressHashed(SP_LINEREDIRECT, + 4))( + dwRequestID, + hdCall, + lpszDestAddress, + dwCountryCode); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineRemoveFromConference( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineRemoveFromConference")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEREMOVEFROMCONFERENCE, + dwRequestID, + (DWORD)hdCall); + + lResult = (* GetProcAddressHashed(SP_LINEREMOVEFROMCONFERENCE, + 2))( + dwRequestID, + hdCall); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSecureCall( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineSecureCall")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINESECURECALL, + dwRequestID, + (DWORD)hdCall); + + lResult = (* GetProcAddressHashed(SP_LINESECURECALL, + 2))( + dwRequestID, + hdCall); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSelectExtVersion( + HDRVLINE hdLine, + DWORD dwExtVersion + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineSelectExtVersion")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINESELECTEXTVERSION, + (DWORD)hdLine, + (DWORD)dwExtVersion); + + lResult = (* GetProcAddressHashed(SP_LINESELECTEXTVERSION, + 2))( + hdLine, + dwExtVersion); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSendUserUserInfo( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_lineSendUserUserInfo")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINESENDUSERUSERINFO, + dwRequestID, + (DWORD)hdCall, + (DWORD)lpsUserUserInfo, + dwSize); + + if (lpsUserUserInfo) + { + WriteStruct(dwID, dwSize, + (LPVOID)lpsUserUserInfo); + } + + lResult = (* GetProcAddressHashed(SP_LINESENDUSERUSERINFO, + 4))( + dwRequestID, + hdCall, + lpsUserUserInfo, + dwSize); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetAppSpecific( + HDRVCALL hdCall, + DWORD dwAppSpecific + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineSetAppSpecific")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINESETAPPSPECIFIC, + (DWORD)hdCall, + dwAppSpecific); + + lResult = (* GetProcAddressHashed(SP_LINESETAPPSPECIFIC, 2))( + hdCall, + dwAppSpecific + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetCallParams( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + DWORD dwBearerMode, + DWORD dwMinRate, + DWORD dwMaxRate, + LPLINEDIALPARAMS const lpDialParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + sizeof(LINEDIALPARAMS)); + + RepeaterDebugString((2, "Entering TSPI_lineSetCallParams")); + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINESETCALLPARAMS, + dwRequestID, + (DWORD)hdCall, + dwBearerMode, + dwMinRate, + dwMaxRate, + (DWORD)lpDialParams); + + if (lpDialParams) + { + WriteStruct(dwID, sizeof(LINEDIALPARAMS), + (LPVOID)lpDialParams); + } + + lResult = (* GetProcAddressHashed(SP_LINESETCALLPARAMS, 6))( + dwRequestID, + hdCall, + dwBearerMode, + dwMinRate, + dwMaxRate, + lpDialParams + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetCurrentLocation( + DWORD dwLocation + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1)); + + RepeaterDebugString((2, "Entering TSPI_lineSetCurrentLocation")); + + WritePreHeader(dwID, SPFUNC1); + + WriteLogStruct1(dwID, SP_LINESETCURRENTLOCATION, + dwLocation); + + lResult = (* GetProcAddressHashed(SP_LINESETCURRENTLOCATION, 1)) + (dwLocation); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetDefaultMediaDetection( + HDRVLINE hdLine, + DWORD dwMediaModes + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineSetDefaultMediaDetection")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINESETDEFAULTMEDIADETECTION, + (DWORD)hdLine, + dwMediaModes); + + lResult = (* GetProcAddressHashed( + SP_LINESETDEFAULTMEDIADETECTION, + 2 + ))(hdLine, dwMediaModes); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetDevConfig( + DWORD dwDeviceID, + LPVOID const lpDeviceConfig, + DWORD dwSize, + LPCWSTR lpszDeviceClass + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC4) + + dwSize + + lstrlen(lpszDeviceClass)); + + RepeaterDebugString((2, "Entering TSPI_lineSetDevConfig")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_LINESETDEVCONFIG, + (DWORD)dwDeviceID, + (DWORD)lpDeviceConfig, + dwSize, + (DWORD)lpszDeviceClass); + + if (lpDeviceConfig) + { + WriteStruct(dwID, dwSize, + (LPVOID)lpDeviceConfig); + } + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + lResult = (* GetProcAddressHashed(SP_LINESETDEVCONFIG, 4))( + dwDeviceID, + lpDeviceConfig, + dwSize, + lpszDeviceClass + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetMediaControl( + HDRVLINE hdLine, + DWORD dwAddressID, + HDRVCALL hdCall, + DWORD dwSelect, + LPLINEMEDIACONTROLDIGIT const lpDigitList, + DWORD dwDigitNumEntries, + LPLINEMEDIACONTROLMEDIA const lpMediaList, + DWORD dwMediaNumEntries, + LPLINEMEDIACONTROLTONE const lpToneList, + DWORD dwToneNumEntries, + LPLINEMEDIACONTROLCALLSTATE const lpCallStateList, + DWORD dwCallStateNumEntries + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC12) + + sizeof(LINEMEDIACONTROLDIGIT) * dwDigitNumEntries + + sizeof(LINEMEDIACONTROLMEDIA) * dwMediaNumEntries + + sizeof(LINEMEDIACONTROLTONE) * dwToneNumEntries + + sizeof(LINEMEDIACONTROLCALLSTATE) * dwCallStateNumEntries); + + + RepeaterDebugString((2, "Entering TSPI_lineSetMediaControl")); + + WritePreHeader(dwID, SPFUNC12); + + WriteLogStruct12(dwID, SP_LINESETMEDIACONTROL, + (DWORD)hdLine, + dwAddressID, + (DWORD)hdCall, + dwSelect, + (DWORD)lpDigitList, + dwDigitNumEntries, + (DWORD)lpMediaList, + dwMediaNumEntries, + (DWORD)lpToneList, + dwToneNumEntries, + (DWORD)lpCallStateList, + dwCallStateNumEntries); + + if (lpDigitList) + { + WriteStruct(dwID, sizeof(LINEMEDIACONTROLDIGIT) * dwDigitNumEntries, + (LPVOID)lpDigitList); + } + + if (lpMediaList) + { + WriteStruct(dwID, sizeof(LINEMEDIACONTROLMEDIA) * dwMediaNumEntries, + (LPVOID)lpMediaList); + } + + if (lpToneList) + { + WriteStruct(dwID, sizeof(LINEMEDIACONTROLTONE) * dwToneNumEntries, + (LPVOID)lpToneList); + } + + if (lpCallStateList) + { + WriteStruct(dwID, sizeof(LINEMEDIACONTROLCALLSTATE) * dwCallStateNumEntries, + (LPVOID)lpCallStateList); + } + + lResult = (* GetProcAddressHashed(SP_LINESETMEDIACONTROL, + 12)) + (hdLine, + dwAddressID, + hdCall, + dwSelect, + lpDigitList, + dwDigitNumEntries, + lpMediaList, + dwMediaNumEntries, + lpToneList, + dwToneNumEntries, + lpCallStateList, + dwCallStateNumEntries); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetMediaMode( + HDRVCALL hdCall, + DWORD dwMediaMode + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineSetMediaMode")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINESETMEDIAMODE, + (DWORD)hdCall, + dwMediaMode); + + lResult = (* GetProcAddressHashed(SP_LINESETMEDIAMODE, 2))( + hdCall, + dwMediaMode + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetStatusMessages( + HDRVLINE hdLine, + DWORD dwLineStates, + DWORD dwAddressStates + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3)); + + RepeaterDebugString((2, "Entering TSPI_lineSetStatusMessages")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINESETSTATUSMESSAGES, + (DWORD)hdLine, + dwLineStates, + dwAddressStates); + + lResult = (* GetProcAddressHashed(SP_LINESETSTATUSMESSAGES, 3))( + hdLine, + dwLineStates, + dwAddressStates + ); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetTerminal( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD dwAddressID, + HDRVCALL hdCall, + DWORD dwSelect, + DWORD dwTerminalModes, + DWORD dwTerminalID, + DWORD bEnable + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC8)); + + RepeaterDebugString((2, "Entering TSPI_lineSetTerminal")); + + WritePreHeader(dwID, SPFUNC8); + + WriteLogStruct8(dwID, SP_LINESETTERMINAL, + dwRequestID, + (DWORD)hdLine, + dwAddressID, + (DWORD)hdCall, + dwSelect, + dwTerminalModes, + dwTerminalID, + bEnable); + + lResult = (* GetProcAddressHashed(SP_LINESETTERMINAL, + 8))( + dwRequestID, + hdLine, + dwAddressID, + hdCall, + dwSelect, + dwTerminalModes, + dwTerminalID, + bEnable); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetupConference( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + HDRVLINE hdLine, + HTAPICALL htConfCall, + LPHDRVCALL lphdConfCall, + HTAPICALL htConsultCall, + LPHDRVCALL lphdConsultCall, + DWORD dwNumParties, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC9) + + sizeof(HDRVCALL) + + sizeof(HDRVCALL)); + + RepeaterDebugString((2, "Entering TSPI_lineSetupConference")); + + WritePreHeader(dwID, SPFUNC9); + + WriteLogStruct9(dwID, SP_LINESETUPCONFERENCE, + dwRequestID, + (DWORD)hdCall, + (DWORD)hdLine, + (DWORD)htConfCall, + (DWORD)lphdConfCall, + (DWORD)htConsultCall, + (DWORD)lphdConsultCall, + dwNumParties, + (DWORD)lpCallParams); + + lResult = (* GetProcAddressHashed(SP_LINESETUPCONFERENCE, + 9))( + dwRequestID, + hdCall, + hdLine, + htConfCall, + lphdConfCall, + htConsultCall, + lphdConsultCall, + dwNumParties, + lpCallParams); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdConfCall); + + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdConsultCall); + } + + ReleaseID(dwID); + + return lResult; +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSetupTransfer( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall, + HTAPICALL htConsultCall, + LPHDRVCALL lphdConsultCall, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC5) + + sizeof(HDRVCALL) + + (lpCallParams ? lpCallParams->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_lineSetupTransfer")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_LINESETUPTRANSFER, + dwRequestID, + (DWORD)hdCall, + (DWORD)htConsultCall, + (DWORD)lphdConsultCall, + (DWORD)lpCallParams); + + if (lpCallParams) + { + WriteStruct(dwID, lpCallParams->dwTotalSize, + (LPVOID)lpCallParams); + } + + lResult = (* GetProcAddressHashed(SP_LINESETUPTRANSFER, + 5))( + dwRequestID, + hdCall, + htConsultCall, + lphdConsultCall, + lpCallParams); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdConsultCall); + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineSwapHold( + DRV_REQUESTID dwRequestID, + HDRVCALL hdActiveCall, + HDRVCALL hdHeldCall + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3)); + + RepeaterDebugString((2, "Entering TSPI_lineSwapHold")); + + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINESWAPHOLD, + dwRequestID, + (DWORD)hdActiveCall, + (DWORD)hdHeldCall); + + + lResult = (* GetProcAddressHashed(SP_LINESWAPHOLD, + 3))( + dwRequestID, + hdActiveCall, + hdHeldCall); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineUncompleteCall( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD dwCompletionID + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3)); + + RepeaterDebugString((2, "Entering TSPI_lineUncompleteCall")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_LINEUNCOMPLETECALL, + dwRequestID, + (DWORD)hdLine, + dwCompletionID); + + lResult = (* GetProcAddressHashed(SP_LINEUNCOMPLETECALL, + 3))( + dwRequestID, + hdLine, + dwCompletionID); + + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineUnhold( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineUnhold")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINEUNHOLD, + dwRequestID, + (DWORD)hdCall); + + lResult = (* GetProcAddressHashed(SP_LINEUNHOLD, + 2))( + dwRequestID, + hdCall); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineUnpark( + DRV_REQUESTID dwRequestID, + HDRVLINE hdLine, + DWORD dwAddressID, + HTAPICALL htCall, + LPHDRVCALL lphdCall, + LPCWSTR lpszDestAddress + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC6) + + lstrlen(lpszDestAddress) + + sizeof(HDRVCALL)); + + RepeaterDebugString((2, "Entering TSPI_lineUnpark")); + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_LINEUNPARK, + dwRequestID, + (DWORD)hdLine, + dwAddressID, + (DWORD)htCall, + (DWORD)lphdCall, + (DWORD)lpszDestAddress); + + if (lpszDestAddress) + { + WriteStruct(dwID, lstrlen(lpszDestAddress), + (LPVOID)lpszDestAddress); + } + + lResult= (* GetProcAddressHashed(SP_LINEUNPARK, + 6))( + dwRequestID, + hdLine, + dwAddressID, + htCall, + lphdCall, + lpszDestAddress); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HDRVCALL), + (LPVOID)lphdCall); + } + + ReleaseID(dwID); + + return lResult; + +} + + +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +////////////////////////////////////////////////////// +LONG +TSPIAPI +TSPI_lineReleaseUserUserInfo( + DRV_REQUESTID dwRequestID, + HDRVCALL hdCall + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_lineReleaseUserUserInfo")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_LINERELEASEUSERUSERINFO, + (DWORD)dwRequestID, + (DWORD)hdCall); + + lResult = (* GetProcAddressHashed(SP_LINERELEASEUSERUSERINFO, + 2))( + dwRequestID, + hdCall); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + + +// +// ----------------------- TSPIAPI TSPI_phone functions ----------------------- +// + +LONG +TSPIAPI +TSPI_phoneClose( + HDRVPHONE hdPhone + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC1)); + + RepeaterDebugString((2, "Entering TSPI_phoneClose")); + + WritePreHeader(dwID, SPFUNC1); + + WriteLogStruct1(dwID, SP_PHONECLOSE, + (DWORD)hdPhone); + + lResult = (* GetProcAddressHashed(SP_PHONECLOSE, 1))( + hdPhone + ); + + WritePostStruct(dwID, lResult); + + RepeaterDebugString((2, "Leaving TSPI_phoneClose - lResult=0x%08lx", lResult)); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneConfigDialog( + DWORD dwDeviceID, + HWND hwndOwner, + LPCWSTR lpszDeviceClass + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + lstrlen(lpszDeviceClass)); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONECONFIGDIALOG, + dwDeviceID, +#ifdef WIN32 + (DWORD)hwndOwner, +#else + (DWORD)MAKELONG(hwndOwner, 0), +#endif + (DWORD)lpszDeviceClass); + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + lResult = (* GetProcAddressHashed(SP_PHONECONFIGDIALOG, 3))( + dwDeviceID, + hwndOwner, + lpszDeviceClass); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneDevSpecific( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_phoneDevSpecific")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONEDEVSPECIFIC, + dwRequestID, + (DWORD)hdPhone, + (DWORD)lpParams, + (DWORD)dwSize); + + if (lpParams) + { + WriteStruct(dwID, dwSize, + (LPVOID)lpParams); + } + + lResult = (* GetProcAddressHashed(SP_PHONEDEVSPECIFIC, + 4))( + dwRequestID, + hdPhone, + lpParams, + dwSize); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneGetButtonInfo( + HDRVPHONE hdPhone, + DWORD dwButtonLampID, + LPPHONEBUTTONINFO lpButtonInfo + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + (lpButtonInfo ? lpButtonInfo->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetButtonInfo")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETBUTTONINFO, + (DWORD)hdPhone, + dwButtonLampID, + (DWORD)lpButtonInfo); + + lResult = (* GetProcAddressHashed(SP_PHONEGETBUTTONINFO, + 3))( + hdPhone, + dwButtonLampID, + lpButtonInfo); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpButtonInfo) + { + WriteStruct(dwID, lpButtonInfo->dwUsedSize, + (LPVOID)lpButtonInfo); + } + } + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneGetData( + HDRVPHONE hdPhone, + DWORD dwDataID, + LPVOID lpData, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_phoneGetData")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONEGETDATA, + (DWORD)hdPhone, + (DWORD)dwDataID, + (DWORD)lpData, + dwSize); + + lResult = (* GetProcAddressHashed(SP_PHONEGETDATA, + 4))( + hdPhone, + dwDataID, + lpData, + dwSize); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpData) + { + WriteStruct(dwID, dwSize, + lpData); + } + } + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneGetDevCaps( + DWORD dwDeviceID, + DWORD dwTSPIVersion, + DWORD dwExtVersion, + LPPHONECAPS lpPhoneCaps + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC4) + + (lpPhoneCaps ? lpPhoneCaps->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetDevCaps")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONEGETDEVCAPS, + dwDeviceID, + dwTSPIVersion, + dwExtVersion, + (DWORD)lpPhoneCaps); + + lResult = (* GetProcAddressHashed(SP_PHONEGETDEVCAPS, 4))( + dwDeviceID, + dwTSPIVersion, + dwExtVersion, + lpPhoneCaps + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpPhoneCaps) + { + WriteStruct(dwID, lpPhoneCaps->dwUsedSize, + (LPVOID)lpPhoneCaps); + } + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetDevCaps")); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetDisplay( + HDRVPHONE hdPhone, + LPVARSTRING lpDisplay + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC2) + + (lpDisplay ? lpDisplay->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetDisplay")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_PHONEGETDISPLAY, + (DWORD)hdPhone, + (DWORD)lpDisplay); + + lResult = (* GetProcAddressHashed(SP_PHONEGETDISPLAY, + 2))( + hdPhone, + lpDisplay); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpDisplay) + { + WriteStruct(dwID, lpDisplay->dwUsedSize, + (LPVOID)lpDisplay); + } + } + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneGetExtensionID( + DWORD dwDeviceID, + DWORD dwTSPIVersion, + LPPHONEEXTENSIONID lpExtensionID + ) +{ + LONG lResult; + DWORD dwID; + TSPAPIPROC lpfn; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(PHONEEXTENSIONID)); + + + RepeaterDebugString((2, "Entering TSPI_phoneGetExtensionID")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETEXTENSIONID, + dwDeviceID, + dwTSPIVersion, + (DWORD)lpExtensionID); + + + lpfn = GetProcAddressHashed(SP_PHONEGETEXTENSIONID, 3); + + // + // Does this service provider export this function? + // + if (lpfn != (TSPAPIPROC)TSPI_PhoneBlank3) + { + lResult = (* lpfn)( + dwDeviceID, + dwTSPIVersion, + lpExtensionID + ); + } + else + { + // + // Nope. Fill it fulla rocks. + // + RepeaterDebugString((2, " SP# does not support TSPI_phoneGetExtensionID. (We'll zero it)")); + + lpExtensionID->dwExtensionID0 = 0; + lpExtensionID->dwExtensionID1 = 0; + lpExtensionID->dwExtensionID2 = 0; + lpExtensionID->dwExtensionID3 = 0; + + lResult = 0; + } + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + if (lpExtensionID) + { + WriteStruct(dwID, sizeof(PHONEEXTENSIONID), + (LPVOID)lpExtensionID); + } + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetExtensionID - lResult=0x%08lx",lResult)); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetGain( + HDRVPHONE hdPhone, + DWORD dwHookSwitchDev, + LPDWORD lpdwGain + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetGain")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETGAIN, + (DWORD)hdPhone, + dwHookSwitchDev, + (DWORD)lpdwGain); + + lResult = (* GetProcAddressHashed(SP_PHONEGETGAIN, 3))( + hdPhone, + dwHookSwitchDev, + lpdwGain + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwGain); + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetGain")); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetHookSwitch( + HDRVPHONE hdPhone, + LPDWORD lpdwHookSwitchDevs + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetHookSwitch")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_PHONEGETHOOKSWITCH, + (DWORD)hdPhone, + (DWORD)lpdwHookSwitchDevs); + + lResult = (* GetProcAddressHashed(SP_PHONEGETHOOKSWITCH, 2))( + hdPhone, + lpdwHookSwitchDevs + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwHookSwitchDevs); + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetHoosSwitch")); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetIcon( + DWORD dwDeviceID, + LPCWSTR lpszDeviceClass, + LPHICON lphIcon + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC3) + + sizeof(HICON) + + lstrlen(lpszDeviceClass)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetIcon")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETICON, + dwDeviceID, + (DWORD)lpszDeviceClass, + (DWORD)lphIcon); + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + + lResult = (* GetProcAddressHashed(SP_PHONEGETICON, 3))( + dwDeviceID, + lpszDeviceClass, + lphIcon + ); + + WritePostStruct(dwID, lResult); + + if (lResult >= 0) + { + WriteStruct(dwID, sizeof(HICON), + (LPVOID)lphIcon); + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetIcon")); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetID( + HDRVPHONE hdPhone, + LPVARSTRING lpDeviceID, + LPCWSTR lpszDeviceClass +#if (TAPI_CURRENT_VERSION >= 0x00020000) + , + HANDLE hTargetProcess +#endif + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC4) + + lstrlen(lpszDeviceClass) + + (lpDeviceID ? lpDeviceID->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetID")); + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONEGETID, + (DWORD)hdPhone, + (DWORD)lpDeviceID, + (DWORD)lpszDeviceClass, + (DWORD)hTargetProcess + ); +#else + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETID, + (DWORD)hdPhone, + (DWORD)lpDeviceID, + (DWORD)lpszDeviceClass + ); +#endif + + + if (lpszDeviceClass) + { + WriteStruct(dwID, lstrlen(lpszDeviceClass), + (LPVOID)lpszDeviceClass); + } + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + lResult = (* GetProcAddressHashed(SP_PHONEGETID, 4))( + hdPhone, + lpDeviceID, + lpszDeviceClass, + hTargetProcess + ); +#else + lResult = (* GetProcAddressHashed(SP_PHONEGETID, 3))( + hdPhone, + lpDeviceID, + lpszDeviceClass + ); +#endif + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + if (lpDeviceID) + { + WriteStruct(dwID, lpDeviceID->dwUsedSize, + (LPVOID)lpDeviceID); + } + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetID - lResult=0x%08lx", + lResult)); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetLamp( + HDRVPHONE hdPhone, + DWORD dwButtonLampID, + LPDWORD lpdwLampMode + ) +{ + + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetLamp")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETLAMP, + (DWORD)hdPhone, + dwButtonLampID, + (DWORD)lpdwLampMode); + + lResult = (* GetProcAddressHashed(SP_PHONEGETLAMP, + 3))( + hdPhone, + dwButtonLampID, + lpdwLampMode); + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwLampMode); + } + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneGetRing( + HDRVPHONE hdPhone, + LPDWORD lpdwRingMode, + LPDWORD lpdwVolume + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetRing")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETRING, + (DWORD)hdPhone, + (DWORD)lpdwRingMode, + (DWORD)lpdwVolume); + + lResult = (* GetProcAddressHashed(SP_PHONEGETRING, + 3))( + hdPhone, + lpdwRingMode, + lpdwVolume); + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwRingMode); + + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwVolume); + } + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneGetStatus( + HDRVPHONE hdPhone, + LPPHONESTATUS lpPhoneStatus + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + + sizeof(LOGSPFUNC2) + + (lpPhoneStatus ? lpPhoneStatus->dwTotalSize : 0)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetStatus")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_PHONEGETSTATUS, + (DWORD)hdPhone, + (DWORD)lpPhoneStatus); + + lResult = (* GetProcAddressHashed(SP_PHONEGETSTATUS, 2))( + hdPhone, + lpPhoneStatus + ); + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + if (lpPhoneStatus) + { + WriteStruct(dwID, lpPhoneStatus->dwUsedSize, + (LPVOID)lpPhoneStatus); + } + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetStatus - lResult=0x%08lx", + lResult)); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneGetVolume( + HDRVPHONE hdPhone, + DWORD dwHookSwitchDev, + LPDWORD lpdwVolume + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC3) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneGetVolume")); + + WritePreHeader(dwID, SPFUNC3); + + WriteLogStruct3(dwID, SP_PHONEGETVOLUME, + (DWORD)hdPhone, + dwHookSwitchDev, + (DWORD)lpdwVolume); + + lResult = (* GetProcAddressHashed(SP_PHONEGETVOLUME, 3))( + hdPhone, + dwHookSwitchDev, + lpdwVolume + ); + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwVolume); + } + + RepeaterDebugString((2, "Leaving TSPI_phoneGetVolume - lResult=0x%08lx", + lResult)); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneNegotiateExtVersion( + DWORD dwDeviceID, + DWORD dwTSPIVersion, + DWORD dwLowVersion, + DWORD dwHighVersion, + LPDWORD lpdwExtVersion + ) +{ + LONG lResult; + DWORD dwID; + TSPAPIPROC lpfn; + + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneNegotiateExtVersion")); + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_PHONENEGOTIATEEXTVERSION, + dwDeviceID, + dwTSPIVersion, + dwLowVersion, + dwHighVersion, + (DWORD)lpdwExtVersion); + + lpfn = GetProcAddressHashed(SP_PHONENEGOTIATEEXTVERSION, + 5); + + if (lpfn) + { + lResult = (*lpfn)( + dwDeviceID, + dwTSPIVersion, + dwLowVersion, + dwHighVersion, + lpdwExtVersion); + } + else + { + lResult = PHONEERR_OPERATIONUNAVAIL; + } + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwExtVersion); + } + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneNegotiateTSPIVersion( + DWORD dwDeviceID, + DWORD dwLowVersion, + DWORD dwHighVersion, + LPDWORD lpdwTSPIVersion + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4) + sizeof(DWORD)); + + RepeaterDebugString((2, "Entering TSPI_phoneNegotiateTSPIVersion")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONENEGOTIATETSPIVERSION, + dwDeviceID, + dwLowVersion, + dwHighVersion, + (DWORD)lpdwTSPIVersion); + + lResult = (* GetProcAddressHashed(SP_PHONENEGOTIATETSPIVERSION, 4))( + dwDeviceID, + dwLowVersion, + dwHighVersion, + lpdwTSPIVersion); + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + WriteStruct(dwID, sizeof(DWORD), + (LPVOID)lpdwTSPIVersion); + } + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneOpen( + DWORD dwDeviceID, + HTAPIPHONE htPhone, + LPHDRVPHONE lphdPhone, + DWORD dwTSPIVersion, + PHONEEVENT lpfnEventProc + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + sizeof(HDRVPHONE)); + + RepeaterDebugString((2, "Entering TSPI_phoneOpen")); + + glpPhoneEventProc32 = lpfnEventProc; + + WritePreHeader(dwID, SPFUNC5); + + WriteLogStruct5(dwID, SP_PHONEOPEN, + dwDeviceID, + (DWORD)htPhone, + (DWORD)lphdPhone, + dwTSPIVersion, + (DWORD)PhoneEventProc); + lResult = + (* GetProcAddressHashed(SP_PHONEOPEN, 5))( + dwDeviceID, + htPhone, + lphdPhone, + dwTSPIVersion, + PhoneEventProc + ); + + WritePostStruct(dwID, lResult); + + if (lResult >=0) + { + WriteStruct(dwID, sizeof(HDRVPHONE), + (LPVOID)lphdPhone); + } + + RepeaterDebugString((2, "Leaving TSPI_phoneOpen - lResult=0x%08lx", lResult)); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneSelectExtVersion( + HDRVPHONE hdPhone, + DWORD dwExtVersion + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC2)); + + RepeaterDebugString((2, "Entering TSPI_phoneSelectExtVersion")); + + WritePreHeader(dwID, SPFUNC2); + + WriteLogStruct2(dwID, SP_PHONESELECTEXTVERSION, + (DWORD)hdPhone, + dwExtVersion); + + lResult = (* GetProcAddressHashed(SP_PHONESELECTEXTVERSION, + 2))( + hdPhone, + dwExtVersion); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneSetButtonInfo( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwButtonLampID, + LPPHONEBUTTONINFO const lpButtonInfo + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetButtonInfo")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETBUTTONINFO, + dwRequestID, + (DWORD)hdPhone, + dwButtonLampID, + (DWORD)lpButtonInfo); + + lResult = (* GetProcAddressHashed(SP_PHONESETBUTTONINFO, + 4))( + dwRequestID, + hdPhone, + dwButtonLampID, + lpButtonInfo); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneSetData( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwDataID, + LPVOID const lpData, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC5) + dwSize); + + WritePreHeader(dwID, SPFUNC5); + + RepeaterDebugString((2, "Entering TSPI_phoneSetData")); + + WriteLogStruct5(dwID, SP_PHONESETDATA, + dwRequestID, + (DWORD)hdPhone, + dwDataID, + (DWORD)lpData, + dwSize); + + if (lpData) + { + WriteStruct(dwID, + dwSize, + (LPVOID)lpData); + } + + lResult = (* GetProcAddressHashed(SP_PHONESETDATA, + 5))( + dwRequestID, + hdPhone, + dwDataID, + lpData, + dwSize); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneSetDisplay( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwRow, + DWORD dwColumn, + LPCWSTR lpsDisplay, + DWORD dwSize + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC6) + dwSize); + + RepeaterDebugString((2, "Entering TSPI_phoneSetDisplay")); + + WritePreHeader(dwID, SPFUNC6); + + WriteLogStruct6(dwID, SP_PHONESETDISPLAY, + dwRequestID, + (DWORD)hdPhone, + dwRow, + dwColumn, + (DWORD)lpsDisplay, + dwSize); + + if (lpsDisplay) + { + WriteStruct(dwID, + dwSize, + (LPVOID)lpsDisplay); + } + + lResult = (* GetProcAddressHashed(SP_PHONESETDISPLAY, + 6))( + dwRequestID, + hdPhone, + dwRow, + dwColumn, + lpsDisplay, + dwSize); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; + +} + + +LONG +TSPIAPI +TSPI_phoneSetGain( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwHookSwitchDev, + DWORD dwGain + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetGain")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETGAIN, + dwRequestID, + (DWORD)hdPhone, + dwHookSwitchDev, + dwGain); + + lResult = (* GetProcAddressHashed(SP_PHONESETGAIN, 4))( + dwRequestID, + hdPhone, + dwHookSwitchDev, + dwGain + ); + + RepeaterDebugString((2, "Leaving TSPI_phoneSetGain - lResult=0x%08lx", + lResult)); + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneSetHookSwitch( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwHookSwitchDevs, + DWORD dwHookSwitchMode + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetHookSwitch")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETHOOKSWITCH, + dwRequestID, + (DWORD)hdPhone, + dwHookSwitchDevs, + dwHookSwitchMode); + + lResult = (* GetProcAddressHashed(SP_PHONESETHOOKSWITCH, 4))( + dwRequestID, + hdPhone, + dwHookSwitchDevs, + dwHookSwitchMode + ); + + RepeaterDebugString((2, "Leaving TSPI_phoneSetHookSwitch - lResult=0x%08lx", + lResult)); + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneSetLamp( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwButtonLampID, + DWORD dwLampMode + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetLamp")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETLAMP, + dwRequestID, + (DWORD)hdPhone, + (DWORD)dwButtonLampID, + dwLampMode); + + lResult = (* GetProcAddressHashed(SP_PHONESETLAMP, + 4))( + dwRequestID, + hdPhone, + dwButtonLampID, + dwLampMode); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneSetRing( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwRingMode, + DWORD dwVolume + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetRing")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETRING, + dwRequestID, + (DWORD)hdPhone, + dwRingMode, + dwVolume); + + lResult = (* GetProcAddressHashed(SP_PHONESETRING, + 4))( + dwRequestID, + hdPhone, + dwRingMode, + dwVolume); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneSetStatusMessages( + HDRVPHONE hdPhone, + DWORD dwPhoneStates, + DWORD dwButtonModes, + DWORD dwButtonStates + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetStatusMessages")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETSTATUSMESSAGES, + (DWORD)hdPhone, + dwPhoneStates, + dwButtonModes, + dwButtonStates); + + lResult = (* GetProcAddressHashed(SP_PHONESETSTATUSMESSAGES, 4))( + hdPhone, + dwPhoneStates, + dwButtonModes, + dwButtonStates + ); + + RepeaterDebugString((2, "Leaving TSPI_phoneSetStatusMessages")); + + WritePostStruct(dwID, lResult); + + ReleaseID(dwID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_phoneSetVolume( + DRV_REQUESTID dwRequestID, + HDRVPHONE hdPhone, + DWORD dwHookSwitchDev, + DWORD dwVolume + ) +{ + LONG lResult; + DWORD dwID; + + GetChunkID(&dwID); + AllocChunk(dwID, NORMALCHUNK + sizeof(LOGSPFUNC4)); + + RepeaterDebugString((2, "Entering TSPI_phoneSetVolume")); + + WritePreHeader(dwID, SPFUNC4); + + WriteLogStruct4(dwID, SP_PHONESETVOLUME, + dwRequestID, + (DWORD)hdPhone, + dwHookSwitchDev, + dwVolume); + + lResult = (* GetProcAddressHashed(SP_PHONESETVOLUME, 4))( + dwRequestID, + hdPhone, + dwHookSwitchDev, + dwVolume + ); + + WritePostStruct(dwID, lResult); + + RepeaterDebugString((2, "Leaving TSPI_phoneSetVolume - lResult=0x%08lx", + lResult)); + + ReleaseID(dwID); + + return lResult; +} + + + + +// +// ----------------------- TSPIAPI TSPI_provider functions -------------------- +// + +LONG +TSPIAPI +TSPI_providerConfig( + HWND hwndOwner, + DWORD dwPermanentProviderID + ) +{ + LONG lResult; + + lResult = (* GetProcAddressHashed(SP_PROVIDERCONFIG, 2)) + (hwndOwner, + dwPermanentProviderID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_providerInit( + DWORD dwTSPIVersion, + DWORD dwPermanentProviderID, + DWORD dwLineDeviceIDBase, + DWORD dwPhoneDeviceIDBase, + DWORD dwNumLines, + DWORD dwNumPhones, + ASYNC_COMPLETION lpfnCompletionProc +#if (TAPI_CURRENT_VERSION >= 0x00020000) + , + LPDWORD lpdwTSPIOptions +#endif + ) +{ + LONG lResult; + + if (!gbStarted) + { + StartMeUp(); + } + + RepeaterDebugString((2, "Entering TSPI_providerInit")); + + glpAsyncCompletionProc32 = lpfnCompletionProc; + + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + lResult = (* GetProcAddressHashed(SP_PROVIDERINIT, 8)) + ( + dwTSPIVersion, + dwPermanentProviderID, + dwLineDeviceIDBase, + dwPhoneDeviceIDBase, + dwNumLines, + dwNumPhones, + AsyncCompletionProc, + lpdwTSPIOptions + ); +#else + lResult = (* GetProcAddressHashed( SP_PROVIDERINIT, 7)) + ( + dwTSPIVersion, + dwPermanentProvider, + dwLineDeviceIDBase, + dwPhoneDeviceIDBase, + dwNumLines, + dwNumPhones, + AsyncCompletionProc + ); +#endif + + DBGOUT((1, "leaving provider init")); + + return lResult; +} + +LONG +TSPIAPI +TSPI_providerInstall( + HWND hwndOwner, + DWORD dwPermanentProviderID + ) +{ + return 0; +} + + +LONG +TSPIAPI +TSPI_providerRemove( + HWND hwndOwner, + DWORD dwPermanentProviderID + ) +{ + return 0; +} + + +LONG +TSPIAPI +TSPI_providerShutdown( + DWORD dwTSPIVersion +#if (TAPI_CURRENT_VERSION >= 0x00020000) + , + DWORD dwPermanentProviderID +#endif + ) +{ + RepeaterDebugString((2, "Entering TSPI_providerShutdown")); + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + (* GetProcAddressHashed(SP_PROVIDERSHUTDOWN, 2))( + dwTSPIVersion, + dwPermanentProviderID + ); +#else + (* GetProcAddressHashed(SP_PROVIDERSHUTDOWN, 1))( + dwTSPIVersion + ); +#endif + +// FreeLibrary(hProvider); + +// MYFREE(lpfnProcAddress); + + return(ERR_NONE); +} + +LONG +TSPIAPI +TSPI_providerEnumDevices( + DWORD dwPermanentProviderID, + LPDWORD lpdwNumLines, + LPDWORD lpdwNumPhones, + HPROVIDER hProvider, + LINEEVENT lpfnLineCreateProc, + PHONEEVENT lpfnPhoneCreateProc + ) +{ + TSPAPIPROC lpfn; + + if (!gbStarted) + { + StartMeUp(); + } + + RepeaterDebugString((2, "Entering TSPI_providerEnumDevices")); + + + glpLineEventProc32 = lpfnLineCreateProc; + glpPhoneEventProc32 = lpfnPhoneCreateProc; + +// InitializeSPs(); + + lpfn = GetProcAddressHashed(SP_PROVIDERENUMDEVICES, 6); + + if (lpfn != (TSPAPIPROC)TSPI_LineBlank6) + { + DBGOUT((1, "calling providerenumdevices")); + + (* lpfn)( + dwPermanentProvider, + &dwNumLines, + &dwNumPhones, + hProvider, + LineEventProc, + PhoneEventProc + ); + + *lpdwNumLines = dwNumLines; + *lpdwNumPhones = dwNumPhones; + } + else + { + DBGOUT((1, "failed to get entry")); + } + + DBGOUT((2, " TSPI_providerEnumDevices: #lines= %d #phones= %d", + *lpdwNumLines, + *lpdwNumPhones)); + + return(ERR_NONE); +} + + +LONG +TSPIAPI +TSPI_providerCreateLineDevice( + DWORD dwTempID, + DWORD dwDeviceID + ) +{ + LONG lResult; + + lResult = (* GetProcAddressHashed(SP_PROVIDERCREATELINEDEVICE, 2))( + dwTempID, + dwDeviceID); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_providerCreatePhoneDevice( + DWORD dwTempID, + DWORD dwDeviceID + ) +{ + LONG lResult; + + lResult = (* GetProcAddressHashed(SP_PROVIDERCREATEPHONEDEVICE, 2))( + dwTempID, + dwDeviceID); + + return lResult; + +} + +#if (TAPI_CURRENT_VERSION >= 0x00020000) + +LONG +TSPIAPI +TSPI_providerFreeDialogInstance( + HDRVDIALOGINSTANCE hdDlgInst + ) +{ + LONG lResult; + + RepeaterDebugString((2, "Entering TSPI_providerFreeDialogInstance")); + + + lResult = (* GetProcAddressHashed(SP_PROVIDERFREEDIALOGINSTANCE,1))( + hdDlgInst); + + return lResult; +} + + + +LONG +TSPIAPI +TSPI_providerGenericDialogData( + DWORD dwObjectID, + DWORD dwObjectType, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + + RepeaterDebugString((2, "Entering TSPI_providerGenericDialogData")); + + lResult = (* GetProcAddressHashed(SP_PROVIDERGENERICDIALOGDATA, 4))( + dwObjectID, + dwObjectType, + lpParams, + dwSize); + + return lResult; +} + + +LONG +TSPIAPI +TSPI_providerUIIdentify( + LPWSTR lpszUIDLLName + ) +{ + LONG lResult; + + RepeaterDebugString((2, "Entering TSPI_providerUIIdentify")); + + lResult = (* GetProcAddressHashed(SP_PROVIDERUIIDENTIFY, 1))( + lpszUIDLLName); + + return lResult; +} + +#endif // tapi 2.0 + +#ifdef WIN32 + +BOOL WINAPI DllMain( + HANDLE hModule, + DWORD dwReason, + DWORD dwReserved + ) +{ + + DBGOUT((1, "DllEntryPoint entered reason=%lx\r\n", dwReason)); + + + if ( dwReason == 1 ) + { +// StartMeUp(); + // don't do nothin' + } + + if (dwReason == 0) + { + if (gbStarted) + { + gfTerminateNow = TRUE; + + WaitForSingleObject(ghLoggingThread, + 2000); + + CloseHandle(ghLoggingThread); + DeleteCriticalSection(&gcsLogging); + DeleteCriticalSection(&gcsID); + FreeLibrary(hProvider); + + MYFREE(lpfnProcAddress); + } + + + } + + + return(1); // success +} + +#else + +int +FAR +PASCAL +LibMain(HANDLE hInstance, + WORD wDataSegment, + WORD wHeapSize, + LPSTR lpszCmdLine) +{ + StartMeUp(); + return TRUE; +} + +#endif diff --git a/private/tapi/dev/sp/repeater/new/repeater.def b/private/tapi/dev/sp/repeater/new/repeater.def new file mode 100644 index 000000000..01ec325c7 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/repeater.def @@ -0,0 +1,122 @@ +LIBRARY repeater.tsp +PROTMODE +CODE MOVEABLE DISCARDABLE +DATA PRELOAD + +EXPORTS + TSPI_lineAccept @500 + TSPI_lineAddToConference @501 + TSPI_lineAnswer @502 + TSPI_lineBlindTransfer @503 + TSPI_lineClose @504 + TSPI_lineCloseCall @505 + TSPI_lineCompleteCall @506 + TSPI_lineCompleteTransfer @507 + TSPI_lineConditionalMediaDetection @508 +; TSPI_lineConfigDialog @509 + TSPI_lineDevSpecific @510 + TSPI_lineDevSpecificFeature @511 + TSPI_lineDial @512 + TSPI_lineDrop @513 + TSPI_lineForward @514 + TSPI_lineGatherDigits @515 + TSPI_lineGenerateDigits @516 + TSPI_lineGenerateTone @517 + TSPI_lineGetAddressCaps @518 + TSPI_lineGetAddressID @519 + TSPI_lineGetAddressStatus @520 + TSPI_lineGetCallAddressID @521 + TSPI_lineGetCallInfo @522 + TSPI_lineGetCallStatus @523 + TSPI_lineGetDevCaps @524 + TSPI_lineGetDevConfig @525 + TSPI_lineGetExtensionID @526 + TSPI_lineGetIcon @527 + TSPI_lineGetID @528 + TSPI_lineGetLineDevStatus @529 + TSPI_lineGetNumAddressIDs @530 + TSPI_lineHold @531 + TSPI_lineMakeCall @532 + TSPI_lineMonitorDigits @533 + TSPI_lineMonitorMedia @534 + TSPI_lineMonitorTones @535 + TSPI_lineNegotiateExtVersion @536 + TSPI_lineNegotiateTSPIVersion @537 + TSPI_lineOpen @538 + TSPI_linePark @539 + TSPI_linePickup @540 + TSPI_linePrepareAddToConference @541 + TSPI_lineRedirect @542 + TSPI_lineRemoveFromConference @543 + TSPI_lineSecureCall @544 + TSPI_lineSelectExtVersion @545 + TSPI_lineSendUserUserInfo @546 + TSPI_lineSetAppSpecific @547 + TSPI_lineSetCallParams @548 + TSPI_lineSetDefaultMediaDetection @549 + TSPI_lineSetDevConfig @550 + TSPI_lineSetMediaControl @551 + TSPI_lineSetMediaMode @552 + TSPI_lineSetStatusMessages @553 + TSPI_lineSetTerminal @554 + TSPI_lineSetupConference @555 + TSPI_lineSetupTransfer @556 + TSPI_lineSwapHold @557 + TSPI_lineUncompleteCall @558 + TSPI_lineUnhold @559 + TSPI_lineUnpark @560 + + TSPI_phoneClose @561 +; TSPI_phoneConfigDialog @562 + TSPI_phoneDevSpecific @563 + TSPI_phoneGetButtonInfo @564 + TSPI_phoneGetData @565 + TSPI_phoneGetDevCaps @566 + TSPI_phoneGetDisplay @567 + TSPI_phoneGetExtensionID @568 + TSPI_phoneGetGain @569 + TSPI_phoneGetHookSwitch @570 + TSPI_phoneGetIcon @571 + TSPI_phoneGetID @572 + TSPI_phoneGetLamp @573 + TSPI_phoneGetRing @574 + TSPI_phoneGetStatus @575 + TSPI_phoneGetVolume @576 + TSPI_phoneNegotiateExtVersion @577 + TSPI_phoneNegotiateTSPIVersion @578 + TSPI_phoneOpen @579 + TSPI_phoneSelectExtVersion @580 + TSPI_phoneSetButtonInfo @581 + TSPI_phoneSetData @582 + TSPI_phoneSetDisplay @583 + TSPI_phoneSetGain @584 + TSPI_phoneSetHookSwitch @585 + TSPI_phoneSetLamp @586 + TSPI_phoneSetRing @587 + TSPI_phoneSetStatusMessages @588 + TSPI_phoneSetVolume @589 + + TSPI_providerConfig @590 + TSPI_providerInit @591 + TSPI_providerInstall @592 + TSPI_providerRemove @593 + TSPI_providerShutdown @594 + + TSPI_providerEnumDevices @595 +; TSPI_lineDropOnClose @596 +; TSPI_lineDropNoOwner @597 + TSPI_providerCreateLineDevice @598 + TSPI_providerCreatePhoneDevice @599 + TSPI_lineSetCurrentLocation @600 +; TSPI_lineConfigDialogEdit @601 + TSPI_lineReleaseUserUserInfo @602 + +; TSPI_lineSetCallData @603 +; TSPI_lineSetCallQualityOfService @604 +; TSPI_lineSetCallTreatment @605 +; TSPI_lineSetLineDevStatus @606 + TSPI_providerFreeDialogInstance @607 + TSPI_providerGenericDialogData @608 + TSPI_providerUIIdentify @609 + + diff --git a/private/tapi/dev/sp/repeater/new/repeater.h b/private/tapi/dev/sp/repeater/new/repeater.h new file mode 100644 index 000000000..8157b9e2f --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/repeater.h @@ -0,0 +1,177 @@ +/* TSP3216S.H + Copyright 1995 (C) Microsoft Corporation + + 32-bit TAPI service provider to act as a cover for a system's 16-bit SPs + + 16-bit part: TSP3216S.DLL + 32-bit part: TSP3216L.DLL + + t-jereh 20-July-1995 + + TODO: + 1) allow debug levels + 2) if oom in InitializeSPs(), fail + + */ + +#define MAXBUFSIZE 256 /* maximum buffer size */ + +#define ERR_NONE 0 /* success return value */ + +#define TAPI_CUR_VER 0x00010004 + +#define TSPI_PROC_LAST 118 /* there are TSPI functions from 500 to 617 */ + + +// structs + +typedef struct tagMYLINE + { + HDRVLINE hdLine; + int iProvider; + DWORD dwDeviceID; + LINEEVENT lpfnEventProc; + HTAPILINE htLine; + } MYLINE, FAR *LPMYLINE; + + +typedef struct tagMYPHONE + { + HDRVPHONE hdPhone; + int iProvider; + DWORD dwDeviceID; + PHONEEVENT lpfnEventProc; + HTAPIPHONE htPhone; + } MYPHONE, FAR *LPMYPHONE; + +typedef struct tagMYHDRVCALL +{ + HTAPICALL htCall; + HDRVCALL hdCall; + int iProvider; + DWORD dwDeviceID; +} MYHDRVCALL, FAR *LPMYHDRVCALL; + +typedef struct tagMYTEMPID +{ + int iProvider; + DWORD dwTempID; +} MYTEMPID, FAR *LPMYTEMPID; + +#define SP_LINEACCEPT 0 +#define SP_LINEADDTOCONFERENCE 1 +#define SP_LINEAGENTSPECIFIC 2 +#define SP_LINEANSWER 3 +#define SP_LINEBLINDTRANSFER 4 +#define SP_LINECLOSE 5 +#define SP_LINECLOSECALL 6 +#define SP_LINECOMPLETECALL 7 +#define SP_LINECOMPLETETRANSFER 8 +#define SP_LINECONDITIONALMEDIADETECTION 9 +#define SP_LINEDEVSPECIFIC 10 +#define SP_LINEDEVSPECIFICFEATURE 11 +#define SP_LINEDIAL 12 +#define SP_LINEDROP 13 +#define SP_LINEFORWARD 14 +#define SP_LINEGATHERDIGITS 15 +#define SP_LINEGENERATEDIGITS 16 +#define SP_LINEGENERATETONE 17 +#define SP_LINEGETADDRESSCAPS 18 +#define SP_LINEGETADDRESSID 19 +#define SP_LINEGETADDRESSSTATUS 20 +#define SP_LINEGETAGENTACTIVITYLIST 21 +#define SP_LINEGETAGENTCAPS 22 +#define SP_LINEGETAGENTGROUPLIST 23 +#define SP_LINEGETAGENTSTATUS 24 +#define SP_LINEGETCALLADDRESSID 25 +#define SP_LINEGETCALLINFO 26 +#define SP_LINEGETCALLSTATUS 27 +#define SP_LINEGETDEVCAPS 28 +#define SP_LINEGETDEVCONFIG 29 +#define SP_LINEGETEXTENSIONID 30 +#define SP_LINEGETICON 31 +#define SP_LINEGETID 32 +#define SP_LINEGETLINEDEVSTATUS 33 +#define SP_LINEGETNUMADDRESSIDS 34 +#define SP_LINEHOLD 35 +#define SP_LINEMAKECALL 36 +#define SP_LINEMONITORDIGITS 37 +#define SP_LINEMONITORMEDIA 38 +#define SP_LINEMONITORTONES 39 +#define SP_LINENEGOTIATEEXTVERSION 40 +#define SP_LINENEGOTIATETSPIVERSION 41 +#define SP_LINEOPEN 42 +#define SP_LINEPARK 43 +#define SP_LINEPICKUP 44 +#define SP_LINEPREPAREADDTOCONFERENCE 45 +#define SP_LINEREDIRECT 46 +#define SP_LINERELEASEUSERUSERINFO 47 +#define SP_LINEREMOVEFROMCONFERENCE 48 +#define SP_LINESECURECALL 49 +#define SP_LINESELECTEXTVERSION 50 +#define SP_LINESENDUSERUSERINFO 51 +#define SP_LINESETAGENTACTIVITY 52 +#define SP_LINESETAGENTGROUP 53 +#define SP_LINESETAGENTSTATE 54 +#define SP_LINESETAPPSPECIFIC 55 +#define SP_LINESETCALLDATA 56 +#define SP_LINESETCALLPARAMS 57 +#define SP_LINESETCALLQUALITYOFSERVICE 58 +#define SP_LINESETCALLTREATMENT 59 +#define SP_LINESETCURRENTLOCATION 60 +#define SP_LINESETDEFAULTMEDIADETECTION 61 +#define SP_LINESETDEVCONFIG 62 +#define SP_LINESETLINEDEVSTATUS 63 +#define SP_LINESETMEDIACONTROL 64 +#define SP_LINESETMEDIAMODE 65 +#define SP_LINESETSTATUSMESSAGES 66 +#define SP_LINESETTERMINAL 67 +#define SP_LINESETUPCONFERENCE 68 +#define SP_LINESETUPTRANSFER 69 +#define SP_LINESWAPHOLD 70 +#define SP_LINEUNCOMPLETECALL 71 +#define SP_LINEUNHOLD 72 +#define SP_LINEUNPARK 73 +#define SP_PHONECLOSE 74 +#define SP_PHONEDEVSPECIFIC 75 +#define SP_PHONEGETBUTTONINFO 76 +#define SP_PHONEGETDATA 77 +#define SP_PHONEGETDEVCAPS 78 +#define SP_PHONEGETDISPLAY 79 +#define SP_PHONEGETEXTENSIONID 80 +#define SP_PHONEGETGAIN 81 +#define SP_PHONEGETHOOKSWITCH 82 +#define SP_PHONEGETICON 83 +#define SP_PHONEGETID 84 +#define SP_PHONEGETLAMP 85 +#define SP_PHONEGETRING 86 +#define SP_PHONEGETSTATUS 87 +#define SP_PHONEGETVOLUME 88 +#define SP_PHONENEGOTIATEEXTVERSION 89 +#define SP_PHONENEGOTIATETSPIVERSION 90 +#define SP_PHONEOPEN 91 +#define SP_PHONESELECTEXTVERSION 92 +#define SP_PHONESETBUTTONINFO 93 +#define SP_PHONESETDATA 94 +#define SP_PHONESETDISPLAY 95 +#define SP_PHONESETGAIN 96 +#define SP_PHONESETHOOKSWITCH 97 +#define SP_PHONESETLAMP 98 +#define SP_PHONESETRING 99 +#define SP_PHONESETSTATUSMESSAGES 100 +#define SP_PHONESETVOLUME 101 +#define SP_PROVIDERCREATELINEDEVICE 102 +#define SP_PROVIDERCREATEPHONEDEVICE 103 +#define SP_PROVIDERENUMDEVICES 104 +#define SP_PROVIDERFREEDIALOGINSTANCE 105 +#define SP_PROVIDERGENERICDIALOGDATA 106 +#define SP_PROVIDERINIT 107 +#define SP_PROVIDERSHUTDOWN 108 +#define SP_PROVIDERUIIDENTIFY 109 +#define SP_LINECONFIGDIALOG 110 +#define SP_LINECONFIGDIALOGEDIT 111 +#define SP_PHONECONFIGDIALOG 112 +#define SP_PROVIDERCONFIG 113 +#define SP_LINEDROPONCLOSE 114 +#define SP_LINEDROPNOOWNER 115 +#define SP_LASTPROCNUMBER (SP_LINEDROPNOOWNER + 1) diff --git a/private/tapi/dev/sp/repeater/new/repeater.rc b/private/tapi/dev/sp/repeater/new/repeater.rc new file mode 100644 index 000000000..cdd206da8 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/repeater.rc @@ -0,0 +1,19 @@ +#include "windows.h" + + +#if WINNT +#include <ntverp.h> +#else +#include <version.h> +#endif + + +#define VER_FILEDESCRIPTION_STR "Microsoft\256 Windows(TM) Telephony API Repeater Service Provider" +#define VER_INTERNALNAME_STR "REPEATER" +#define VER_ORIGINALFILENAME_STR "REPEATER.TSP" +#define VER_LEGALCOPYRIGHT_STR "Copyright \251 Microsoft Corporation 1996. All Rights Reserved." + +#define VER_FILETYPE VFT_DLL +#define VER_FILESUBTYPE VFT2_UNKNOWN + +#include <common.ver> diff --git a/private/tapi/dev/sp/repeater/new/repeater.txt b/private/tapi/dev/sp/repeater/new/repeater.txt new file mode 100644 index 000000000..bff82259a --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/repeater.txt @@ -0,0 +1,87 @@ +At install time: + +// If for record, list all providers and ask user which one to record +// (Multiple at once? *Not at first.) + +// If for playback, install as a new provider(?) + + +----------------------------------------------------------------------------- +At record time: + +// Insert between TAPI & target SP (multiple SPs at once? *Not at first.) + +// Really cool to self-modify export table so that only functions exported +// are those exported by the target SP (unlikely) + +// On startup, spin a thread that will take messages & write to a file + +// When a message comes up, all parms & timestamp will be added to a queue and the +// other thread will be signaled to put messages to the queue + +// When a function call comes down, parms will be recorded for comparison +// to parms sent down during playback (THIS DEFINITION NEEDS WORK!!) + + +// !! Events going up should get TWO timestamps!!! One since startup and +// !! one since last (non-status?) function going down. + + +// After a function call, the return stuff (retcode, async buffer if any, +// async retcode) and timestamp are recorded + + +Features for recording: + +// At set times, or before/after passing functions down to target SP +// and/or after/during messages up, call status functions on calls & lines +// so that if, during playback, status is unexpectedly asked for (because +// the ISV is trying something new) "correct" status is returned + + +----------------------------------------------------------------------------- +At playback: + +// Already installed. Separate app to kick off, log stuff, and maybe get +// some user intervention (eg: have user manually kick off each event; have +// user alter data going up/down; etc) + +// FileOpen common-dialog box to open Repeater file + +// Talk through sidedoor (NOT LINEDEVSPECIFIC - MUST NOT ALREADY init provider) +// to get filename to Repeater + +// On startup, spin a thread that will log stuff? + +// When function calls come down, check them off the list if they are expected +// If not expected, log it (maybe even log it if it was expected, LOGLEVEL) +// If not expected, THEN WHAT? If a status call, return same status if this +// call was reported previously for 2 calls then the same status that was +// returned next. IE: A developer is working to fix a bug in an event stream +// and sets a loop to check the status of a call before continuing. He should +// receive a couple of "not done yet" statuses before the "ok, it's done" +// status. + +// When completing async events, be sure to use the GOOD (current) asyncID! + +// If a function call does not happen by (SOME AMOUNT OF TIME - the next +// status up message?), then log it. + +// Pass any events up at the time delta they happened. (Delta from func down?) + +// What about UI functions? Probably just put up a MessageBox that says +// "Kilroy was here" + + +Features for playback: + +// Have playback optionally ignore function down stuff. So that a PBX maker +// can record events that are calls coming in and send that to ISVs. The +// ISV can then test their apps against incoming calls on the PBX. + +// How valuable to be able to insert into a playback stream? EG: A PBX +// stream has incoming calls, but to test IVR stuff, an ISV wants to simulate +// DTMF pressed. EG2: An ISV realizes what he did wrong and wants to run +// a simulation and so wants to change one of the status returned messages. +// - changes a disconnect to dialing, then inserts a conntected then changes +// the disconnect to happen a MINUTE later... diff --git a/private/tapi/dev/sp/repeater/new/sources b/private/tapi/dev/sp/repeater/new/sources new file mode 100644 index 000000000..52bde1c8c --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/sources @@ -0,0 +1,53 @@ +!IF 0 + +Copyright (c) 1989-1993 Microsoft Corporation + +Module Name: + + sources. + +Abstract: + + This file specifies the target component being built and the list of + sources files needed to build that component. Also specifies optional + compiler switches and libraries that are unique for the component being + built. + +Author: + + John Rogers (JohnRo) 25-Oct-1991 + +NOTE: Commented description of this file is in \nt\public\oak\bin\sources.tpl + +Revision History: + +!ENDIF + +MAJORCOMP=net +MINORCOMP=tapi + +TARGETNAME=repeater +TARGETPATH=$(BASEDIR)\public\sdk\lib +TARGETTYPE=DYNLINK +TARGETEXT=TSP + +TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \ + $(BASEDIR)\public\sdk\lib\*\advapi32.lib \ + $(BASEDIR)\public\sdk\lib\*\user32.lib + +DLLBASE=0x60000000 + +INCLUDES=.;$(BASEDIR)\public\sdk\inc + +SOURCES=repeater.c \ + logger.c \ + debug.c \ + repeater.rc + +UMTYPE=windows + +DLLENTRY=DllMain + +!IFNDEF 386_WARNING_LEVEL +386_WARNING_LEVEL=/W3 +!ENDIF diff --git a/private/tapi/dev/sp/repeater/new/tsp3216.h b/private/tapi/dev/sp/repeater/new/tsp3216.h new file mode 100644 index 000000000..4b4959868 --- /dev/null +++ b/private/tapi/dev/sp/repeater/new/tsp3216.h @@ -0,0 +1,10 @@ +#define TSP3216L_MESSAGE (WM_USER+10) + +enum {CALLBACK_ASYNCCOMPLETION, + CALLBACK_LINEEVENT, + CALLBACK_PHONEEVENT, + CALLBACK_LINECREATE, + CALLBACK_PHONECREATE + } CALLBACK_TYPES; + + diff --git a/private/tapi/dev/sp/repeater/setup/makefile b/private/tapi/dev/sp/repeater/setup/makefile new file mode 100644 index 000000000..f1084966b --- /dev/null +++ b/private/tapi/dev/sp/repeater/setup/makefile @@ -0,0 +1,29 @@ +!if "$(OS)" == "Windows_NT" + +!INCLUDE $(NTMAKEENV)\makefile.def + +!else + +############################################################################## +# +# Dialer.exe Make file +# +############################################################################## + +#Ok, we're doing a Win9x build. + +ROOT=..\..\..\..\.. + +VERSIONLIST=debug retail + +DEPENDNAME=depend.mk + +COMMONMKFILE=makefile.def + +IS_OEM=TRUE +IS_32 = TRUE + +!include $(ROOT)\dev\master.mk + +!endif + diff --git a/private/tapi/dev/sp/repeater/setup/resource.h b/private/tapi/dev/sp/repeater/setup/resource.h new file mode 100644 index 000000000..c20e295b0 --- /dev/null +++ b/private/tapi/dev/sp/repeater/setup/resource.h @@ -0,0 +1,22 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Developer Studio generated include file. +// Used by Setup.rc +// +#define IDD_REPEATER 101 +#define IDC_FILEDIRECTORY 1000 +#define IDC_SPNAME 1001 +#define ID_UNINSTALL 1002 +#define ID_INSTALL 1003 +#define ID_MOREINFO 1004 +#define IDC_STATIC -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1005 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/private/tapi/dev/sp/repeater/setup/setup.cpp b/private/tapi/dev/sp/repeater/setup/setup.cpp new file mode 100644 index 000000000..79169a1a1 --- /dev/null +++ b/private/tapi/dev/sp/repeater/setup/setup.cpp @@ -0,0 +1,779 @@ +////////////////////////////////////////////////////////////////////////////// +// +// +// +////////////////////////////////////////////////////////////////////////////// +#include <windows.h> +#include <commdlg.h> +#include "resource.h" + +////////////////////////////////////////////////////////////////////////////// +// PROTOTYPES +////////////////////////////////////////////////////////////////////////////// +static BOOL CreateMainWindow (int nCmdShow); + +BOOL CALLBACK RepeaterDlgProc (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam); +BOOL DoInstall(HWND); +BOOL DoUninstall(HWND); +BOOL DoMoreInfo(); + +////////////////////////////////////////////////////////////////////////////// +// GLOBALS +////////////////////////////////////////////////////////////////////////////// +HINSTANCE ghInstance; +BOOL gbIsNT = FALSE; + +////////////////////////////////////////////////////////////////////////////// +// +// WinMain() +// +////////////////////////////////////////////////////////////////////////////// + +int WINAPI WinMain (HINSTANCE hInstance, + HINSTANCE hPrevInstance, + LPSTR lpszCmdLine, + int nCmdShow) +{ + ghInstance = GetModuleHandle(NULL); + + if (GetVersion() < 0x80000000) + { + gbIsNT = TRUE; + } + + DialogBox(ghInstance, + MAKEINTRESOURCE(IDD_REPEATER), + GetDesktopWindow(), + (DLGPROC)RepeaterDlgProc); + return 1; +} + + +//***************************************************************************** +// MainWndProc() +//***************************************************************************** + +BOOL CALLBACK RepeaterDlgProc (HWND hwnd, + UINT uMsg, + WPARAM wParam, + LPARAM lParam) +{ + switch (uMsg) + { + case WM_INITDIALOG: + + SetWindowPos(hwnd, + HWND_TOP, + GetSystemMetrics(SM_CXSCREEN)/4, + GetSystemMetrics(SM_CYSCREEN)/4, + 0, + 0, + SWP_NOSIZE); + + + SetFocus(GetDlgItem(hwnd, + IDC_SPNAME)); + + return 0; + + case WM_COMMAND: + + switch (LOWORD(wParam)) + { + case ID_UNINSTALL: + if (DoUninstall(hwnd)) + { + MessageBox(hwnd, + "Repeater successfully uninstalled.", + "Repeater Setup", + NULL); + EndDialog(hwnd, 1); + } + break; + + case ID_INSTALL: + if (DoInstall(hwnd)) + { + MessageBox(hwnd, + "Repeater successfully installed.", + "Repeater Setup", + NULL); + EndDialog(hwnd, 1); + } + break; + + case ID_MOREINFO: + if (DoMoreInfo()) + { + EndDialog(hwnd, 1); + } + break; + + case IDCANCEL: + EndDialog(hwnd, 0); + break; + default: + return FALSE; + } + + default: + return FALSE; + } + + return TRUE; +} + +#define SZTAPIKEY "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Telephony" +#define SZREPEATERSETUP "Repeater Setup" +#define SZPROVIDERS "Providers" +#define SZREPEATER "Repeater" +#define SZNUMPROVIDERS "NumProviders" +#define SZREPEATERFILENAME "Repeater.TSP" +#define SZLOGDIR "LogFileDirectory" +#define SZPROVIDERFILENAME "ProviderFilename" +#define SZPROVIDER "Provider" +#define SZPROVIDERID "ProviderID" +#define SZTELEPHONINI "TELEPHON.INI" + + +BOOL DoInstall(HWND hWnd) +{ + char szSPName[256]; + char szLogFilePath[256]; + char szTestName[256]; + int i; + HANDLE hFileHandle; + DWORD dwSize; + DWORD dwHold, dwNumProviders; + HKEY hTapiKey, hProvidersKey, hRepeaterKey; + char szbuf[64], szfilebuf[256]; + char sznum[16]; + + + + GetDlgItemText(hWnd, + IDC_SPNAME, + szSPName, + 256); + + GetDlgItemText(hWnd, + IDC_FILEDIRECTORY, + szLogFilePath, + 256); + + i = lstrlen(szLogFilePath); + if (szLogFilePath[i-1] != '\\') + { + szLogFilePath[i+1]=0; + szLogFilePath[i]='\\'; + } + + wsprintf(szTestName, "%s%s", szLogFilePath, "testme"); + if ((hFileHandle = CreateFile(szTestName, + GENERIC_READ, + FILE_SHARE_READ, + NULL, + OPEN_ALWAYS, + FILE_ATTRIBUTE_NORMAL, + NULL)) == INVALID_HANDLE_VALUE) + { + MessageBox(NULL, "Directory does not exist", NULL, MB_OK); + return FALSE; + } + else + { + CloseHandle(hFileHandle); + DeleteFile(szTestName); + } + + if (gbIsNT) + { + // get tapi key + RegOpenKeyEx(HKEY_LOCAL_MACHINE, + SZTAPIKEY, + 0, + KEY_ALL_ACCESS, + &hTapiKey); + + // get providers key + RegOpenKeyEx(hTapiKey, + SZPROVIDERS, + 0, + KEY_ALL_ACCESS, + &hProvidersKey); + + // create repeater key + RegCreateKeyEx(hTapiKey, + SZREPEATER, + 0, + "Repeater Type", + REG_OPTION_VOLATILE, + KEY_ALL_ACCESS, + NULL, + &hRepeaterKey, + &dwHold); + + // get number of providers + dwSize = sizeof(DWORD); + RegQueryValueEx(hProvidersKey, + SZNUMPROVIDERS, + NULL, + NULL, + (LPBYTE)&dwNumProviders, + &dwSize); + + // find the provider + for (i = 0; i < (int)dwNumProviders; i++) + { + wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i); + + dwSize = 256; + RegQueryValueEx(hProvidersKey, + szbuf, + NULL, + NULL, + (LPBYTE)szfilebuf, + &dwSize); + + // if it's the same break + if (!lstrcmpi(szfilebuf, szSPName)) + { + break; + } + + } + + // didn't find the provider + if (i == (int)dwNumProviders) + { + char szmessage[256]; + + wsprintf(szmessage, + "Provider %s is not installed\n", + szSPName); + + MessageBox(hWnd, + szmessage, + SZREPEATERSETUP, + MB_OK); + + // return false so they can reenter the name correctly + return FALSE; + } + + + } + + else // win95 + { + // get number of providers + dwNumProviders = GetPrivateProfileInt(SZPROVIDERS, + SZNUMPROVIDERS, + 0, + SZTELEPHONINI); + + // find the provider + for (i = 0; i < (int)dwNumProviders; i++) + { + wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i); + + GetPrivateProfileString(SZPROVIDERS, + szbuf, + "", + szfilebuf, + 256, + SZTELEPHONINI); + + // if it's the same break + if (!lstrcmpi(szfilebuf, szSPName)) + { + break; + } + + } + + // didn't find the provider + if (i == (int)dwNumProviders) + { + char szmessage[256]; + + wsprintf(szmessage, + "Provider %s is not installed\n", + szSPName); + + MessageBox(hWnd, + szmessage, + SZREPEATERSETUP, + MB_OK); + + // return false so they can reenter the name correctly + return FALSE; + } + + } + + // ok now copy repeater + + { + char szfile[MAX_PATH]; + char sztarget[MAX_PATH]; + char szdir[MAX_PATH]; + int j; + + GetModuleFileName(NULL, + szdir, + MAX_PATH); + + j = lstrlen(szdir); + while (szdir[j] != '\\') + { + szdir[j] = 0; + j--; + } + + // get rid of \ too + szdir[j] = 0; + + wsprintf(szfile, "%s\\%s", szdir, SZREPEATERFILENAME); + + GetSystemDirectory(szdir, MAX_PATH); + + wsprintf(sztarget, "%s\\%s", szdir, SZREPEATERFILENAME); + + if (!CopyFile(szfile, + sztarget, + FALSE)) + { + if (GetLastError() == ERROR_FILE_NOT_FOUND) + { + // ask them where the file is + OPENFILENAME ofn; + BOOL bReturn; + + szfile[0] = '\0'; + + ofn.lStructSize = sizeof(ofn); + ofn.hwndOwner = hWnd; + ofn.hInstance = ghInstance; + ofn.lpstrFilter = "TSP Files\0*.tsp\0\0"; + ofn.lpstrCustomFilter = NULL; + ofn.nMaxCustFilter = 0; + ofn.nFilterIndex = 0; + ofn.lpstrFile = szfile; + ofn.nMaxFile = MAX_PATH; + ofn.lpstrFileTitle = NULL; + ofn.nMaxFileTitle = 0; + ofn.lpstrInitialDir = NULL; + ofn.lpstrTitle ="Location of REPEATER.TSP"; + ofn.Flags = OFN_FILEMUSTEXIST | OFN_EXPLORER; + ofn.nFileOffset = 0; + ofn.nFileExtension = 0; + ofn.lpstrDefExt = "TSP"; + ofn.lCustData = 0; + ofn.lpfnHook = NULL; + ofn.lpTemplateName = NULL; + + bReturn = GetOpenFileName(&ofn); + + if (!bReturn) + { + return FALSE; + } + + if (!CopyFile(szfile, + sztarget, + FALSE)) + { + MessageBox(NULL, "Copy file failed", NULL, MB_OK); + return FALSE; + } + + } + else + { + MessageBox(NULL, "CopyFile failed", NULL, MB_OK); + return FALSE; + } + + } + } + + + + if (gbIsNT) + { + // now i is the provider number, so put repeater there + // and move provider's info to repeater key + + // set ProviderFilenameX=repeater.tsp + dwSize = lstrlen(SZREPEATERFILENAME) + 1; + RegSetValueEx(hProvidersKey, + szbuf, + 0, + REG_SZ, + (LPBYTE)SZREPEATERFILENAME, + dwSize); + + // set providerfilename0 = szProviderName + dwSize = lstrlen(szSPName) + 1; + wsprintf(szfilebuf, "%s%d", SZPROVIDERFILENAME, 0); + RegSetValueEx(hRepeaterKey, + szfilebuf, + 0, + REG_SZ, + (LPBYTE)szSPName, + dwSize); + + // get provider id + + wsprintf(szbuf, "%s%d", SZPROVIDERID, i); + dwSize = sizeof(DWORD); + RegQueryValueEx(hProvidersKey, + szbuf, + NULL, + NULL, + (LPBYTE)&dwHold, + &dwSize); + + // write in as provider ID 0 + wsprintf(szbuf, "%s%d", SZPROVIDERID, 0); + dwSize = sizeof(DWORD); + RegSetValueEx(hRepeaterKey, + szbuf, + 0, + REG_DWORD, + (LPBYTE)&dwHold, + dwSize); + + // write num providers in repeater key (always 1) + dwHold = 1; + dwSize = sizeof(DWORD); + RegSetValueEx(hRepeaterKey, + SZNUMPROVIDERS, + 0, + REG_DWORD, + (LPBYTE)&dwHold, + dwSize); + + dwSize = lstrlen(szLogFilePath) + 1; + RegSetValueEx(hRepeaterKey, + SZLOGDIR, + 0, + REG_SZ, + (LPBYTE)szLogFilePath, + dwSize); + + RegCloseKey(hRepeaterKey); + RegCloseKey(hProvidersKey); + RegCloseKey(hTapiKey); + } + else + { + // now i is the provider number, so put repeater there + // and move provider's info to repeater key + + // set ProviderFilenameX=repeater.tsp + WritePrivateProfileString(SZPROVIDERS, + szbuf, + SZREPEATERFILENAME, + SZTELEPHONINI); + // set providerfilename0 = szProviderName + wsprintf(szfilebuf, "%s%d", SZPROVIDERFILENAME, 0); + WritePrivateProfileString(SZREPEATER, + szfilebuf, + szSPName, + SZTELEPHONINI); + + // get provider id + wsprintf(szbuf, "%s%d", SZPROVIDERID, i); + dwHold = GetPrivateProfileInt(SZPROVIDERS, + szbuf, + 0, + SZTELEPHONINI); + + // write in as provider ID 0 + wsprintf(szbuf, "%s%d", SZPROVIDERID, 0); + wsprintf(sznum, "%d", dwHold); + WritePrivateProfileString(SZREPEATER, + szbuf, + sznum, + SZTELEPHONINI); + + // write num providers in repeater key (always 1) + WritePrivateProfileString(SZREPEATER, + SZNUMPROVIDERS, + "1", + SZTELEPHONINI); + + WritePrivateProfileString(SZREPEATER, + SZLOGDIR, + szLogFilePath, + SZTELEPHONINI); + + + } + return TRUE; +} + +BOOL DoUninstall(HWND hWnd) +{ + if (gbIsNT) + { + DWORD dwSize, dwHold, dwNumProviders; + HKEY hTapiKey, hProvidersKey, hRepeaterKey; + char szbuf[64], szfilebuf[256]; + int i; + + // get tapi key + RegOpenKeyEx(HKEY_LOCAL_MACHINE, + SZTAPIKEY, + 0, + KEY_ALL_ACCESS, + &hTapiKey); + + // get providers key + RegOpenKeyEx(hTapiKey, + SZPROVIDERS, + 0, + KEY_ALL_ACCESS, + &hProvidersKey); + + RegOpenKeyEx(hTapiKey, + SZREPEATER, + 0, + KEY_ALL_ACCESS, + &hRepeaterKey); + + // get number of providers + dwSize = sizeof(DWORD); + RegQueryValueEx(hProvidersKey, + SZNUMPROVIDERS, + NULL, + NULL, + (LPBYTE)&dwNumProviders, + &dwSize); + + // find the provider + for (i = 0; i < (int)dwNumProviders; i++) + { + wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i); + + dwSize = 256; + RegQueryValueEx(hProvidersKey, + szbuf, + NULL, + NULL, + (LPBYTE)szfilebuf, + &dwSize); + + // if it's the same break + if (!lstrcmpi(szfilebuf, SZREPEATERFILENAME)) + { + break; + } + + } + + // didn't find the repeater provider + if (i == (int)dwNumProviders) + { + MessageBox(hWnd, + "Repeater is not installed", + SZREPEATERSETUP, + MB_OK); + + return TRUE; + } + + // now i is the provider number, so put repeater there + // and move provider's info to repeater key + + // get original sp's name + wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, 0); + dwSize = 256; + RegQueryValueEx(hRepeaterKey, + szbuf, + NULL, + NULL, + (LPBYTE)szfilebuf, + &dwSize); + + // write name back into provider's key + wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, i); + dwSize = lstrlen(szfilebuf) + 1; + RegSetValueEx(hProvidersKey, + szbuf, + 0, + REG_SZ, + (LPBYTE)szfilebuf, + dwSize); + + // get provider id + wsprintf(szbuf, "%s%d", SZPROVIDERID, 0); + dwSize = sizeof(DWORD); + RegQueryValueEx(hRepeaterKey, + szbuf, + NULL, + NULL, + (LPBYTE)&dwHold, + &dwSize); + + // write in as provider ID + wsprintf(szbuf, "%s%d", SZPROVIDERID, i); + dwSize = sizeof(DWORD); + RegSetValueEx(hProvidersKey, + szbuf, + 0, + REG_DWORD, + (LPBYTE)&dwHold, + dwSize); + + RegCloseKey(hRepeaterKey); + RegCloseKey(hProvidersKey); + RegDeleteKey(hTapiKey, + SZREPEATER); + RegCloseKey(hTapiKey); + + } + + else // win95 + { + DWORD dwHold, dwNumProviders; + char szbuf[64], szfilebuf[256]; + int i; + + // get number of providers + dwNumProviders = GetPrivateProfileInt(SZPROVIDERS, + SZNUMPROVIDERS, + 0, + SZTELEPHONINI); + + // find the provider + for (i = 0; i < (int)dwNumProviders; i++) + { + wsprintf(szbuf, "%s%d",SZPROVIDERFILENAME, i); + + GetPrivateProfileString(SZPROVIDERS, + szbuf, + "", + szfilebuf, + 256, + SZTELEPHONINI); + // if it's the same break + if (!lstrcmpi(szfilebuf, SZREPEATERFILENAME)) + { + break; + } + + } + + // didn't find the repeater provider + if (i == (int)dwNumProviders) + { + MessageBox(hWnd, + "Repeater is not installed", + SZREPEATERSETUP, + MB_OK); + + return TRUE; + } + + // now i is the provider number, so put repeater there + // and move provider's info to repeater key + + // get original sp's name + wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, 0); + GetPrivateProfileString(SZREPEATER, + szbuf, + "", + szfilebuf, + 256, + SZTELEPHONINI); + + // write name back into provider's key + wsprintf(szbuf, "%s%d", SZPROVIDERFILENAME, i); + WritePrivateProfileString(SZPROVIDERS, + szbuf, + szfilebuf, + SZTELEPHONINI); + + // get provider id + wsprintf(szbuf, "%s%d", SZPROVIDERID, 0); + dwHold = GetPrivateProfileInt(SZREPEATER, + szbuf, + 0, + SZTELEPHONINI); + + // write in as provider ID + wsprintf(szbuf, "%s%d", SZPROVIDERID, i); + wsprintf(szfilebuf, "%d", dwHold); + WritePrivateProfileString(SZPROVIDERS, + szbuf, + szfilebuf, + SZTELEPHONINI); + + } + + // ok now copy repeater + + { + char szfile[MAX_PATH]; + char szdir[MAX_PATH]; + + GetSystemDirectory(szdir, MAX_PATH); + + wsprintf(szfile, "%s\\%s", szdir, SZREPEATERFILENAME); + + if (!DeleteFile(szfile)) + { + MessageBox(NULL, "DeleteFile failed", NULL, MB_OK); + return FALSE; + } + } + + + return TRUE; +} + + +BOOL DoMoreInfo() +{ + char szname[MAX_PATH], szbuf[MAX_PATH]; + int i; + PROCESS_INFORMATION pi; + STARTUPINFO si; + + FillMemory(&si, + sizeof(si), + 0); + + si.cb = sizeof(si); + + GetModuleFileName(NULL, + szname, + MAX_PATH); + + i = lstrlen(szname); + + while (szname[i] != '\\') + { + szname[i] = 0; + i--; + } + + wsprintf(szbuf, "notepad.exe %srepeater.txt", szname); + CreateProcess(NULL, + szbuf, + NULL, + NULL, + FALSE, + NORMAL_PRIORITY_CLASS, + NULL, + NULL, + &si, + &pi); + return FALSE; +} diff --git a/private/tapi/dev/sp/repeater/setup/setup.rc b/private/tapi/dev/sp/repeater/setup/setup.rc new file mode 100644 index 000000000..63272a2af --- /dev/null +++ b/private/tapi/dev/sp/repeater/setup/setup.rc @@ -0,0 +1,46 @@ +//Microsoft Developer Studio generated resource script. +// +#include <windows.h> +#include "resource.h" + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_REPEATER DIALOG DISCARDABLE 0, 0, 268, 159 +STYLE DS_MODALFRAME | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Repeater Setup" +FONT 8, "MS Sans Serif" +BEGIN + DEFPUSHBUTTON "&Install",ID_INSTALL,211,7,50,14 + PUSHBUTTON "&Uninstall",ID_UNINSTALL,211,24,50,14 + PUSHBUTTON "&More Info",ID_MOREINFO,211,42,50,14 + PUSHBUTTON "Cancel",IDCANCEL,211,59,50,14 + EDITTEXT IDC_SPNAME,7,98,229,14,ES_AUTOHSCROLL + EDITTEXT IDC_FILEDIRECTORY,7,132,229,14,ES_AUTOHSCROLL + LTEXT "Full path to directory to hold log files:",IDC_STATIC,7, + 121,228,8 + LTEXT "Name of service provider (the .TSP file) EX: repeater.tsp", + IDC_STATIC,7,86,226,8 + LTEXT "This program will install or uninstall the Repeater service provider. The TAPI service provider that Repeater is collecting information about MUST be installed before this program can be run. ", + IDC_STATIC,11,11,186,35 +END + + +#if WINNT +#include <ntverp.h> +#else +#include <version.h> +#endif + + +#define VER_FILEDESCRIPTION_STR "Microsoft\256 Windows(TM) Telephony API Repeater Setup" +#define VER_INTERNALNAME_STR "SETUP" +#define VER_ORIGINALFILENAME_STR "SETUP.EXE" +#define VER_LEGALCOPYRIGHT_STR "Copyright \251 Microsoft Corporation 1996. All Rights Reserved." + +#define VER_FILETYPE VFT_APP +#define VER_FILESUBTYPE VFT2_UNKNOWN + +#include <common.ver> diff --git a/private/tapi/dev/sp/repeater/setup/sources b/private/tapi/dev/sp/repeater/setup/sources new file mode 100644 index 000000000..f1ddd48a6 --- /dev/null +++ b/private/tapi/dev/sp/repeater/setup/sources @@ -0,0 +1,55 @@ +!IF 0 + +Copyright (c) 1989-1993 Microsoft Corporation + +Module Name: + + sources. + +Abstract: + + This file specifies the target component being built and the list of + sources files needed to build that component. Also specifies optional + compiler switches and libraries that are unique for the component being + built. + +Author: + + John Rogers (JohnRo) 25-Oct-1991 + +Notes: + + Commented description of this file is in \nt\public\oak\bin\sources.tpl + +Revision History: + +!ENDIF + + +MAJORCOMP=net +MINORCOMP=tapi + +TARGETNAME=setup +TARGETPATH=$(BASEDIR)\public\sdk\lib +TARGETTYPE=PROGRAM + +TARGETLIBS=$(BASEDIR)\public\sdk\lib\*\kernel32.lib \ + $(BASEDIR)\public\sdk\lib\*\shell32.lib \ + $(BASEDIR)\public\sdk\lib\*\comdlg32.lib + +INCLUDES=.;$(BASEDIR)\public\sdk\inc + +USE_CRTDLL=1 + +SOURCES=setup.rc \ + setup.cpp + +C_DEFINES=-DWINVER=0x0400 + +UMTYPE=windows + +UMENTRY=winmain + +!IFNDEF 386_WARNING_LEVEL +386_WARNING_LEVEL=/W3 +!ENDIF |