diff options
Diffstat (limited to '')
| -rw-r--r-- | private/tapi/dev/thunk/depend.mk | 3 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/dirs | 2 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/makefil0 | 126 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/makefile | 30 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/makefile.def | 68 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/tapi.def | 140 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/tapi.rc | 25 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/thunk.c | 3771 | ||||
| -rw-r--r-- | private/tapi/dev/thunk/thunk.h | 369 |
9 files changed, 4534 insertions, 0 deletions
diff --git a/private/tapi/dev/thunk/depend.mk b/private/tapi/dev/thunk/depend.mk new file mode 100644 index 000000000..74a0d8f95 --- /dev/null +++ b/private/tapi/dev/thunk/depend.mk @@ -0,0 +1,3 @@ +.\thunk.obj: ..\thunk.c ..\thunk.h ..\..\inc\tapi.x + +.\tapi.res: ..\tapi.rc diff --git a/private/tapi/dev/thunk/dirs b/private/tapi/dev/thunk/dirs new file mode 100644 index 000000000..139597f9c --- /dev/null +++ b/private/tapi/dev/thunk/dirs @@ -0,0 +1,2 @@ + + diff --git a/private/tapi/dev/thunk/makefil0 b/private/tapi/dev/thunk/makefil0 new file mode 100644 index 000000000..808bfc0fb --- /dev/null +++ b/private/tapi/dev/thunk/makefil0 @@ -0,0 +1,126 @@ + +# TAPI.DLL thunk makefile +# +# Copyright (c) 1995, Microsoft Corporation +# +# History: +# Created. +# + + +!INCLUDE $(NTMAKEENV)\makefile.plt + + +!IFDEF USEBUILD + +# If using BUILD.EXE, edit .\sources. if you want to add a new source +# file to this component. This file merely indirects to the real make file +# that is shared by all the components of NT + +!INCLUDE $(NTMAKEENV)\makefile.def + +!ELSE + +.SUFFIXES: +.SUFFIXES: .c .asm .h .inc .obj .lst .sys .exe .com .map .sym .def .lib .rc .res + + +#!ifdef INCLUDE +#INCS = +#!else +INCS = -I..\inc -I$(_NTDRIVE)$(_NTROOT)\private\mvdm\wow16\inc -I$(BASEDIR)\public\sdk\inc +#!endif + +########## Path definition so we find 16 bit tools ########## +# Also works around stupid bug in RC 3.1 that doesn't allow rcpp.err to be +# in a directory that is greater than 128 chars down the path, even if +# rc 3.1 is running as an OS/2 app. + +#PATH = $(BASEDIR)\private\mvdm\tools16;$(PATH) +PATH=..\tools16;$(PATH) + +# DEFINES = -DWOW -DDEBUG $(MVDMFLAGS) +# DEFINES = -DWOW $(MVDMFLAGS) + +AOBJ = -t $(DEFINES) $(INCS) + +CW16 = -ALw -G2sw -Os -W3 -Zd -Zp $(DEFINES) $(INCS) +CW16B = $(CW16) -B1 c1l.exe -B2 c2l.exe -B3 c3l.exe + +LINK = /map /align:16 + +!if "$(NTDEBUG)"!="" && "$(NTDEBUG)"!="retail" && "$(NTDEBUG)" != "ntsdnodbg" +AOBJ = $(AOBJ) -Zd +CW16 = $(CW16) /Od /Oi +LINK = $(LINK) /LI +!endif + +#!ifdef LIB +#W16LIBS = snocrtd +#!else +#W16LIBS = ..\..\lib\snocrtd.lib +#!endif + + +.asm.obj: + masm $(AOBJ) $*; + +.asm.lst: + masm $(AOBJ) -l $*,nul,$*.lst; + + +.c.obj: + ..\tools16\cl16 -c $(CW16) $*.c + +.c.lst: + ..\tools16\cl16 -c $(CW16) -Fonul -Fc$*.lst $*.c + + +.def.lib: + implib $*.lib $*.def + +.map.sym: + mapsym $* + +.rc.res: + rc16 -r $(INCS) -fo $@ $*.rc + + +all: tapi.dll tapi.sym + binplace tapi.dll tapi.sym + +clean: cleanup all + +cleanup: + if exist *.lrf del *.lrf + if exist *.obj del *.obj + if exist *.exe del *.exe + if exist *.map del *.map + if exist *.sym del *.sym + if exist *.drv del *.drv + if exist *.res del *.res + + +thunk.obj thunk.lst: thunk.c thunk.h + +tapi.res: $*.rc + +tapi.lrf: makefil0 + echo $(BASEDIR)\private\mvdm\wow16\lib\libentry.obj thunk >$@ + echo $*.dll/align:16>>$@ + echo $* $(LINK)>>$@ +# echo $(BASEDIR)\private\mvdm\wow16\lib\libw.lib ..\..\lib\snocrtd.lib /map /nod>>$@ +# echo $(BASEDIR)\private\mvdm\wow16\lib\ldllcew.lib + echo $(BASEDIR)\private\mvdm\wow16\lib\ldllcew.lib libw.lib /map /nod>>$@ + echo $*;>>$@ + +tapi.dll tapi.map: thunk.obj \ + $*.def $*.res $*.lrf + link16 @$*.lrf; + rc16 -t $*.res $*.dll +# if exist *.drv del *.drv +# ren $*.dll $@ + +tapi.sym: $*.map + mapsym $* +!ENDIF diff --git a/private/tapi/dev/thunk/makefile b/private/tapi/dev/thunk/makefile new file mode 100644 index 000000000..eb7bad4a7 --- /dev/null +++ b/private/tapi/dev/thunk/makefile @@ -0,0 +1,30 @@ +!if "$(OS)" == "Windows_NT" + +clean: + echo "Clean target null in this directory" + +!else + +############################################################################## +# +# TAPI THUNK 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/thunk/makefile.def b/private/tapi/dev/thunk/makefile.def new file mode 100644 index 000000000..ceabc7744 --- /dev/null +++ b/private/tapi/dev/thunk/makefile.def @@ -0,0 +1,68 @@ +############################################################################## +# +# tapi.dll Make file +# +############################################################################## + +#Ok, we're doing a Win9x build. + +ROOT=..\..\..\..\.. + +PATH=..\tools16;$(PATH) + +IS_OEM=TRUE +MASM6=1 +IS_16 = TRUE +C16ONLY=1 + +BUILDDLL=1 + +DEPENDNAME=..\depend.mk + +TARGETS=tapi.dll tapi.sym + +SRCDIR=.. + +CLEANLIST=*.dll *.pdb + +#BUILD_COFF=1 + + +L16EXE=tapi.dll # Name of exe. +L16DEF=..\tapi.def # Our def file. +L16MAP=tapi.map # Our map file. +L16SYM=tapi.sym # Our sym file. +L16LIBSNODEP= \ + ldllcew.lib \ + libw.lib \ + ..\w32sut16.lib + +L16RES=tapi.res # Resource file. + + +#C16SRCS=..\thunk.c +#RCSRCS=..\tapi.rc + +#----------------------------------------------------------------------- +# Object files +#----------------------------------------------------------------------- +L16OBJS=thunk.obj + + + +!include $(ROOT)\dev\master.mk + + +CFLAGS=$(CFLAGS) -DCHICOBUILD=1 -Og -ALw /G3sw /Ow /W3 /Zi -DTAPI_CURRENT_VERSION=0x00010004 +#CFLAGS=$(CFLAGS) -ALw /G3sw /Ow /W3 /Zi -DCHICOBUILD=1 +# cl /c /ALw /G2sw -Ow -W3 -Zp /Od /Oi /Zi thunk.c + + +!IF "$(VERDIR)" == "debug" +CFLAGS = $(CFLAGS) -DDBG=1 +!endif + + +# link thunk,$(TARGET).dll,nul,/NOE /COD /NOD:llibce ldllcew libw.lib w32sut16.lib,tapi.def +#LFLAGS= /NOD /NOE /ALIGN:8 /NONULLS /PACKD /PACKF @tapi.crf + diff --git a/private/tapi/dev/thunk/tapi.def b/private/tapi/dev/thunk/tapi.def new file mode 100644 index 000000000..2a13fefd9 --- /dev/null +++ b/private/tapi/dev/thunk/tapi.def @@ -0,0 +1,140 @@ +LIBRARY tapi + +EXETYPE WINDOWS + +CODE PRELOAD MOVEABLE DISCARDABLE +DATA PRELOAD MOVEABLE + +HEAPSIZE 2048 + +IMPORTS + kernel.LoadLibraryEx32W + kernel.FreeLibrary32W + kernel.GetProcAddress32W + kernel.CallProc32W + +EXPORTS + WEP @1 RESIDENTNAME + LibMain + Tapi16HiddenWndProc + + lineAccept @82 + lineAddToConference @47 + lineAnswer @103 + lineBlindTransfer @25 + lineClose @78 + lineCompleteCall @76 + lineCompleteTransfer @73 + lineConfigDialog @12 + lineDeallocateCall @111 + lineDevSpecific @21 + lineDevSpecificFeature @22 + lineDial @29 + lineDrop @23 + lineForward @87 + lineGatherDigits @52 + lineGenerateDigits @105 + lineGenerateTone @80 + lineGetAddressCaps @71 + lineGetAddressID @104 + lineGetAddressStatus @60 + lineGetCallInfo @97 + lineGetCallStatus @94 + lineGetConfRelatedCalls @72 + lineGetDevCaps @116 + lineGetDevConfig @79 + lineGetIcon @53 + lineGetID @40 + lineGetLineDevStatus @49 + lineGetNewCalls @34 + lineGetNumRings @62 + lineGetStatusMessages @45 + lineHandoff @11 + lineHold @6 + lineInitialize @33 + lineMakeCall @32 + lineMonitorDigits @24 + lineMonitorMedia @15 + lineMonitorTones @31 + lineNegotiateAPIVersion @64 + lineNegotiateExtVersion @17 + lineOpen @46 + linePark @5 + linePickup @102 + linePrepareAddToConference @50 + lineRedirect @38 + lineRemoveFromConference @43 + lineSecureCall @57 + lineSendUserUserInfo @63 + lineSetAppSpecific @88 + lineSetCallParams @2 + lineSetCallPrivilege @95 + lineSetDevConfig @107 + lineSetMediaControl @37 + lineSetMediaMode @115 + lineSetNumRings @61 + lineSetStatusMessages @44 + lineSetTerminal @108 + lineSetupConference @48 + lineSetupTransfer @65 + lineShutdown @8 + lineSwapHold @109 + lineUncompleteCall @41 + lineUnhold @113 + lineUnpark @77 + phoneClose @119 + phoneConfigDialog @16 + phoneDevSpecific @9 + phoneGetButtonInfo @4 + phoneGetData @93 + phoneGetDevCaps @114 + phoneGetDisplay @83 + phoneGetGain @68 + phoneGetHookSwitch @27 + phoneGetID @106 + phoneGetIcon @74 + phoneGetLamp @117 + phoneGetRing @70 + phoneGetStatus @39 + phoneGetStatusMessages @55 + phoneGetVolume @59 + phoneInitialize @35 + phoneOpen @89 + phoneNegotiateAPIVersion @7 + phoneNegotiateExtVersion @14 + phoneSetButtonInfo @42 + phoneSetData @92 + phoneSetDisplay @98 + phoneSetGain @67 + phoneSetHookSwitch @51 + phoneSetLamp @118 + phoneSetRing @69 + phoneSetStatusMessages @56 + phoneSetVolume @54 + phoneShutdown @26 + tapiRequestMakeCall @28 + tapiRequestMediaCall @101 + tapiRequestDrop @112 + tapiGetLocationInfo @85 + lineRegisterRequestRecipient @10 + lineGetRequest @86 + lineSetCurrentLocation @81 + lineSetTollList @3 + lineTranslateAddress @19 + lineGetTranslateCaps @100 + +; Tapi 1.1 extensions + + lineTranslateDialog + lineGetCountry + lineGetAppPriority + lineSetAppPriority + lineAddProvider + lineConfigProvider + lineRemoveProvider + lineGetProviderList + lineReleaseUserUserInfo + +; Misc + LOpenDialAsst + LAddrParamsInited diff --git a/private/tapi/dev/thunk/tapi.rc b/private/tapi/dev/thunk/tapi.rc new file mode 100644 index 000000000..7f262b32c --- /dev/null +++ b/private/tapi/dev/thunk/tapi.rc @@ -0,0 +1,25 @@ +#include "windows.h" + +// ///////////////////////////////////////////////////////////////////////// +// ///////////////////////////////////////////////////////////////////////// + +#if WINNT +#include <ntverp.h> +#else +#include <version.h> +#endif + +#define VER_FILEDESCRIPTION_STR "Microsoft\256 Windows(TM) Telephony Server" +#define VER_INTERNALNAME_STR "tapi" +#define VER_ORIGINALFILENAME_STR "TAPI.DLL" +#define VER_LEGALCOPYRIGHT_STR "Copyright \251 Microsoft Corporation 1995. All Rights Reserved." + +#define VER_FILETYPE VFT_APP +#define VER_FILESUBTYPE VFT2_UNKNOWN + +#include <common.ver> + +// ///////////////////////////////////////////////////////////////////////// +// ///////////////////////////////////////////////////////////////////////// + + diff --git a/private/tapi/dev/thunk/thunk.c b/private/tapi/dev/thunk/thunk.c new file mode 100644 index 000000000..0e0a56434 --- /dev/null +++ b/private/tapi/dev/thunk/thunk.c @@ -0,0 +1,3771 @@ +/*++ BUILD Version: 0000 // Increment this if a change has global effects + +Copyright (c) 1995 Microsoft Corporation + +Module Name: + + thunk.c + +Abstract: + + This module contains + +Author: + + Dan Knudson (DanKn) dd-Mmm-1995 + +Revision History: + +--*/ + + +// BUGBUG? do we need a notifyregister proc in here to clean up after bad apps +// BUGBUG how to clean up after apps that've closed w/o do a shutdown? + + +#include <windows.h> + +#include <stdlib.h> +//#include <malloc.h> + +#include <string.h> + + +#define TAPI_CURRENT_VERSION 0x00010004 + +//#include "..\inc\tapi.h" +#include <tapi.h> + +#include "thunk.h" + +char gszWndClass[] = "TapiClient16Class"; + +// BUGBUG + +//#define DBG + +#if DBG + +DWORD gdwDebugLevel; + +#define DBGOUT OutputDebugString +#else + +#define DBGOUT // + +#endif + +int +FAR +PASCAL +LibMain( + HINSTANCE hInst, + WORD wDataSeg, + WORD cbHeapSize, + LPSTR lpszCmdLine + ) +{ + int i; + WNDCLASS wc; + + DBGOUT ("Libmain entered\n"); + + // + // + // + +#if DBG + + gdwDebugLevel = (DWORD) GetPrivateProfileInt( + "Debug", + "TapiDebugLevel", + 0x0, + "Telephon.ini" + ); + +#endif + + + // + // Save the hInst in a global + // + + ghInst = hInst; + + + // + // Register a window class for windows used for signaling async + // completions & unsolicited events + // + + wc.style = 0; + wc.lpfnWndProc = (WNDPROC) Tapi16HiddenWndProc; + wc.cbClsExtra = 0; + wc.cbWndExtra = 2 * sizeof(DWORD); + wc.hInstance = hInst; + wc.hIcon = NULL; + wc.hCursor = NULL; + wc.hbrBackground = NULL; + wc.lpszMenuName = NULL; + wc.lpszClassName = gszWndClass; + + if (!RegisterClass (&wc)) + { + DBGOUT ("RegisterClass() failed\n"); + } + + + // + // Load tapi32.dll & Get all the proc pointers + // + + ghLib = LoadLibraryEx32W ("tapi32.dll", NULL, 0); + + for (i = 0; i < NUM_TAPI32_PROCS; i++) + { + gaProcs[i] = (MYPROC) GetProcAddress32W( + ghLib, + (LPCSTR)gaFuncNames[i] + ); + } + + // set the error mode. + // this has no effect on x86 platforms + // on RISC platforms, NT will fix + // alignment faults (at a cost of time) + { +#define SEM_NOALIGNMENTFAULTEXCEPT 0x0004 + + DWORD dwModule; + DWORD dwFunc; + + if ((dwModule = LoadLibraryEx32W("kernel32.dll", + NULL, + 0)) == NULL) + { + DBGOUT("LoadLibraryEx32W on kernel32.dll failed\n"); + } + else + { + if ((dwFunc = GetProcAddress32W(dwModule, + "SetErrorMode")) == NULL) + { + DBGOUT("GetProcAddress32W on SetErrorMode failed\n"); + } + else + { + DBGOUT("Calling CallProcEx32W\n"); + + CallProcEx32W(1, + 0, + dwFunc, + (DWORD)SEM_NOALIGNMENTFAULTEXCEPT); + } + + FreeLibrary32W(dwModule); + } + } + + return TRUE; +} + + +int +FAR +PASCAL +WEP( + int nParam + ) +{ + FreeLibrary32W (ghLib); + + return TRUE; +} + + +LRESULT +CALLBACK +Tapi16HiddenWndProc( + HWND hwnd, + UINT msg, + WPARAM wParam, + LPARAM lParam + ) +{ + switch (msg) + { + case WM_ASYNCEVENT: + { + // + // This msg gets posted to us by tapi32.dll to alert us that + // there's a new callback msg available for the app instance + // associated with this window. "lParam" is an app instance + // context tapi32.dll-space. + // + + LPTAPI_APP_DATA pAppData = (LPTAPI_APP_DATA) + GetWindowLong (hwnd, GWL_APPDATA); + TAPI16_CALLBACKMSG msg; + + + pAppData->bPendingAsyncEventMsg = FALSE; + + while ((*pfnCallProc2)( + (DWORD) lParam, + (DWORD) ((LPVOID)&msg), + (LPVOID)gaProcs[GetTapi16CallbkMsg], + 0x1, + 2 + )) + { + if (pAppData->bPendingAsyncEventMsg == FALSE) + { + pAppData->bPendingAsyncEventMsg = TRUE; + PostMessage (hwnd, WM_ASYNCEVENT, wParam, lParam); + +// BUGBUG Tapi16HiddenWndProc: need to verify pAppData in case app calls +// shutdown from callback? + } + + (*(pAppData->lpfnCallback))( + msg.hDevice, + msg.dwMsg, + msg.dwCallbackInstance, + msg.dwParam1, + msg.dwParam2, + msg.dwParam3 + ); + } + + break; + } + default: + { + return (DefWindowProc (hwnd, msg, wParam, lParam)); + } + } // switch + + return 0; +} + + +// +// The following are the routines to thunk TAPI calls from 16-bit apps to +// the 32-bit tapi32.dll. In general, this is done as follows: +// +// CallProc32W( +// arg1, // TAPI proc args +// ..., +// argN, +// +// pfnTapi32, // Pointer to the function in tapi32.dll +// +// 0x???, // Bit mask indicating which args are pointers +// // that need to be mapped from a 16:16 address +// // to a 0:32 address. The least significant +// // bit corresponds to argN, and the Nth bit +// // corresponds to arg1. +// // +// // For example, if arg1 & arg2 are pointers, and +// // arg3 is a DWORD, the the mask would be 0x6 +// // (110 in binary, indicating arg1 & arg2 need to +// // be mapped) +// +// N // Number of TAPI proc args +// ); +// +// +// Since callbacks to 16-bit procs cannot be done directly by a 32-bit +// module, we create a hidden window for each successful call to +// lineInitialize and phoneInitialize, and tapi32.dll posts msgs to this +// window when LINE_XXX & PHONE_XXX msgs become available for the client +// process. The window then retrieves all the msgs parameters and calls +// the 16-bit proc's callback function. +// +// Note that we swap the hLineApp & hPhoneApp returned by tapi32.dll with +// the hidden window handle on the client proc side, and substitute the +// window handle for the pointer to the callback function on the tapi32.dll +// side. The former is done to make it easier to reference which window +// belongs to which hLine/PhoneApp, and the latter is done to provide +// tapi32.dll with a means of alerting us of callback msgs. (Tapi32.dll +// distinguishes whether the lpfnCallback it is passed in +// line/phoneInitialize is a pointer to a function of a window handle by +// checking the high WORD- if it is 0xffff then it assumes lpfnCallback +// is really a 16-bit proc's window handle. +// + +#if DBG + +void +LineResult( + char *pszFuncName, + LONG lResult + ) +{ + if (gdwDebugLevel > 3) + { + char buf[80]; + + wsprintf (buf, "TAPI: line%s result=x%lx\n", pszFuncName, lResult); + DBGOUT (buf); + } +} + +void +PhoneResult( + char *pszFuncName, + LONG lResult + ) +{ + if (gdwDebugLevel > 3) + { + char buf[80]; + + wsprintf (buf, "TAPI: phone%s result=x%lx\n", pszFuncName, lResult); + DBGOUT (buf); + } +} + +void +TapiResult( + char *pszFuncName, + LONG lResult + ) +{ + if (gdwDebugLevel > 3) + { + char buf[80]; + + wsprintf (buf, "TAPI: tapi%s result=x%lx\n", pszFuncName, lResult); + DBGOUT (buf); + } +} + +#else + +#define LineResult(arg1,arg2) +#define PhoneResult(arg1,arg2) +#define TapiResult(arg1,arg2) + +#endif + + +LONG +WINAPI +xxxInitialize( + BOOL bLine, + LPHLINEAPP lphXxxApp, + HINSTANCE hInstance, + LINECALLBACK lpfnCallback, + LPCSTR lpszAppName, + LPDWORD lpdwNumDevs + ) +{ + HWND hwnd = NULL; + LONG lResult; + char far *lpszModuleNamePath = NULL; + char far *lpszModuleName; + char far *lpszFriendlyAndModuleName = NULL; + LPTAPI_APP_DATA pAppData = (LPTAPI_APP_DATA) NULL; + +#if DBG + + if (bLine) + { + DBGOUT ("lineInitialize: enter\n"); + } + else + { + DBGOUT ("phoneInitialize: enter\n"); + } + +#endif + + // + // Verify the ptrs + // + + if (IsBadWritePtr (lphXxxApp, sizeof(HLINEAPP)) || + IsBadCodePtr ((FARPROC) lpfnCallback) || + (lpszAppName && IsBadStringPtr (lpszAppName,(UINT)TAPIMAXAPPNAMESIZE))) + { + lResult = (bLine ? LINEERR_INVALPOINTER : PHONEERR_INVALPOINTER); + goto xxxInitialize_showResult; + } + + + // + // Create a string that looks like: "<friendly name>\0<module name>\0" + // (because i don't know if i can work with a 16-bit hInstance in tapi32) + // + + if ((lpszModuleNamePath = (char far *) malloc (260))) + { + if (GetModuleFileName (hInstance, lpszModuleNamePath, 260)) + { + lpszModuleName = 1 + _fstrrchr (lpszModuleNamePath, '\\'); + + if ((lpszFriendlyAndModuleName = (char far *) malloc (260))) + { + int length; + + + strncpy( + lpszFriendlyAndModuleName, + (lpszAppName ? lpszAppName : lpszModuleName), + (UINT)TAPIMAXAPPNAMESIZE + ); + + lpszFriendlyAndModuleName[TAPIMAXAPPNAMESIZE] = 0; + + length = strlen (lpszFriendlyAndModuleName); + + strcpy( + lpszFriendlyAndModuleName + length + 1, + lpszModuleName + ); + } + else + { + lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM); + goto xxxInitialize_done; + } + } + else + { + DBGOUT ("GetModuleFileName() failed\n"); + + lResult = + (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED); + goto xxxInitialize_done; + } + } + else + { + lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM); + goto xxxInitialize_done; + } + + + // + // Create a window that we can use for signaling async completions + // & unsolicited events + // + + if (!(hwnd = CreateWindow( + gszWndClass, + "", + WS_POPUP, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + CW_USEDEFAULT, + NULL, + NULL, + ghInst, + NULL + ))) + { + lResult = (bLine ? LINEERR_OPERATIONFAILED : PHONEERR_OPERATIONFAILED); + + DBGOUT ("CreateWindow failed\n"); + + goto xxxInitialize_done; + } + + + // + // + // + + if (!(pAppData = (LPTAPI_APP_DATA) malloc (sizeof (TAPI_APP_DATA)))) + { + lResult = (bLine ? LINEERR_NOMEM : PHONEERR_NOMEM); + + DBGOUT ("malloc failed\n"); + + goto xxxInitialize_done; + } + + pAppData->dwKey = TAPI_APP_DATA_KEY; + pAppData->hwnd = hwnd; + pAppData->bPendingAsyncEventMsg = FALSE; + pAppData->lpfnCallback = lpfnCallback; + + SetWindowLong (hwnd, GWL_APPDATA, (LONG) pAppData); + + + // + // Call tapi32.dll + // + + lResult = (LONG) (*pfnCallProc5)( + (DWORD) ((LPVOID)&pAppData->hXxxApp), + (DWORD) hInstance, + (DWORD) (0xffff0000 | hwnd), // lpfnCallback + (DWORD) lpszFriendlyAndModuleName, + (DWORD) lpdwNumDevs, + (LPVOID)gaProcs[(bLine ? lInitialize : pInitialize)], + 0x13, + 5 + ); + +xxxInitialize_done: + + if (lpszModuleNamePath) + { + free (lpszModuleNamePath); + + if (lpszFriendlyAndModuleName) + { + free (lpszFriendlyAndModuleName); + } + } + + if (lResult == 0) + { + // + // Set the app's hLineApp to be the hwnd rather than the real + // hLineApp, making it easier to locate the window + // + + *lphXxxApp = (HLINEAPP) pAppData; + } + else if (hwnd) + { + DestroyWindow (hwnd); + + if (pAppData) + { + free (pAppData); + } + } + +xxxInitialize_showResult: + +#if DBG + + if (bLine) + { + LineResult ("Initialize", lResult); + } + else + { + PhoneResult ("Initialize", lResult); + } + +#endif + + return lResult; +} + + +LPTAPI_APP_DATA +FAR +PASCAL +IsValidXxxApp( + HLINEAPP hXxxApp + ) +{ + if (IsBadReadPtr ((LPVOID) hXxxApp, sizeof (TAPI_APP_DATA)) || + ((LPTAPI_APP_DATA) hXxxApp)->dwKey != TAPI_APP_DATA_KEY) + { + return (LPTAPI_APP_DATA) NULL; + } + + return (LPTAPI_APP_DATA) hXxxApp; +} + + +LONG +WINAPI +lineAccept( + HCALL hCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpsUserUserInfo, + (DWORD) dwSize, + (LPVOID)gaProcs[lAccept], + 0x2, + 3 + ); + + LineResult ("Accept", lResult); + + return lResult; +} + + +LONG +WINAPI +lineAddProvider( + LPCSTR lpszProviderFilename, + HWND hwndOwner, + LPDWORD lpdwPermanentProviderID + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) lpszProviderFilename, + (DWORD) (0xffff0000 | hwndOwner), + (DWORD) lpdwPermanentProviderID, + (LPVOID)gaProcs[lAddProvider], + 0x5, + 3 + ); + + LineResult ("AddProvider", lResult); + + return lResult; +} + + +LONG +WINAPI +lineAddToConference( + HCALL hConfCall, + HCALL hConsultCall + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hConfCall, + (DWORD) hConsultCall, + (LPVOID)gaProcs[lAddToConference], + 0x0, + 2 + ); + + LineResult ("AddToConference", lResult); + + return lResult; +} + + +LONG +WINAPI +lineAnswer( + HCALL hCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpsUserUserInfo, + (DWORD) dwSize, + (LPVOID)gaProcs[lAnswer], + 0x2, + 3 + ); + + LineResult ("Answer", lResult); + + return lResult; +} + + +LONG +WINAPI +lineBlindTransfer( + HCALL hCall, + LPCSTR lpszDestAddress, + DWORD dwCountryCode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpszDestAddress, + (DWORD) dwCountryCode, + (LPVOID)gaProcs[lBlindTransfer], + 0x2, + 3 + ); + + LineResult ("BlindTransfer", lResult); + + return lResult; +} + + +LONG +WINAPI +lineClose( + HLINE hLine + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hLine, + (LPVOID)gaProcs[lClose], + 0x0, + 1 + ); + + LineResult ("Close", lResult); + + return lResult; +} + + +LONG +WINAPI +lineCompleteCall( + HCALL hCall, + LPDWORD lpdwCompletionID, + DWORD dwCompletionMode, + DWORD dwMessageID + ) +{ + LONG lResult; + + + if (IsBadWritePtr (lpdwCompletionID, sizeof (DWORD))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc4)( + (DWORD) hCall, + (DWORD) lpdwCompletionID, // let tapi32.dll map this + (DWORD) dwCompletionMode, + (DWORD) dwMessageID, + (LPVOID)gaProcs[lCompleteCall], + 0x0, + 4 + ); + } + LineResult ("CompleteCall", lResult); + + return lResult; +} + + +LONG +WINAPI +lineCompleteTransfer( + HCALL hCall, + HCALL hConsultCall, + LPHCALL lphConfCall, + DWORD dwTransferMode + ) +{ + // + // Tapi32.dll will take care of mapping lphConfCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if ( + ( dwTransferMode & LINETRANSFERMODE_CONFERENCE ) + && + IsBadWritePtr ((void FAR *) lphConfCall, sizeof(HCALL)) + ) + { + DBGOUT ("Bad lphConfCall with TRANSFERMODE_CONFERENCE"); + lResult = LINEERR_INVALPOINTER; + goto CompleteTransfer_cleanup; + } + + lResult = (*pfnCallProc4)( + (DWORD) hCall, + (DWORD) hConsultCall, + (DWORD) lphConfCall, + (DWORD) dwTransferMode, + (LPVOID)gaProcs[lCompleteTransfer], + 0x0, + 4 + ); + +CompleteTransfer_cleanup: + LineResult ("CompleteTransfer", lResult); + + return lResult; +} + + +LONG +WINAPI +lineConfigDialog( + DWORD dwDeviceID, + HWND hwndOwner, + LPCSTR lpszDeviceClass + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) dwDeviceID, + (DWORD) (0xffff0000 | hwndOwner), + (DWORD) lpszDeviceClass, + (LPVOID)gaProcs[lConfigDialog], + 0x1, + 3 + ); + + LineResult ("ConfigDialog", lResult); + + return lResult; +} + + +LONG +WINAPI +lineConfigDialogEdit( + DWORD dwDeviceID, + HWND hwndOwner, + LPCSTR lpszDeviceClass, + LPVOID lpDeviceConfigIn, + DWORD dwSize, + LPVARSTRING lpDeviceConfigOut + ) +{ + LONG lResult = (*pfnCallProc6)( + (DWORD) dwDeviceID, + (DWORD) (0xffff0000 | hwndOwner), + (DWORD) lpszDeviceClass, + (DWORD) lpDeviceConfigIn, + (DWORD) dwSize, + (DWORD) lpDeviceConfigOut, + (LPVOID)gaProcs[lConfigDialogEdit], + 0xd, + 6 + ); + + LineResult ("ConfigDialogEdit", lResult); + + return lResult; +} + + +LONG +WINAPI +lineConfigProvider( + HWND hwndOwner, + DWORD dwPermanentProviderID + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) (0xffff0000 | hwndOwner), + (DWORD) dwPermanentProviderID, + (LPVOID)gaProcs[lConfigProvider], + 0x0, + 2 + ); + + LineResult ("ConfigProvider", lResult); + + return lResult; +} + + +LONG +WINAPI +lineDeallocateCall( + HCALL hCall + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hCall, + (LPVOID)gaProcs[lDeallocateCall], + 0x0, + 1 + ); + + LineResult ("DeallocateCall", lResult); + + return lResult; +} + + +LONG +WINAPI +lineDevSpecific( + HLINE hLine, + DWORD dwAddressID, + HCALL hCall, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + + + if (IsBadWritePtr (lpParams, (UINT) dwSize)) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc5)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) hCall, + (DWORD) lpParams, // let tapi32.dll map this + (DWORD) dwSize, + (LPVOID)gaProcs[lDevSpecific], + 0x0, + 5 + ); + } + + LineResult ("DevSpecific", lResult); + + return lResult; +} + + +LONG +WINAPI +lineDevSpecificFeature( + HLINE hLine, + DWORD dwFeature, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + + + if (IsBadWritePtr (lpParams, (UINT) dwSize)) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc4)( + (DWORD) hLine, + (DWORD) dwFeature, + (DWORD) lpParams, // let tapi32.dll map this + (DWORD) dwSize, + (LPVOID)gaProcs[lDevSpecificFeature], + 0x0, + 4 + ); + } + + LineResult ("DevSpecificFeature", lResult); + + return lResult; +} + + +LONG +WINAPI +lineDial( + HCALL hCall, + LPCSTR lpszDestAddress, + DWORD dwCountryCode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpszDestAddress, + (DWORD) dwCountryCode, + (LPVOID)gaProcs[lDial], + 0x2, + 3 + ); + + LineResult ("Dial", lResult); + + return lResult; +} + + +LONG +WINAPI +lineDrop( + HCALL hCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpsUserUserInfo, + (DWORD) dwSize, + (LPVOID)gaProcs[lDrop], + 0x2, + 3 + ); + + LineResult ("Drop", lResult); + + return lResult; +} + + +LONG +WINAPI +lineForward( + HLINE hLine, + DWORD bAllAddresses, + DWORD dwAddressID, + LPLINEFORWARDLIST const lpForwardList, + DWORD dwNumRingsNoAnswer, + LPHCALL lphConsultCall, + LPLINECALLPARAMS const lpCallParams + ) +{ + // + // Tapi32.dll will take care of mapping lphConsultCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc7)( + (DWORD) hLine, + (DWORD) bAllAddresses, + (DWORD) dwAddressID, + (DWORD) lpForwardList, + (DWORD) dwNumRingsNoAnswer, + (DWORD) lphConsultCall, + (DWORD) lpCallParams, + (LPVOID)gaProcs[lForward], + 0x9, + 7 + ); + } + + LineResult ("Forward", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGatherDigits( + HCALL hCall, + DWORD dwDigitModes, + LPSTR lpsDigits, + DWORD dwNumDigits, + LPCSTR lpszTerminationDigits, + DWORD dwFirstDigitTimeout, + DWORD dwInterDigitTimeout + ) +{ + LONG lResult; + + + if (lpsDigits && IsBadWritePtr (lpsDigits, dwNumDigits)) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc7)( + (DWORD) hCall, + (DWORD) dwDigitModes, + (DWORD) lpsDigits, // let tapi32.dll map this + (DWORD) dwNumDigits, + (DWORD) lpszTerminationDigits, + (DWORD) dwFirstDigitTimeout, + (DWORD) dwInterDigitTimeout, + (LPVOID)gaProcs[lGatherDigits], + 0x4, + 7 + ); + } + + LineResult ("GatherDigits", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGenerateDigits( + HCALL hCall, + DWORD dwDigitMode, + LPCSTR lpsDigits, + DWORD dwDuration + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hCall, + (DWORD) dwDigitMode, + (DWORD) lpsDigits, + (DWORD) dwDuration, + (LPVOID)gaProcs[lGenerateDigits], + 0x2, + 4 + ); + + LineResult ("GenerateDigits", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGenerateTone( + HCALL hCall, + DWORD dwToneMode, + DWORD dwDuration, + DWORD dwNumTones, + LPLINEGENERATETONE const lpTones + ) +{ + LONG lResult = (*pfnCallProc5)( + (DWORD) hCall, + (DWORD) dwToneMode, + (DWORD) dwDuration, + (DWORD) dwNumTones, + (DWORD) lpTones, + (LPVOID)gaProcs[lGenerateTone], + 0x1, + 5 + ); + + LineResult ("GenerateTone", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetAddressCaps( + HLINEAPP hLineApp, + DWORD dwDeviceID, + DWORD dwAddressID, + DWORD dwAPIVersion, + DWORD dwExtVersion, + LPLINEADDRESSCAPS lpAddressCaps + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc6)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAddressID, + (DWORD) dwAPIVersion, + (DWORD) dwExtVersion, + (DWORD) lpAddressCaps, + (LPVOID)gaProcs[lGetAddressCaps], + 0x1, + 6 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("GetAddressCaps", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetAddressID( + HLINE hLine, + LPDWORD lpdwAddressID, + DWORD dwAddressMode, + LPCSTR lpsAddress, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc5)( + (DWORD) hLine, + (DWORD) lpdwAddressID, + (DWORD) dwAddressMode, + (DWORD) lpsAddress, + (DWORD) dwSize, + (LPVOID)gaProcs[lGetAddressID], + 0xa, + 5 + ); + + LineResult ("GetAddressID", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetAddressStatus( + HLINE hLine, + DWORD dwAddressID, + LPLINEADDRESSSTATUS lpAddressStatus + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) lpAddressStatus, + (LPVOID)gaProcs[lGetAddressStatus], + 0x1, + 3 + ); + + LineResult ("GetAddressStatus", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetAppPriority( + LPCSTR lpszAppName, + DWORD dwMediaMode, + LPLINEEXTENSIONID lpExtensionID, + DWORD dwRequestMode, + LPVARSTRING lpExtensionName, + LPDWORD lpdwPriority + ) +{ + LONG lResult = (*pfnCallProc6)( + (DWORD) lpszAppName, + (DWORD) dwMediaMode, + (DWORD) lpExtensionID, + (DWORD) dwRequestMode, + (DWORD) lpExtensionName, + (DWORD) lpdwPriority, + (LPVOID)gaProcs[lGetAppPriority], + 0x2b, + 6 + ); + + LineResult ("GetAppPriority", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetCallInfo( + HCALL hCall, + LPLINECALLINFO lpCallInfo + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) lpCallInfo, + (LPVOID)gaProcs[lGetCallInfo], + 0x1, + 2 + ); + + LineResult ("GetCallInfo", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetCallStatus( + HCALL hCall, + LPLINECALLSTATUS lpCallStatus + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) lpCallStatus, + (LPVOID)gaProcs[lGetCallStatus], + 0x1, + 2 + ); + + LineResult ("GetCallStatus", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetConfRelatedCalls( + HCALL hCall, + LPLINECALLLIST lpCallList + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) lpCallList, + (LPVOID)gaProcs[lGetConfRelatedCalls], + 0x1, + 2 + ); + + LineResult ("GetConfRelatedCalls", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetCountry( + DWORD dwCountryID, + DWORD dwAPIVersion, + LPLINECOUNTRYLIST lpLineCountryList + ) +{ + LONG lResult = (*pfnCallProc3)( + dwCountryID, + dwAPIVersion, + (DWORD) lpLineCountryList, + (LPVOID)gaProcs[lGetCountry], + 0x1, + 3 + ); + + LineResult ("GetCountry", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetDevCaps( + HLINEAPP hLineApp, + DWORD dwDeviceID, + DWORD dwAPIVersion, + DWORD dwExtVersion, + LPLINEDEVCAPS lpLineDevCaps + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc5)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPIVersion, + (DWORD) dwExtVersion, + (DWORD) lpLineDevCaps, + (LPVOID)gaProcs[lGetDevCaps], + 0x1, + 5 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("GetDevCaps", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetDevConfig( + DWORD dwDeviceID, + LPVARSTRING lpDeviceConfig, + LPCSTR lpszDeviceClass + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) dwDeviceID, + (DWORD) lpDeviceConfig, + (DWORD) lpszDeviceClass, + (LPVOID)gaProcs[lGetDevConfig], + 0x3, + 3 + ); + + LineResult ("GetDevConfig", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetIcon( + DWORD dwDeviceID, + LPCSTR lpszDeviceClass, + LPHICON lphIcon + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) dwDeviceID, + (DWORD) lpszDeviceClass, + (DWORD) lphIcon, + (LPVOID)gaProcs[lGetIcon], + 0x3, + 3 + ); + + LineResult ("GetIcon", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetID( + HLINE hLine, + DWORD dwAddressID, + HCALL hCall, + DWORD dwSelect, + LPVARSTRING lpDeviceID, + LPCSTR lpszDeviceClass + ) +{ + LONG lResult = (*pfnCallProc6)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) hCall, + (DWORD) dwSelect, + (DWORD) lpDeviceID, + (DWORD) lpszDeviceClass, + (LPVOID)gaProcs[lGetID], + 0x3, + 6 + ); + + LineResult ("GetID", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetLineDevStatus( + HLINE hLine, + LPLINEDEVSTATUS lpLineDevStatus + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hLine, + (DWORD) lpLineDevStatus, + (LPVOID)gaProcs[lGetLineDevStatus], + 0x1, + 2 + ); + + LineResult ("GetLineDevStatus", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetNewCalls( + HLINE hLine, + DWORD dwAddressID, + DWORD dwSelect, + LPLINECALLLIST lpCallList + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) dwSelect, + (DWORD) lpCallList, + (LPVOID)gaProcs[lGetNewCalls], + 0x1, + 4 + ); + + LineResult ("GetNewCalls", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetNumRings( + HLINE hLine, + DWORD dwAddressID, + LPDWORD lpdwNumRings + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) lpdwNumRings, + (LPVOID)gaProcs[lGetNumRings], + 0x1, + 3 + ); + + LineResult ("GetNumRings", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetProviderList( + DWORD dwAPIVersion, + LPLINEPROVIDERLIST lpProviderList + ) +{ + LONG lResult = (*pfnCallProc2)( + dwAPIVersion, + (DWORD) lpProviderList, + (LPVOID)gaProcs[lGetProviderList], + 0x1, + 2 + ); + + LineResult ("GetProviderList", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetRequest( + HLINEAPP hLineApp, + DWORD dwRequestMode, + LPVOID lpRequestBuffer + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc3)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwRequestMode, + (DWORD) lpRequestBuffer, + (LPVOID)gaProcs[lGetRequest], + 0x1, + 3 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("GetRequest", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetStatusMessages( + HLINE hLine, + LPDWORD lpdwLineStates, + LPDWORD lpdwAddressStates + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hLine, + (DWORD) lpdwLineStates, + (DWORD) lpdwAddressStates, + (LPVOID)gaProcs[lGetStatusMessages], + 0x3, + 3 + ); + + LineResult ("GetStatusMessages", lResult); + + return lResult; +} + + +LONG +WINAPI +lineGetTranslateCaps( + HLINEAPP hLineApp, + DWORD dwAPIVersion, + LPLINETRANSLATECAPS lpTranslateCaps + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if (hLineApp == NULL || (pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc3)( + (hLineApp == NULL ? (DWORD) 0 : pAppData->hXxxApp), + (DWORD) dwAPIVersion, + (DWORD) lpTranslateCaps, + (LPVOID)gaProcs[lGetTranslateCaps], + 0x1, + 3 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("GetTranslateCaps", lResult); + + return lResult; +} + + +LONG +WINAPI +lineHandoff( + HCALL hCall, + LPCSTR lpszFileName, + DWORD dwMediaMode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpszFileName, + (DWORD) dwMediaMode, + (LPVOID)gaProcs[lHandoff], + 0x2, + 3 + ); + + LineResult ("Handoff", lResult); + + return lResult; +} + + +LONG +WINAPI +lineHold( + HCALL hCall + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hCall, + (LPVOID)gaProcs[lHold], + 0x0, + 1 + ); + + LineResult ("Hold", lResult); + + return lResult; +} + + +LONG +WINAPI +lineInitialize( + LPHLINEAPP lphLineApp, + HINSTANCE hInstance, + LINECALLBACK lpfnCallback, + LPCSTR lpszAppName, + LPDWORD lpdwNumDevs + ) +{ + return (xxxInitialize( + TRUE, + lphLineApp, + hInstance, + lpfnCallback, + lpszAppName, + lpdwNumDevs + )); +} + + +LONG +WINAPI +lineMakeCall( + HLINE hLine, + LPHCALL lphCall, + LPCSTR lpszDestAddress, + DWORD dwCountryCode, + LPLINECALLPARAMS const lpCallParams + ) +{ + // + // Tapi32.dll will take care of mapping lphCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc5)( + (DWORD) hLine, + (DWORD) lphCall, + (DWORD) lpszDestAddress, + (DWORD) dwCountryCode, + (DWORD) lpCallParams, + (LPVOID)gaProcs[lMakeCall], + 0x5, + 5 + ); + } + + LineResult ("MakeCall", lResult); + + return lResult; +} + + +LONG +WINAPI +lineMonitorDigits( + HCALL hCall, + DWORD dwDigitModes + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) dwDigitModes, + (LPVOID)gaProcs[lMonitorDigits], + 0x0, + 2 + ); + + LineResult ("MonitorDigits", lResult); + + return lResult; +} + + +LONG +WINAPI +lineMonitorMedia( + HCALL hCall, + DWORD dwMediaModes + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) dwMediaModes, + (LPVOID)gaProcs[lMonitorMedia], + 0x0, + 2 + ); + + LineResult ("MonitorMedia", lResult); + + return lResult; +} + + +LONG +WINAPI +lineMonitorTones( + HCALL hCall, + LPLINEMONITORTONE const lpToneList, + DWORD dwNumEntries + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpToneList, + (DWORD) dwNumEntries, + (LPVOID)gaProcs[lMonitorTones], + 0x2, + 3 + ); + + LineResult ("MonitorTones", lResult); + + return lResult; +} + + +LONG +WINAPI +lineNegotiateAPIVersion( + HLINEAPP hLineApp, + DWORD dwDeviceID, + DWORD dwAPILowVersion, + DWORD dwAPIHighVersion, + LPDWORD lpdwAPIVersion, + LPLINEEXTENSIONID lpExtensionID + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc6)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPILowVersion, + (DWORD) dwAPIHighVersion, + (DWORD) lpdwAPIVersion, + (DWORD) lpExtensionID, + (LPVOID)gaProcs[lNegotiateAPIVersion], + 0x3, + 6 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("NegotiateAPIVersion", lResult); + + return lResult; +} + + +LONG +WINAPI +lineNegotiateExtVersion( + HLINEAPP hLineApp, + DWORD dwDeviceID, + DWORD dwAPIVersion, + DWORD dwExtLowVersion, + DWORD dwExtHighVersion, + LPDWORD lpdwExtVersion + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc6)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPIVersion, + (DWORD) dwExtLowVersion, + (DWORD) dwExtHighVersion, + (DWORD) lpdwExtVersion, + (LPVOID)gaProcs[lNegotiateExtVersion], + 0x1, + 6 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("NegotiateExtVersion", lResult); + + return lResult; +} + + +LONG +WINAPI +lineOpen( + HLINEAPP hLineApp, + DWORD dwDeviceID, + LPHLINE lphLine, + DWORD dwAPIVersion, + DWORD dwExtVersion, + DWORD dwCallbackInstance, + DWORD dwPrivileges, + DWORD dwMediaModes, + LPLINECALLPARAMS const lpCallParams + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc9)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) lphLine, + (DWORD) dwAPIVersion, + (DWORD) dwExtVersion, + (DWORD) dwCallbackInstance, + (DWORD) dwPrivileges, + (DWORD) dwMediaModes, + (DWORD) lpCallParams, + (LPVOID)gaProcs[lOpen], + 0x41, + 9 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("Open", lResult); + + return lResult; +} + + +LONG +WINAPI +linePark( + HCALL hCall, + DWORD dwParkMode, + LPCSTR lpszDirAddress, + LPVARSTRING lpNonDirAddress + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hCall, + (DWORD) dwParkMode, + (DWORD) lpszDirAddress, + (DWORD) lpNonDirAddress, // let tapi32.dll map this + (LPVOID)gaProcs[lPark], + 0x2, + 4 + ); + + LineResult ("Park", lResult); + + return lResult; +} + + +LONG +WINAPI +linePickup( + HLINE hLine, + DWORD dwAddressID, + LPHCALL lphCall, + LPCSTR lpszDestAddress, + LPCSTR lpszGroupID + ) +{ + // + // Tapi32.dll will take care of mapping lphCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc5)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) lphCall, + (DWORD) lpszDestAddress, + (DWORD) lpszGroupID, + (LPVOID)gaProcs[lPickup], + 0x3, + 5 + ); + } + + LineResult ("Pickup", lResult); + + return lResult; +} + + +LONG +WINAPI +linePrepareAddToConference( + HCALL hConfCall, + LPHCALL lphConsultCall, + LPLINECALLPARAMS const lpCallParams + ) +{ + // + // Tapi32.dll will take care of mapping lphConsultCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc3)( + (DWORD) hConfCall, + (DWORD) lphConsultCall, + (DWORD) lpCallParams, + (LPVOID)gaProcs[lPrepareAddToConference], + 0x1, + 3 + ); + } + + LineResult ("PrepareAddToConference", lResult); + + return lResult; +} + + +LONG +WINAPI +lineRedirect( + HCALL hCall, + LPCSTR lpszDestAddress, + DWORD dwCountryCode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpszDestAddress, + (DWORD) dwCountryCode, + (LPVOID)gaProcs[lRedirect], + 0x2, + 3 + ); + + LineResult ("Redirect", lResult); + + return lResult; +} + + +LONG +WINAPI +lineRegisterRequestRecipient( + HLINEAPP hLineApp, + DWORD dwRegistrationInstance, + DWORD dwRequestMode, + DWORD bEnable + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc4)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwRegistrationInstance, + (DWORD) dwRequestMode, + (DWORD) bEnable, + (LPVOID)gaProcs[lRegisterRequestRecipient], + 0x0, + 4 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("RegisterRequestRecipient", lResult); + + return lResult; +} + + +LONG +WINAPI +lineReleaseUserUserInfo( + HCALL hCall + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hCall, + (LPVOID)gaProcs[lReleaseUserUserInfo], + 0x0, + 1 + ); + + LineResult ("ReleaseUserUserInfo", lResult); + + return lResult; +} + + +LONG +WINAPI +lineRemoveFromConference( + HCALL hCall + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hCall, + (LPVOID)gaProcs[lRemoveFromConference], + 0x0, + 1 + ); + + LineResult ("RemoveFromConference", lResult); + + return lResult; +} + + +LONG +WINAPI +lineRemoveProvider( + DWORD dwPermanentProviderID, + HWND hwndOwner + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) dwPermanentProviderID, + (DWORD) (0xffff0000 | hwndOwner), + (LPVOID)gaProcs[lRemoveProvider], + 0x0, + 2 + ); + + LineResult ("RemoveProvider", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSecureCall( + HCALL hCall + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hCall, + (LPVOID)gaProcs[lSecureCall], + 0x0, + 1 + ); + + LineResult ("SecureCall", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSendUserUserInfo( + HCALL hCall, + LPCSTR lpsUserUserInfo, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lpsUserUserInfo, + (DWORD) dwSize, + (LPVOID)gaProcs[lSendUserUserInfo], + 0x2, + 3 + ); + + LineResult ("SendUserUserInfo", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetAppPriority( + LPCSTR lpszAppName, + DWORD dwMediaMode, + LPLINEEXTENSIONID lpExtensionID, + DWORD dwRequestMode, + LPCSTR lpszExtensionName, + DWORD dwPriority + ) +{ + LONG lResult = (*pfnCallProc6)( + (DWORD) lpszAppName, + (DWORD) dwMediaMode, + (DWORD) lpExtensionID, + (DWORD) dwRequestMode, + (DWORD) lpszExtensionName, + (DWORD) dwPriority, + (LPVOID)gaProcs[lSetAppPriority], + 0x2a, + 6 + ); + + LineResult ("SetAppPriority", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetAppSpecific( + HCALL hCall, + DWORD dwAppSpecific + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) dwAppSpecific, + (LPVOID)gaProcs[lSetAppSpecific], + 0x0, + 2 + ); + + LineResult ("SetAppSpecific", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetCallParams( + HCALL hCall, + DWORD dwBearerMode, + DWORD dwMinRate, + DWORD dwMaxRate, + LPLINEDIALPARAMS const lpDialParams + ) +{ + LONG lResult = (*pfnCallProc5)( + (DWORD) hCall, + (DWORD) dwBearerMode, + (DWORD) dwMinRate, + (DWORD) dwMaxRate, + (DWORD) lpDialParams, + (LPVOID)gaProcs[lSetCallParams], + 0x1, + 5 + ); + + LineResult ("SetCallParams", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetCallPrivilege( + HCALL hCall, + DWORD dwCallPrivilege + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) dwCallPrivilege, + (LPVOID)gaProcs[lSetCallPrivilege], + 0x0, + 2 + ); + + LineResult ("SetCallPrivilege", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetCurrentLocation( + HLINEAPP hLineApp, + DWORD dwLocation + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc2)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwLocation, + (LPVOID)gaProcs[lSetCurrentLocation], + 0x0, + 2 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("SetCurrentLocation", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetDevConfig( + DWORD dwDeviceID, + LPVOID const lpDeviceConfig, + DWORD dwSize, + LPCSTR lpszDeviceClass + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) dwDeviceID, + (DWORD) lpDeviceConfig, + (DWORD) dwSize, + (DWORD) lpszDeviceClass, + (LPVOID)gaProcs[lSetDevConfig], + 0x5, + 4 + ); + + LineResult ("SetDevConfig", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetMediaControl( + HLINE hLine, + DWORD dwAddressID, + HCALL hCall, + DWORD dwSelect, + LPLINEMEDIACONTROLDIGIT const lpDigitList, + DWORD dwDigitNumEntries, + LPLINEMEDIACONTROLMEDIA const lpMediaList, + DWORD dwMediaNumEntries, + LPLINEMEDIACONTROLTONE const lpToneList, + DWORD dwToneNumEntries, + LPLINEMEDIACONTROLCALLSTATE const lpCallStateList, + DWORD dwCallStateNumEntries + ) +{ + LONG lResult = (*pfnCallProc12)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) hCall, + (DWORD) dwSelect, + (DWORD) lpDigitList, + (DWORD) dwDigitNumEntries, + (DWORD) lpMediaList, + (DWORD) dwMediaNumEntries, + (DWORD) lpToneList, + (DWORD) dwToneNumEntries, + (DWORD) lpCallStateList, + (DWORD) dwCallStateNumEntries, + (LPVOID)gaProcs[lSetMediaControl], + 0xaa, + 12 + ); + + LineResult ("SetMediaControl", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetMediaMode( + HCALL hCall, + DWORD dwMediaModes + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hCall, + (DWORD) dwMediaModes, + (LPVOID)gaProcs[lSetMediaMode], + 0x0, + 2 + ); + + LineResult ("lineSetMediaMode", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetNumRings( + HLINE hLine, + DWORD dwAddressID, + DWORD dwNumRings + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) dwNumRings, + (LPVOID)gaProcs[lSetNumRings], + 0x0, + 3 + ); + + LineResult ("SetNumRings", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetStatusMessages( + HLINE hLine, + DWORD dwLineStates, + DWORD dwAddressStates + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hLine, + (DWORD) dwLineStates, + (DWORD) dwAddressStates, + (LPVOID)gaProcs[lSetStatusMessages], + 0x0, + 3 + ); + + LineResult ("SetStatusMessages", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetTerminal( + HLINE hLine, + DWORD dwAddressID, + HCALL hCall, + DWORD dwSelect, + DWORD dwTerminalModes, + DWORD dwTerminalID, + DWORD bEnable + ) +{ + LONG lResult = (*pfnCallProc7)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) hCall, + (DWORD) dwSelect, + (DWORD) dwTerminalModes, + (DWORD) dwTerminalID, + (DWORD) bEnable, + (LPVOID)gaProcs[lSetTerminal], + 0x0, + 7 + ); + + LineResult ("SetTerminal", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetTollList( + HLINEAPP hLineApp, + DWORD dwDeviceID, + LPCSTR lpszAddressIn, + DWORD dwTollListOption + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc4)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) lpszAddressIn, + (DWORD) dwTollListOption, + (LPVOID)gaProcs[lSetTollList], + 0x2, + 4 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("SetTollList", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetupConference( + HCALL hCall, + HLINE hLine, + LPHCALL lphConfCall, + LPHCALL lphConsultCall, + DWORD dwNumParties, + LPLINECALLPARAMS const lpCallParams + ) +{ + // + // Tapi32.dll will take care of mapping lphXxxCall's if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphConfCall, sizeof(HCALL)) || + IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc6)( + (DWORD) hCall, + (DWORD) hLine, + (DWORD) lphConfCall, + (DWORD) lphConsultCall, + (DWORD) dwNumParties, + (DWORD) lpCallParams, + (LPVOID)gaProcs[lSetupConference], + 0x1, + 6 + ); + } + + LineResult ("SetupConference", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSetupTransfer( + HCALL hCall, + LPHCALL lphConsultCall, + LPLINECALLPARAMS const lpCallParams + ) +{ + // + // Tapi32.dll will take care of mapping lphConsultCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphConsultCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc3)( + (DWORD) hCall, + (DWORD) lphConsultCall, + (DWORD) lpCallParams, + (LPVOID)gaProcs[lSetupTransfer], + 0x1, + 3 + ); + } + + LineResult ("SetupTransfer", lResult); + + return lResult; +} + + +LONG +WINAPI +lineShutdown( + HLINEAPP hLineApp + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + if ((lResult = (LONG) (*pfnCallProc1)( + (DWORD) pAppData->hXxxApp, + (LPVOID)gaProcs[lShutdown], + 0x0, + 1 + + )) == 0) + { + // + // Destroy the associated window & free the app data instance + // + + DestroyWindow (pAppData->hwnd); + pAppData->dwKey = 0xefefefef; + free (pAppData); + } + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("Shutdown", lResult); + + return lResult; +} + + +LONG +WINAPI +lineSwapHold( + HCALL hActiveCall, + HCALL hHeldCall + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hActiveCall, + (DWORD) hHeldCall, + (LPVOID)gaProcs[lSwapHold], + 0x0, + 2 + ); + + LineResult ("SwapHold", lResult); + + return lResult; +} + + +LONG +WINAPI +lineTranslateAddress( + HLINEAPP hLineApp, + DWORD dwDeviceID, + DWORD dwAPIVersion, + LPCSTR lpszAddressIn, + DWORD dwCard, + DWORD dwTranslateOptions, + LPLINETRANSLATEOUTPUT lpTranslateOutput + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc7)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPIVersion, + (DWORD) lpszAddressIn, + (DWORD) dwCard, + (DWORD) dwTranslateOptions, + (DWORD) lpTranslateOutput, + (LPVOID)gaProcs[lTranslateAddress], + 0x9, + 7 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("TranslateAddress", lResult); + + return lResult; +} + + +LONG +WINAPI +lineTranslateDialog( + HLINEAPP hLineApp, + DWORD dwDeviceID, + DWORD dwAPIVersion, + HWND hwndOwner, + LPCSTR lpszAddressIn + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp (hLineApp))) + { + lResult = (*pfnCallProc5)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPIVersion, + (DWORD) (0xffff0000 | hwndOwner), + (DWORD) lpszAddressIn, + (LPVOID)gaProcs[lTranslateDialog], + 0x1, + 5 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + LineResult ("TranslateDialog", lResult); + + return lResult; +} + + +LONG +WINAPI +lineUncompleteCall( + HLINE hLine, + DWORD dwCompletionID + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hLine, + (DWORD) dwCompletionID, + (LPVOID)gaProcs[lUncompleteCall], + 0x0, + 2 + ); + + LineResult ("UncompleteCall", lResult); + + return lResult; +} + + +LONG +WINAPI +lineUnhold( + HCALL hCall + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hCall, + (LPVOID)gaProcs[lUnhold], + 0x0, + 1 + ); + + LineResult ("Unhold", lResult); + + return lResult; +} + + +LONG +WINAPI +lineUnpark( + HLINE hLine, + DWORD dwAddressID, + LPHCALL lphCall, + LPCSTR lpszDestAddress + ) +{ + // + // Tapi32.dll will take care of mapping lphCall if/when the + // request completes successfully, so we don't set the mapping + // bit down below; do check to see if pointer is valid though. + // + + LONG lResult; + + + if (IsBadWritePtr ((void FAR *) lphCall, sizeof(HCALL))) + { + lResult = LINEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc4)( + (DWORD) hLine, + (DWORD) dwAddressID, + (DWORD) lphCall, + (DWORD) lpszDestAddress, + (LPVOID)gaProcs[lUnpark], + 0x1, + 4 + ); + } + + LineResult ("Unpark", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneClose( + HPHONE hPhone + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD) hPhone, + (LPVOID)gaProcs[pClose], + 0x0, + 1 + ); + + PhoneResult ("Close", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneConfigDialog( + DWORD dwDeviceID, + HWND hwndOwner, + LPCSTR lpszDeviceClass + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) dwDeviceID, + (DWORD) (0xffff0000 | hwndOwner), + (DWORD) lpszDeviceClass, + (LPVOID)gaProcs[pConfigDialog], + 0x1, + 3 + ); + + PhoneResult ("ConfigDialog", lResult); + + return lResult; +} + + + +LONG +WINAPI +phoneDevSpecific( + HPHONE hPhone, + LPVOID lpParams, + DWORD dwSize + ) +{ + LONG lResult; + + + if (IsBadWritePtr (lpParams, (UINT) dwSize)) + { + lResult = PHONEERR_INVALPOINTER; + } + else + { + lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) lpParams, // let tapi32.dll map this + (DWORD) dwSize, + (LPVOID)gaProcs[pDevSpecific], + 0x0, + 3 + ); + } + + PhoneResult ("DevSpecific", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetButtonInfo( + HPHONE hPhone, + DWORD dwButtonLampID, + LPPHONEBUTTONINFO lpButtonInfo + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwButtonLampID, + (DWORD) lpButtonInfo, + (LPVOID)gaProcs[pGetButtonInfo], + 0x1, + 3 + ); + + PhoneResult ("GetButtonInfo", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetData( + HPHONE hPhone, + DWORD dwDataID, + LPVOID lpData, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hPhone, + (DWORD) dwDataID, + (DWORD) lpData, + (DWORD) dwSize, + (LPVOID)gaProcs[pGetData], + 0x2, + 4 + ); + + PhoneResult ("GetData", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetDevCaps( + HPHONEAPP hPhoneApp, + DWORD dwDeviceID, + DWORD dwAPIVersion, + DWORD dwExtVersion, + LPPHONECAPS lpPhoneCaps + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp))) + { + lResult = (*pfnCallProc5)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPIVersion, + (DWORD) dwExtVersion, + (DWORD) lpPhoneCaps, + (LPVOID)gaProcs[pGetDevCaps], + 0x1, + 5 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + PhoneResult ("GetDevCaps", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetDisplay( + HPHONE hPhone, + LPVARSTRING lpDisplay + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hPhone, + (DWORD) lpDisplay, + (LPVOID)gaProcs[pGetDisplay], + 0x1, + 2 + ); + + PhoneResult ("GetDisplay", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetGain( + HPHONE hPhone, + DWORD dwHookSwitchDev, + LPDWORD lpdwGain + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwHookSwitchDev, + (DWORD) lpdwGain, + (LPVOID)gaProcs[pGetGain], + 0x1, + 3 + ); + + PhoneResult ("GetGain", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetHookSwitch( + HPHONE hPhone, + LPDWORD lpdwHookSwitchDevs + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hPhone, + (DWORD) lpdwHookSwitchDevs, + (LPVOID)gaProcs[pGetHookSwitch], + 0x1, + 2 + ); + + PhoneResult ("GetHookSwitch", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetIcon( + DWORD dwDeviceID, + LPCSTR lpszDeviceClass, + LPHICON lphIcon + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) dwDeviceID, + (DWORD) lpszDeviceClass, + (DWORD) lphIcon, + (LPVOID)gaProcs[pGetIcon], + 0x3, + 3 + ); + + PhoneResult ("GetIcon", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetID( + HPHONE hPhone, + LPVARSTRING lpDeviceID, + LPCSTR lpszDeviceClass + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) lpDeviceID, + (DWORD) lpszDeviceClass, + (LPVOID)gaProcs[pGetID], + 0x3, + 3 + ); + + PhoneResult ("GetID", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetLamp( + HPHONE hPhone, + DWORD dwButtonLampID, + LPDWORD lpdwLampMode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwButtonLampID, + (DWORD) lpdwLampMode, + (LPVOID)gaProcs[pGetLamp], + 0x1, + 3 + ); + + PhoneResult ("GetLamp", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetRing( + HPHONE hPhone, + LPDWORD lpdwRingMode, + LPDWORD lpdwVolume + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) lpdwRingMode, + (DWORD) lpdwVolume, + (LPVOID)gaProcs[pGetRing], + 0x3, + 3 + ); + + PhoneResult ("GetRing", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetStatus( + HPHONE hPhone, + LPPHONESTATUS lpPhoneStatus + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hPhone, + (DWORD) lpPhoneStatus, + (LPVOID)gaProcs[pGetStatus], + 0x1, + 2 + ); + + PhoneResult ("GetStatus", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetStatusMessages( + HPHONE hPhone, + LPDWORD lpdwPhoneStates, + LPDWORD lpdwButtonModes, + LPDWORD lpdwButtonStates + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hPhone, + (DWORD) lpdwPhoneStates, + (DWORD) lpdwButtonModes, + (DWORD) lpdwButtonStates, + (LPVOID)gaProcs[pGetStatusMessages], + 0x7, + 4 + ); + + PhoneResult ("GetStatusMessages", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneGetVolume( + HPHONE hPhone, + DWORD dwHookSwitchDev, + LPDWORD lpdwVolume + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwHookSwitchDev, + (DWORD) lpdwVolume, + (LPVOID)gaProcs[pGetVolume], + 0x1, + 3 + ); + + PhoneResult ("GetVolume", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneInitialize( + LPHPHONEAPP lphPhoneApp, + HINSTANCE hInstance, + PHONECALLBACK lpfnCallback, + LPCSTR lpszAppName, + LPDWORD lpdwNumDevs + ) +{ + return (xxxInitialize( + FALSE, + (LPHLINEAPP) lphPhoneApp, + hInstance, + lpfnCallback, + lpszAppName, + lpdwNumDevs + )); +} + + +LONG +WINAPI +phoneNegotiateAPIVersion( + HPHONEAPP hPhoneApp, + DWORD dwDeviceID, + DWORD dwAPILowVersion, + DWORD dwAPIHighVersion, + LPDWORD lpdwAPIVersion, + LPPHONEEXTENSIONID lpExtensionID + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp))) + { + lResult = (*pfnCallProc6)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPILowVersion, + (DWORD) dwAPIHighVersion, + (DWORD) lpdwAPIVersion, + (DWORD) lpExtensionID, + (LPVOID)gaProcs[pNegotiateAPIVersion], + 0x3, + 6 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + PhoneResult ("NegotiateAPIVersion", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneNegotiateExtVersion( + HPHONEAPP hPhoneApp, + DWORD dwDeviceID, + DWORD dwAPIVersion, + DWORD dwExtLowVersion, + DWORD dwExtHighVersion, + LPDWORD lpdwExtVersion + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp))) + { + lResult = (*pfnCallProc6)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) dwAPIVersion, + (DWORD) dwExtLowVersion, + (DWORD) dwExtHighVersion, + (DWORD) lpdwExtVersion, + (LPVOID)gaProcs[pNegotiateExtVersion], + 0x1, + 6 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + PhoneResult ("NegotiateExtVersion", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneOpen( + HPHONEAPP hPhoneApp, + DWORD dwDeviceID, + LPHPHONE lphPhone, + DWORD dwAPIVersion, + DWORD dwExtVersion, + DWORD dwCallbackInstance, + DWORD dwPrivilege + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp))) + { + lResult = (*pfnCallProc7)( + (DWORD) pAppData->hXxxApp, + (DWORD) dwDeviceID, + (DWORD) lphPhone, + (DWORD) dwAPIVersion, + (DWORD) dwExtVersion, + (DWORD) dwCallbackInstance, + (DWORD) dwPrivilege, + (LPVOID)gaProcs[pOpen], + 0x10, + 7 + ); + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + PhoneResult ("Open", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetButtonInfo( + HPHONE hPhone, + DWORD dwButtonLampID, + LPPHONEBUTTONINFO const lpButtonInfo + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwButtonLampID, + (DWORD) lpButtonInfo, + (LPVOID)gaProcs[pSetButtonInfo], + 0x1, + 3 + ); + + PhoneResult ("SetButtonInfo", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetData( + HPHONE hPhone, + DWORD dwDataID, + LPVOID const lpData, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hPhone, + (DWORD) dwDataID, + (DWORD) lpData, + (DWORD) dwSize, + (LPVOID)gaProcs[pSetData], + 0x2, + 4 + ); + + PhoneResult ("SetData", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetDisplay( + HPHONE hPhone, + DWORD dwRow, + DWORD dwColumn, + LPCSTR lpsDisplay, + DWORD dwSize + ) +{ + LONG lResult = (*pfnCallProc5)( + (DWORD) hPhone, + (DWORD) dwRow, + (DWORD) dwColumn, + (DWORD) lpsDisplay, + (DWORD) dwSize, + (LPVOID)gaProcs[pSetDisplay], + 0x2, + 5 + ); + + PhoneResult ("SetDisplay", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetGain( + HPHONE hPhone, + DWORD dwHookSwitchDev, + DWORD dwGain + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwHookSwitchDev, + (DWORD) dwGain, + (LPVOID)gaProcs[pSetGain], + 0x0, + 3 + ); + + PhoneResult ("SetGain", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetHookSwitch( + HPHONE hPhone, + DWORD dwHookSwitchDevs, + DWORD dwHookSwitchMode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwHookSwitchDevs, + (DWORD) dwHookSwitchMode, + (LPVOID)gaProcs[pSetHookSwitch], + 0x0, + 3 + ); + + PhoneResult ("SetHookSwitch", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetLamp( + HPHONE hPhone, + DWORD dwButtonLampID, + DWORD dwLampMode + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwButtonLampID, + (DWORD) dwLampMode, + (LPVOID)gaProcs[pSetLamp], + 0x0, + 3 + ); + + PhoneResult ("SetLamp", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetRing( + HPHONE hPhone, + DWORD dwRingMode, + DWORD dwVolume + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwRingMode, + (DWORD) dwVolume, + (LPVOID)gaProcs[pSetRing], + 0x0, + 3 + ); + + PhoneResult ("SetRing", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetStatusMessages( + HPHONE hPhone, + DWORD dwPhoneStates, + DWORD dwButtonModes, + DWORD dwButtonStates + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) hPhone, + (DWORD) dwPhoneStates, + (DWORD) dwButtonModes, + (DWORD) dwButtonStates, + (LPVOID)gaProcs[pSetStatusMessages], + 0x0, + 4 + ); + + PhoneResult ("SetStatusMessages", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneSetVolume( + HPHONE hPhone, + DWORD dwHookSwitchDev, + DWORD dwVolume + ) +{ + LONG lResult = (*pfnCallProc3)( + (DWORD) hPhone, + (DWORD) dwHookSwitchDev, + (DWORD) dwVolume, + (LPVOID)gaProcs[pSetVolume], + 0x0, + 3 + ); + + PhoneResult ("SetVolume", lResult); + + return lResult; +} + + +LONG +WINAPI +phoneShutdown( + HPHONEAPP hPhoneApp + ) +{ + LONG lResult; + LPTAPI_APP_DATA pAppData; + + + if ((pAppData = IsValidXxxApp ((HLINEAPP) hPhoneApp))) + { + if ((lResult = (*pfnCallProc1)( + (DWORD) pAppData->hXxxApp, + (LPVOID)gaProcs[pShutdown], + 0x0, + 1 + + )) == 0) + { + // + // Destroy the associated window & free the app data instance + // + + DestroyWindow (pAppData->hwnd); + pAppData->dwKey = 0xefefefef; + free (pAppData); + } + } + else + { + lResult = LINEERR_INVALAPPHANDLE; + } + + PhoneResult ("Shutdown", lResult); + + return lResult; +} + + +LONG +WINAPI +tapiRequestMakeCall( + LPCSTR lpszDestAddress, + LPCSTR lpszAppName, + LPCSTR lpszCalledParty, + LPCSTR lpszComment + ) +{ + LONG lResult = (*pfnCallProc4)( + (DWORD) lpszDestAddress, + (DWORD) lpszAppName, + (DWORD) lpszCalledParty, + (DWORD) lpszComment, + (LPVOID)gaProcs[tRequestMakeCall], + 0xf, + 4 + ); + + TapiResult ("RequestMakeCall", lResult); + + return lResult; +} + + +LONG +WINAPI +tapiRequestMediaCall( + HWND hWnd, + WPARAM wRequestID, + LPCSTR lpszDeviceClass, + LPCSTR lpDeviceID, + DWORD dwSize, + DWORD dwSecure, + LPCSTR lpszDestAddress, + LPCSTR lpszAppName, + LPCSTR lpszCalledParty, + LPCSTR lpszComment + ) +{ + LONG lResult = (*pfnCallProc10)( + (DWORD) hWnd, + (DWORD) wRequestID, + (DWORD) lpszDeviceClass, + (DWORD) lpDeviceID, + (DWORD) dwSize, + (DWORD) dwSecure, + (DWORD) lpszDestAddress, + (DWORD) lpszAppName, + (DWORD) lpszCalledParty, + (DWORD) lpszComment, + (LPVOID)gaProcs[tRequestMediaCall], + 0xcf, + 10 + ); + + TapiResult ("RequestMediaCall", lResult); + + return lResult; +} + + +LONG +WINAPI +tapiRequestDrop( + HWND hWnd, + WPARAM wRequestID + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) hWnd, + (DWORD) wRequestID, + (LPVOID)gaProcs[tRequestDrop], + 0x0, + 2 + ); + + TapiResult ("Drop", lResult); + + return lResult; +} + + +LONG +WINAPI +tapiGetLocationInfo( + LPSTR lpszCountryCode, + LPSTR lpszCityCode + ) +{ + LONG lResult = (*pfnCallProc2)( + (DWORD) lpszCountryCode, + (DWORD) lpszCityCode, + (LPVOID)gaProcs[tGetLocationInfo], + 0x3, + 2 + ); + + TapiResult ("GetLocationInfo", lResult); + + return lResult; +} + + + + +LONG +WINAPI +LAddrParamsInited( + LPDWORD lpdwInited + ) +{ + LONG lResult = (*pfnCallProc1)( + (DWORD)lpdwInited, + (LPVOID)gaProcs[LAddrParamsInitedVAL], + 0x1, + 1 + ); + + LineResult ("LAddrParamsInited", lResult); + + return lResult; +} + + +LONG +WINAPI +LOpenDialAsst( + HWND hwnd, + LPCSTR lpszAddressIn, + BOOL fSimple, + BOOL fSilentInstall) +{ + LONG lResult = (*pfnCallProc4)( + hwnd, + (DWORD)lpszAddressIn, + fSimple, + fSilentInstall, + (LPVOID)gaProcs[LOpenDialAsstVAL], + 0x0, + 4 + ); + + LineResult ("LOpenDialAsst", lResult); + + return lResult; +} diff --git a/private/tapi/dev/thunk/thunk.h b/private/tapi/dev/thunk/thunk.h new file mode 100644 index 000000000..d3f9c4bbc --- /dev/null +++ b/private/tapi/dev/thunk/thunk.h @@ -0,0 +1,369 @@ +#define WF_WINNT 0x4000 + +#define TAPI_APP_DATA_KEY 0x44415441 +#define GWL_APPDATA 0 +#define WM_ASYNCEVENT (WM_USER+111) +#define NUM_TAPI32_PROCS 117 + +typedef void (FAR PASCAL *MYPROC)(); +//typedef MYPROC NEAR * PMYPROC; + + +typedef LONG (FAR PASCAL *PFNCALLPROC1)(DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC2)(DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC3)(DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC4)(DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC5)(DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC6)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC7)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC8)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC9)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC10)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC11)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); +typedef LONG (FAR PASCAL *PFNCALLPROC12)(DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, DWORD, LPVOID, DWORD, DWORD); + +typedef enum +{ + lAccept, + lAddProvider, + lAddToConference, + lAnswer, + lBlindTransfer, + lClose, + lCompleteCall, + lCompleteTransfer, + lConfigDialog, + lConfigDialogEdit, + lConfigProvider, + lDeallocateCall, + lDevSpecific, + lDevSpecificFeature, + lDial, + lDrop, + lForward, + lGatherDigits, + lGenerateDigits, + lGenerateTone, + lGetAddressCaps, + lGetAddressID, + lGetAddressStatus, + lGetAppPriority, + lGetCallInfo, + lGetCallStatus, + lGetConfRelatedCalls, + lGetCountry, + lGetDevCaps, + lGetDevConfig, + lGetIcon, + lGetID, + lGetLineDevStatus, + lGetNewCalls, + lGetNumRings, + lGetProviderList, + lGetRequest, + lGetStatusMessages, + lGetTranslateCaps, + lHandoff, + lHold, + lInitialize, + lMakeCall, + lMonitorDigits, + lMonitorMedia, + lMonitorTones, + lNegotiateAPIVersion, + lNegotiateExtVersion, + lOpen, + lPark, + lPickup, + lPrepareAddToConference, + lRedirect, + lRegisterRequestRecipient, + lReleaseUserUserInfo, + lRemoveFromConference, + lRemoveProvider, + lSecureCall, + lSendUserUserInfo, + lSetAppPriority, + lSetAppSpecific, + lSetCallParams, + lSetCallPrivilege, + lSetCurrentLocation, + lSetDevConfig, + lSetMediaControl, + lSetMediaMode, + lSetNumRings, + lSetStatusMessages, + lSetTerminal, + lSetTollList, + lSetupConference, + lSetupTransfer, + lShutdown, + lSwapHold, + lTranslateAddress, + lTranslateDialog, + lUncompleteCall, + lUnhold, + lUnpark, + + pClose, + pConfigDialog, + pDevSpecific, + pGetButtonInfo, + pGetData, + pGetDevCaps, + pGetDisplay, + pGetGain, + pGetHookSwitch, + pGetID, + pGetIcon, + pGetLamp, + pGetRing, + pGetStatus, + pGetStatusMessages, + pGetVolume, + pInitialize, + pOpen, + pNegotiateAPIVersion, + pNegotiateExtVersion, + pSetButtonInfo, + pSetData, + pSetDisplay, + pSetGain, + pSetHookSwitch, + pSetLamp, + pSetRing, + pSetStatusMessages, + pSetVolume, + pShutdown, + + tGetLocationInfo, + tRequestDrop, + tRequestMakeCall, + tRequestMediaCall, + + GetTapi16CallbkMsg, + LOpenDialAsstVAL, + LAddrParamsInitedVAL + +} PROC_INDICES; + + +typedef struct _TAPI16_CALLBACKMSG +{ + DWORD hDevice; + + DWORD dwMsg; + + DWORD dwCallbackInstance; + + DWORD dwParam1; + + DWORD dwParam2; + + DWORD dwParam3; + +} TAPI16_CALLBACKMSG, FAR *LPTAPI16_CALLBACKMSG; + + +typedef struct _TAPI_APP_DATA +{ + DWORD dwKey; + + HWND hwnd; + + LINECALLBACK lpfnCallback; + + BOOL bPendingAsyncEventMsg; + + DWORD hXxxApp; + +} TAPI_APP_DATA, FAR *LPTAPI_APP_DATA; + + +char far *gaFuncNames[] = +{ + "lineAccept", + "lineAddProvider", + "lineAddToConference", + "lineAnswer", + "lineBlindTransfer", + "lineClose", + "lineCompleteCall", + "lineCompleteTransfer", + "lineConfigDialog", + "lineConfigDialogEdit", + "lineConfigProvider", + "lineDeallocateCall", + "lineDevSpecific", + "lineDevSpecificFeature", + "lineDial", + "lineDrop", + "lineForward", + "lineGatherDigits", + "lineGenerateDigits", + "lineGenerateTone", + "lineGetAddressCaps", + "lineGetAddressID", + "lineGetAddressStatus", + "lineGetAppPriority", + "lineGetCallInfo", + "lineGetCallStatus", + "lineGetConfRelatedCalls", + "lineGetCountry", + "lineGetDevCaps", + "lineGetDevConfig", + "lineGetIcon", + "lineGetID", + "lineGetLineDevStatus", + "lineGetNewCalls", + "lineGetNumRings", + "lineGetProviderList", + "lineGetRequest", + "lineGetStatusMessages", + "lineGetTranslateCaps", + "lineHandoff", + "lineHold", + "lineInitialize", + "lineMakeCall", + "lineMonitorDigits", + "lineMonitorMedia", + "lineMonitorTones", + "lineNegotiateAPIVersion", + "lineNegotiateExtVersion", + "lineOpen", + "linePark", + "linePickup", + "linePrepareAddToConference", + "lineRedirect", + "lineRegisterRequestRecipient", + "lineReleaseUserUserInfo", + "lineRemoveFromConference", + "lineRemoveProvider", + "lineSecureCall", + "lineSendUserUserInfo", + "lineSetAppPriority", + "lineSetAppSpecific", + "lineSetCallParams", + "lineSetCallPrivilege", + "lineSetCurrentLocation", + "lineSetDevConfig", + "lineSetMediaControl", + "lineSetMediaMode", + "lineSetNumRings", + "lineSetStatusMessages", + "lineSetTerminal", + "lineSetTollList", + "lineSetupConference", + "lineSetupTransfer", + "lineShutdown", + "lineSwapHold", + "lineTranslateAddress", + "lineTranslateDialog", + "lineUncompleteCall", + "lineUnhold", + "lineUnpark", + + "phoneClose", + "phoneConfigDialog", + "phoneDevSpecific", + "phoneGetButtonInfo", + "phoneGetData", + "phoneGetDevCaps", + "phoneGetDisplay", + "phoneGetGain", + "phoneGetHookSwitch", + "phoneGetID", + "phoneGetIcon", + "phoneGetLamp", + "phoneGetRing", + "phoneGetStatus", + "phoneGetStatusMessages", + "phoneGetVolume", + "phoneInitialize", + "phoneOpen", + "phoneNegotiateAPIVersion", + "phoneNegotiateExtVersion", + "phoneSetButtonInfo", + "phoneSetData", + "phoneSetDisplay", + "phoneSetGain", + "phoneSetHookSwitch", + "phoneSetLamp", + "phoneSetRing", + "phoneSetStatusMessages", + "phoneSetVolume", + "phoneShutdown", + + "tapiGetLocationInfo", + "tapiRequestDrop", + "tapiRequestMakeCall", + "tapiRequestMediaCall", + + "GetTapi16CallbackMsg", + "LOpenDialAsst", + "LAddrParamsInited" +}; + + +DWORD ghLib; +HINSTANCE ghInst; +MYPROC gaProcs[NUM_TAPI32_PROCS]; + +LRESULT +CALLBACK +Tapi16HiddenWndProc( + HWND hwnd, + UINT msg, + WPARAM wParam, + LPARAM lParam + ); + +#if CHICOBUILD +DWORD +FAR +PASCAL +LoadLibraryEx32W( + LPCSTR, + DWORD, + DWORD + ); + +BOOL +FAR +PASCAL +FreeLibrary32W( + DWORD + ); + +DWORD +FAR +PASCAL +GetProcAddress32W( + DWORD, + LPCSTR + ); + +DWORD +FAR +PASCAL +CallProc32W( + DWORD, + LPVOID, + DWORD, + DWORD + ); +#endif + + +PFNCALLPROC1 pfnCallProc1 = (PFNCALLPROC1) CallProc32W; +PFNCALLPROC2 pfnCallProc2 = (PFNCALLPROC2) CallProc32W; +PFNCALLPROC3 pfnCallProc3 = (PFNCALLPROC3) CallProc32W; +PFNCALLPROC4 pfnCallProc4 = (PFNCALLPROC4) CallProc32W; +PFNCALLPROC5 pfnCallProc5 = (PFNCALLPROC5) CallProc32W; +PFNCALLPROC6 pfnCallProc6 = (PFNCALLPROC6) CallProc32W; +PFNCALLPROC7 pfnCallProc7 = (PFNCALLPROC7) CallProc32W; +PFNCALLPROC8 pfnCallProc8 = (PFNCALLPROC8) CallProc32W; +PFNCALLPROC9 pfnCallProc9 = (PFNCALLPROC9) CallProc32W; +PFNCALLPROC10 pfnCallProc10 = (PFNCALLPROC10) CallProc32W; +PFNCALLPROC11 pfnCallProc11 = (PFNCALLPROC11) CallProc32W; +PFNCALLPROC12 pfnCallProc12 = (PFNCALLPROC12) CallProc32W; |