/*++ Copyright (c) 1995 Microsoft Corporation Module Name: tcore.h Abstract: This module contains the prototypes and data type definitions used by the core dll that wraps around TAPI. Author: Oliver Wallace (OliverW) 13-July-1995 Revision History: --*/ #ifndef TAPICORE_H #define TAPICORE_H #include "windows.h" #include "tapi.h" #include "trapper.h" #include "vars.h" #include "devspec.h" // Macro definitions #define TapiLogDetail (* ((LOGPROC) GetLogProc())) #define MultipleBitsSetInDWORD(dw) (((DWORD) dw) & ((DWORD) dw - 1)) #define TAPI_LINEMEDIAMODE_ALL (LINEMEDIAMODE_UNKNOWN | \ LINEMEDIAMODE_INTERACTIVEVOICE | \ LINEMEDIAMODE_AUTOMATEDVOICE | \ LINEMEDIAMODE_DATAMODEM | \ LINEMEDIAMODE_G3FAX | \ LINEMEDIAMODE_TDD | \ LINEMEDIAMODE_G4FAX | \ LINEMEDIAMODE_DIGITALDATA | \ LINEMEDIAMODE_TELETEX | \ LINEMEDIAMODE_VIDEOTEX | \ LINEMEDIAMODE_TELEX | \ LINEMEDIAMODE_MIXED | \ LINEMEDIAMODE_ADSI | \ LINEMEDIAMODE_VOICEVIEW ) typedef enum { lAccept, #if TAPI_1_1 lAddProvider, #endif lAddToConference, lAnswer, lBlindTransfer, lClose, lCompleteCall, lCompleteTransfer, lConfigDialog, #if TAPI_1_1 lConfigDialogEdit, lConfigProvider, #endif lDeallocateCall, lDevSpecific, lDevSpecificFeature, lDial, lDrop, lForward, lGatherDigits, lGenerateDigits, lGenerateTone, lGetAddressCaps, lGetAddressID, lGetAddressStatus, #if TAPI_1_1 lGetAppPriority, #endif lGetCallInfo, lGetCallStatus, lGetConfRelatedCalls, #if TAPI_1_1 lGetCountry, #endif lGetDevCaps, lGetDevConfig, lGetIcon, lGetID, lGetLineDevStatus, lGetNewCalls, lGetNumRings, #if TAPI_1_1 lGetProviderList, #endif lGetRequest, lGetStatusMessages, lGetTranslateCaps, lHandoff, lHold, lInitialize, lMakeCall, lMonitorDigits, lMonitorMedia, lMonitorTones, lNegotiateAPIVersion, lNegotiateExtVersion, lOpen, lPark, lPickup, lPrepareAddToConference, lRedirect, lRegisterRequestRecipient, #if TAPI_1_1 lReleaseUserUserInfo, #endif lRemoveFromConference, #if TAPI_1_1 lRemoveProvider, #endif lSecureCall, lSendUserUserInfo, #if TAPI_1_1 lSetAppPriority, #endif lSetAppSpecific, lSetCallParams, lSetCallPrivilege, lSetCurrentLocation, lSetDevConfig, lSetMediaControl, lSetMediaMode, lSetNumRings, lSetStatusMessages, lSetTerminal, lSetTollList, lSetupConference, lSetupTransfer, lShutdown, lSwapHold, lTranslateAddress, #if TAPI_1_1 lTranslateDialog, #endif lUncompleteCall, lUnhold, lUnpark, pClose, pConfigDialog, pDevSpecific, pGetButtonInfo, pGetData, pGetDevCaps, pGetDisplay, pGetGain, pGetHookSwitch, pGetIcon, pGetID, pGetLamp, pGetRing, pGetStatus, pGetStatusMessages, pGetVolume, pInitialize, pOpen, pNegotiateAPIVersion, pNegotiateExtVersion, pSetButtonInfo, pSetData, pSetDisplay, pSetGain, pSetHookSwitch, pSetLamp, pSetRing, pSetStatusMessages, pSetVolume, pShutdown, tGetLocationInfo, tRequestDrop, tRequestMakeCall, tRequestMediaCall, #if TAPI_2_0 lAgentSpecific, lGetAgentCaps, lGetAgentActivityList, lGetAgentGroupList, lGetAgentStatus, lProxyMessage, lProxyResponse, lSetAgentActivity, lSetAgentGroup, lSetAgentState, lSetCallData, lSetCallQualityOfService, lSetCallTreatment, lSetLineDevStatus, lInitializeEx, lGetMessage, pInitializeEx, pGetMessage, #endif } FUNCINDEX; // Flags used for calling sequence of APIs in DoTapiLineFuncs // and DoTapiPhoneFuncs #define LINITIALIZE 0x00000001 #define LINITIALIZEEX 0X00000002 #define LNEGOTIATEAPIVERSION 0x00000004 #define LGETDEVCAPS 0x00000008 #define LOPEN 0x00000010 #define LMAKECALL 0x00000020 #define LDROP 0x00000040 #define LDEALLOCATECALL 0x00000080 #define LCLOSE 0x00000100 #define LSHUTDOWN 0x00000200 #if TAPI_2_0 #define LAST_LINEERR LINEERR_DIALVOICEDETECT #else #define LAST_LINEERR LINEERR_NOMULTIPLEINSTANCE #endif #define LAST_PHONEERR PHONEERR_REINIT #define LAST_TAPIERR TAPIERR_INVALPOINTER #define TAPI_VERSION1_0 0x10003 #define TAPI_VERSION1_4 0x10004 #define TAPI_VERSION2_0 0x20000 #if TAPI_2_0 #define LAST_TAPIMSG 26L #else #define LAST_TAPIMSG 20L #endif #define TAPISUCCESS 0 // Defines for Debug levels #define DBUG_SHOW_FAILURE 0 #define DBUG_SHOW_PASS 1 #define DBUG_SHOW_SUCCESS 3 #define DBUG_SHOW_DETAIL 4 #define DBUG_SHOW_ENTER_EXIT 6 #define DBUG_SHOW_PARAMS 9 // values for masking all messages #define LINEDEVSTATE_NONE 0x00000000 #define LINEADDRESSSTATE_NONE 0x00000000 // API and extension version values #define LOW_APIVERSION 0x10003 #define HIGH_APIVERSION 0x20000 #define TOOLOW_APIVERSION 0x10002 #define TOOHIGH_APIVERSION 0x20001 #define WAYTOOHIGH_APIVERSION 0xFFFFFFFF // these values aren't really good and bad yet // support needs to be in SP for strict extension version checking #define GOOD_EXTVERSION 0x10000000 #define BAD_EXTVERSION 0xFFFFFFFF // dw constants #define DWMINUSONE 0xFFFFFFFF #define DWMAXPOSVALUE 0x7FFFFFFF #define ONE_K 1024 #define TWO_K 2048 #define THREE_K 3072 // Bit flags to determine which msg params should be checked #define TAPIMSG_HDEVCALL 0x00000001 #define TAPIMSG_DWMSG 0x00000002 #define TAPIMSG_DWCALLBACKINST 0x00000004 #define TAPIMSG_DWPARAM1 0x00000008 #define TAPIMSG_DWPARAM2 0x00000010 #define TAPIMSG_DWPARAM3 0x00000020 #define TAPIMSG_ALL 0x0000003F // Structure used to store and retrieve the last TAPI error code, which // TAPI function was called, and the expected error code. typedef struct TAPIRESULTTAG { LONG lExpected; LONG lActual; FUNCINDEX eTapiFunc; } TAPIRESULT, FAR* LPTAPIRESULT; // Heap structure for quicker testing typedef struct TESTHEAPINFOTAG { LPVOID lpHeap; DWORD dwFreeOffset; } TESTHEAPINFO, FAR* LPTESTHEAPINFO; #define TESTHEAPSIZE 16384 // Data structure used to hold test values for TAPI line interface tests typedef struct TAPILINETESTINFOTAG { // Fields directly used as parameters to API calls during testing BOOL fCompletionModeSet; LPHLINEAPP lphLineApp; LPHLINE lphLine; HINSTANCE hInstance; LINECALLBACK lpfnCallback; LPDWORD lpdwNumDevs; HANDLE hwndOwner; LPHCALL lphCall; LPHCALL lphConfCall; LPHCALL lphConsultCall; DWORD dwCountryCode; DWORD dwCountryID; DWORD dwLocation; DWORD dwTollListOption; DWORD dwTerminalModes; DWORD dwTerminalID; DWORD dwTranslateOptions; DWORD dwCard; LPDWORD lpdwLineStates; LPDWORD lpdwAddressStates; LPDWORD lpdwCompletionID; LPVOID lpParams; DWORD dwDeviceID; LPDWORD lpdwAddressID; DWORD dwAddressID; DWORD dwAddressMode; DWORD dwAPILowVersion; DWORD dwAPIHighVersion; DWORD dwExtLowVersion; DWORD dwExtHighVersion; LPDWORD lpdwAPIVersion; LPDWORD lpdwExtVersion; LPLINEEXTENSIONID lpExtID; LINEEXTENSIONID ExtIDZero; LPVARSTRING lpExtensionName; #ifdef WUNICODE LPWSTR lpwszMediaExtName; #else LPSTR lpszMediaExtName; #endif DWORD dwCallbackInstance; DWORD dwMediaModes; DWORD dwMediaMode; DWORD dwRequestMode; DWORD dwPriority; DWORD dwPrivileges; DWORD dwCallPrivilege; DWORD dwSelect; DWORD dwSize; DWORD dwBearerMode; DWORD dwMinRate; DWORD dwMaxRate; DWORD dwLineStates; DWORD dwAddressStates; DWORD dwCompletionID; DWORD dwCompletionMode; DWORD dwTransferMode; DWORD dwMessageID; LPDWORD lpdwNumRings; DWORD dwPermanentProviderID; LPDWORD lpdwPermanentProviderID; DWORD dwAppSpecific; DWORD dwFeature; DWORD bAllAddresses; DWORD dwNumParties; DWORD dwNumRingsNoAnswer; LPDWORD lpdwPriority; DWORD dwParkMode; LPVARSTRING lpNonDirAddress; #ifdef WUNICODE LPWSTR lpwszDirAddress; LPWSTR lpwszGroupID; LPWSTR lpwsDigits; LPWSTR lpwszTerminationDigits; LPWSTR lpwszDigits; #else LPSTR lpszDirAddress; LPSTR lpszGroupID; LPSTR lpsDigits; LPSTR lpszTerminationDigits; LPSTR lpszDigits; #endif DWORD dwNumDigits; DWORD dwFirstDigitTimeout; DWORD dwInterDigitTimeout; DWORD dwDigitModes; DWORD dwDigitMode; DWORD dwDuration; DWORD dwToneMode; DWORD dwNumTones; DWORD dwNumEntries; DWORD dwDigitNumEntries; DWORD dwMediaNumEntries; DWORD dwToneNumEntries; DWORD dwCallStateNumEntries; LPLINEMEDIACONTROLDIGIT lpMCDigitList; LPLINEMEDIACONTROLMEDIA lpMCMediaList; LPLINEMEDIACONTROLTONE lpMCToneList; LPLINEMEDIACONTROLCALLSTATE lpMCCallStateList; LPLINEMONITORTONE lpToneList; LPLINEGENERATETONE lpTones; DWORD dwRegistrationInstance; DWORD bEnable; LPLINEDEVCAPS lpLineDevCaps; LPLINEDEVSTATUS lpLineDevStatus; LPLINEADDRESSCAPS lpLineAddressCaps; LPLINEADDRESSSTATUS lpLineAddressStatus; LPLINECALLPARAMS lpCallParams; LPLINECALLSTATUS lpCallStatus; LPLINECALLINFO lpCallInfo; LPLINECALLLIST lpCallList; LPLINECOUNTRYLIST lpLineCountryList; LPLINEFORWARDLIST lpForwardList; LPHICON lphIcon; LPLINEPROVIDERLIST lpProviderList; LPLINETRANSLATECAPS lpTranslateCaps; LPLINETRANSLATEOUTPUT lpTranslateOutput; LPLINEDIALPARAMS lpDialParams; LPVARSTRING lpDeviceConfig; LPVOID lpDeviceConfigIn; LPVARSTRING lpDeviceConfigOut; VARSTRING DeviceID; LPVARSTRING lpDeviceID; #ifdef WUNICODE LPWSTR lpwsztapiAppName; LPWSTR lpwszAppFilename; LPWSTR lpwszFileName; LPWSTR lpwsAddress; LPWSTR lpwszAddressIn; LPWSTR lpwszDeviceClass; LPWSTR lpwszDestAddress; LPWSTR lpwszProviderFilename; #else LPSTR lpsztapiAppName; LPSTR lpszAppFilename; LPSTR lpszFileName; LPSTR lpsAddress; LPSTR lpszAddressIn; LPSTR lpszDeviceClass; LPSTR lpszDestAddress; LPSTR lpszProviderFilename; #endif LPSTR lpszAppName; LPSTR lpsUserUserInfo; LPVOID lpRequestBuffer; // Fields used to back up data during testing LINECALLBACK lpfnCallback_Orig; HLINEAPP hLineApp_Orig; HINSTANCE hInstance_Orig; HLINE hLine_Orig; HCALL hCall_Orig; DWORD dwCountryCode_Orig; DWORD dwDeviceID_Orig; #ifdef WUNICODE LPWSTR lpwszDeviceClass_Orig; #else LPSTR lpszDeviceClass_Orig; #endif DWORD dwAPIVersion_Orig; DWORD dwExtVersion_Orig; DWORD dwMediaModes_Orig; DWORD dwPrivileges_Orig; DWORD dwNumDevs_Orig; DWORD dwNumRings_Orig; DWORD dwAddressID_Orig; DWORD dwSelect_Orig; DWORD dwSize_Orig; DWORD dwLineStates_Orig; DWORD dwAddressStates_Orig; VARSTRING DeviceID_Orig; // Fields used to store information used during the tests //#ifdef WUNICODE // WCHAR wszAppName[40]; //#else CHAR szAppName[40]; // #endif CHAR szTestFunc[40]; CHAR szTestStepDesc[80]; HLINEAPP hLineApp1; HLINEAPP hLineApp2; HLINEAPP hLineApp3; HLINE hLine1; HLINE hLine2; HLINE hLine3; HCALL hCall1; HCALL hCall2; HCALL hCall3; HCALL hConfCall1; HCALL hConsultCall1; HCALL hActiveCall; HCALL hHeldCall; HICON hIcon; DWORD dwNumDevs; DWORD dwNumRings; DWORD dwAPIVersion; DWORD dwExtVersion; LINEDEVCAPS LineDevCaps; LINEDEVSTATUS LineDevStatus; LINEADDRESSCAPS LineAddressCaps; LINEADDRESSSTATUS LineAddressStatus; LINECALLPARAMS CallParams; LINECALLSTATUS CallStatus; LINEEXTENSIONID ExtID; #ifdef WUNICODE LPWSTR lpwszCountryCode; LPWSTR lpwszCityCode; LPWSTR lpwszCalledParty; LPWSTR lpwszComment; LPWSTR lpwszDeviceID; #else LPSTR lpszCountryCode; LPSTR lpszCityCode; LPSTR lpszCalledParty; LPSTR lpszComment; LPSTR lpszDeviceID; #endif HWND hwnd; WPARAM wRequestID; DWORD dwSecure; #if TAPI_2_0 DWORD dwAgentExtensionIDIndex; DWORD dwAppAPIVersion; LPLINEAGENTCAPS lpAgentCaps; LINEAGENTCAPS AgentCaps; LPLINEAGENTACTIVITYLIST lpAgentActivityList; LINEAGENTACTIVITYLIST AgentActivityList; LPLINEAGENTGROUPLIST lpAgentGroupList; LINEAGENTGROUPLIST AgentGroupList; LPLINEAGENTSTATUS lpAgentStatus; LINEAGENTSTATUS AgentStatus; DWORD dwMsg; DWORD dwParam1; DWORD dwParam2; DWORD dwParam3; LPLINEPROXYREQUEST lpProxyRequest; LINEPROXYREQUEST ProxyRequest; DWORD dwResult; DWORD dwActivityID; DWORD dwAgentState; DWORD dwNextAgentState; LPVOID lpCallData; LPVOID lpSendingFlowspec; DWORD dwSendingFlowspecSize; LPVOID lpReceivingFlowspec; DWORD dwReceivingFlowspecSize; DWORD dwTreatment; DWORD dwStatusToChange; DWORD fStatus; #ifdef WUNICODE LPWSTR lpwszFriendlyAppName; #else LPSTR lpszFriendlyAppName; #endif LPLINEINITIALIZEEXPARAMS lpLineInitializeExParams; LPLINEMESSAGE lpMessage; DWORD dwTimeout; #endif } TAPILINETESTINFO, FAR* LPTAPILINETESTINFO; typedef struct TAPIPHONETESTINFOTAG { BOOL fCompletionModeSet; LPHPHONEAPP lphPhoneApp; LPHPHONE lphPhone; HINSTANCE hInstance; LPDWORD lpdwAPIVersion; LPDWORD lpdwExtVersion; LPDWORD lpdwGain; LPDWORD lpdwHookSwitchDevs; LPDWORD lpdwLampMode; LPDWORD lpdwRingMode; LPDWORD lpdwVolume; LPDWORD lpdwPhoneStates; LPDWORD lpdwButtonModes; LPDWORD lpdwButtonStates; LPDWORD lpdwNumDevs; LPVOID lpParams; LPPHONEBUTTONINFO lpButtonInfo; LPVOID lpData; LPPHONECAPS lpPhoneCaps; LPVARSTRING lpDisplay; LPHICON lphIcon; LPVARSTRING lpDeviceID; #ifdef WUNICODE LPWSTR lpwszDeviceClass; #else LPSTR lpszDeviceClass; #endif LPPHONESTATUS lpPhoneStatus; PHONECALLBACK lpfnCallback; /* #ifdef WUNICODE LPWSTR lpwszAppName; #else */ LPSTR lpszAppName; //#endif LPPHONEEXTENSIONID lpExtensionID; LPSTR lpsDisplay; DWORD dwDeviceID; DWORD dwSize; DWORD dwButtonLampID; DWORD dwDataID; DWORD dwAPILowVersion; DWORD dwAPIHighVersion; DWORD dwExtLowVersion; DWORD dwExtHighVersion; DWORD dwCallbackInstance; DWORD dwPrivilege; DWORD dwRow; DWORD dwColumn; HPHONEAPP hPhoneApp1; HPHONEAPP hPhoneApp2; HPHONEAPP hPhoneApp3; HPHONE hPhone1; HPHONE hPhone2; HPHONE hPhone3; DWORD dwAPIVersion; DWORD dwExtVersion; DWORD dwGain; DWORD dwHookSwitchDev; DWORD dwHookSwitchDevs; DWORD dwHookSwitchMode; DWORD dwLampMode; DWORD dwRingMode; DWORD dwVolume; DWORD dwPhoneStates; DWORD dwButtonModes; DWORD dwButtonStates; DWORD dwNumDevs; HICON hIcon; HWND hwndOwner; PHONEEXTENSIONID ExtensionID; VARSTRING DeviceID; HPHONEAPP hPhoneApp_Orig; HPHONE hPhone_Orig; HINSTANCE hInstance_Orig; PHONECALLBACK lpfnCallback_Orig; DWORD dwDeviceID_Orig; DWORD dwSize_Orig; DWORD dwButtonLampID_Orig; DWORD dwDataID_Orig; DWORD dwAPIVersion_Orig; DWORD dwExtVersion_Orig; DWORD dwGain_Orig; DWORD dwHookSwitchDev_Orig; DWORD dwHookSwitchDevs_Orig; DWORD dwHookSwitchMode_Orig; DWORD dwLampMode_Orig; DWORD dwRingMode_Orig; DWORD dwVolume_Orig; DWORD dwPhoneStates_Orig; DWORD dwButtonModes_Orig; DWORD dwButtonStates_Orig; DWORD dwCallbackInstance_Orig; DWORD dwPrivilege_Orig; DWORD dwRow_Orig; DWORD dwColumn_Orig; HWND hwndOwner_Orig; #if TAPI_2_0 #ifdef WUNICODE LPWSTR lpwszFriendlyAppName; #else LPSTR lpszFriendlyAppName; #endif LPPHONEINITIALIZEEXPARAMS lpPhoneInitializeExParams; LPPHONEMESSAGE lpMessage; DWORD dwTimeout; #endif } TAPIPHONETESTINFO, FAR* LPTAPIPHONETESTINFO; // typedefs for Test(In)ValidBitFlags functions typedef enum BITFIELDSIZETAG { FIELDSIZE_16, FIELDSIZE_24, FIELDSIZE_32, } BITFIELDSIZE; typedef enum BITFIELDTYPETAG { FIELDTYPE_MUTEX, FIELDTYPE_UNION, FIELDTYPE_NA } BITFIELDTYPE; /* // Typedef for pointer to sync line test function typedef BOOL TAPILINETESTFUNC( LPTAPILINETESTINFO, LONG ); typedef TAPILINETESTFUNC FAR *LPFN_TAPILINETESTFUNC; // Typedef for pointer to sync phone test function typedef BOOL TAPIPHONETESTFUNCA( LPTAPIPHONETESTINFO, LONG ); typedef TAPIPHONETESTFUNC FAR *LPFN_TAPIPHONETESTFUNC; */ // Typedef for pointer to sync line test function typedef BOOL TAPILINETESTFUNC( LPTAPILINETESTINFO, LONG ); typedef TAPILINETESTFUNC FAR *LPFN_TAPILINETESTFUNC; // Typedef for pointer to sync phone test function typedef BOOL TAPIPHONETESTFUNC( LPTAPIPHONETESTINFO, LONG ); typedef TAPIPHONETESTFUNC FAR *LPFN_TAPIPHONETESTFUNC; // Typedef for pointer to Async line test function typedef BOOL TAPILINETESTFUNCASY( LPTAPILINETESTINFO, LONG, BOOL ); typedef TAPILINETESTFUNCASY FAR *LPFN_TAPILINETESTFUNCASY; // Typedef for pointer to sync phone test function typedef BOOL TAPIPHONETESTFUNCASY( LPTAPIPHONETESTINFO, LONG, BOOL ); typedef TAPIPHONETESTFUNCASY FAR *LPFN_TAPIPHONETESTFUNCASY; // Array containing list of expected asynchronous request messages typedef struct TAPIMSGTAG { DWORD hDevCall; DWORD dwMsg; DWORD dwCallbackInstance; DWORD dwParam1; DWORD dwParam2; DWORD dwParam3; DWORD dwFlags; // flags showing which params are important struct TAPIMSGTAG * lpNext; // pointer to next msg in the list } TAPIMSG, FAR* LPTAPIMSG; // Structure used to keep track of expected TAPI messages typedef struct CALLBACKPARAMSTAG { LPTAPIMSG lpReceivedMsg; // last received message params LPTAPIMSG lpExpTapiMsgs; // linked list storing the expected msgs LPTAPIMSG lpRecTapiMsgs; // linked list storing the received msgs LPTAPIMSG lpRecTapiMsgTail; // pointer to the last rec msg in the list // Since received messages are appended to // the linked list to preserve the order, // it's more efficient to use a tail pointer UINT uTimerID; // store timerID for msg timeouts BOOL fCallbackFatalError; // Reports fatal msg errors BOOL fMsgTimeout; // Did a timeout occur in msg loop? } CALLBACKPARAMS, FAR* LPCALLBACKPARAMS; // Structure used to store the test resources (async message array, // line test info, phone test info, test heap, last tapi call result, // and log function pointer) typedef struct TESTRESOURCESTAG { LPTAPILINETESTINFO lpTapiLineTestInfo; LPTAPIPHONETESTINFO lpTapiPhoneTestInfo; LOGPROC lpfnLogProc; LPCALLBACKPARAMS lpCallbackParams; LPTESTHEAPINFO lpTestHeapInfo; LPTAPIRESULT lpLastTapiResult; } TESTRESOURCES, FAR* LPTESTRESOURCES; BOOL WINAPI TcoreSuiteInit( LOGPROC pfnLog ); BOOL WINAPI TcoreSuiteShutdown( void ); BOOL WINAPI TcoreSuiteAbout( HWND hwndOwner ); BOOL WINAPI TcoreSuiteConfig( HWND hwndOwner ); // Functions used to manipulate the message array // WaitForAllMessages() enters a message loop until all of the messages in // the expected message array have been received. The function returns // a BOOL indicating whether all of the messages were successfully received. // If an asynchronous reply message indicates an unexpected failure, then // this function will return FALSE. // // Note: This function will not return until all expected messages have // been received or a timeout occurs. BOOL WINAPI WaitForAllMessages(); BOOL WINAPI WaitForMessage( LPTAPIMSG lExpectedMsg ); HLOCAL WINAPI ITAlloc( size_t size ); HLOCAL WINAPI ITFree( LPVOID lpvMem ); DWORD WINAPI ITSize( LPVOID lpvMem ); BOOL ProcessAsyncFunc( LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lActual, LONG lExpected ); BOOL ProcessAsyncPhoneAPI( LPTAPIPHONETESTINFO lpTapiPhoneTestInfo, LONG lActual, LONG lExpected ); BOOL CheckSyncPhoneResult( LPTAPIPHONETESTINFO lpTapiPhoneTestInfo, LONG lActual, LONG lExpected ); BOOL CheckSyncTapiResult( LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lActual, LONG lExpected ); BOOL SyncCheckResult( LPTAPILINETESTINFO lpTapiLineTestInfo, LONG lActual, LONG lExpected ); VOID WINAPI TapiLineTestInit(); VOID WINAPI TapiPhoneTestInit(); // AddMessageByStruct() takes the expected message parameters and adds the // expected message information to the end of the active elements in // the message list stored in the test resources structure. If // the lpCallbackParams pointer is NULL, // the message information will not be added to the list and the // function will return FALSE, otherwise AddMessageByStruct() will // return TRUE. LPTAPIMSG WINAPI AddMessageByStruct( LPTAPIMSG lpMsg ); // AddReceivedMessageByStruct() takes the expected message parameters // and adds the received message information to the end of the // the received message list stored in the test resources structure. If // the lpCallbackParams pointer is NULL, // the message information will not be added to the list and the // function will return FALSE, otherwise AddMessageByStruct() will // return TRUE. LPTAPIMSG WINAPI AddReceivedMessageByStruct( LPTAPIMSG lpMsg ); // AddMessage() takes the expected message parameters and adds the // expected message information to the end of the active elements in // the array. If the array is full or the lpTapiMsgArry pointer is NULL, // the message information will not be added to the array and the // function will return FALSE, otherwise AddMessage() will return TRUE. LPTAPIMSG WINAPI AddMessage( DWORD dwMsg, DWORD hDevice, DWORD dwCallbackInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, DWORD dwFlags ); // AddReceivedMessage() takes the received message parameters and adds the // received message information to the end of the active elements in // the array. If the lpCallbackParams pointer is NULL, // the message information will not be added to the list and the function // will return FALSE, otherwise AddReceivedMessage() will return TRUE. LPTAPIMSG WINAPI AddReceivedMessage( DWORD dwMsg, DWORD hDevice, DWORD dwCallbackInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, DWORD dwFlags ); // CheckReceivedMessage() searches the array of messages being waited on // and finds the message corresponding to the values in the TapiMsgParams // parameter. If none of the messages in the array match, then FALSE is // returned. If the message parameters do not match the expected message // parameters for corresponding IDs, then FALSE is returned. Otherwise, // the array element storing the expected message is marked as received, // nMsgsNotReceived is decremented, and TRUE is returned. BOOL CheckReceivedMessage( LPCALLBACKPARAMS lpCallbackParams, LPTAPIMSG lpReceivedMsg, LPDWORD lpdwFlags ); // IsTapiMsgInQ() searches a linked list of msgs for a match. // If lpTapiMsg is in the list pointed to by lpFirstTapiMsg, then // this function returns TRUE. Otherwise, FALSE is returned. BOOL IsTapiMsgInQ( LPTAPIMSG lpFirstTapiMsg, LPTAPIMSG lpTapiMsg ); // CopyTapiMsgParams() copies the message parameters into the // TAPIMSG structure pointed to by lpTapiMsg if lpTapiMsg is // not null. If lpTapiMsg is null, this function does nothing. VOID WINAPI CopyTapiMsgParams( LPTAPIMSG lpTapiMsg, DWORD hDevCall, DWORD dwCallbackInstance, DWORD dwMsg, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3, DWORD dwFlags ); // CompareTapiMsgs() compares two messages and returns TRUE if the messages // match. Otherwise FALSE is returned. This function only compares // parameters that are specified according to the set bit flags in the // dwFlags field of the expected message (lpExpectedMsg). BOOL WINAPI CompareTapiMsgs( LPTAPIMSG lpExpectedMsg, LPTAPIMSG lpReceivedMsg ); // This function returns the first available address that a test function // can use out of a thread local heap. If there is not enough room for // the LPVOID WINAPI AllocFromTestHeap( size_t NeededSize ); // FreeTestHeap() zeroes the bytes contained in the heap, and resets the // first available offset to 0. // // Note: The memory containing the heap is not free'd. VOID WINAPI FreeTestHeap(); // AllocTestResources() allocates the memory needed to store the fields // in the test resources structure. This function then sets the test // resources pointer as the value stored in thread local storage. VOID AllocTestResources(); // FreeTestResources() frees the memory used to store the fields in the // resources. This function does not free the test resources pointer. VOID FreeTestResources(); // GetTestHeapInfo returns the pointer to the test heap info structure // in the test resources stored in thread local storage. LPTESTHEAPINFO WINAPI GetTestHeapInfo(); // GetLineTestInfo returns the pointer to the line test info structure // in the test resources stored in thread local storage. LPTAPILINETESTINFO WINAPI GetLineTestInfo(); // GetPhoneTestInfo returns the pointer to the phone test info structure // in the test resources stored in thread local storage. LPTAPIPHONETESTINFO WINAPI GetPhoneTestInfo(); // GetCallbackParams returns the pointer to the structure used // to store information for processing TAPI messages. LPCALLBACKPARAMS WINAPI GetCallbackParams(); LOGPROC WINAPI GetLogProc(); VOID InitializeCallbackParams(); VOID WINAPI CopyTapiMsgs( LPTAPIMSG lpSrcMsg, LPTAPIMSG lpDestMsg ); VOID WINAPI RemoveReceivedMsgs( LPCALLBACKPARAMS lpCallbackParams ); VOID WINAPI RemoveExpectedMsgs( LPCALLBACKPARAMS lpCallbackParams ); VOID FreeTapiMsgList( LPTAPIMSG *lppTapiMsgList ); DWORD WINAPI CallbackParamsGetDevCallHandle( LPCALLBACKPARAMS lpCallbackParams, DWORD dwMsg ); BOOL WINAPI DoExtensionIDsMatch( LPLINEEXTENSIONID lpExtID1, LPLINEEXTENSIONID lpExtID2 ); VOID WINAPI OutputTAPIDebugInfo( int nLogLvl, LPSTR lpszDebugInfo ); VOID WINAPI ShowTapiMsgInfo( LPTAPIMSG lpMsg ); VOID WINAPI ShowExpectedMsgs( LPCALLBACKPARAMS lpCallbackParams ); VOID WINAPI ShowReceivedMsgs( LPCALLBACKPARAMS lpCallbackParams ); VOID WINAPI ShowTapiMsgList( LPTAPIMSG lpTapiMsg ); VOID WINAPI FreeTapiMsgList( LPTAPIMSG *lppMsg ); BOOL WINAPI GetVarField( LPVOID lpVarDataStructure, LPVOID lpVarField, DWORD dwVarFieldSize, DWORD dwVarFieldOffset ); BOOL WINAPI DoTapiLineFuncs( LPTAPILINETESTINFO lpTapiLineTestInfo, DWORD dwFunc ); VOID WINAPI GetLastTapiResult( LPTAPIRESULT lpTapiResult ); VOID SetLastTapiResult( FUNCINDEX eFuncIndex, LONG lActual, LONG lExpected ); // FindReceivedMsgs() will return the last received TAPI message // that matches the params in lpMatch if fFindMostRecent is false. // If fFindMostRecent is true, this function will return all received // messages in an allocated linked list stored in lppTapiMsg. // This function returns -1 if an allocation fails or an invalid // parameter is passed to it (e.g. lppTapiMsg or lpMatch is null). // Otherwise, the number of matches is returned. LONG WINAPI FindReceivedMsgs( LPTAPIMSG *lppTapiMsg, LPTAPIMSG lpMatch, DWORD fFindMostRecent ); #endif // TAPICORE_H