// unprocessed information from tapi.h: // #define DECLARE_OPAQUE32(name) struct name##__ { int unused; }; typedef const struct name##__ FAR* name // #define LAST_LINEREQUESTMODE LINEREQUESTMODE_MEDIACALL // #define LINEMAPPER 0xFFFFFFFF // #define TAPIERROR_FORMATMESSAGE(__ErrCode__) (((__ErrCode__) > 0xFFFF0000) ? ((__ErrCode__) & 0x0000FFFF) : (((__ErrCode__) & 0x10000000) ? ((__ErrCode__) - 0x90000000 + 0xF000) : ((__ErrCode__) - 0x80000000 + 0xE000))) // #define TAPIMAXAPPNAMESIZE 40L // #define TAPIMAXCALLEDPARTYSIZE 40L // #define TAPIMAXCOMMENTSIZE 80L // #define TAPIMAXDESTADDRESSSIZE 80L // #define TAPIMAXDEVICECLASSSIZE 40L // #define TAPIMAXDEVICEIDSIZE 40L // #define TAPI_REPLY WM_USER + 99 // #define lineAddProviderW lineAddProvider // #define lineBlindTransferW lineBlindTransfer // #define lineConfigDialogEditW lineConfigDialogEdit // #define lineDialW lineDial // #define lineForwardW lineForward // #define lineGenerateDigitsW lineGenerateDigits // #define lineGetAddressCapsW lineGetAddressCaps // #define lineGetAddressIDW lineGetAddressID // #define lineGetAddressStatusW lineGetAddressStatus // #define lineGetAppPriorityW lineGetAppPriority // #define lineGetCallInfoW lineGetCallInfo // #define lineGetDevCapsW lineGetDevCaps // #define lineGetDevConfigW lineGetDevConfig // #define lineGetIDW lineGetID // #define lineGetIconW lineGetIcon // #define lineGetProviderListW lineGetProviderList // #define lineGetTranslateCapsW lineGetTranslateCaps // #define lineHandoffW lineHandoff // #define lineInitializeExW lineInitializeEx // #define lineMakeCallW lineMakeCall // #define lineOpenW lineOpen // #define linePickupW linePickup // #define linePrepareAddToConferenceW linePrepareAddToConference // #define lineRedirectW lineRedirect // #define lineSetAppPriorityW lineSetAppPriority // #define lineSetDevConfigW lineSetDevConfig // #define lineSetTollListW lineSetTollList // #define lineSetupConferenceW lineSetupConference // #define lineSetupTransferW lineSetupTransfer // #define lineTranslateAddressW lineTranslateAddress // #define lineTranslateDialogW lineTranslateDialog // #define phoneConfigDialogW phoneConfigDialog // #define phoneGetDevCapsW phoneGetDevCaps // #define phoneGetIDW phoneGetID // #define phoneGetIconW phoneGetIcon // #define phoneGetStatusW phoneGetStatus // #define phoneInitializeExW phoneInitializeEx // typedef void (CALLBACK * LINECALLBACK)(DWORD hDevice, DWORD dwMessage, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3); // typedef void (CALLBACK * PHONECALLBACK)(DWORD hDevice, DWORD dwMessage, DWORD dwInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3); // // simple types: // HICON is resulting from: // phoneGetIcon : DWORD dwDeviceID, LPCWSTR lpszDeviceClass // lineGetIcon : DWORD dwDeviceID, LPCWSTR lpszDeviceClass // DWORD is resulting from: // phoneGetRing : HPHONE hPhone // phoneGetVolume : HPHONE hPhone, DWORD dwHookSwitchDev // phoneNegotiateExtVersion : HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion // lineInitialize : HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszAppName // phoneGetHookSwitch : HPHONE hPhone // lineGetAppPriority : LPCWSTR lpszAppFilename, DWORD dwMediaMode, DWORD dwRequestMode // phoneNegotiateAPIVersion : HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion // lineNegotiateExtVersion : HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtLowVersion, DWORD dwExtHighVersion // phoneInitializeEx : HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName // phoneGetGain : HPHONE hPhone, DWORD dwHookSwitchDev // phoneGetStatusMessages : HPHONE hPhone // lineGetAddressID : HLINE hLine, DWORD dwAddressMode, LPCWSTR lpsAddress, DWORD dwSize // lineGetNumRings : HLINE hLine, DWORD dwAddressID // lineGetStatusMessages : HLINE hLine // lineInitializeEx : HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName // lineAddProvider : LPCWSTR lpszProviderFilename, HWND hwndOwner // lineNegotiateAPIVersion : HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion // HLINEAPP is resulting from: // lineInitializeEx : HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName // lineInitialize : HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszAppName // HPHONE is resulting from: // phoneOpen : HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivilege // VOID is resulting from: // phoneDevSpecific : HPHONE hPhone, DWORD dwSize // lineDevSpecific : HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSize // HCALL is resulting from: // linePrepareAddToConference : HCALL hConfCall, LPLINECALLPARAMS lpCallParams // lineSetupTransfer : HCALL hCall, LPLINECALLPARAMS lpCallParams // linePickup : HLINE hLine, DWORD dwAddressID, LPCWSTR lpszDestAddress, LPCWSTR lpszGroupID // lineMakeCall : HLINE hLine, LPCWSTR lpszDestAddress, DWORD dwCountryCode, LPLINECALLPARAMS lpCallParams // lineSetupConference : HCALL hCall, HLINE hLine, DWORD dwNumParties, LPLINECALLPARAMS lpCallParams // lineForward : HLINE hLine, DWORD bAllAddresses, DWORD dwAddressID, LPLINEFORWARDLIST lpForwardList, DWORD dwNumRingsNoAnswer, LPLINECALLPARAMS lpCallParams // lineCompleteTransfer : HCALL hCall, HCALL hConsultCall, DWORD dwTransferMode // HLINE is resulting from: // lineOpen : HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, DWORD dwCallbackInstance, DWORD dwPrivileges, DWORD dwMediaModes, LPLINECALLPARAMS lpCallParams // HPHONEAPP is resulting from: // phoneInitializeEx : HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName #include #include #include "debug.h" #include "vectorutils.h" #include "stringutils.h" DWORD g_t0; std::string InitializeString(DWORD dw); std::string LineString(DWORD dw); std::string LineAddrCapFlagsString(DWORD dw); std::string LineAddressModeString(DWORD dw); std::string LineAddressSharingString(DWORD dw); std::string LineAddressStateString(DWORD dw); std::string LineAddressTypeString(DWORD dw); std::string LineAddrFeatureString(DWORD dw); std::string LineAgentFeatureString(DWORD dw); std::string LineAgentStateString(DWORD dw); std::string LineAgentStatusString(DWORD dw); std::string LineAnswerModeString(DWORD dw); std::string LineBearerModeString(DWORD dw); std::string LineBusyModeString(DWORD dw); std::string LineCallComplCondString(DWORD dw); std::string LineCallComplModeString(DWORD dw); std::string LineCallFeatureString(DWORD dw); std::string LineCallFeature2String(DWORD dw); std::string LineCallInfoStateString(DWORD dw); std::string LineCallOriginString(DWORD dw); std::string LineCallParamFlagsString(DWORD dw); std::string LineCallPartyIDString(DWORD dw); std::string LineCallPrivilegeString(DWORD dw); std::string LineCallReasonString(DWORD dw); std::string LineCallselectString(DWORD dw); std::string LineCallStateString(DWORD dw); std::string LineCallTreatmentString(DWORD dw); std::string LineCardOptionString(DWORD dw); std::string LineConnectedModeString(DWORD dw); std::string LineDevCapFlagsString(DWORD dw); std::string LineDevStateString(DWORD dw); std::string LineDevStatusFlagsString(DWORD dw); std::string LineDialToneModeString(DWORD dw); std::string LineDigitModeString(DWORD dw); std::string LineDisconnectModeString(DWORD dw); std::string LineErrString(DWORD dw); std::string LineFeatureString(DWORD dw); std::string LineForwardModeString(DWORD dw); std::string LineGatherTermString(DWORD dw); std::string LineGenerateTermString(DWORD dw); std::string LineInitializeExOptionString(DWORD dw); std::string LineLocationOptionString(DWORD dw); std::string LineMediaControlString(DWORD dw); std::string LineMediaModeString(DWORD dw); std::string LineOfferingModeString(DWORD dw); std::string LineOpenOptionString(DWORD dw); std::string LineParkModeString(DWORD dw); std::string LineProxyRequestString(DWORD dw); std::string LineRemoveFromConfString(DWORD dw); std::string LineRequestModeString(DWORD dw); std::string LineRoamModeString(DWORD dw); std::string LineSpecialInfoString(DWORD dw); std::string LineTermDevString(DWORD dw); std::string LineTermModeString(DWORD dw); std::string LineTermSharingString(DWORD dw); std::string LineTolllistOptionString(DWORD dw); std::string LineToneModeString(DWORD dw); std::string LineTransferModeString(DWORD dw); std::string LineTranslateOptionString(DWORD dw); std::string LineTranslateResultString(DWORD dw); std::string PhoneString(DWORD dw); std::string PhoneButtonFunctionString(DWORD dw); std::string PhoneButtonModeString(DWORD dw); std::string PhoneButtonStateString(DWORD dw); std::string PhoneErrString(DWORD dw); std::string PhoneFeatureString(DWORD dw); std::string PhoneHookSwitchDevString(DWORD dw); std::string PhoneHookSwitchModeString(DWORD dw); std::string PhoneInitializeexOptionString(DWORD dw); std::string PhoneLampModeString(DWORD dw); std::string PhonePrivilegeString(DWORD dw); std::string PhoneStateString(DWORD dw); std::string PhoneStatusFlagsString(DWORD dw); std::string StringFormatString(DWORD dw); std::string TapiErrString(DWORD dw); void log_tapi_linemediacontrolmedia(const LINEMEDIACONTROLMEDIA *p); void log_tapi_linemediacontroltone(const LINEMEDIACONTROLTONE *p); void log_tapi_linecountrylist(const LINECOUNTRYLIST *p); void log_tapi_linemediacontrolcallstate(const LINEMEDIACONTROLCALLSTATE *p); void log_tapi_lineforwardlist(const LINEFORWARDLIST *p); void log_tapi_linetermcaps(const LINETERMCAPS *p); void log_tapi_lineproviderentry(const LINEPROVIDERENTRY *p); void log_tapi_linecalltreatmententry(const LINECALLTREATMENTENTRY *p); void log_tapi_linecountryentry(const LINECOUNTRYENTRY *p); void log_tapi_linedialparams(const LINEDIALPARAMS *p); void log_tapi_lineforward(const LINEFORWARD *p); #ifdef _HAVE_PHONEBUTTONINFO void log_tapi_phonebuttoninfo(HPHONE hPhone, DWORD dwButtonLampID, const PHONEBUTTONINFO *p); #endif void log_tapi_linemediacontroldigit(const LINEMEDIACONTROLDIGIT *p); void log_tapi_linecardentry(const LINECARDENTRY *p); void log_tapi_linegeneratetone(const LINEGENERATETONE *p); void log_tapi_linecallparams(const LINECALLPARAMS *p); void log_tapi_linelocationentry(const LINELOCATIONENTRY *p); void log_tapi_linemonitortone(const LINEMONITORTONE *p); void log_tapi_linetranslateoutput(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCWSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, const LINETRANSLATEOUTPUT *p); void log_tapi_phoneextensionid(HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, const PHONEEXTENSIONID *p); void log_tapi_linemessage(HLINEAPP hLineApp, DWORD dwTimeout, const LINEMESSAGE *p); void log_tapi_linecallstatus(HCALL hCall, const LINECALLSTATUS *p); void log_tapi_lineaddressstatus(HLINE hLine, DWORD dwAddressID, const LINEADDRESSSTATUS *p); void log_tapi_phonestatus(HPHONE hPhone, const PHONESTATUS *p); void log_tapi_linetranslatecaps(HLINEAPP hLineApp, DWORD dwAPIVersion, const LINETRANSLATECAPS *p); void log_tapi_linedevstatus(HLINE hLine, const LINEDEVSTATUS *p); void log_tapi_phoneinitializeexparams(HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, const PHONEINITIALIZEEXPARAMS *p); void log_tapi_lineproviderlist(DWORD dwAPIVersion, const LINEPROVIDERLIST *p); void log_tapi_lineaddresscaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, const LINEADDRESSCAPS *p, DWORD sf); void log_tapi_linedevcaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, const LINEDEVCAPS *p); void log_tapi_lineinitializeexparams(HINSTANCE hInstance, LINECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, const LINEINITIALIZEEXPARAMS *p); void log_tapi_phonecaps(HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, const PHONECAPS *p); void log_tapi_phonemessage(HPHONEAPP hPhoneApp, DWORD dwTimeout, const PHONEMESSAGE *p); void log_tapi_linecallinfo(HCALL hCall, const LINECALLINFO *p); void log_tapi_linecalllist(HLINE hLine, DWORD dwAddressID, DWORD dwSelect, const LINECALLLIST *p); void log_tapi_lineextensionid(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, const LINEEXTENSIONID *p); void log_tapi_linegetid(HLINE hLine, DWORD dwAddressID, HCALL hCall, DWORD dwSelect, VARSTRING *p, LPCTSTR lpszDeviceClass); void FAR PASCAL phoneCallbackFunc(DWORD hDevice, DWORD dwMsg, DWORD dwCallbackInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3);; void ph_init_phone_api(HINSTANCE hInst, const TCHAR *appname); void ph_getstatusmsgs(); void ph_status(); void ph_gethookswitch(); void ph_getvolumes(); void ph_setvolumes(DWORD dwVolHeadset, DWORD dwVolHandset, DWORD dwVolSpeaker); void ph_close(); void FAR PASCAL phoneCallbackFunc(DWORD hDevice, DWORD dwMsg, DWORD dwCallbackInstance, DWORD dwParam1, DWORD dwParam2, DWORD dwParam3); void ph_dump_status(); void usage(); // enum decoder for INITIALIZE: 1 values std::string InitializeString(DWORD dw) { switch (dw) { case INITIALIZE_NEGOTIATION: return "NEGOTIATION"; default: return stringformat("INITIALIZE_%08lx", dw); } } // enum decoder for LINE: 20 values std::string LineString(DWORD dw) { switch (dw) { case LINE_ADDRESSSTATE: return "ADDRESSSTATE"; case LINE_CALLINFO: return "CALLINFO"; case LINE_CALLSTATE: return "CALLSTATE"; case LINE_CLOSE: return "CLOSE"; case LINE_DEVSPECIFIC: return "DEVSPECIFIC"; case LINE_DEVSPECIFICFEATURE: return "DEVSPECIFICFEATURE"; case LINE_GATHERDIGITS: return "GATHERDIGITS"; case LINE_GENERATE: return "GENERATE"; case LINE_LINEDEVSTATE: return "LINEDEVSTATE"; case LINE_MONITORDIGITS: return "MONITORDIGITS"; case LINE_MONITORMEDIA: return "MONITORMEDIA"; case LINE_MONITORTONE: return "MONITORTONE"; case LINE_REPLY: return "REPLY"; case LINE_REQUEST: return "REQUEST"; case LINE_CREATE: return "CREATE"; case LINE_AGENTSPECIFIC: return "AGENTSPECIFIC"; case LINE_AGENTSTATUS: return "AGENTSTATUS"; case LINE_APPNEWCALL: return "APPNEWCALL"; case LINE_PROXYREQUEST: return "PROXYREQUEST"; case LINE_REMOVE: return "REMOVE"; default: return stringformat("LINE_%08lx", dw); } } // bitmask decoder for LINEADDRCAPFLAGS: 30 values std::string LineAddrCapFlagsString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEADDRCAPFLAGS_FWDNUMRINGS) list.push_back("FWDNUMRINGS"); if (dw & LINEADDRCAPFLAGS_PICKUPGROUPID) list.push_back("PICKUPGROUPID"); if (dw & LINEADDRCAPFLAGS_SECURE) list.push_back("SECURE"); if (dw & LINEADDRCAPFLAGS_BLOCKIDDEFAULT) list.push_back("BLOCKIDDEFAULT"); if (dw & LINEADDRCAPFLAGS_BLOCKIDOVERRIDE) list.push_back("BLOCKIDOVERRIDE"); if (dw & LINEADDRCAPFLAGS_DIALED) list.push_back("DIALED"); if (dw & LINEADDRCAPFLAGS_ORIGOFFHOOK) list.push_back("ORIGOFFHOOK"); if (dw & LINEADDRCAPFLAGS_DESTOFFHOOK) list.push_back("DESTOFFHOOK"); if (dw & LINEADDRCAPFLAGS_FWDCONSULT) list.push_back("FWDCONSULT"); if (dw & LINEADDRCAPFLAGS_SETUPCONFNULL) list.push_back("SETUPCONFNULL"); if (dw & LINEADDRCAPFLAGS_AUTORECONNECT) list.push_back("AUTORECONNECT"); if (dw & LINEADDRCAPFLAGS_COMPLETIONID) list.push_back("COMPLETIONID"); if (dw & LINEADDRCAPFLAGS_TRANSFERHELD) list.push_back("TRANSFERHELD"); if (dw & LINEADDRCAPFLAGS_TRANSFERMAKE) list.push_back("TRANSFERMAKE"); if (dw & LINEADDRCAPFLAGS_CONFERENCEHELD) list.push_back("CONFERENCEHELD"); if (dw & LINEADDRCAPFLAGS_CONFERENCEMAKE) list.push_back("CONFERENCEMAKE"); if (dw & LINEADDRCAPFLAGS_PARTIALDIAL) list.push_back("PARTIALDIAL"); if (dw & LINEADDRCAPFLAGS_FWDSTATUSVALID) list.push_back("FWDSTATUSVALID"); if (dw & LINEADDRCAPFLAGS_FWDINTEXTADDR) list.push_back("FWDINTEXTADDR"); if (dw & LINEADDRCAPFLAGS_FWDBUSYNAADDR) list.push_back("FWDBUSYNAADDR"); if (dw & LINEADDRCAPFLAGS_ACCEPTTOALERT) list.push_back("ACCEPTTOALERT"); if (dw & LINEADDRCAPFLAGS_CONFDROP) list.push_back("CONFDROP"); if (dw & LINEADDRCAPFLAGS_PICKUPCALLWAIT) list.push_back("PICKUPCALLWAIT"); if (dw & LINEADDRCAPFLAGS_PREDICTIVEDIALER) list.push_back("PREDICTIVEDIALER"); if (dw & LINEADDRCAPFLAGS_QUEUE) list.push_back("QUEUE"); if (dw & LINEADDRCAPFLAGS_ROUTEPOINT) list.push_back("ROUTEPOINT"); if (dw & LINEADDRCAPFLAGS_HOLDMAKESNEW) list.push_back("HOLDMAKESNEW"); if (dw & LINEADDRCAPFLAGS_NOINTERNALCALLS) list.push_back("NOINTERNALCALLS"); if (dw & LINEADDRCAPFLAGS_NOEXTERNALCALLS) list.push_back("NOEXTERNALCALLS"); if (dw & LINEADDRCAPFLAGS_SETCALLINGID) list.push_back("SETCALLINGID"); DWORD dwKnown= LINEADDRCAPFLAGS_FWDNUMRINGS|LINEADDRCAPFLAGS_PICKUPGROUPID|LINEADDRCAPFLAGS_SECURE|LINEADDRCAPFLAGS_BLOCKIDDEFAULT|LINEADDRCAPFLAGS_BLOCKIDOVERRIDE|LINEADDRCAPFLAGS_DIALED|LINEADDRCAPFLAGS_ORIGOFFHOOK|LINEADDRCAPFLAGS_DESTOFFHOOK|LINEADDRCAPFLAGS_FWDCONSULT|LINEADDRCAPFLAGS_SETUPCONFNULL|LINEADDRCAPFLAGS_AUTORECONNECT|LINEADDRCAPFLAGS_COMPLETIONID|LINEADDRCAPFLAGS_TRANSFERHELD|LINEADDRCAPFLAGS_TRANSFERMAKE|LINEADDRCAPFLAGS_CONFERENCEHELD|LINEADDRCAPFLAGS_CONFERENCEMAKE|LINEADDRCAPFLAGS_PARTIALDIAL|LINEADDRCAPFLAGS_FWDSTATUSVALID|LINEADDRCAPFLAGS_FWDINTEXTADDR|LINEADDRCAPFLAGS_FWDBUSYNAADDR|LINEADDRCAPFLAGS_ACCEPTTOALERT|LINEADDRCAPFLAGS_CONFDROP|LINEADDRCAPFLAGS_PICKUPCALLWAIT|LINEADDRCAPFLAGS_PREDICTIVEDIALER|LINEADDRCAPFLAGS_QUEUE|LINEADDRCAPFLAGS_ROUTEPOINT|LINEADDRCAPFLAGS_HOLDMAKESNEW|LINEADDRCAPFLAGS_NOINTERNALCALLS|LINEADDRCAPFLAGS_NOEXTERNALCALLS|LINEADDRCAPFLAGS_SETCALLINGID; if (dw&~dwKnown) list.push_back(stringformat("LINEADDRCAPFLAGS_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEADDRESSMODE: 2 values std::string LineAddressModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEADDRESSMODE_ADDRESSID) list.push_back("ADDRESSID"); if (dw & LINEADDRESSMODE_DIALABLEADDR) list.push_back("DIALABLEADDR"); DWORD dwKnown= LINEADDRESSMODE_ADDRESSID|LINEADDRESSMODE_DIALABLEADDR; if (dw&~dwKnown) list.push_back(stringformat("LINEADDRESSMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEADDRESSSHARING: 5 values std::string LineAddressSharingString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEADDRESSSHARING_PRIVATE) list.push_back("PRIVATE"); if (dw & LINEADDRESSSHARING_BRIDGEDEXCL) list.push_back("BRIDGEDEXCL"); if (dw & LINEADDRESSSHARING_BRIDGEDNEW) list.push_back("BRIDGEDNEW"); if (dw & LINEADDRESSSHARING_BRIDGEDSHARED) list.push_back("BRIDGEDSHARED"); if (dw & LINEADDRESSSHARING_MONITORED) list.push_back("MONITORED"); DWORD dwKnown= LINEADDRESSSHARING_PRIVATE|LINEADDRESSSHARING_BRIDGEDEXCL|LINEADDRESSSHARING_BRIDGEDNEW|LINEADDRESSSHARING_BRIDGEDSHARED|LINEADDRESSSHARING_MONITORED; if (dw&~dwKnown) list.push_back(stringformat("LINEADDRESSSHARING_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEADDRESSSTATE: 9 values std::string LineAddressStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEADDRESSSTATE_OTHER) list.push_back("OTHER"); if (dw & LINEADDRESSSTATE_DEVSPECIFIC) list.push_back("DEVSPECIFIC"); if (dw & LINEADDRESSSTATE_INUSEZERO) list.push_back("INUSEZERO"); if (dw & LINEADDRESSSTATE_INUSEONE) list.push_back("INUSEONE"); if (dw & LINEADDRESSSTATE_INUSEMANY) list.push_back("INUSEMANY"); if (dw & LINEADDRESSSTATE_NUMCALLS) list.push_back("NUMCALLS"); if (dw & LINEADDRESSSTATE_FORWARD) list.push_back("FORWARD"); if (dw & LINEADDRESSSTATE_TERMINALS) list.push_back("TERMINALS"); if (dw & LINEADDRESSSTATE_CAPSCHANGE) list.push_back("CAPSCHANGE"); DWORD dwKnown= LINEADDRESSSTATE_OTHER|LINEADDRESSSTATE_DEVSPECIFIC|LINEADDRESSSTATE_INUSEZERO|LINEADDRESSSTATE_INUSEONE|LINEADDRESSSTATE_INUSEMANY|LINEADDRESSSTATE_NUMCALLS|LINEADDRESSSTATE_FORWARD|LINEADDRESSSTATE_TERMINALS|LINEADDRESSSTATE_CAPSCHANGE; if (dw&~dwKnown) list.push_back(stringformat("LINEADDRESSSTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEADDRESSTYPE: 5 values std::string LineAddressTypeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEADDRESSTYPE_PHONENUMBER) list.push_back("PHONENUMBER"); if (dw & LINEADDRESSTYPE_SDP) list.push_back("SDP"); if (dw & LINEADDRESSTYPE_EMAILNAME) list.push_back("EMAILNAME"); if (dw & LINEADDRESSTYPE_DOMAINNAME) list.push_back("DOMAINNAME"); if (dw & LINEADDRESSTYPE_IPADDRESS) list.push_back("IPADDRESS"); DWORD dwKnown= LINEADDRESSTYPE_PHONENUMBER|LINEADDRESSTYPE_SDP|LINEADDRESSTYPE_EMAILNAME|LINEADDRESSTYPE_DOMAINNAME|LINEADDRESSTYPE_IPADDRESS; if (dw&~dwKnown) list.push_back(stringformat("LINEADDRESSTYPE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEADDRFEATURE: 14 values std::string LineAddrFeatureString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEADDRFEATURE_FORWARD) list.push_back("FORWARD"); if (dw & LINEADDRFEATURE_MAKECALL) list.push_back("MAKECALL"); if (dw & LINEADDRFEATURE_PICKUP) list.push_back("PICKUP"); if (dw & LINEADDRFEATURE_SETMEDIACONTROL) list.push_back("SETMEDIACONTROL"); if (dw & LINEADDRFEATURE_SETTERMINAL) list.push_back("SETTERMINAL"); if (dw & LINEADDRFEATURE_SETUPCONF) list.push_back("SETUPCONF"); if (dw & LINEADDRFEATURE_UNCOMPLETECALL) list.push_back("UNCOMPLETECALL"); if (dw & LINEADDRFEATURE_UNPARK) list.push_back("UNPARK"); if (dw & LINEADDRFEATURE_PICKUPHELD) list.push_back("PICKUPHELD"); if (dw & LINEADDRFEATURE_PICKUPGROUP) list.push_back("PICKUPGROUP"); if (dw & LINEADDRFEATURE_PICKUPDIRECT) list.push_back("PICKUPDIRECT"); if (dw & LINEADDRFEATURE_PICKUPWAITING) list.push_back("PICKUPWAITING"); if (dw & LINEADDRFEATURE_FORWARDFWD) list.push_back("FORWARDFWD"); if (dw & LINEADDRFEATURE_FORWARDDND) list.push_back("FORWARDDND"); DWORD dwKnown= LINEADDRFEATURE_FORWARD|LINEADDRFEATURE_MAKECALL|LINEADDRFEATURE_PICKUP|LINEADDRFEATURE_SETMEDIACONTROL|LINEADDRFEATURE_SETTERMINAL|LINEADDRFEATURE_SETUPCONF|LINEADDRFEATURE_UNCOMPLETECALL|LINEADDRFEATURE_UNPARK|LINEADDRFEATURE_PICKUPHELD|LINEADDRFEATURE_PICKUPGROUP|LINEADDRFEATURE_PICKUPDIRECT|LINEADDRFEATURE_PICKUPWAITING|LINEADDRFEATURE_FORWARDFWD|LINEADDRFEATURE_FORWARDDND; if (dw&~dwKnown) list.push_back(stringformat("LINEADDRFEATURE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEAGENTFEATURE: 6 values std::string LineAgentFeatureString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEAGENTFEATURE_SETAGENTGROUP) list.push_back("SETAGENTGROUP"); if (dw & LINEAGENTFEATURE_SETAGENTSTATE) list.push_back("SETAGENTSTATE"); if (dw & LINEAGENTFEATURE_SETAGENTACTIVITY) list.push_back("SETAGENTACTIVITY"); if (dw & LINEAGENTFEATURE_AGENTSPECIFIC) list.push_back("AGENTSPECIFIC"); if (dw & LINEAGENTFEATURE_GETAGENTACTIVITYLIST) list.push_back("GETAGENTACTIVITYLIST"); if (dw & LINEAGENTFEATURE_GETAGENTGROUP) list.push_back("GETAGENTGROUP"); DWORD dwKnown= LINEAGENTFEATURE_SETAGENTGROUP|LINEAGENTFEATURE_SETAGENTSTATE|LINEAGENTFEATURE_SETAGENTACTIVITY|LINEAGENTFEATURE_AGENTSPECIFIC|LINEAGENTFEATURE_GETAGENTACTIVITYLIST|LINEAGENTFEATURE_GETAGENTGROUP; if (dw&~dwKnown) list.push_back(stringformat("LINEAGENTFEATURE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEAGENTSTATE: 10 values std::string LineAgentStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEAGENTSTATE_LOGGEDOFF) list.push_back("LOGGEDOFF"); if (dw & LINEAGENTSTATE_NOTREADY) list.push_back("NOTREADY"); if (dw & LINEAGENTSTATE_READY) list.push_back("READY"); if (dw & LINEAGENTSTATE_BUSYACD) list.push_back("BUSYACD"); if (dw & LINEAGENTSTATE_BUSYINCOMING) list.push_back("BUSYINCOMING"); if (dw & LINEAGENTSTATE_BUSYOUTBOUND) list.push_back("BUSYOUTBOUND"); if (dw & LINEAGENTSTATE_BUSYOTHER) list.push_back("BUSYOTHER"); if (dw & LINEAGENTSTATE_WORKINGAFTERCALL) list.push_back("WORKINGAFTERCALL"); if (dw & LINEAGENTSTATE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEAGENTSTATE_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= LINEAGENTSTATE_LOGGEDOFF|LINEAGENTSTATE_NOTREADY|LINEAGENTSTATE_READY|LINEAGENTSTATE_BUSYACD|LINEAGENTSTATE_BUSYINCOMING|LINEAGENTSTATE_BUSYOUTBOUND|LINEAGENTSTATE_BUSYOTHER|LINEAGENTSTATE_WORKINGAFTERCALL|LINEAGENTSTATE_UNKNOWN|LINEAGENTSTATE_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("LINEAGENTSTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEAGENTSTATUS: 9 values std::string LineAgentStatusString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEAGENTSTATUS_GROUP) list.push_back("GROUP"); if (dw & LINEAGENTSTATUS_STATE) list.push_back("STATE"); if (dw & LINEAGENTSTATUS_NEXTSTATE) list.push_back("NEXTSTATE"); if (dw & LINEAGENTSTATUS_ACTIVITY) list.push_back("ACTIVITY"); if (dw & LINEAGENTSTATUS_ACTIVITYLIST) list.push_back("ACTIVITYLIST"); if (dw & LINEAGENTSTATUS_GROUPLIST) list.push_back("GROUPLIST"); if (dw & LINEAGENTSTATUS_CAPSCHANGE) list.push_back("CAPSCHANGE"); if (dw & LINEAGENTSTATUS_VALIDSTATES) list.push_back("VALIDSTATES"); if (dw & LINEAGENTSTATUS_VALIDNEXTSTATES) list.push_back("VALIDNEXTSTATES"); DWORD dwKnown= LINEAGENTSTATUS_GROUP|LINEAGENTSTATUS_STATE|LINEAGENTSTATUS_NEXTSTATE|LINEAGENTSTATUS_ACTIVITY|LINEAGENTSTATUS_ACTIVITYLIST|LINEAGENTSTATUS_GROUPLIST|LINEAGENTSTATUS_CAPSCHANGE|LINEAGENTSTATUS_VALIDSTATES|LINEAGENTSTATUS_VALIDNEXTSTATES; if (dw&~dwKnown) list.push_back(stringformat("LINEAGENTSTATUS_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEANSWERMODE: 3 values std::string LineAnswerModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEANSWERMODE_NONE) list.push_back("NONE"); if (dw & LINEANSWERMODE_DROP) list.push_back("DROP"); if (dw & LINEANSWERMODE_HOLD) list.push_back("HOLD"); DWORD dwKnown= LINEANSWERMODE_NONE|LINEANSWERMODE_DROP|LINEANSWERMODE_HOLD; if (dw&~dwKnown) list.push_back(stringformat("LINEANSWERMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEBEARERMODE: 8 values std::string LineBearerModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEBEARERMODE_VOICE) list.push_back("VOICE"); if (dw & LINEBEARERMODE_SPEECH) list.push_back("SPEECH"); if (dw & LINEBEARERMODE_MULTIUSE) list.push_back("MULTIUSE"); if (dw & LINEBEARERMODE_DATA) list.push_back("DATA"); if (dw & LINEBEARERMODE_ALTSPEECHDATA) list.push_back("ALTSPEECHDATA"); if (dw & LINEBEARERMODE_NONCALLSIGNALING) list.push_back("NONCALLSIGNALING"); if (dw & LINEBEARERMODE_PASSTHROUGH) list.push_back("PASSTHROUGH"); if (dw & LINEBEARERMODE_RESTRICTEDDATA) list.push_back("RESTRICTEDDATA"); DWORD dwKnown= LINEBEARERMODE_VOICE|LINEBEARERMODE_SPEECH|LINEBEARERMODE_MULTIUSE|LINEBEARERMODE_DATA|LINEBEARERMODE_ALTSPEECHDATA|LINEBEARERMODE_NONCALLSIGNALING|LINEBEARERMODE_PASSTHROUGH|LINEBEARERMODE_RESTRICTEDDATA; if (dw&~dwKnown) list.push_back(stringformat("LINEBEARERMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEBUSYMODE: 4 values std::string LineBusyModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEBUSYMODE_STATION) list.push_back("STATION"); if (dw & LINEBUSYMODE_TRUNK) list.push_back("TRUNK"); if (dw & LINEBUSYMODE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEBUSYMODE_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= LINEBUSYMODE_STATION|LINEBUSYMODE_TRUNK|LINEBUSYMODE_UNKNOWN|LINEBUSYMODE_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("LINEBUSYMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLCOMPLCOND: 2 values std::string LineCallComplCondString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLCOMPLCOND_BUSY) list.push_back("BUSY"); if (dw & LINECALLCOMPLCOND_NOANSWER) list.push_back("NOANSWER"); DWORD dwKnown= LINECALLCOMPLCOND_BUSY|LINECALLCOMPLCOND_NOANSWER; if (dw&~dwKnown) list.push_back(stringformat("LINECALLCOMPLCOND_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLCOMPLMODE: 4 values std::string LineCallComplModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLCOMPLMODE_CAMPON) list.push_back("CAMPON"); if (dw & LINECALLCOMPLMODE_CALLBACK) list.push_back("CALLBACK"); if (dw & LINECALLCOMPLMODE_INTRUDE) list.push_back("INTRUDE"); if (dw & LINECALLCOMPLMODE_MESSAGE) list.push_back("MESSAGE"); DWORD dwKnown= LINECALLCOMPLMODE_CAMPON|LINECALLCOMPLMODE_CALLBACK|LINECALLCOMPLMODE_INTRUDE|LINECALLCOMPLMODE_MESSAGE; if (dw&~dwKnown) list.push_back(stringformat("LINECALLCOMPLMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLFEATURE: 32 values std::string LineCallFeatureString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLFEATURE_ACCEPT) list.push_back("ACCEPT"); if (dw & LINECALLFEATURE_ADDTOCONF) list.push_back("ADDTOCONF"); if (dw & LINECALLFEATURE_ANSWER) list.push_back("ANSWER"); if (dw & LINECALLFEATURE_BLINDTRANSFER) list.push_back("BLINDTRANSFER"); if (dw & LINECALLFEATURE_COMPLETECALL) list.push_back("COMPLETECALL"); if (dw & LINECALLFEATURE_COMPLETETRANSF) list.push_back("COMPLETETRANSF"); if (dw & LINECALLFEATURE_DIAL) list.push_back("DIAL"); if (dw & LINECALLFEATURE_DROP) list.push_back("DROP"); if (dw & LINECALLFEATURE_GATHERDIGITS) list.push_back("GATHERDIGITS"); if (dw & LINECALLFEATURE_GENERATEDIGITS) list.push_back("GENERATEDIGITS"); if (dw & LINECALLFEATURE_GENERATETONE) list.push_back("GENERATETONE"); if (dw & LINECALLFEATURE_HOLD) list.push_back("HOLD"); if (dw & LINECALLFEATURE_MONITORDIGITS) list.push_back("MONITORDIGITS"); if (dw & LINECALLFEATURE_MONITORMEDIA) list.push_back("MONITORMEDIA"); if (dw & LINECALLFEATURE_MONITORTONES) list.push_back("MONITORTONES"); if (dw & LINECALLFEATURE_PARK) list.push_back("PARK"); if (dw & LINECALLFEATURE_PREPAREADDCONF) list.push_back("PREPAREADDCONF"); if (dw & LINECALLFEATURE_REDIRECT) list.push_back("REDIRECT"); if (dw & LINECALLFEATURE_REMOVEFROMCONF) list.push_back("REMOVEFROMCONF"); if (dw & LINECALLFEATURE_SECURECALL) list.push_back("SECURECALL"); if (dw & LINECALLFEATURE_SENDUSERUSER) list.push_back("SENDUSERUSER"); if (dw & LINECALLFEATURE_SETCALLPARAMS) list.push_back("SETCALLPARAMS"); if (dw & LINECALLFEATURE_SETMEDIACONTROL) list.push_back("SETMEDIACONTROL"); if (dw & LINECALLFEATURE_SETTERMINAL) list.push_back("SETTERMINAL"); if (dw & LINECALLFEATURE_SETUPCONF) list.push_back("SETUPCONF"); if (dw & LINECALLFEATURE_SETUPTRANSFER) list.push_back("SETUPTRANSFER"); if (dw & LINECALLFEATURE_SWAPHOLD) list.push_back("SWAPHOLD"); if (dw & LINECALLFEATURE_UNHOLD) list.push_back("UNHOLD"); if (dw & LINECALLFEATURE_RELEASEUSERUSERINFO) list.push_back("RELEASEUSERUSERINFO"); if (dw & LINECALLFEATURE_SETTREATMENT) list.push_back("SETTREATMENT"); if (dw & LINECALLFEATURE_SETQOS) list.push_back("SETQOS"); if (dw & LINECALLFEATURE_SETCALLDATA) list.push_back("SETCALLDATA"); DWORD dwKnown= LINECALLFEATURE_ACCEPT|LINECALLFEATURE_ADDTOCONF|LINECALLFEATURE_ANSWER|LINECALLFEATURE_BLINDTRANSFER|LINECALLFEATURE_COMPLETECALL|LINECALLFEATURE_COMPLETETRANSF|LINECALLFEATURE_DIAL|LINECALLFEATURE_DROP|LINECALLFEATURE_GATHERDIGITS|LINECALLFEATURE_GENERATEDIGITS|LINECALLFEATURE_GENERATETONE|LINECALLFEATURE_HOLD|LINECALLFEATURE_MONITORDIGITS|LINECALLFEATURE_MONITORMEDIA|LINECALLFEATURE_MONITORTONES|LINECALLFEATURE_PARK|LINECALLFEATURE_PREPAREADDCONF|LINECALLFEATURE_REDIRECT|LINECALLFEATURE_REMOVEFROMCONF|LINECALLFEATURE_SECURECALL|LINECALLFEATURE_SENDUSERUSER|LINECALLFEATURE_SETCALLPARAMS|LINECALLFEATURE_SETMEDIACONTROL|LINECALLFEATURE_SETTERMINAL|LINECALLFEATURE_SETUPCONF|LINECALLFEATURE_SETUPTRANSFER|LINECALLFEATURE_SWAPHOLD|LINECALLFEATURE_UNHOLD|LINECALLFEATURE_RELEASEUSERUSERINFO|LINECALLFEATURE_SETTREATMENT|LINECALLFEATURE_SETQOS|LINECALLFEATURE_SETCALLDATA; if (dw&~dwKnown) list.push_back(stringformat("LINECALLFEATURE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLFEATURE2: 10 values std::string LineCallFeature2String(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLFEATURE2_NOHOLDCONFERENCE) list.push_back("NOHOLDCONFERENCE"); if (dw & LINECALLFEATURE2_ONESTEPTRANSFER) list.push_back("ONESTEPTRANSFER"); if (dw & LINECALLFEATURE2_COMPLCAMPON) list.push_back("COMPLCAMPON"); if (dw & LINECALLFEATURE2_COMPLCALLBACK) list.push_back("COMPLCALLBACK"); if (dw & LINECALLFEATURE2_COMPLINTRUDE) list.push_back("COMPLINTRUDE"); if (dw & LINECALLFEATURE2_COMPLMESSAGE) list.push_back("COMPLMESSAGE"); if (dw & LINECALLFEATURE2_TRANSFERNORM) list.push_back("TRANSFERNORM"); if (dw & LINECALLFEATURE2_TRANSFERCONF) list.push_back("TRANSFERCONF"); if (dw & LINECALLFEATURE2_PARKDIRECT) list.push_back("PARKDIRECT"); if (dw & LINECALLFEATURE2_PARKNONDIRECT) list.push_back("PARKNONDIRECT"); DWORD dwKnown= LINECALLFEATURE2_NOHOLDCONFERENCE|LINECALLFEATURE2_ONESTEPTRANSFER|LINECALLFEATURE2_COMPLCAMPON|LINECALLFEATURE2_COMPLCALLBACK|LINECALLFEATURE2_COMPLINTRUDE|LINECALLFEATURE2_COMPLMESSAGE|LINECALLFEATURE2_TRANSFERNORM|LINECALLFEATURE2_TRANSFERCONF|LINECALLFEATURE2_PARKDIRECT|LINECALLFEATURE2_PARKNONDIRECT; if (dw&~dwKnown) list.push_back(stringformat("LINECALLFEATURE2_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLINFOSTATE: 31 values std::string LineCallInfoStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLINFOSTATE_OTHER) list.push_back("OTHER"); if (dw & LINECALLINFOSTATE_DEVSPECIFIC) list.push_back("DEVSPECIFIC"); if (dw & LINECALLINFOSTATE_BEARERMODE) list.push_back("BEARERMODE"); if (dw & LINECALLINFOSTATE_RATE) list.push_back("RATE"); if (dw & LINECALLINFOSTATE_MEDIAMODE) list.push_back("MEDIAMODE"); if (dw & LINECALLINFOSTATE_APPSPECIFIC) list.push_back("APPSPECIFIC"); if (dw & LINECALLINFOSTATE_CALLID) list.push_back("CALLID"); if (dw & LINECALLINFOSTATE_RELATEDCALLID) list.push_back("RELATEDCALLID"); if (dw & LINECALLINFOSTATE_ORIGIN) list.push_back("ORIGIN"); if (dw & LINECALLINFOSTATE_REASON) list.push_back("REASON"); if (dw & LINECALLINFOSTATE_COMPLETIONID) list.push_back("COMPLETIONID"); if (dw & LINECALLINFOSTATE_NUMOWNERINCR) list.push_back("NUMOWNERINCR"); if (dw & LINECALLINFOSTATE_NUMOWNERDECR) list.push_back("NUMOWNERDECR"); if (dw & LINECALLINFOSTATE_NUMMONITORS) list.push_back("NUMMONITORS"); if (dw & LINECALLINFOSTATE_TRUNK) list.push_back("TRUNK"); if (dw & LINECALLINFOSTATE_CALLERID) list.push_back("CALLERID"); if (dw & LINECALLINFOSTATE_CALLEDID) list.push_back("CALLEDID"); if (dw & LINECALLINFOSTATE_CONNECTEDID) list.push_back("CONNECTEDID"); if (dw & LINECALLINFOSTATE_REDIRECTIONID) list.push_back("REDIRECTIONID"); if (dw & LINECALLINFOSTATE_REDIRECTINGID) list.push_back("REDIRECTINGID"); if (dw & LINECALLINFOSTATE_DISPLAY) list.push_back("DISPLAY"); if (dw & LINECALLINFOSTATE_USERUSERINFO) list.push_back("USERUSERINFO"); if (dw & LINECALLINFOSTATE_HIGHLEVELCOMP) list.push_back("HIGHLEVELCOMP"); if (dw & LINECALLINFOSTATE_LOWLEVELCOMP) list.push_back("LOWLEVELCOMP"); if (dw & LINECALLINFOSTATE_CHARGINGINFO) list.push_back("CHARGINGINFO"); if (dw & LINECALLINFOSTATE_TERMINAL) list.push_back("TERMINAL"); if (dw & LINECALLINFOSTATE_DIALPARAMS) list.push_back("DIALPARAMS"); if (dw & LINECALLINFOSTATE_MONITORMODES) list.push_back("MONITORMODES"); if (dw & LINECALLINFOSTATE_TREATMENT) list.push_back("TREATMENT"); if (dw & LINECALLINFOSTATE_QOS) list.push_back("QOS"); if (dw & LINECALLINFOSTATE_CALLDATA) list.push_back("CALLDATA"); DWORD dwKnown= LINECALLINFOSTATE_OTHER|LINECALLINFOSTATE_DEVSPECIFIC|LINECALLINFOSTATE_BEARERMODE|LINECALLINFOSTATE_RATE|LINECALLINFOSTATE_MEDIAMODE|LINECALLINFOSTATE_APPSPECIFIC|LINECALLINFOSTATE_CALLID|LINECALLINFOSTATE_RELATEDCALLID|LINECALLINFOSTATE_ORIGIN|LINECALLINFOSTATE_REASON|LINECALLINFOSTATE_COMPLETIONID|LINECALLINFOSTATE_NUMOWNERINCR|LINECALLINFOSTATE_NUMOWNERDECR|LINECALLINFOSTATE_NUMMONITORS|LINECALLINFOSTATE_TRUNK|LINECALLINFOSTATE_CALLERID|LINECALLINFOSTATE_CALLEDID|LINECALLINFOSTATE_CONNECTEDID|LINECALLINFOSTATE_REDIRECTIONID|LINECALLINFOSTATE_REDIRECTINGID|LINECALLINFOSTATE_DISPLAY|LINECALLINFOSTATE_USERUSERINFO|LINECALLINFOSTATE_HIGHLEVELCOMP|LINECALLINFOSTATE_LOWLEVELCOMP|LINECALLINFOSTATE_CHARGINGINFO|LINECALLINFOSTATE_TERMINAL|LINECALLINFOSTATE_DIALPARAMS|LINECALLINFOSTATE_MONITORMODES|LINECALLINFOSTATE_TREATMENT|LINECALLINFOSTATE_QOS|LINECALLINFOSTATE_CALLDATA; if (dw&~dwKnown) list.push_back(stringformat("LINECALLINFOSTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLORIGIN: 7 values std::string LineCallOriginString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLORIGIN_OUTBOUND) list.push_back("OUTBOUND"); if (dw & LINECALLORIGIN_INTERNAL) list.push_back("INTERNAL"); if (dw & LINECALLORIGIN_EXTERNAL) list.push_back("EXTERNAL"); if (dw & LINECALLORIGIN_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINECALLORIGIN_UNAVAIL) list.push_back("UNAVAIL"); if (dw & LINECALLORIGIN_CONFERENCE) list.push_back("CONFERENCE"); if (dw & LINECALLORIGIN_INBOUND) list.push_back("INBOUND"); DWORD dwKnown= LINECALLORIGIN_OUTBOUND|LINECALLORIGIN_INTERNAL|LINECALLORIGIN_EXTERNAL|LINECALLORIGIN_UNKNOWN|LINECALLORIGIN_UNAVAIL|LINECALLORIGIN_CONFERENCE|LINECALLORIGIN_INBOUND; if (dw&~dwKnown) list.push_back(stringformat("LINECALLORIGIN_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLPARAMFLAGS: 8 values std::string LineCallParamFlagsString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLPARAMFLAGS_SECURE) list.push_back("SECURE"); if (dw & LINECALLPARAMFLAGS_IDLE) list.push_back("IDLE"); if (dw & LINECALLPARAMFLAGS_BLOCKID) list.push_back("BLOCKID"); if (dw & LINECALLPARAMFLAGS_ORIGOFFHOOK) list.push_back("ORIGOFFHOOK"); if (dw & LINECALLPARAMFLAGS_DESTOFFHOOK) list.push_back("DESTOFFHOOK"); if (dw & LINECALLPARAMFLAGS_NOHOLDCONFERENCE) list.push_back("NOHOLDCONFERENCE"); if (dw & LINECALLPARAMFLAGS_PREDICTIVEDIAL) list.push_back("PREDICTIVEDIAL"); if (dw & LINECALLPARAMFLAGS_ONESTEPTRANSFER) list.push_back("ONESTEPTRANSFER"); DWORD dwKnown= LINECALLPARAMFLAGS_SECURE|LINECALLPARAMFLAGS_IDLE|LINECALLPARAMFLAGS_BLOCKID|LINECALLPARAMFLAGS_ORIGOFFHOOK|LINECALLPARAMFLAGS_DESTOFFHOOK|LINECALLPARAMFLAGS_NOHOLDCONFERENCE|LINECALLPARAMFLAGS_PREDICTIVEDIAL|LINECALLPARAMFLAGS_ONESTEPTRANSFER; if (dw&~dwKnown) list.push_back(stringformat("LINECALLPARAMFLAGS_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLPARTYID: 7 values std::string LineCallPartyIDString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLPARTYID_BLOCKED) list.push_back("BLOCKED"); if (dw & LINECALLPARTYID_OUTOFAREA) list.push_back("OUTOFAREA"); if (dw & LINECALLPARTYID_NAME) list.push_back("NAME"); if (dw & LINECALLPARTYID_ADDRESS) list.push_back("ADDRESS"); if (dw & LINECALLPARTYID_PARTIAL) list.push_back("PARTIAL"); if (dw & LINECALLPARTYID_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINECALLPARTYID_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= LINECALLPARTYID_BLOCKED|LINECALLPARTYID_OUTOFAREA|LINECALLPARTYID_NAME|LINECALLPARTYID_ADDRESS|LINECALLPARTYID_PARTIAL|LINECALLPARTYID_UNKNOWN|LINECALLPARTYID_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("LINECALLPARTYID_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLPRIVILEGE: 3 values std::string LineCallPrivilegeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLPRIVILEGE_NONE) list.push_back("NONE"); if (dw & LINECALLPRIVILEGE_MONITOR) list.push_back("MONITOR"); if (dw & LINECALLPRIVILEGE_OWNER) list.push_back("OWNER"); DWORD dwKnown= LINECALLPRIVILEGE_NONE|LINECALLPRIVILEGE_MONITOR|LINECALLPRIVILEGE_OWNER; if (dw&~dwKnown) list.push_back(stringformat("LINECALLPRIVILEGE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLREASON: 16 values std::string LineCallReasonString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLREASON_DIRECT) list.push_back("DIRECT"); if (dw & LINECALLREASON_FWDBUSY) list.push_back("FWDBUSY"); if (dw & LINECALLREASON_FWDNOANSWER) list.push_back("FWDNOANSWER"); if (dw & LINECALLREASON_FWDUNCOND) list.push_back("FWDUNCOND"); if (dw & LINECALLREASON_PICKUP) list.push_back("PICKUP"); if (dw & LINECALLREASON_UNPARK) list.push_back("UNPARK"); if (dw & LINECALLREASON_REDIRECT) list.push_back("REDIRECT"); if (dw & LINECALLREASON_CALLCOMPLETION) list.push_back("CALLCOMPLETION"); if (dw & LINECALLREASON_TRANSFER) list.push_back("TRANSFER"); if (dw & LINECALLREASON_REMINDER) list.push_back("REMINDER"); if (dw & LINECALLREASON_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINECALLREASON_UNAVAIL) list.push_back("UNAVAIL"); if (dw & LINECALLREASON_INTRUDE) list.push_back("INTRUDE"); if (dw & LINECALLREASON_PARKED) list.push_back("PARKED"); if (dw & LINECALLREASON_CAMPEDON) list.push_back("CAMPEDON"); if (dw & LINECALLREASON_ROUTEREQUEST) list.push_back("ROUTEREQUEST"); DWORD dwKnown= LINECALLREASON_DIRECT|LINECALLREASON_FWDBUSY|LINECALLREASON_FWDNOANSWER|LINECALLREASON_FWDUNCOND|LINECALLREASON_PICKUP|LINECALLREASON_UNPARK|LINECALLREASON_REDIRECT|LINECALLREASON_CALLCOMPLETION|LINECALLREASON_TRANSFER|LINECALLREASON_REMINDER|LINECALLREASON_UNKNOWN|LINECALLREASON_UNAVAIL|LINECALLREASON_INTRUDE|LINECALLREASON_PARKED|LINECALLREASON_CAMPEDON|LINECALLREASON_ROUTEREQUEST; if (dw&~dwKnown) list.push_back(stringformat("LINECALLREASON_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLSELECT: 5 values std::string LineCallselectString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLSELECT_LINE) list.push_back("LINE"); if (dw & LINECALLSELECT_ADDRESS) list.push_back("ADDRESS"); if (dw & LINECALLSELECT_CALL) list.push_back("CALL"); if (dw & LINECALLSELECT_DEVICEID) list.push_back("DEVICEID"); if (dw & LINECALLSELECT_CALLID) list.push_back("CALLID"); DWORD dwKnown= LINECALLSELECT_LINE|LINECALLSELECT_ADDRESS|LINECALLSELECT_CALL|LINECALLSELECT_DEVICEID|LINECALLSELECT_CALLID; if (dw&~dwKnown) list.push_back(stringformat("LINECALLSELECT_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINECALLSTATE: 16 values std::string LineCallStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECALLSTATE_IDLE) list.push_back("IDLE"); if (dw & LINECALLSTATE_OFFERING) list.push_back("OFFERING"); if (dw & LINECALLSTATE_ACCEPTED) list.push_back("ACCEPTED"); if (dw & LINECALLSTATE_DIALTONE) list.push_back("DIALTONE"); if (dw & LINECALLSTATE_DIALING) list.push_back("DIALING"); if (dw & LINECALLSTATE_RINGBACK) list.push_back("RINGBACK"); if (dw & LINECALLSTATE_BUSY) list.push_back("BUSY"); if (dw & LINECALLSTATE_SPECIALINFO) list.push_back("SPECIALINFO"); if (dw & LINECALLSTATE_CONNECTED) list.push_back("CONNECTED"); if (dw & LINECALLSTATE_PROCEEDING) list.push_back("PROCEEDING"); if (dw & LINECALLSTATE_ONHOLD) list.push_back("ONHOLD"); if (dw & LINECALLSTATE_CONFERENCED) list.push_back("CONFERENCED"); if (dw & LINECALLSTATE_ONHOLDPENDCONF) list.push_back("ONHOLDPENDCONF"); if (dw & LINECALLSTATE_ONHOLDPENDTRANSFER) list.push_back("ONHOLDPENDTRANSFER"); if (dw & LINECALLSTATE_DISCONNECTED) list.push_back("DISCONNECTED"); if (dw & LINECALLSTATE_UNKNOWN) list.push_back("UNKNOWN"); DWORD dwKnown= LINECALLSTATE_IDLE|LINECALLSTATE_OFFERING|LINECALLSTATE_ACCEPTED|LINECALLSTATE_DIALTONE|LINECALLSTATE_DIALING|LINECALLSTATE_RINGBACK|LINECALLSTATE_BUSY|LINECALLSTATE_SPECIALINFO|LINECALLSTATE_CONNECTED|LINECALLSTATE_PROCEEDING|LINECALLSTATE_ONHOLD|LINECALLSTATE_CONFERENCED|LINECALLSTATE_ONHOLDPENDCONF|LINECALLSTATE_ONHOLDPENDTRANSFER|LINECALLSTATE_DISCONNECTED|LINECALLSTATE_UNKNOWN; if (dw&~dwKnown) list.push_back(stringformat("LINECALLSTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for LINECALLTREATMENT: 4 values std::string LineCallTreatmentString(DWORD dw) { switch (dw) { case LINECALLTREATMENT_SILENCE: return "SILENCE"; case LINECALLTREATMENT_RINGBACK: return "RINGBACK"; case LINECALLTREATMENT_BUSY: return "BUSY"; case LINECALLTREATMENT_MUSIC: return "MUSIC"; default: return stringformat("LINECALLTREATMENT_%08lx", dw); } } // enum decoder for LINECARDOPTION: 2 values std::string LineCardOptionString(DWORD dw) { switch (dw) { case LINECARDOPTION_PREDEFINED: return "PREDEFINED"; case LINECARDOPTION_HIDDEN: return "HIDDEN"; default: return stringformat("LINECARDOPTION_%08lx", dw); } } // bitmask decoder for LINECONNECTEDMODE: 5 values std::string LineConnectedModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINECONNECTEDMODE_ACTIVE) list.push_back("ACTIVE"); if (dw & LINECONNECTEDMODE_INACTIVE) list.push_back("INACTIVE"); if (dw & LINECONNECTEDMODE_ACTIVEHELD) list.push_back("ACTIVEHELD"); if (dw & LINECONNECTEDMODE_INACTIVEHELD) list.push_back("INACTIVEHELD"); if (dw & LINECONNECTEDMODE_CONFIRMED) list.push_back("CONFIRMED"); DWORD dwKnown= LINECONNECTEDMODE_ACTIVE|LINECONNECTEDMODE_INACTIVE|LINECONNECTEDMODE_ACTIVEHELD|LINECONNECTEDMODE_INACTIVEHELD|LINECONNECTEDMODE_CONFIRMED; if (dw&~dwKnown) list.push_back(stringformat("LINECONNECTEDMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEDEVCAPFLAGS: 13 values std::string LineDevCapFlagsString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEDEVCAPFLAGS_CROSSADDRCONF) list.push_back("CROSSADDRCONF"); if (dw & LINEDEVCAPFLAGS_HIGHLEVCOMP) list.push_back("HIGHLEVCOMP"); if (dw & LINEDEVCAPFLAGS_LOWLEVCOMP) list.push_back("LOWLEVCOMP"); if (dw & LINEDEVCAPFLAGS_MEDIACONTROL) list.push_back("MEDIACONTROL"); if (dw & LINEDEVCAPFLAGS_MULTIPLEADDR) list.push_back("MULTIPLEADDR"); if (dw & LINEDEVCAPFLAGS_CLOSEDROP) list.push_back("CLOSEDROP"); if (dw & LINEDEVCAPFLAGS_DIALBILLING) list.push_back("DIALBILLING"); if (dw & LINEDEVCAPFLAGS_DIALQUIET) list.push_back("DIALQUIET"); if (dw & LINEDEVCAPFLAGS_DIALDIALTONE) list.push_back("DIALDIALTONE"); if (dw & LINEDEVCAPFLAGS_MSP) list.push_back("MSP"); if (dw & LINEDEVCAPFLAGS_CALLHUB) list.push_back("CALLHUB"); if (dw & LINEDEVCAPFLAGS_CALLHUBTRACKING) list.push_back("CALLHUBTRACKING"); if (dw & LINEDEVCAPFLAGS_PRIVATEOBJECTS) list.push_back("PRIVATEOBJECTS"); DWORD dwKnown= LINEDEVCAPFLAGS_CROSSADDRCONF|LINEDEVCAPFLAGS_HIGHLEVCOMP|LINEDEVCAPFLAGS_LOWLEVCOMP|LINEDEVCAPFLAGS_MEDIACONTROL|LINEDEVCAPFLAGS_MULTIPLEADDR|LINEDEVCAPFLAGS_CLOSEDROP|LINEDEVCAPFLAGS_DIALBILLING|LINEDEVCAPFLAGS_DIALQUIET|LINEDEVCAPFLAGS_DIALDIALTONE|LINEDEVCAPFLAGS_MSP|LINEDEVCAPFLAGS_CALLHUB|LINEDEVCAPFLAGS_CALLHUBTRACKING|LINEDEVCAPFLAGS_PRIVATEOBJECTS; if (dw&~dwKnown) list.push_back(stringformat("LINEDEVCAPFLAGS_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEDEVSTATE: 25 values std::string LineDevStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEDEVSTATE_OTHER) list.push_back("OTHER"); if (dw & LINEDEVSTATE_RINGING) list.push_back("RINGING"); if (dw & LINEDEVSTATE_CONNECTED) list.push_back("CONNECTED"); if (dw & LINEDEVSTATE_DISCONNECTED) list.push_back("DISCONNECTED"); if (dw & LINEDEVSTATE_MSGWAITON) list.push_back("MSGWAITON"); if (dw & LINEDEVSTATE_MSGWAITOFF) list.push_back("MSGWAITOFF"); if (dw & LINEDEVSTATE_INSERVICE) list.push_back("INSERVICE"); if (dw & LINEDEVSTATE_OUTOFSERVICE) list.push_back("OUTOFSERVICE"); if (dw & LINEDEVSTATE_MAINTENANCE) list.push_back("MAINTENANCE"); if (dw & LINEDEVSTATE_OPEN) list.push_back("OPEN"); if (dw & LINEDEVSTATE_CLOSE) list.push_back("CLOSE"); if (dw & LINEDEVSTATE_NUMCALLS) list.push_back("NUMCALLS"); if (dw & LINEDEVSTATE_NUMCOMPLETIONS) list.push_back("NUMCOMPLETIONS"); if (dw & LINEDEVSTATE_TERMINALS) list.push_back("TERMINALS"); if (dw & LINEDEVSTATE_ROAMMODE) list.push_back("ROAMMODE"); if (dw & LINEDEVSTATE_BATTERY) list.push_back("BATTERY"); if (dw & LINEDEVSTATE_SIGNAL) list.push_back("SIGNAL"); if (dw & LINEDEVSTATE_DEVSPECIFIC) list.push_back("DEVSPECIFIC"); if (dw & LINEDEVSTATE_REINIT) list.push_back("REINIT"); if (dw & LINEDEVSTATE_LOCK) list.push_back("LOCK"); if (dw & LINEDEVSTATE_CAPSCHANGE) list.push_back("CAPSCHANGE"); if (dw & LINEDEVSTATE_CONFIGCHANGE) list.push_back("CONFIGCHANGE"); if (dw & LINEDEVSTATE_TRANSLATECHANGE) list.push_back("TRANSLATECHANGE"); if (dw & LINEDEVSTATE_COMPLCANCEL) list.push_back("COMPLCANCEL"); if (dw & LINEDEVSTATE_REMOVED) list.push_back("REMOVED"); DWORD dwKnown= LINEDEVSTATE_OTHER|LINEDEVSTATE_RINGING|LINEDEVSTATE_CONNECTED|LINEDEVSTATE_DISCONNECTED|LINEDEVSTATE_MSGWAITON|LINEDEVSTATE_MSGWAITOFF|LINEDEVSTATE_INSERVICE|LINEDEVSTATE_OUTOFSERVICE|LINEDEVSTATE_MAINTENANCE|LINEDEVSTATE_OPEN|LINEDEVSTATE_CLOSE|LINEDEVSTATE_NUMCALLS|LINEDEVSTATE_NUMCOMPLETIONS|LINEDEVSTATE_TERMINALS|LINEDEVSTATE_ROAMMODE|LINEDEVSTATE_BATTERY|LINEDEVSTATE_SIGNAL|LINEDEVSTATE_DEVSPECIFIC|LINEDEVSTATE_REINIT|LINEDEVSTATE_LOCK|LINEDEVSTATE_CAPSCHANGE|LINEDEVSTATE_CONFIGCHANGE|LINEDEVSTATE_TRANSLATECHANGE|LINEDEVSTATE_COMPLCANCEL|LINEDEVSTATE_REMOVED; if (dw&~dwKnown) list.push_back(stringformat("LINEDEVSTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEDEVSTATUSFLAGS: 4 values std::string LineDevStatusFlagsString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEDEVSTATUSFLAGS_CONNECTED) list.push_back("CONNECTED"); if (dw & LINEDEVSTATUSFLAGS_MSGWAIT) list.push_back("MSGWAIT"); if (dw & LINEDEVSTATUSFLAGS_INSERVICE) list.push_back("INSERVICE"); if (dw & LINEDEVSTATUSFLAGS_LOCKED) list.push_back("LOCKED"); DWORD dwKnown= LINEDEVSTATUSFLAGS_CONNECTED|LINEDEVSTATUSFLAGS_MSGWAIT|LINEDEVSTATUSFLAGS_INSERVICE|LINEDEVSTATUSFLAGS_LOCKED; if (dw&~dwKnown) list.push_back(stringformat("LINEDEVSTATUSFLAGS_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEDIALTONEMODE: 6 values std::string LineDialToneModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEDIALTONEMODE_NORMAL) list.push_back("NORMAL"); if (dw & LINEDIALTONEMODE_SPECIAL) list.push_back("SPECIAL"); if (dw & LINEDIALTONEMODE_INTERNAL) list.push_back("INTERNAL"); if (dw & LINEDIALTONEMODE_EXTERNAL) list.push_back("EXTERNAL"); if (dw & LINEDIALTONEMODE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEDIALTONEMODE_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= LINEDIALTONEMODE_NORMAL|LINEDIALTONEMODE_SPECIAL|LINEDIALTONEMODE_INTERNAL|LINEDIALTONEMODE_EXTERNAL|LINEDIALTONEMODE_UNKNOWN|LINEDIALTONEMODE_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("LINEDIALTONEMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEDIGITMODE: 3 values std::string LineDigitModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEDIGITMODE_PULSE) list.push_back("PULSE"); if (dw & LINEDIGITMODE_DTMF) list.push_back("DTMF"); if (dw & LINEDIGITMODE_DTMFEND) list.push_back("DTMFEND"); DWORD dwKnown= LINEDIGITMODE_PULSE|LINEDIGITMODE_DTMF|LINEDIGITMODE_DTMFEND; if (dw&~dwKnown) list.push_back(stringformat("LINEDIGITMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEDISCONNECTMODE: 20 values std::string LineDisconnectModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEDISCONNECTMODE_NORMAL) list.push_back("NORMAL"); if (dw & LINEDISCONNECTMODE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEDISCONNECTMODE_REJECT) list.push_back("REJECT"); if (dw & LINEDISCONNECTMODE_PICKUP) list.push_back("PICKUP"); if (dw & LINEDISCONNECTMODE_FORWARDED) list.push_back("FORWARDED"); if (dw & LINEDISCONNECTMODE_BUSY) list.push_back("BUSY"); if (dw & LINEDISCONNECTMODE_NOANSWER) list.push_back("NOANSWER"); if (dw & LINEDISCONNECTMODE_BADADDRESS) list.push_back("BADADDRESS"); if (dw & LINEDISCONNECTMODE_UNREACHABLE) list.push_back("UNREACHABLE"); if (dw & LINEDISCONNECTMODE_CONGESTION) list.push_back("CONGESTION"); if (dw & LINEDISCONNECTMODE_INCOMPATIBLE) list.push_back("INCOMPATIBLE"); if (dw & LINEDISCONNECTMODE_UNAVAIL) list.push_back("UNAVAIL"); if (dw & LINEDISCONNECTMODE_NODIALTONE) list.push_back("NODIALTONE"); if (dw & LINEDISCONNECTMODE_NUMBERCHANGED) list.push_back("NUMBERCHANGED"); if (dw & LINEDISCONNECTMODE_OUTOFORDER) list.push_back("OUTOFORDER"); if (dw & LINEDISCONNECTMODE_TEMPFAILURE) list.push_back("TEMPFAILURE"); if (dw & LINEDISCONNECTMODE_QOSUNAVAIL) list.push_back("QOSUNAVAIL"); if (dw & LINEDISCONNECTMODE_BLOCKED) list.push_back("BLOCKED"); if (dw & LINEDISCONNECTMODE_DONOTDISTURB) list.push_back("DONOTDISTURB"); if (dw & LINEDISCONNECTMODE_CANCELLED) list.push_back("CANCELLED"); DWORD dwKnown= LINEDISCONNECTMODE_NORMAL|LINEDISCONNECTMODE_UNKNOWN|LINEDISCONNECTMODE_REJECT|LINEDISCONNECTMODE_PICKUP|LINEDISCONNECTMODE_FORWARDED|LINEDISCONNECTMODE_BUSY|LINEDISCONNECTMODE_NOANSWER|LINEDISCONNECTMODE_BADADDRESS|LINEDISCONNECTMODE_UNREACHABLE|LINEDISCONNECTMODE_CONGESTION|LINEDISCONNECTMODE_INCOMPATIBLE|LINEDISCONNECTMODE_UNAVAIL|LINEDISCONNECTMODE_NODIALTONE|LINEDISCONNECTMODE_NUMBERCHANGED|LINEDISCONNECTMODE_OUTOFORDER|LINEDISCONNECTMODE_TEMPFAILURE|LINEDISCONNECTMODE_QOSUNAVAIL|LINEDISCONNECTMODE_BLOCKED|LINEDISCONNECTMODE_DONOTDISTURB|LINEDISCONNECTMODE_CANCELLED; if (dw&~dwKnown) list.push_back(stringformat("LINEDISCONNECTMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for LINEERR: 90 values std::string LineErrString(DWORD dw) { switch (dw) { case LINEERR_ALLOCATED: return "ALLOCATED"; case LINEERR_BADDEVICEID: return "BADDEVICEID"; case LINEERR_BEARERMODEUNAVAIL: return "BEARERMODEUNAVAIL"; case LINEERR_CALLUNAVAIL: return "CALLUNAVAIL"; case LINEERR_COMPLETIONOVERRUN: return "COMPLETIONOVERRUN"; case LINEERR_CONFERENCEFULL: return "CONFERENCEFULL"; case LINEERR_DIALBILLING: return "DIALBILLING"; case LINEERR_DIALDIALTONE: return "DIALDIALTONE"; case LINEERR_DIALPROMPT: return "DIALPROMPT"; case LINEERR_DIALQUIET: return "DIALQUIET"; case LINEERR_INCOMPATIBLEAPIVERSION: return "INCOMPATIBLEAPIVERSION"; case LINEERR_INCOMPATIBLEEXTVERSION: return "INCOMPATIBLEEXTVERSION"; case LINEERR_INIFILECORRUPT: return "INIFILECORRUPT"; case LINEERR_INUSE: return "INUSE"; case LINEERR_INVALADDRESS: return "INVALADDRESS"; case LINEERR_INVALADDRESSID: return "INVALADDRESSID"; case LINEERR_INVALADDRESSMODE: return "INVALADDRESSMODE"; case LINEERR_INVALADDRESSSTATE: return "INVALADDRESSSTATE"; case LINEERR_INVALAPPHANDLE: return "INVALAPPHANDLE"; case LINEERR_INVALAPPNAME: return "INVALAPPNAME"; case LINEERR_INVALBEARERMODE: return "INVALBEARERMODE"; case LINEERR_INVALCALLCOMPLMODE: return "INVALCALLCOMPLMODE"; case LINEERR_INVALCALLHANDLE: return "INVALCALLHANDLE"; case LINEERR_INVALCALLPARAMS: return "INVALCALLPARAMS"; case LINEERR_INVALCALLPRIVILEGE: return "INVALCALLPRIVILEGE"; case LINEERR_INVALCALLSELECT: return "INVALCALLSELECT"; case LINEERR_INVALCALLSTATE: return "INVALCALLSTATE"; case LINEERR_INVALCALLSTATELIST: return "INVALCALLSTATELIST"; case LINEERR_INVALCARD: return "INVALCARD"; case LINEERR_INVALCOMPLETIONID: return "INVALCOMPLETIONID"; case LINEERR_INVALCONFCALLHANDLE: return "INVALCONFCALLHANDLE"; case LINEERR_INVALCONSULTCALLHANDLE: return "INVALCONSULTCALLHANDLE"; case LINEERR_INVALCOUNTRYCODE: return "INVALCOUNTRYCODE"; case LINEERR_INVALDEVICECLASS: return "INVALDEVICECLASS"; case LINEERR_INVALDEVICEHANDLE: return "INVALDEVICEHANDLE"; case LINEERR_INVALDIALPARAMS: return "INVALDIALPARAMS"; case LINEERR_INVALDIGITLIST: return "INVALDIGITLIST"; case LINEERR_INVALDIGITMODE: return "INVALDIGITMODE"; case LINEERR_INVALDIGITS: return "INVALDIGITS"; case LINEERR_INVALEXTVERSION: return "INVALEXTVERSION"; case LINEERR_INVALGROUPID: return "INVALGROUPID"; case LINEERR_INVALLINEHANDLE: return "INVALLINEHANDLE"; case LINEERR_INVALLINESTATE: return "INVALLINESTATE"; case LINEERR_INVALLOCATION: return "INVALLOCATION"; case LINEERR_INVALMEDIALIST: return "INVALMEDIALIST"; case LINEERR_INVALMEDIAMODE: return "INVALMEDIAMODE"; case LINEERR_INVALMESSAGEID: return "INVALMESSAGEID"; case LINEERR_INVALPARAM: return "INVALPARAM"; case LINEERR_INVALPARKID: return "INVALPARKID"; case LINEERR_INVALPARKMODE: return "INVALPARKMODE"; case LINEERR_INVALPOINTER: return "INVALPOINTER"; case LINEERR_INVALPRIVSELECT: return "INVALPRIVSELECT"; case LINEERR_INVALRATE: return "INVALRATE"; case LINEERR_INVALREQUESTMODE: return "INVALREQUESTMODE"; case LINEERR_INVALTERMINALID: return "INVALTERMINALID"; case LINEERR_INVALTERMINALMODE: return "INVALTERMINALMODE"; case LINEERR_INVALTIMEOUT: return "INVALTIMEOUT"; case LINEERR_INVALTONE: return "INVALTONE"; case LINEERR_INVALTONELIST: return "INVALTONELIST"; case LINEERR_INVALTONEMODE: return "INVALTONEMODE"; case LINEERR_INVALTRANSFERMODE: return "INVALTRANSFERMODE"; case LINEERR_LINEMAPPERFAILED: return "LINEMAPPERFAILED"; case LINEERR_NOCONFERENCE: return "NOCONFERENCE"; case LINEERR_NODEVICE: return "NODEVICE"; case LINEERR_NODRIVER: return "NODRIVER"; case LINEERR_NOMEM: return "NOMEM"; case LINEERR_NOREQUEST: return "NOREQUEST"; case LINEERR_NOTOWNER: return "NOTOWNER"; case LINEERR_NOTREGISTERED: return "NOTREGISTERED"; case LINEERR_OPERATIONFAILED: return "OPERATIONFAILED"; case LINEERR_OPERATIONUNAVAIL: return "OPERATIONUNAVAIL"; case LINEERR_RATEUNAVAIL: return "RATEUNAVAIL"; case LINEERR_RESOURCEUNAVAIL: return "RESOURCEUNAVAIL"; case LINEERR_REQUESTOVERRUN: return "REQUESTOVERRUN"; case LINEERR_STRUCTURETOOSMALL: return "STRUCTURETOOSMALL"; case LINEERR_TARGETNOTFOUND: return "TARGETNOTFOUND"; case LINEERR_TARGETSELF: return "TARGETSELF"; case LINEERR_UNINITIALIZED: return "UNINITIALIZED"; case LINEERR_USERUSERINFOTOOBIG: return "USERUSERINFOTOOBIG"; case LINEERR_REINIT: return "REINIT"; case LINEERR_ADDRESSBLOCKED: return "ADDRESSBLOCKED"; case LINEERR_BILLINGREJECTED: return "BILLINGREJECTED"; case LINEERR_INVALFEATURE: return "INVALFEATURE"; case LINEERR_NOMULTIPLEINSTANCE: return "NOMULTIPLEINSTANCE"; case LINEERR_INVALAGENTID: return "INVALAGENTID"; case LINEERR_INVALAGENTGROUP: return "INVALAGENTGROUP"; case LINEERR_INVALPASSWORD: return "INVALPASSWORD"; case LINEERR_INVALAGENTSTATE: return "INVALAGENTSTATE"; case LINEERR_INVALAGENTACTIVITY: return "INVALAGENTACTIVITY"; case LINEERR_DIALVOICEDETECT: return "DIALVOICEDETECT"; default: return stringformat("LINEERR_%08lx", dw); } } // bitmask decoder for LINEFEATURE: 9 values std::string LineFeatureString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEFEATURE_DEVSPECIFIC) list.push_back("DEVSPECIFIC"); if (dw & LINEFEATURE_DEVSPECIFICFEAT) list.push_back("DEVSPECIFICFEAT"); if (dw & LINEFEATURE_FORWARD) list.push_back("FORWARD"); if (dw & LINEFEATURE_MAKECALL) list.push_back("MAKECALL"); if (dw & LINEFEATURE_SETMEDIACONTROL) list.push_back("SETMEDIACONTROL"); if (dw & LINEFEATURE_SETTERMINAL) list.push_back("SETTERMINAL"); if (dw & LINEFEATURE_SETDEVSTATUS) list.push_back("SETDEVSTATUS"); if (dw & LINEFEATURE_FORWARDFWD) list.push_back("FORWARDFWD"); if (dw & LINEFEATURE_FORWARDDND) list.push_back("FORWARDDND"); DWORD dwKnown= LINEFEATURE_DEVSPECIFIC|LINEFEATURE_DEVSPECIFICFEAT|LINEFEATURE_FORWARD|LINEFEATURE_MAKECALL|LINEFEATURE_SETMEDIACONTROL|LINEFEATURE_SETTERMINAL|LINEFEATURE_SETDEVSTATUS|LINEFEATURE_FORWARDFWD|LINEFEATURE_FORWARDDND; if (dw&~dwKnown) list.push_back(stringformat("LINEFEATURE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEFORWARDMODE: 18 values std::string LineForwardModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEFORWARDMODE_UNCOND) list.push_back("UNCOND"); if (dw & LINEFORWARDMODE_UNCONDINTERNAL) list.push_back("UNCONDINTERNAL"); if (dw & LINEFORWARDMODE_UNCONDEXTERNAL) list.push_back("UNCONDEXTERNAL"); if (dw & LINEFORWARDMODE_UNCONDSPECIFIC) list.push_back("UNCONDSPECIFIC"); if (dw & LINEFORWARDMODE_BUSY) list.push_back("BUSY"); if (dw & LINEFORWARDMODE_BUSYINTERNAL) list.push_back("BUSYINTERNAL"); if (dw & LINEFORWARDMODE_BUSYEXTERNAL) list.push_back("BUSYEXTERNAL"); if (dw & LINEFORWARDMODE_BUSYSPECIFIC) list.push_back("BUSYSPECIFIC"); if (dw & LINEFORWARDMODE_NOANSW) list.push_back("NOANSW"); if (dw & LINEFORWARDMODE_NOANSWINTERNAL) list.push_back("NOANSWINTERNAL"); if (dw & LINEFORWARDMODE_NOANSWEXTERNAL) list.push_back("NOANSWEXTERNAL"); if (dw & LINEFORWARDMODE_NOANSWSPECIFIC) list.push_back("NOANSWSPECIFIC"); if (dw & LINEFORWARDMODE_BUSYNA) list.push_back("BUSYNA"); if (dw & LINEFORWARDMODE_BUSYNAINTERNAL) list.push_back("BUSYNAINTERNAL"); if (dw & LINEFORWARDMODE_BUSYNAEXTERNAL) list.push_back("BUSYNAEXTERNAL"); if (dw & LINEFORWARDMODE_BUSYNASPECIFIC) list.push_back("BUSYNASPECIFIC"); if (dw & LINEFORWARDMODE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEFORWARDMODE_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= LINEFORWARDMODE_UNCOND|LINEFORWARDMODE_UNCONDINTERNAL|LINEFORWARDMODE_UNCONDEXTERNAL|LINEFORWARDMODE_UNCONDSPECIFIC|LINEFORWARDMODE_BUSY|LINEFORWARDMODE_BUSYINTERNAL|LINEFORWARDMODE_BUSYEXTERNAL|LINEFORWARDMODE_BUSYSPECIFIC|LINEFORWARDMODE_NOANSW|LINEFORWARDMODE_NOANSWINTERNAL|LINEFORWARDMODE_NOANSWEXTERNAL|LINEFORWARDMODE_NOANSWSPECIFIC|LINEFORWARDMODE_BUSYNA|LINEFORWARDMODE_BUSYNAINTERNAL|LINEFORWARDMODE_BUSYNAEXTERNAL|LINEFORWARDMODE_BUSYNASPECIFIC|LINEFORWARDMODE_UNKNOWN|LINEFORWARDMODE_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("LINEFORWARDMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEGATHERTERM: 5 values std::string LineGatherTermString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEGATHERTERM_BUFFERFULL) list.push_back("BUFFERFULL"); if (dw & LINEGATHERTERM_TERMDIGIT) list.push_back("TERMDIGIT"); if (dw & LINEGATHERTERM_FIRSTTIMEOUT) list.push_back("FIRSTTIMEOUT"); if (dw & LINEGATHERTERM_INTERTIMEOUT) list.push_back("INTERTIMEOUT"); if (dw & LINEGATHERTERM_CANCEL) list.push_back("CANCEL"); DWORD dwKnown= LINEGATHERTERM_BUFFERFULL|LINEGATHERTERM_TERMDIGIT|LINEGATHERTERM_FIRSTTIMEOUT|LINEGATHERTERM_INTERTIMEOUT|LINEGATHERTERM_CANCEL; if (dw&~dwKnown) list.push_back(stringformat("LINEGATHERTERM_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEGENERATETERM: 2 values std::string LineGenerateTermString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEGENERATETERM_DONE) list.push_back("DONE"); if (dw & LINEGENERATETERM_CANCEL) list.push_back("CANCEL"); DWORD dwKnown= LINEGENERATETERM_DONE|LINEGENERATETERM_CANCEL; if (dw&~dwKnown) list.push_back(stringformat("LINEGENERATETERM_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for LINEINITIALIZEEXOPTION: 3 values std::string LineInitializeExOptionString(DWORD dw) { switch (dw) { case LINEINITIALIZEEXOPTION_USEHIDDENWINDOW: return "USEHIDDENWINDOW"; case LINEINITIALIZEEXOPTION_USEEVENT: return "USEEVENT"; case LINEINITIALIZEEXOPTION_USECOMPLETIONPORT: return "USECOMPLETIONPORT"; default: return stringformat("LINEINITIALIZEEXOPTION_%08lx", dw); } } // enum decoder for LINELOCATIONOPTION: 1 values std::string LineLocationOptionString(DWORD dw) { switch (dw) { case LINELOCATIONOPTION_PULSEDIAL: return "PULSEDIAL"; default: return stringformat("LINELOCATIONOPTION_%08lx", dw); } } // bitmask decoder for LINEMEDIACONTROL: 11 values std::string LineMediaControlString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEMEDIACONTROL_NONE) list.push_back("NONE"); if (dw & LINEMEDIACONTROL_START) list.push_back("START"); if (dw & LINEMEDIACONTROL_RESET) list.push_back("RESET"); if (dw & LINEMEDIACONTROL_PAUSE) list.push_back("PAUSE"); if (dw & LINEMEDIACONTROL_RESUME) list.push_back("RESUME"); if (dw & LINEMEDIACONTROL_RATEUP) list.push_back("RATEUP"); if (dw & LINEMEDIACONTROL_RATEDOWN) list.push_back("RATEDOWN"); if (dw & LINEMEDIACONTROL_RATENORMAL) list.push_back("RATENORMAL"); if (dw & LINEMEDIACONTROL_VOLUMEUP) list.push_back("VOLUMEUP"); if (dw & LINEMEDIACONTROL_VOLUMEDOWN) list.push_back("VOLUMEDOWN"); if (dw & LINEMEDIACONTROL_VOLUMENORMAL) list.push_back("VOLUMENORMAL"); DWORD dwKnown= LINEMEDIACONTROL_NONE|LINEMEDIACONTROL_START|LINEMEDIACONTROL_RESET|LINEMEDIACONTROL_PAUSE|LINEMEDIACONTROL_RESUME|LINEMEDIACONTROL_RATEUP|LINEMEDIACONTROL_RATEDOWN|LINEMEDIACONTROL_RATENORMAL|LINEMEDIACONTROL_VOLUMEUP|LINEMEDIACONTROL_VOLUMEDOWN|LINEMEDIACONTROL_VOLUMENORMAL; if (dw&~dwKnown) list.push_back(stringformat("LINEMEDIACONTROL_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEMEDIAMODE: 14 values std::string LineMediaModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEMEDIAMODE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEMEDIAMODE_INTERACTIVEVOICE) list.push_back("INTERACTIVEVOICE"); if (dw & LINEMEDIAMODE_AUTOMATEDVOICE) list.push_back("AUTOMATEDVOICE"); if (dw & LINEMEDIAMODE_DATAMODEM) list.push_back("DATAMODEM"); if (dw & LINEMEDIAMODE_G3FAX) list.push_back("G3FAX"); if (dw & LINEMEDIAMODE_TDD) list.push_back("TDD"); if (dw & LINEMEDIAMODE_G4FAX) list.push_back("G4FAX"); if (dw & LINEMEDIAMODE_DIGITALDATA) list.push_back("DIGITALDATA"); if (dw & LINEMEDIAMODE_TELETEX) list.push_back("TELETEX"); if (dw & LINEMEDIAMODE_VIDEOTEX) list.push_back("VIDEOTEX"); if (dw & LINEMEDIAMODE_TELEX) list.push_back("TELEX"); if (dw & LINEMEDIAMODE_MIXED) list.push_back("MIXED"); if (dw & LINEMEDIAMODE_ADSI) list.push_back("ADSI"); if (dw & LINEMEDIAMODE_VOICEVIEW) list.push_back("VOICEVIEW"); DWORD dwKnown= 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; if (dw&~dwKnown) list.push_back(stringformat("LINEMEDIAMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEOFFERINGMODE: 2 values std::string LineOfferingModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEOFFERINGMODE_ACTIVE) list.push_back("ACTIVE"); if (dw & LINEOFFERINGMODE_INACTIVE) list.push_back("INACTIVE"); DWORD dwKnown= LINEOFFERINGMODE_ACTIVE|LINEOFFERINGMODE_INACTIVE; if (dw&~dwKnown) list.push_back(stringformat("LINEOFFERINGMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEOPENOPTION: 2 values std::string LineOpenOptionString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEOPENOPTION_PROXY) list.push_back("PROXY"); if (dw & LINEOPENOPTION_SINGLEADDRESS) list.push_back("SINGLEADDRESS"); DWORD dwKnown= LINEOPENOPTION_PROXY|LINEOPENOPTION_SINGLEADDRESS; if (dw&~dwKnown) list.push_back(stringformat("LINEOPENOPTION_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEPARKMODE: 2 values std::string LineParkModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEPARKMODE_DIRECTED) list.push_back("DIRECTED"); if (dw & LINEPARKMODE_NONDIRECTED) list.push_back("NONDIRECTED"); DWORD dwKnown= LINEPARKMODE_DIRECTED|LINEPARKMODE_NONDIRECTED; if (dw&~dwKnown) list.push_back(stringformat("LINEPARKMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for LINEPROXYREQUEST: 8 values std::string LineProxyRequestString(DWORD dw) { switch (dw) { case LINEPROXYREQUEST_SETAGENTGROUP: return "SETAGENTGROUP"; case LINEPROXYREQUEST_SETAGENTSTATE: return "SETAGENTSTATE"; case LINEPROXYREQUEST_SETAGENTACTIVITY: return "SETAGENTACTIVITY"; case LINEPROXYREQUEST_GETAGENTCAPS: return "GETAGENTCAPS"; case LINEPROXYREQUEST_GETAGENTSTATUS: return "GETAGENTSTATUS"; case LINEPROXYREQUEST_AGENTSPECIFIC: return "AGENTSPECIFIC"; case LINEPROXYREQUEST_GETAGENTACTIVITYLIST: return "GETAGENTACTIVITYLIST"; case LINEPROXYREQUEST_GETAGENTGROUPLIST: return "GETAGENTGROUPLIST"; default: return stringformat("LINEPROXYREQUEST_%08lx", dw); } } // enum decoder for LINEREMOVEFROMCONF: 3 values std::string LineRemoveFromConfString(DWORD dw) { switch (dw) { case LINEREMOVEFROMCONF_NONE: return "NONE"; case LINEREMOVEFROMCONF_LAST: return "LAST"; case LINEREMOVEFROMCONF_ANY: return "ANY"; default: return stringformat("LINEREMOVEFROMCONF_%08lx", dw); } } // bitmask decoder for LINEREQUESTMODE: 3 values std::string LineRequestModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEREQUESTMODE_MAKECALL) list.push_back("MAKECALL"); if (dw & LINEREQUESTMODE_MEDIACALL) list.push_back("MEDIACALL"); if (dw & LINEREQUESTMODE_DROP) list.push_back("DROP"); DWORD dwKnown= LINEREQUESTMODE_MAKECALL|LINEREQUESTMODE_MEDIACALL|LINEREQUESTMODE_DROP; if (dw&~dwKnown) list.push_back(stringformat("LINEREQUESTMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINEROAMMODE: 5 values std::string LineRoamModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINEROAMMODE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINEROAMMODE_UNAVAIL) list.push_back("UNAVAIL"); if (dw & LINEROAMMODE_HOME) list.push_back("HOME"); if (dw & LINEROAMMODE_ROAMA) list.push_back("ROAMA"); if (dw & LINEROAMMODE_ROAMB) list.push_back("ROAMB"); DWORD dwKnown= LINEROAMMODE_UNKNOWN|LINEROAMMODE_UNAVAIL|LINEROAMMODE_HOME|LINEROAMMODE_ROAMA|LINEROAMMODE_ROAMB; if (dw&~dwKnown) list.push_back(stringformat("LINEROAMMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINESPECIALINFO: 5 values std::string LineSpecialInfoString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINESPECIALINFO_NOCIRCUIT) list.push_back("NOCIRCUIT"); if (dw & LINESPECIALINFO_CUSTIRREG) list.push_back("CUSTIRREG"); if (dw & LINESPECIALINFO_REORDER) list.push_back("REORDER"); if (dw & LINESPECIALINFO_UNKNOWN) list.push_back("UNKNOWN"); if (dw & LINESPECIALINFO_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= LINESPECIALINFO_NOCIRCUIT|LINESPECIALINFO_CUSTIRREG|LINESPECIALINFO_REORDER|LINESPECIALINFO_UNKNOWN|LINESPECIALINFO_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("LINESPECIALINFO_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETERMDEV: 3 values std::string LineTermDevString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETERMDEV_PHONE) list.push_back("PHONE"); if (dw & LINETERMDEV_HEADSET) list.push_back("HEADSET"); if (dw & LINETERMDEV_SPEAKER) list.push_back("SPEAKER"); DWORD dwKnown= LINETERMDEV_PHONE|LINETERMDEV_HEADSET|LINETERMDEV_SPEAKER; if (dw&~dwKnown) list.push_back(stringformat("LINETERMDEV_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETERMMODE: 8 values std::string LineTermModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETERMMODE_BUTTONS) list.push_back("BUTTONS"); if (dw & LINETERMMODE_LAMPS) list.push_back("LAMPS"); if (dw & LINETERMMODE_DISPLAY) list.push_back("DISPLAY"); if (dw & LINETERMMODE_RINGER) list.push_back("RINGER"); if (dw & LINETERMMODE_HOOKSWITCH) list.push_back("HOOKSWITCH"); if (dw & LINETERMMODE_MEDIATOLINE) list.push_back("MEDIATOLINE"); if (dw & LINETERMMODE_MEDIAFROMLINE) list.push_back("MEDIAFROMLINE"); if (dw & LINETERMMODE_MEDIABIDIRECT) list.push_back("MEDIABIDIRECT"); DWORD dwKnown= LINETERMMODE_BUTTONS|LINETERMMODE_LAMPS|LINETERMMODE_DISPLAY|LINETERMMODE_RINGER|LINETERMMODE_HOOKSWITCH|LINETERMMODE_MEDIATOLINE|LINETERMMODE_MEDIAFROMLINE|LINETERMMODE_MEDIABIDIRECT; if (dw&~dwKnown) list.push_back(stringformat("LINETERMMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETERMSHARING: 3 values std::string LineTermSharingString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETERMSHARING_PRIVATE) list.push_back("PRIVATE"); if (dw & LINETERMSHARING_SHAREDEXCL) list.push_back("SHAREDEXCL"); if (dw & LINETERMSHARING_SHAREDCONF) list.push_back("SHAREDCONF"); DWORD dwKnown= LINETERMSHARING_PRIVATE|LINETERMSHARING_SHAREDEXCL|LINETERMSHARING_SHAREDCONF; if (dw&~dwKnown) list.push_back(stringformat("LINETERMSHARING_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETOLLLISTOPTION: 2 values std::string LineTolllistOptionString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETOLLLISTOPTION_ADD) list.push_back("ADD"); if (dw & LINETOLLLISTOPTION_REMOVE) list.push_back("REMOVE"); DWORD dwKnown= LINETOLLLISTOPTION_ADD|LINETOLLLISTOPTION_REMOVE; if (dw&~dwKnown) list.push_back(stringformat("LINETOLLLISTOPTION_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETONEMODE: 5 values std::string LineToneModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETONEMODE_CUSTOM) list.push_back("CUSTOM"); if (dw & LINETONEMODE_RINGBACK) list.push_back("RINGBACK"); if (dw & LINETONEMODE_BUSY) list.push_back("BUSY"); if (dw & LINETONEMODE_BEEP) list.push_back("BEEP"); if (dw & LINETONEMODE_BILLING) list.push_back("BILLING"); DWORD dwKnown= LINETONEMODE_CUSTOM|LINETONEMODE_RINGBACK|LINETONEMODE_BUSY|LINETONEMODE_BEEP|LINETONEMODE_BILLING; if (dw&~dwKnown) list.push_back(stringformat("LINETONEMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETRANSFERMODE: 2 values std::string LineTransferModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETRANSFERMODE_TRANSFER) list.push_back("TRANSFER"); if (dw & LINETRANSFERMODE_CONFERENCE) list.push_back("CONFERENCE"); DWORD dwKnown= LINETRANSFERMODE_TRANSFER|LINETRANSFERMODE_CONFERENCE; if (dw&~dwKnown) list.push_back(stringformat("LINETRANSFERMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETRANSLATEOPTION: 4 values std::string LineTranslateOptionString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETRANSLATEOPTION_CARDOVERRIDE) list.push_back("CARDOVERRIDE"); if (dw & LINETRANSLATEOPTION_CANCELCALLWAITING) list.push_back("CANCELCALLWAITING"); if (dw & LINETRANSLATEOPTION_FORCELOCAL) list.push_back("FORCELOCAL"); if (dw & LINETRANSLATEOPTION_FORCELD) list.push_back("FORCELD"); DWORD dwKnown= LINETRANSLATEOPTION_CARDOVERRIDE|LINETRANSLATEOPTION_CANCELCALLWAITING|LINETRANSLATEOPTION_FORCELOCAL|LINETRANSLATEOPTION_FORCELD; if (dw&~dwKnown) list.push_back(stringformat("LINETRANSLATEOPTION_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for LINETRANSLATERESULT: 11 values std::string LineTranslateResultString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & LINETRANSLATERESULT_CANONICAL) list.push_back("CANONICAL"); if (dw & LINETRANSLATERESULT_INTERNATIONAL) list.push_back("INTERNATIONAL"); if (dw & LINETRANSLATERESULT_LONGDISTANCE) list.push_back("LONGDISTANCE"); if (dw & LINETRANSLATERESULT_LOCAL) list.push_back("LOCAL"); if (dw & LINETRANSLATERESULT_INTOLLLIST) list.push_back("INTOLLLIST"); if (dw & LINETRANSLATERESULT_NOTINTOLLLIST) list.push_back("NOTINTOLLLIST"); if (dw & LINETRANSLATERESULT_DIALBILLING) list.push_back("DIALBILLING"); if (dw & LINETRANSLATERESULT_DIALQUIET) list.push_back("DIALQUIET"); if (dw & LINETRANSLATERESULT_DIALDIALTONE) list.push_back("DIALDIALTONE"); if (dw & LINETRANSLATERESULT_DIALPROMPT) list.push_back("DIALPROMPT"); if (dw & LINETRANSLATERESULT_VOICEDETECT) list.push_back("VOICEDETECT"); DWORD dwKnown= LINETRANSLATERESULT_CANONICAL|LINETRANSLATERESULT_INTERNATIONAL|LINETRANSLATERESULT_LONGDISTANCE|LINETRANSLATERESULT_LOCAL|LINETRANSLATERESULT_INTOLLLIST|LINETRANSLATERESULT_NOTINTOLLLIST|LINETRANSLATERESULT_DIALBILLING|LINETRANSLATERESULT_DIALQUIET|LINETRANSLATERESULT_DIALDIALTONE|LINETRANSLATERESULT_DIALPROMPT|LINETRANSLATERESULT_VOICEDETECT; if (dw&~dwKnown) list.push_back(stringformat("LINETRANSLATERESULT_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for PHONE: 7 values std::string PhoneString(DWORD dw) { switch (dw) { case PHONE_BUTTON: return "BUTTON"; case PHONE_CLOSE: return "CLOSE"; case PHONE_DEVSPECIFIC: return "DEVSPECIFIC"; case PHONE_REPLY: return "REPLY"; case PHONE_STATE: return "STATE"; case PHONE_CREATE: return "CREATE"; case PHONE_REMOVE: return "REMOVE"; default: return stringformat("PHONE_%08lx", dw); } } // enum decoder for PHONEBUTTONFUNCTION: 47 values std::string PhoneButtonFunctionString(DWORD dw) { switch (dw) { case PHONEBUTTONFUNCTION_UNKNOWN: return "UNKNOWN"; case PHONEBUTTONFUNCTION_CONFERENCE: return "CONFERENCE"; case PHONEBUTTONFUNCTION_TRANSFER: return "TRANSFER"; case PHONEBUTTONFUNCTION_DROP: return "DROP"; case PHONEBUTTONFUNCTION_HOLD: return "HOLD"; case PHONEBUTTONFUNCTION_RECALL: return "RECALL"; case PHONEBUTTONFUNCTION_DISCONNECT: return "DISCONNECT"; case PHONEBUTTONFUNCTION_CONNECT: return "CONNECT"; case PHONEBUTTONFUNCTION_MSGWAITON: return "MSGWAITON"; case PHONEBUTTONFUNCTION_MSGWAITOFF: return "MSGWAITOFF"; case PHONEBUTTONFUNCTION_SELECTRING: return "SELECTRING"; case PHONEBUTTONFUNCTION_ABBREVDIAL: return "ABBREVDIAL"; case PHONEBUTTONFUNCTION_FORWARD: return "FORWARD"; case PHONEBUTTONFUNCTION_PICKUP: return "PICKUP"; case PHONEBUTTONFUNCTION_RINGAGAIN: return "RINGAGAIN"; case PHONEBUTTONFUNCTION_PARK: return "PARK"; case PHONEBUTTONFUNCTION_REJECT: return "REJECT"; case PHONEBUTTONFUNCTION_REDIRECT: return "REDIRECT"; case PHONEBUTTONFUNCTION_MUTE: return "MUTE"; case PHONEBUTTONFUNCTION_VOLUMEUP: return "VOLUMEUP"; case PHONEBUTTONFUNCTION_VOLUMEDOWN: return "VOLUMEDOWN"; case PHONEBUTTONFUNCTION_SPEAKERON: return "SPEAKERON"; case PHONEBUTTONFUNCTION_SPEAKEROFF: return "SPEAKEROFF"; case PHONEBUTTONFUNCTION_FLASH: return "FLASH"; case PHONEBUTTONFUNCTION_DATAON: return "DATAON"; case PHONEBUTTONFUNCTION_DATAOFF: return "DATAOFF"; case PHONEBUTTONFUNCTION_DONOTDISTURB: return "DONOTDISTURB"; case PHONEBUTTONFUNCTION_INTERCOM: return "INTERCOM"; case PHONEBUTTONFUNCTION_BRIDGEDAPP: return "BRIDGEDAPP"; case PHONEBUTTONFUNCTION_BUSY: return "BUSY"; case PHONEBUTTONFUNCTION_CALLAPP: return "CALLAPP"; case PHONEBUTTONFUNCTION_DATETIME: return "DATETIME"; case PHONEBUTTONFUNCTION_DIRECTORY: return "DIRECTORY"; case PHONEBUTTONFUNCTION_COVER: return "COVER"; case PHONEBUTTONFUNCTION_CALLID: return "CALLID"; case PHONEBUTTONFUNCTION_LASTNUM: return "LASTNUM"; case PHONEBUTTONFUNCTION_NIGHTSRV: return "NIGHTSRV"; case PHONEBUTTONFUNCTION_SENDCALLS: return "SENDCALLS"; case PHONEBUTTONFUNCTION_MSGINDICATOR: return "MSGINDICATOR"; case PHONEBUTTONFUNCTION_REPDIAL: return "REPDIAL"; case PHONEBUTTONFUNCTION_SETREPDIAL: return "SETREPDIAL"; case PHONEBUTTONFUNCTION_SYSTEMSPEED: return "SYSTEMSPEED"; case PHONEBUTTONFUNCTION_STATIONSPEED: return "STATIONSPEED"; case PHONEBUTTONFUNCTION_CAMPON: return "CAMPON"; case PHONEBUTTONFUNCTION_SAVEREPEAT: return "SAVEREPEAT"; case PHONEBUTTONFUNCTION_QUEUECALL: return "QUEUECALL"; case PHONEBUTTONFUNCTION_NONE: return "NONE"; default: return stringformat("PHONEBUTTONFUNCTION_%08lx", dw); } } // bitmask decoder for PHONEBUTTONMODE: 6 values std::string PhoneButtonModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONEBUTTONMODE_DUMMY) list.push_back("DUMMY"); if (dw & PHONEBUTTONMODE_CALL) list.push_back("CALL"); if (dw & PHONEBUTTONMODE_FEATURE) list.push_back("FEATURE"); if (dw & PHONEBUTTONMODE_KEYPAD) list.push_back("KEYPAD"); if (dw & PHONEBUTTONMODE_LOCAL) list.push_back("LOCAL"); if (dw & PHONEBUTTONMODE_DISPLAY) list.push_back("DISPLAY"); DWORD dwKnown= PHONEBUTTONMODE_DUMMY|PHONEBUTTONMODE_CALL|PHONEBUTTONMODE_FEATURE|PHONEBUTTONMODE_KEYPAD|PHONEBUTTONMODE_LOCAL|PHONEBUTTONMODE_DISPLAY; if (dw&~dwKnown) list.push_back(stringformat("PHONEBUTTONMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for PHONEBUTTONSTATE: 4 values std::string PhoneButtonStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONEBUTTONSTATE_UP) list.push_back("UP"); if (dw & PHONEBUTTONSTATE_DOWN) list.push_back("DOWN"); if (dw & PHONEBUTTONSTATE_UNKNOWN) list.push_back("UNKNOWN"); if (dw & PHONEBUTTONSTATE_UNAVAIL) list.push_back("UNAVAIL"); DWORD dwKnown= PHONEBUTTONSTATE_UP|PHONEBUTTONSTATE_DOWN|PHONEBUTTONSTATE_UNKNOWN|PHONEBUTTONSTATE_UNAVAIL; if (dw&~dwKnown) list.push_back(stringformat("PHONEBUTTONSTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for PHONEERR: 34 values std::string PhoneErrString(DWORD dw) { switch (dw) { case PHONEERR_ALLOCATED: return "ALLOCATED"; case PHONEERR_BADDEVICEID: return "BADDEVICEID"; case PHONEERR_INCOMPATIBLEAPIVERSION: return "INCOMPATIBLEAPIVERSION"; case PHONEERR_INCOMPATIBLEEXTVERSION: return "INCOMPATIBLEEXTVERSION"; case PHONEERR_INIFILECORRUPT: return "INIFILECORRUPT"; case PHONEERR_INUSE: return "INUSE"; case PHONEERR_INVALAPPHANDLE: return "INVALAPPHANDLE"; case PHONEERR_INVALAPPNAME: return "INVALAPPNAME"; case PHONEERR_INVALBUTTONLAMPID: return "INVALBUTTONLAMPID"; case PHONEERR_INVALBUTTONMODE: return "INVALBUTTONMODE"; case PHONEERR_INVALBUTTONSTATE: return "INVALBUTTONSTATE"; case PHONEERR_INVALDATAID: return "INVALDATAID"; case PHONEERR_INVALDEVICECLASS: return "INVALDEVICECLASS"; case PHONEERR_INVALEXTVERSION: return "INVALEXTVERSION"; case PHONEERR_INVALHOOKSWITCHDEV: return "INVALHOOKSWITCHDEV"; case PHONEERR_INVALHOOKSWITCHMODE: return "INVALHOOKSWITCHMODE"; case PHONEERR_INVALLAMPMODE: return "INVALLAMPMODE"; case PHONEERR_INVALPARAM: return "INVALPARAM"; case PHONEERR_INVALPHONEHANDLE: return "INVALPHONEHANDLE"; case PHONEERR_INVALPHONESTATE: return "INVALPHONESTATE"; case PHONEERR_INVALPOINTER: return "INVALPOINTER"; case PHONEERR_INVALPRIVILEGE: return "INVALPRIVILEGE"; case PHONEERR_INVALRINGMODE: return "INVALRINGMODE"; case PHONEERR_NODEVICE: return "NODEVICE"; case PHONEERR_NODRIVER: return "NODRIVER"; case PHONEERR_NOMEM: return "NOMEM"; case PHONEERR_NOTOWNER: return "NOTOWNER"; case PHONEERR_OPERATIONFAILED: return "OPERATIONFAILED"; case PHONEERR_OPERATIONUNAVAIL: return "OPERATIONUNAVAIL"; case PHONEERR_RESOURCEUNAVAIL: return "RESOURCEUNAVAIL"; case PHONEERR_REQUESTOVERRUN: return "REQUESTOVERRUN"; case PHONEERR_STRUCTURETOOSMALL: return "STRUCTURETOOSMALL"; case PHONEERR_UNINITIALIZED: return "UNINITIALIZED"; case PHONEERR_REINIT: return "REINIT"; default: return stringformat("PHONEERR_%08lx", dw); } } // bitmask decoder for PHONEFEATURE: 28 values std::string PhoneFeatureString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONEFEATURE_GETBUTTONINFO) list.push_back("GETBUTTONINFO"); if (dw & PHONEFEATURE_GETDATA) list.push_back("GETDATA"); if (dw & PHONEFEATURE_GETDISPLAY) list.push_back("GETDISPLAY"); if (dw & PHONEFEATURE_GETGAINHANDSET) list.push_back("GETGAINHANDSET"); if (dw & PHONEFEATURE_GETGAINSPEAKER) list.push_back("GETGAINSPEAKER"); if (dw & PHONEFEATURE_GETGAINHEADSET) list.push_back("GETGAINHEADSET"); if (dw & PHONEFEATURE_GETHOOKSWITCHHANDSET) list.push_back("GETHOOKSWITCHHANDSET"); if (dw & PHONEFEATURE_GETHOOKSWITCHSPEAKER) list.push_back("GETHOOKSWITCHSPEAKER"); if (dw & PHONEFEATURE_GETHOOKSWITCHHEADSET) list.push_back("GETHOOKSWITCHHEADSET"); if (dw & PHONEFEATURE_GETLAMP) list.push_back("GETLAMP"); if (dw & PHONEFEATURE_GETRING) list.push_back("GETRING"); if (dw & PHONEFEATURE_GETVOLUMEHANDSET) list.push_back("GETVOLUMEHANDSET"); if (dw & PHONEFEATURE_GETVOLUMESPEAKER) list.push_back("GETVOLUMESPEAKER"); if (dw & PHONEFEATURE_GETVOLUMEHEADSET) list.push_back("GETVOLUMEHEADSET"); if (dw & PHONEFEATURE_SETBUTTONINFO) list.push_back("SETBUTTONINFO"); if (dw & PHONEFEATURE_SETDATA) list.push_back("SETDATA"); if (dw & PHONEFEATURE_SETDISPLAY) list.push_back("SETDISPLAY"); if (dw & PHONEFEATURE_SETGAINHANDSET) list.push_back("SETGAINHANDSET"); if (dw & PHONEFEATURE_SETGAINSPEAKER) list.push_back("SETGAINSPEAKER"); if (dw & PHONEFEATURE_SETGAINHEADSET) list.push_back("SETGAINHEADSET"); if (dw & PHONEFEATURE_SETHOOKSWITCHHANDSET) list.push_back("SETHOOKSWITCHHANDSET"); if (dw & PHONEFEATURE_SETHOOKSWITCHSPEAKER) list.push_back("SETHOOKSWITCHSPEAKER"); if (dw & PHONEFEATURE_SETHOOKSWITCHHEADSET) list.push_back("SETHOOKSWITCHHEADSET"); if (dw & PHONEFEATURE_SETLAMP) list.push_back("SETLAMP"); if (dw & PHONEFEATURE_SETRING) list.push_back("SETRING"); if (dw & PHONEFEATURE_SETVOLUMEHANDSET) list.push_back("SETVOLUMEHANDSET"); if (dw & PHONEFEATURE_SETVOLUMESPEAKER) list.push_back("SETVOLUMESPEAKER"); if (dw & PHONEFEATURE_SETVOLUMEHEADSET) list.push_back("SETVOLUMEHEADSET"); DWORD dwKnown= PHONEFEATURE_GETBUTTONINFO|PHONEFEATURE_GETDATA|PHONEFEATURE_GETDISPLAY|PHONEFEATURE_GETGAINHANDSET|PHONEFEATURE_GETGAINSPEAKER|PHONEFEATURE_GETGAINHEADSET|PHONEFEATURE_GETHOOKSWITCHHANDSET|PHONEFEATURE_GETHOOKSWITCHSPEAKER|PHONEFEATURE_GETHOOKSWITCHHEADSET|PHONEFEATURE_GETLAMP|PHONEFEATURE_GETRING|PHONEFEATURE_GETVOLUMEHANDSET|PHONEFEATURE_GETVOLUMESPEAKER|PHONEFEATURE_GETVOLUMEHEADSET|PHONEFEATURE_SETBUTTONINFO|PHONEFEATURE_SETDATA|PHONEFEATURE_SETDISPLAY|PHONEFEATURE_SETGAINHANDSET|PHONEFEATURE_SETGAINSPEAKER|PHONEFEATURE_SETGAINHEADSET|PHONEFEATURE_SETHOOKSWITCHHANDSET|PHONEFEATURE_SETHOOKSWITCHSPEAKER|PHONEFEATURE_SETHOOKSWITCHHEADSET|PHONEFEATURE_SETLAMP|PHONEFEATURE_SETRING|PHONEFEATURE_SETVOLUMEHANDSET|PHONEFEATURE_SETVOLUMESPEAKER|PHONEFEATURE_SETVOLUMEHEADSET; if (dw&~dwKnown) list.push_back(stringformat("PHONEFEATURE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for PHONEHOOKSWITCHDEV: 3 values std::string PhoneHookSwitchDevString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONEHOOKSWITCHDEV_HANDSET) list.push_back("HANDSET"); if (dw & PHONEHOOKSWITCHDEV_SPEAKER) list.push_back("SPEAKER"); if (dw & PHONEHOOKSWITCHDEV_HEADSET) list.push_back("HEADSET"); DWORD dwKnown= PHONEHOOKSWITCHDEV_HANDSET|PHONEHOOKSWITCHDEV_SPEAKER|PHONEHOOKSWITCHDEV_HEADSET; if (dw&~dwKnown) list.push_back(stringformat("PHONEHOOKSWITCHDEV_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for PHONEHOOKSWITCHMODE: 5 values std::string PhoneHookSwitchModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONEHOOKSWITCHMODE_ONHOOK) list.push_back("ONHOOK"); if (dw & PHONEHOOKSWITCHMODE_MIC) list.push_back("MIC"); if (dw & PHONEHOOKSWITCHMODE_SPEAKER) list.push_back("SPEAKER"); if (dw & PHONEHOOKSWITCHMODE_MICSPEAKER) list.push_back("MICSPEAKER"); if (dw & PHONEHOOKSWITCHMODE_UNKNOWN) list.push_back("UNKNOWN"); DWORD dwKnown= PHONEHOOKSWITCHMODE_ONHOOK|PHONEHOOKSWITCHMODE_MIC|PHONEHOOKSWITCHMODE_SPEAKER|PHONEHOOKSWITCHMODE_MICSPEAKER|PHONEHOOKSWITCHMODE_UNKNOWN; if (dw&~dwKnown) list.push_back(stringformat("PHONEHOOKSWITCHMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for PHONEINITIALIZEEXOPTION: 3 values std::string PhoneInitializeexOptionString(DWORD dw) { switch (dw) { case PHONEINITIALIZEEXOPTION_USEHIDDENWINDOW: return "USEHIDDENWINDOW"; case PHONEINITIALIZEEXOPTION_USEEVENT: return "USEEVENT"; case PHONEINITIALIZEEXOPTION_USECOMPLETIONPORT: return "USECOMPLETIONPORT"; default: return stringformat("PHONEINITIALIZEEXOPTION_%08lx", dw); } } // bitmask decoder for PHONELAMPMODE: 8 values std::string PhoneLampModeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONELAMPMODE_DUMMY) list.push_back("DUMMY"); if (dw & PHONELAMPMODE_OFF) list.push_back("OFF"); if (dw & PHONELAMPMODE_STEADY) list.push_back("STEADY"); if (dw & PHONELAMPMODE_WINK) list.push_back("WINK"); if (dw & PHONELAMPMODE_FLASH) list.push_back("FLASH"); if (dw & PHONELAMPMODE_FLUTTER) list.push_back("FLUTTER"); if (dw & PHONELAMPMODE_BROKENFLUTTER) list.push_back("BROKENFLUTTER"); if (dw & PHONELAMPMODE_UNKNOWN) list.push_back("UNKNOWN"); DWORD dwKnown= PHONELAMPMODE_DUMMY|PHONELAMPMODE_OFF|PHONELAMPMODE_STEADY|PHONELAMPMODE_WINK|PHONELAMPMODE_FLASH|PHONELAMPMODE_FLUTTER|PHONELAMPMODE_BROKENFLUTTER|PHONELAMPMODE_UNKNOWN; if (dw&~dwKnown) list.push_back(stringformat("PHONELAMPMODE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for PHONEPRIVILEGE: 2 values std::string PhonePrivilegeString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONEPRIVILEGE_MONITOR) list.push_back("MONITOR"); if (dw & PHONEPRIVILEGE_OWNER) list.push_back("OWNER"); DWORD dwKnown= PHONEPRIVILEGE_MONITOR|PHONEPRIVILEGE_OWNER; if (dw&~dwKnown) list.push_back(stringformat("PHONEPRIVILEGE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for PHONESTATE: 24 values std::string PhoneStateString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONESTATE_OTHER) list.push_back("OTHER"); if (dw & PHONESTATE_CONNECTED) list.push_back("CONNECTED"); if (dw & PHONESTATE_DISCONNECTED) list.push_back("DISCONNECTED"); if (dw & PHONESTATE_OWNER) list.push_back("OWNER"); if (dw & PHONESTATE_MONITORS) list.push_back("MONITORS"); if (dw & PHONESTATE_DISPLAY) list.push_back("DISPLAY"); if (dw & PHONESTATE_LAMP) list.push_back("LAMP"); if (dw & PHONESTATE_RINGMODE) list.push_back("RINGMODE"); if (dw & PHONESTATE_RINGVOLUME) list.push_back("RINGVOLUME"); if (dw & PHONESTATE_HANDSETHOOKSWITCH) list.push_back("HANDSETHOOKSWITCH"); if (dw & PHONESTATE_HANDSETVOLUME) list.push_back("HANDSETVOLUME"); if (dw & PHONESTATE_HANDSETGAIN) list.push_back("HANDSETGAIN"); if (dw & PHONESTATE_SPEAKERHOOKSWITCH) list.push_back("SPEAKERHOOKSWITCH"); if (dw & PHONESTATE_SPEAKERVOLUME) list.push_back("SPEAKERVOLUME"); if (dw & PHONESTATE_SPEAKERGAIN) list.push_back("SPEAKERGAIN"); if (dw & PHONESTATE_HEADSETHOOKSWITCH) list.push_back("HEADSETHOOKSWITCH"); if (dw & PHONESTATE_HEADSETVOLUME) list.push_back("HEADSETVOLUME"); if (dw & PHONESTATE_HEADSETGAIN) list.push_back("HEADSETGAIN"); if (dw & PHONESTATE_SUSPEND) list.push_back("SUSPEND"); if (dw & PHONESTATE_RESUME) list.push_back("RESUME"); if (dw & PHONESTATE_DEVSPECIFIC) list.push_back("DEVSPECIFIC"); if (dw & PHONESTATE_REINIT) list.push_back("REINIT"); if (dw & PHONESTATE_CAPSCHANGE) list.push_back("CAPSCHANGE"); if (dw & PHONESTATE_REMOVED) list.push_back("REMOVED"); DWORD dwKnown= PHONESTATE_OTHER|PHONESTATE_CONNECTED|PHONESTATE_DISCONNECTED|PHONESTATE_OWNER|PHONESTATE_MONITORS|PHONESTATE_DISPLAY|PHONESTATE_LAMP|PHONESTATE_RINGMODE|PHONESTATE_RINGVOLUME|PHONESTATE_HANDSETHOOKSWITCH|PHONESTATE_HANDSETVOLUME|PHONESTATE_HANDSETGAIN|PHONESTATE_SPEAKERHOOKSWITCH|PHONESTATE_SPEAKERVOLUME|PHONESTATE_SPEAKERGAIN|PHONESTATE_HEADSETHOOKSWITCH|PHONESTATE_HEADSETVOLUME|PHONESTATE_HEADSETGAIN|PHONESTATE_SUSPEND|PHONESTATE_RESUME|PHONESTATE_DEVSPECIFIC|PHONESTATE_REINIT|PHONESTATE_CAPSCHANGE|PHONESTATE_REMOVED; if (dw&~dwKnown) list.push_back(stringformat("PHONESTATE_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // bitmask decoder for PHONESTATUSFLAGS: 2 values std::string PhoneStatusFlagsString(DWORD dw) { if (dw==0) return "(none)"; StringList list; if (dw & PHONESTATUSFLAGS_CONNECTED) list.push_back("CONNECTED"); if (dw & PHONESTATUSFLAGS_SUSPENDED) list.push_back("SUSPENDED"); DWORD dwKnown= PHONESTATUSFLAGS_CONNECTED|PHONESTATUSFLAGS_SUSPENDED; if (dw&~dwKnown) list.push_back(stringformat("PHONESTATUSFLAGS_%08lx", dw&~dwKnown)); return JoinStringList(list, ","); } // enum decoder for STRINGFORMAT: 4 values std::string StringFormatString(DWORD dw) { switch (dw) { case STRINGFORMAT_ASCII: return "ASCII"; case STRINGFORMAT_DBCS: return "DBCS"; case STRINGFORMAT_UNICODE: return "UNICODE"; case STRINGFORMAT_BINARY: return "BINARY"; default: return stringformat("STRINGFORMAT_%08lx", dw); } } // enum decoder for TAPIERR: 19 values std::string TapiErrString(DWORD dw) { switch (dw) { case TAPIERR_INVALPOINTER: return "INVALPOINTER"; case TAPIERR_REQUESTCANCELLED: return "REQUESTCANCELLED"; case TAPIERR_REQUESTFAILED: return "REQUESTFAILED"; case TAPIERR_UNKNOWNREQUESTID: return "UNKNOWNREQUESTID"; case TAPIERR_UNKNOWNWINHANDLE: return "UNKNOWNWINHANDLE"; case TAPIERR_DESTUNAVAIL: return "DESTUNAVAIL"; case TAPIERR_DESTNOANSWER: return "DESTNOANSWER"; case TAPIERR_DESTBUSY: return "DESTBUSY"; case TAPIERR_DEVICEINUSE: return "DEVICEINUSE"; case TAPIERR_DEVICEIDUNAVAIL: return "DEVICEIDUNAVAIL"; case TAPIERR_DEVICECLASSUNAVAIL: return "DEVICECLASSUNAVAIL"; case TAPIERR_INVALDEVICEID: return "INVALDEVICEID"; case TAPIERR_INVALDEVICECLASS: return "INVALDEVICECLASS"; case TAPIERR_INVALWINDOWHANDLE: return "INVALWINDOWHANDLE"; case TAPIERR_INVALDESTADDRESS: return "INVALDESTADDRESS"; case TAPIERR_REQUESTQUEUEFULL: return "REQUESTQUEUEFULL"; case TAPIERR_NOREQUESTRECIPIENT: return "NOREQUESTRECIPIENT"; case TAPIERR_DROPPED: return "DROPPED"; case TAPIERR_CONNECTED: return "CONNECTED"; default: return stringformat("TAPIERR_%08lx", dw); } } // TODO: create std::string LineCallStateModeString(DWORD dwState, DWORD dwMode) { switch (dwState) { case LINECALLSTATE_BUSY: return LineBusyModeString(dwMode); case LINECALLSTATE_CONNECTED: return LineConnectedModeString(dwMode); case LINECALLSTATE_DIALTONE: return LineDialToneModeString(dwMode); case LINECALLSTATE_DISCONNECTED: return LineDisconnectModeString(dwMode); case LINECALLSTATE_OFFERING: return LineOfferingModeString(dwMode); case LINECALLSTATE_SPECIALINFO: return LineSpecialInfoString(dwMode); default: return stringformat("LINE_%08lxMODE_%08lx", dwState, dwMode); } } std::string SZString(const BYTE *p, DWORD dwLen) { TCHAR *str= (TCHAR*)p; #ifndef _UNICODE return stringformat("'%hs'", str); #else return stringformat("'%ls'", str); #endif } LPCTSTRVector GetSzStringList(const BYTE *p, DWORD dwLen) { LPCTSTRVector list; DWORD dwOfs= 0; TCHAR *str= (TCHAR*)p; while (str[dwOfs] && dwOfsdwMediaModes).c_str()); debug("tapi_LINEMEDIACONTROLMEDIA: dwDuration=%08lx\n", p->dwDuration); debug("tapi_LINEMEDIACONTROLMEDIA: dwMediaControl=%hs\n", LineMediaControlString(p->dwMediaControl).c_str()); } // result of void log_tapi_linemediacontroltone(const LINEMEDIACONTROLTONE *p) { debug("tapi_LINEMEDIACONTROLTONE: dwAppSpecific=%08lx\n", p->dwAppSpecific); debug("tapi_LINEMEDIACONTROLTONE: dwDuration=%08lx\n", p->dwDuration); debug("tapi_LINEMEDIACONTROLTONE: dwFrequency1=%08lx\n", p->dwFrequency1); debug("tapi_LINEMEDIACONTROLTONE: dwFrequency2=%08lx\n", p->dwFrequency2); debug("tapi_LINEMEDIACONTROLTONE: dwFrequency3=%08lx\n", p->dwFrequency3); debug("tapi_LINEMEDIACONTROLTONE: dwMediaControl=%hs\n", LineMediaControlString(p->dwMediaControl).c_str()); } // result of void log_tapi_linecountrylist(const LINECOUNTRYLIST *p) { debug("tapi_LINECOUNTRYLIST: dwNumCountries=%08lx\n", p->dwNumCountries); // TODO: special ((BYTE*)p+p->dwCountryListOffset), p->dwCountryListSize if (p->dwCountryListOffset!=0 || p->dwCountryListSize!=0) debug("tapi_LINECOUNTRYLIST: CountryList : %08lx %08lx\n", p->dwCountryListOffset, p->dwCountryListSize); } // result of void log_tapi_linemediacontrolcallstate(const LINEMEDIACONTROLCALLSTATE *p) { debug("tapi_LINEMEDIACONTROLCALLSTATE: dwCallStates=%hs\n", LineCallStateString(p->dwCallStates).c_str()); debug("tapi_LINEMEDIACONTROLCALLSTATE: dwMediaControl=%hs\n", LineMediaControlString(p->dwMediaControl).c_str()); } // result of void log_tapi_lineforwardlist(const LINEFORWARDLIST *p) { debug("tapi_LINEFORWARDLIST: dwNumEntries=%08lx\n", p->dwNumEntries); for (DWORD i=0 ; idwNumEntries ; i++) { debug("tapi_LINEFORWARDLIST: %d :", i); log_tapi_lineforward(&(p->ForwardList[i])); } } // result of void log_tapi_linetermcaps(const LINETERMCAPS *p) { debug("tapi_LINETERMCAPS: dwTermDev=%hs\n", LineTermDevString(p->dwTermDev).c_str()); debug("tapi_LINETERMCAPS: dwTermModes=%hs\n", LineTermModeString(p->dwTermModes).c_str()); debug("tapi_LINETERMCAPS: dwTermSharing=%hs\n", LineTermSharingString(p->dwTermSharing).c_str()); } // result of void log_tapi_lineproviderentry(const LINEPROVIDERENTRY *p) { debug("tapi_LINEPROVIDERENTRY: dwPermanentProviderID=%08lx\n", p->dwPermanentProviderID); // TODO: special ((BYTE*)p+p->dwProviderFilenameOffset), p->dwProviderFilenameSize if (p->dwProviderFilenameOffset!=0 || p->dwProviderFilenameSize!=0) debug("tapi_LINEPROVIDERENTRY: ProviderFilename : %08lx %08lx\n", p->dwProviderFilenameOffset, p->dwProviderFilenameSize); } // result of void log_tapi_linecalltreatmententry(const LINECALLTREATMENTENTRY *p) { debug("tapi_LINECALLTREATMENTENTRY: dwCallTreatmentID=%08lx\n", p->dwCallTreatmentID); // TODO: special ((BYTE*)p+p->dwCallTreatmentNameOffset), p->dwCallTreatmentNameSize if (p->dwCallTreatmentNameOffset!=0 || p->dwCallTreatmentNameSize!=0) debug("tapi_LINECALLTREATMENTENTRY: CallTreatmentName : %08lx %08lx\n", p->dwCallTreatmentNameOffset, p->dwCallTreatmentNameSize); } // result of void log_tapi_linecountryentry(const LINECOUNTRYENTRY *p) { debug("tapi_LINECOUNTRYENTRY: dwCountryID=%08lx\n", p->dwCountryID); debug("tapi_LINECOUNTRYENTRY: dwCountryCode=%08lx\n", p->dwCountryCode); debug("tapi_LINECOUNTRYENTRY: dwNextCountryID=%08lx\n", p->dwNextCountryID); // TODO: special ((BYTE*)p+p->dwCountryNameOffset), p->dwCountryNameSize if (p->dwCountryNameOffset!=0 || p->dwCountryNameSize!=0) debug("tapi_LINECOUNTRYENTRY: CountryName : %08lx %08lx\n", p->dwCountryNameOffset, p->dwCountryNameSize); // TODO: special ((BYTE*)p+p->dwInternationalRuleOffset), p->dwInternationalRuleSize if (p->dwInternationalRuleOffset!=0 || p->dwInternationalRuleSize!=0) debug("tapi_LINECOUNTRYENTRY: InternationalRule : %08lx %08lx\n", p->dwInternationalRuleOffset, p->dwInternationalRuleSize); // TODO: special ((BYTE*)p+p->dwLongDistanceRuleOffset), p->dwLongDistanceRuleSize if (p->dwLongDistanceRuleOffset!=0 || p->dwLongDistanceRuleSize!=0) debug("tapi_LINECOUNTRYENTRY: LongDistanceRule : %08lx %08lx\n", p->dwLongDistanceRuleOffset, p->dwLongDistanceRuleSize); // TODO: special ((BYTE*)p+p->dwSameAreaRuleOffset), p->dwSameAreaRuleSize if (p->dwSameAreaRuleOffset!=0 || p->dwSameAreaRuleSize!=0) debug("tapi_LINECOUNTRYENTRY: SameAreaRule : %08lx %08lx\n", p->dwSameAreaRuleOffset, p->dwSameAreaRuleSize); } // result of void log_tapi_linedialparams(const LINEDIALPARAMS *p) { debug("tapi_LINEDIALPARAMS: dwDialPause=%08lx\n", p->dwDialPause); debug("tapi_LINEDIALPARAMS: dwDialSpeed=%08lx\n", p->dwDialSpeed); debug("tapi_LINEDIALPARAMS: dwDigitDuration=%08lx\n", p->dwDigitDuration); debug("tapi_LINEDIALPARAMS: dwWaitForDialtone=%08lx\n", p->dwWaitForDialtone); } // result of void log_tapi_lineforward(const LINEFORWARD *p) { debug("tapi_LINEFORWARD: dwForwardMode=%hs\n", LineForwardModeString(p->dwForwardMode).c_str()); debug("tapi_LINEFORWARD: dwDestCountryCode=%08lx\n", p->dwDestCountryCode); // TODO: special ((BYTE*)p+p->dwDestAddressOffset), p->dwDestAddressSize if (p->dwDestAddressOffset!=0 || p->dwDestAddressSize!=0) debug("tapi_LINEFORWARD: DestAddress : %08lx %08lx\n", p->dwDestAddressOffset, p->dwDestAddressSize); // TODO: special ((BYTE*)p+p->dwCallerAddressOffset), p->dwCallerAddressSize if (p->dwCallerAddressOffset!=0 || p->dwCallerAddressSize!=0) debug("tapi_LINEFORWARD: CallerAddress : %08lx %08lx\n", p->dwCallerAddressOffset, p->dwCallerAddressSize); } #ifdef _HAVE_PHONEBUTTONINFO // result of phoneGetButtonInfo void log_tapi_phonebuttoninfo(HPHONE hPhone, DWORD dwButtonLampID, const PHONEBUTTONINFO *p) { debug("tapi_PHONEBUTTONINFO(hPhone=%08lx dwButtonLampID=%08lx)\n", hPhone, dwButtonLampID); debug("tapi_PHONEBUTTONINFO: dwButtonMode=%hs\n", PhoneButtonModeString(p->dwButtonMode).c_str()); debug("tapi_PHONEBUTTONINFO: dwButtonFunction=%hs\n", PhoneButtonFunctionString(p->dwButtonFunction).c_str()); debug("tapi_PHONEBUTTONINFO: dwButtonState=%hs\n", PhoneButtonStateString(p->dwButtonState).c_str()); // TODO: special ((BYTE*)p+p->dwButtonTextOffset), p->dwButtonTextSize if (p->dwButtonTextOffset!=0 || p->dwButtonTextSize!=0) debug("tapi_PHONEBUTTONINFO: ButtonText : %08lx %08lx\n", p->dwButtonTextOffset, p->dwButtonTextSize); debug("tapi_PHONEBUTTONINFO: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); } #endif // result of void log_tapi_linemediacontroldigit(const LINEMEDIACONTROLDIGIT *p) { debug("tapi_LINEMEDIACONTROLDIGIT: dwDigit=%08lx\n", p->dwDigit); debug("tapi_LINEMEDIACONTROLDIGIT: dwDigitModes=%hs\n", LineDigitModeString(p->dwDigitModes).c_str()); debug("tapi_LINEMEDIACONTROLDIGIT: dwMediaControl=%hs\n", LineMediaControlString(p->dwMediaControl).c_str()); } // result of void log_tapi_linecardentry(const LINECARDENTRY *p) { debug("tapi_LINECARDENTRY: dwPermanentCardID=%08lx\n", p->dwPermanentCardID); debug("tapi_LINECARDENTRY: dwCardNumberDigits=%08lx\n", p->dwCardNumberDigits); debug("tapi_LINECARDENTRY: dwOptions=%08lx\n", p->dwOptions); // TODO: special ((BYTE*)p+p->dwInternationalRuleOffset), p->dwInternationalRuleSize if (p->dwInternationalRuleOffset!=0 || p->dwInternationalRuleSize!=0) debug("tapi_LINECARDENTRY: InternationalRule : %08lx %08lx\n", p->dwInternationalRuleOffset, p->dwInternationalRuleSize); // TODO: special ((BYTE*)p+p->dwLongDistanceRuleOffset), p->dwLongDistanceRuleSize if (p->dwLongDistanceRuleOffset!=0 || p->dwLongDistanceRuleSize!=0) debug("tapi_LINECARDENTRY: LongDistanceRule : %08lx %08lx\n", p->dwLongDistanceRuleOffset, p->dwLongDistanceRuleSize); // TODO: special ((BYTE*)p+p->dwCardNameOffset), p->dwCardNameSize if (p->dwCardNameOffset!=0 || p->dwCardNameSize!=0) debug("tapi_LINECARDENTRY: CardName : %08lx %08lx\n", p->dwCardNameOffset, p->dwCardNameSize); // TODO: special ((BYTE*)p+p->dwSameAreaRuleOffset), p->dwSameAreaRuleSize if (p->dwSameAreaRuleOffset!=0 || p->dwSameAreaRuleSize!=0) debug("tapi_LINECARDENTRY: SameAreaRule : %08lx %08lx\n", p->dwSameAreaRuleOffset, p->dwSameAreaRuleSize); } // result of void log_tapi_linegeneratetone(const LINEGENERATETONE *p) { debug("tapi_LINEGENERATETONE: dwFrequency=%08lx\n", p->dwFrequency); debug("tapi_LINEGENERATETONE: dwCadenceOn=%08lx\n", p->dwCadenceOn); debug("tapi_LINEGENERATETONE: dwCadenceOff=%08lx\n", p->dwCadenceOff); debug("tapi_LINEGENERATETONE: dwVolume=%08lx\n", p->dwVolume); } // result of void log_tapi_linecallparams(const LINECALLPARAMS *p) { debug("tapi_LINECALLPARAMS: dwBearerMode=%hs\n", LineBearerModeString(p->dwBearerMode).c_str()); debug("tapi_LINECALLPARAMS: dwMinRate=%08lx\n", p->dwMinRate); debug("tapi_LINECALLPARAMS: dwMaxRate=%08lx\n", p->dwMaxRate); debug("tapi_LINECALLPARAMS: dwMediaMode=%hs\n", LineMediaModeString(p->dwMediaMode).c_str()); debug("tapi_LINECALLPARAMS: dwCallParamFlags=%hs\n", LineCallParamFlagsString(p->dwCallParamFlags).c_str()); debug("tapi_LINECALLPARAMS: dwAddressMode=%hs\n", LineAddressModeString(p->dwAddressMode).c_str()); debug("tapi_LINECALLPARAMS: dwAddressID=%08lx\n", p->dwAddressID); log_tapi_linedialparams(&(p->DialParams)); debug("tapi_LINECALLPARAMS: dwPredictiveAutoTransferStates=%08lx\n", p->dwPredictiveAutoTransferStates); debug("tapi_LINECALLPARAMS: dwNoAnswerTimeout=%08lx\n", p->dwNoAnswerTimeout); debug("tapi_LINECALLPARAMS: dwAddressType=%hs\n", LineAddressTypeString(p->dwAddressType).c_str()); // TODO: special ((BYTE*)p+p->dwSendingFlowspecOffset), p->dwSendingFlowspecSize if (p->dwSendingFlowspecOffset!=0 || p->dwSendingFlowspecSize!=0) debug("tapi_LINECALLPARAMS: SendingFlowspec : %08lx %08lx\n", p->dwSendingFlowspecOffset, p->dwSendingFlowspecSize); // TODO: special ((BYTE*)p+p->dwTargetAddressOffset), p->dwTargetAddressSize if (p->dwTargetAddressOffset!=0 || p->dwTargetAddressSize!=0) debug("tapi_LINECALLPARAMS: TargetAddress : %08lx %08lx\n", p->dwTargetAddressOffset, p->dwTargetAddressSize); // TODO: special ((BYTE*)p+p->dwOrigAddressOffset), p->dwOrigAddressSize if (p->dwOrigAddressOffset!=0 || p->dwOrigAddressSize!=0) debug("tapi_LINECALLPARAMS: OrigAddress : %08lx %08lx\n", p->dwOrigAddressOffset, p->dwOrigAddressSize); // TODO: special ((BYTE*)p+p->dwDeviceClassOffset), p->dwDeviceClassSize if (p->dwDeviceClassOffset!=0 || p->dwDeviceClassSize!=0) debug("tapi_LINECALLPARAMS: DeviceClass : %08lx %08lx\n", p->dwDeviceClassOffset, p->dwDeviceClassSize); // TODO: special ((BYTE*)p+p->dwReceivingFlowspecOffset), p->dwReceivingFlowspecSize if (p->dwReceivingFlowspecOffset!=0 || p->dwReceivingFlowspecSize!=0) debug("tapi_LINECALLPARAMS: ReceivingFlowspec : %08lx %08lx\n", p->dwReceivingFlowspecOffset, p->dwReceivingFlowspecSize); debug("tapi_LINECALLPARAMS: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); // TODO: special ((BYTE*)p+p->dwCallingPartyIDOffset), p->dwCallingPartyIDSize if (p->dwCallingPartyIDOffset!=0 || p->dwCallingPartyIDSize!=0) debug("tapi_LINECALLPARAMS: CallingPartyID : %08lx %08lx\n", p->dwCallingPartyIDOffset, p->dwCallingPartyIDSize); // TODO: special ((BYTE*)p+p->dwUserUserInfoOffset), p->dwUserUserInfoSize if (p->dwUserUserInfoOffset!=0 || p->dwUserUserInfoSize!=0) debug("tapi_LINECALLPARAMS: UserUserInfo : %08lx %08lx\n", p->dwUserUserInfoOffset, p->dwUserUserInfoSize); // TODO: special ((BYTE*)p+p->dwDisplayableAddressOffset), p->dwDisplayableAddressSize if (p->dwDisplayableAddressOffset!=0 || p->dwDisplayableAddressSize!=0) debug("tapi_LINECALLPARAMS: DisplayableAddress : %08lx %08lx\n", p->dwDisplayableAddressOffset, p->dwDisplayableAddressSize); // TODO: special ((BYTE*)p+p->dwCommentOffset), p->dwCommentSize if (p->dwCommentOffset!=0 || p->dwCommentSize!=0) debug("tapi_LINECALLPARAMS: Comment : %08lx %08lx\n", p->dwCommentOffset, p->dwCommentSize); // TODO: special ((BYTE*)p+p->dwCalledPartyOffset), p->dwCalledPartySize if (p->dwCalledPartyOffset!=0 || p->dwCalledPartySize!=0) debug("tapi_LINECALLPARAMS: CalledParty : %08lx %08lx\n", p->dwCalledPartyOffset, p->dwCalledPartySize); // TODO: special ((BYTE*)p+p->dwCallDataOffset), p->dwCallDataSize if (p->dwCallDataOffset!=0 || p->dwCallDataSize!=0) debug("tapi_LINECALLPARAMS: CallData : %08lx %08lx\n", p->dwCallDataOffset, p->dwCallDataSize); // TODO: special ((BYTE*)p+p->dwDeviceConfigOffset), p->dwDeviceConfigSize if (p->dwDeviceConfigOffset!=0 || p->dwDeviceConfigSize!=0) debug("tapi_LINECALLPARAMS: DeviceConfig : %08lx %08lx\n", p->dwDeviceConfigOffset, p->dwDeviceConfigSize); // TODO: special ((BYTE*)p+p->dwHighLevelCompOffset), p->dwHighLevelCompSize if (p->dwHighLevelCompOffset!=0 || p->dwHighLevelCompSize!=0) debug("tapi_LINECALLPARAMS: HighLevelComp : %08lx %08lx\n", p->dwHighLevelCompOffset, p->dwHighLevelCompSize); // TODO: special ((BYTE*)p+p->dwLowLevelCompOffset), p->dwLowLevelCompSize if (p->dwLowLevelCompOffset!=0 || p->dwLowLevelCompSize!=0) debug("tapi_LINECALLPARAMS: LowLevelComp : %08lx %08lx\n", p->dwLowLevelCompOffset, p->dwLowLevelCompSize); } // result of void log_tapi_linelocationentry(const LINELOCATIONENTRY *p) { debug("tapi_LINELOCATIONENTRY: dwPermanentLocationID=%08lx\n", p->dwPermanentLocationID); debug("tapi_LINELOCATIONENTRY: dwCountryCode=%08lx\n", p->dwCountryCode); debug("tapi_LINELOCATIONENTRY: dwPreferredCardID=%08lx\n", p->dwPreferredCardID); debug("tapi_LINELOCATIONENTRY: dwCountryID=%08lx\n", p->dwCountryID); debug("tapi_LINELOCATIONENTRY: dwOptions=%08lx\n", p->dwOptions); // TODO: special ((BYTE*)p+p->dwLongDistanceAccessCodeOffset), p->dwLongDistanceAccessCodeSize if (p->dwLongDistanceAccessCodeOffset!=0 || p->dwLongDistanceAccessCodeSize!=0) debug("tapi_LINELOCATIONENTRY: LongDistanceAccessCode : %08lx %08lx\n", p->dwLongDistanceAccessCodeOffset, p->dwLongDistanceAccessCodeSize); // TODO: special ((BYTE*)p+p->dwLocationNameOffset), p->dwLocationNameSize if (p->dwLocationNameOffset!=0 || p->dwLocationNameSize!=0) debug("tapi_LINELOCATIONENTRY: LocationName : %08lx %08lx\n", p->dwLocationNameOffset, p->dwLocationNameSize); // TODO: special ((BYTE*)p+p->dwCancelCallWaitingOffset), p->dwCancelCallWaitingSize if (p->dwCancelCallWaitingOffset!=0 || p->dwCancelCallWaitingSize!=0) debug("tapi_LINELOCATIONENTRY: CancelCallWaiting : %08lx %08lx\n", p->dwCancelCallWaitingOffset, p->dwCancelCallWaitingSize); // TODO: special ((BYTE*)p+p->dwLocalAccessCodeOffset), p->dwLocalAccessCodeSize if (p->dwLocalAccessCodeOffset!=0 || p->dwLocalAccessCodeSize!=0) debug("tapi_LINELOCATIONENTRY: LocalAccessCode : %08lx %08lx\n", p->dwLocalAccessCodeOffset, p->dwLocalAccessCodeSize); // TODO: special ((BYTE*)p+p->dwTollPrefixListOffset), p->dwTollPrefixListSize if (p->dwTollPrefixListOffset!=0 || p->dwTollPrefixListSize!=0) debug("tapi_LINELOCATIONENTRY: TollPrefixList : %08lx %08lx\n", p->dwTollPrefixListOffset, p->dwTollPrefixListSize); // TODO: special ((BYTE*)p+p->dwCityCodeOffset), p->dwCityCodeSize if (p->dwCityCodeOffset!=0 || p->dwCityCodeSize!=0) debug("tapi_LINELOCATIONENTRY: CityCode : %08lx %08lx\n", p->dwCityCodeOffset, p->dwCityCodeSize); } // result of void log_tapi_linemonitortone(const LINEMONITORTONE *p) { debug("tapi_LINEMONITORTONE: dwAppSpecific=%08lx\n", p->dwAppSpecific); debug("tapi_LINEMONITORTONE: dwDuration=%08lx\n", p->dwDuration); debug("tapi_LINEMONITORTONE: dwFrequency1=%08lx\n", p->dwFrequency1); debug("tapi_LINEMONITORTONE: dwFrequency2=%08lx\n", p->dwFrequency2); debug("tapi_LINEMONITORTONE: dwFrequency3=%08lx\n", p->dwFrequency3); } // result of lineTranslateAddress void log_tapi_linetranslateoutput(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, LPCWSTR lpszAddressIn, DWORD dwCard, DWORD dwTranslateOptions, const LINETRANSLATEOUTPUT *p) { debug("tapi_LINETRANSLATEOUTPUT(hLineApp=%08lx, dwDeviceID=%08lx, dwAPIVersion=%08lx, lpszAddressIn=%08lx, dwCard=%08lx, dwTranslateOptions=%08lx)\n", hLineApp, dwDeviceID, dwAPIVersion, lpszAddressIn, dwCard, dwTranslateOptions); debug("tapi_LINETRANSLATEOUTPUT: dwCurrentCountry=%08lx\n", p->dwCurrentCountry); debug("tapi_LINETRANSLATEOUTPUT: dwDestCountry=%08lx\n", p->dwDestCountry); debug("tapi_LINETRANSLATEOUTPUT: dwTranslateResults=%hs\n", LineTranslateResultString(p->dwTranslateResults).c_str()); // TODO: special ((BYTE*)p+p->dwDialableStringOffset), p->dwDialableStringSize if (p->dwDialableStringOffset!=0 || p->dwDialableStringSize!=0) debug("tapi_LINETRANSLATEOUTPUT: DialableString : %08lx %08lx\n", p->dwDialableStringOffset, p->dwDialableStringSize); // TODO: special ((BYTE*)p+p->dwDisplayableStringOffset), p->dwDisplayableStringSize if (p->dwDisplayableStringOffset!=0 || p->dwDisplayableStringSize!=0) debug("tapi_LINETRANSLATEOUTPUT: DisplayableString : %08lx %08lx\n", p->dwDisplayableStringOffset, p->dwDisplayableStringSize); } // result of phoneNegotiateAPIVersion void log_tapi_phoneextensionid(HPHONEAPP hPhoneApp, DWORD dwDeviceID, DWORD dwAPILowVersion, DWORD dwAPIHighVersion, const PHONEEXTENSIONID *p) { debug("tapi_PHONEEXTENSIONID(hPhoneApp=%08lx, dwDeviceID=%08lx, dwAPILowVersion=%08lx, dwAPIHighVersion=%08lx)\n", hPhoneApp, dwDeviceID, dwAPILowVersion, dwAPIHighVersion); debug("tapi_PHONEEXTENSIONID: dwExtensionID0=%08lx\n", p->dwExtensionID0); debug("tapi_PHONEEXTENSIONID: dwExtensionID1=%08lx\n", p->dwExtensionID1); debug("tapi_PHONEEXTENSIONID: dwExtensionID2=%08lx\n", p->dwExtensionID2); debug("tapi_PHONEEXTENSIONID: dwExtensionID3=%08lx\n", p->dwExtensionID3); } // result of lineGetMessage void log_tapi_linemessage(HLINEAPP hLineApp, DWORD dwTimeout, const LINEMESSAGE *p) { debug("tapi_LINEMESSAGE(hLineApp=%08lx, dwTimeout=%08lx)\n", hLineApp, dwTimeout); debug("tapi_LINEMESSAGE: hDevice=%08lx\n", p->hDevice); debug("tapi_LINEMESSAGE: dwMessageID=%hs\n", LineString(p->dwMessageID).c_str()); debug("tapi_LINEMESSAGE: dwCallbackInstance=%08lx\n", p->dwCallbackInstance); debug("tapi_LINEMESSAGE: dwParam1=%08lx\n", p->dwParam1); debug("tapi_LINEMESSAGE: dwParam2=%08lx\n", p->dwParam2); debug("tapi_LINEMESSAGE: dwParam3=%08lx\n", p->dwParam3); } // result of lineGetCallStatus void log_tapi_linecallstatus(HCALL hCall, const LINECALLSTATUS *p) { debug("tapi_LINECALLSTATUS(hCall=%08lx)\n", hCall); debug("tapi_LINECALLSTATUS: dwCallState=%hs\n", LineCallStateString(p->dwCallState).c_str()); debug("tapi_LINECALLSTATUS: dwCallStateMode=%hs\n", LineCallStateModeString(p->dwCallState, p->dwCallStateMode).c_str()); debug("tapi_LINECALLSTATUS: dwCallPrivilege=%hs\n", LineCallPrivilegeString(p->dwCallPrivilege).c_str()); debug("tapi_LINECALLSTATUS: dwCallFeatures=%hs\n", LineCallFeatureString(p->dwCallFeatures).c_str()); debug("tapi_LINECALLSTATUS: dwCallFeatures2=%hs\n", LineCallFeature2String(p->dwCallFeatures2).c_str()); // TODO: unhandled type: SYSTEMTIME p->tStateEntryTime debug("tapi_LINECALLSTATUS: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); } // result of lineGetAddressStatus void log_tapi_lineaddressstatus(HLINE hLine, DWORD dwAddressID, const LINEADDRESSSTATUS *p) { debug("tapi_LINEADDRESSSTATUS(hLine=%08lx, dwAddressID=%08lx)\n", hLine, dwAddressID); debug("tapi_LINEADDRESSSTATUS: dwNumInUse=%08lx\n", p->dwNumInUse); debug("tapi_LINEADDRESSSTATUS: dwNumActiveCalls=%08lx\n", p->dwNumActiveCalls); debug("tapi_LINEADDRESSSTATUS: dwNumOnHoldCalls=%08lx\n", p->dwNumOnHoldCalls); debug("tapi_LINEADDRESSSTATUS: dwNumOnHoldPendCalls=%08lx\n", p->dwNumOnHoldPendCalls); debug("tapi_LINEADDRESSSTATUS: dwAddressFeatures=%hs\n", LineAddrFeatureString(p->dwAddressFeatures).c_str()); debug("tapi_LINEADDRESSSTATUS: dwNumRingsNoAnswer=%08lx\n", p->dwNumRingsNoAnswer); debug("tapi_LINEADDRESSSTATUS: dwForwardNumEntries=%08lx\n", p->dwForwardNumEntries); // TODO: special ((BYTE*)p+p->dwForwardOffset), p->dwForwardSize if (p->dwForwardOffset!=0 || p->dwForwardSize!=0) debug("tapi_LINEADDRESSSTATUS: Forward : %08lx %08lx\n", p->dwForwardOffset, p->dwForwardSize); debug("tapi_LINEADDRESSSTATUS: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); // TODO: special ((BYTE*)p+p->dwTerminalModesOffset), p->dwTerminalModesSize if (p->dwTerminalModesOffset!=0 || p->dwTerminalModesSize!=0) debug("tapi_LINEADDRESSSTATUS: TerminalModes : %08lx %08lx\n", p->dwTerminalModesOffset, p->dwTerminalModesSize); DWORD *q= (DWORD*)((BYTE*)p+p->dwTerminalModesOffset); for (DWORD i=0; idwTerminalModesSize/sizeof(DWORD) ; i++) debug(" terminal %d: %hs\n", i, LineTermModeString(q[i]).c_str()); } // result of phoneGetStatus void log_tapi_phonestatus(HPHONE hPhone, const PHONESTATUS *p) { debug("tapi_PHONESTATUS(hPhone=%08lx)\n", hPhone); debug("tapi_PHONESTATUS: dwStatusFlags=%hs\n", PhoneStatusFlagsString(p->dwStatusFlags).c_str()); debug("tapi_PHONESTATUS: dwNumOwners=%08lx\n", p->dwNumOwners); debug("tapi_PHONESTATUS: dwNumMonitors=%08lx\n", p->dwNumMonitors); debug("tapi_PHONESTATUS: dwRingMode=%08lx\n", p->dwRingMode); debug("tapi_PHONESTATUS: dwRingVolume=%08lx\n", p->dwRingVolume); debug("tapi_PHONESTATUS: dwHandsetHookSwitchMode=%hs\n", PhoneHookSwitchModeString(p->dwHandsetHookSwitchMode).c_str()); debug("tapi_PHONESTATUS: dwHandsetVolume=%08lx\n", p->dwHandsetVolume); debug("tapi_PHONESTATUS: dwHandsetGain=%08lx\n", p->dwHandsetGain); debug("tapi_PHONESTATUS: dwSpeakerHookSwitchMode=%hs\n", PhoneHookSwitchModeString(p->dwSpeakerHookSwitchMode).c_str()); debug("tapi_PHONESTATUS: dwSpeakerVolume=%08lx\n", p->dwSpeakerVolume); debug("tapi_PHONESTATUS: dwSpeakerGain=%08lx\n", p->dwSpeakerGain); debug("tapi_PHONESTATUS: dwHeadsetHookSwitchMode=%hs\n", PhoneHookSwitchModeString(p->dwHeadsetHookSwitchMode).c_str()); debug("tapi_PHONESTATUS: dwHeadsetVolume=%08lx\n", p->dwHeadsetVolume); debug("tapi_PHONESTATUS: dwHeadsetGain=%08lx\n", p->dwHeadsetGain); debug("tapi_PHONESTATUS: dwPhoneFeatures=%hs\n", PhoneFeatureString(p->dwPhoneFeatures).c_str()); // TODO: special ((BYTE*)p+p->dwOwnerNameOffset), p->dwOwnerNameSize if (p->dwOwnerNameOffset!=0 || p->dwOwnerNameSize!=0) debug("tapi_PHONESTATUS: OwnerName : %08lx %08lx\n", p->dwOwnerNameOffset, p->dwOwnerNameSize); // TODO: special ((BYTE*)p+p->dwDisplayOffset), p->dwDisplaySize if (p->dwDisplayOffset!=0 || p->dwDisplaySize!=0) debug("tapi_PHONESTATUS: Display : %08lx %08lx\n", p->dwDisplayOffset, p->dwDisplaySize); debug("tapi_PHONESTATUS: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); // TODO: special ((BYTE*)p+p->dwLampModesOffset), p->dwLampModesSize if (p->dwLampModesOffset!=0 || p->dwLampModesSize!=0) debug("tapi_PHONESTATUS: LampModes : %08lx %08lx\n", p->dwLampModesOffset, p->dwLampModesSize); } // result of lineGetTranslateCaps void log_tapi_linetranslatecaps(HLINEAPP hLineApp, DWORD dwAPIVersion, const LINETRANSLATECAPS *p) { debug("tapi_LINETRANSLATECAPS(hLineApp=%08lx, dwAPIVersion=%08lx)\n", hLineApp, dwAPIVersion); debug("tapi_LINETRANSLATECAPS: dwNumLocations=%08lx\n", p->dwNumLocations); debug("tapi_LINETRANSLATECAPS: dwCurrentLocationID=%08lx\n", p->dwCurrentLocationID); debug("tapi_LINETRANSLATECAPS: dwNumCards=%08lx\n", p->dwNumCards); debug("tapi_LINETRANSLATECAPS: dwCurrentPreferredCardID=%08lx\n", p->dwCurrentPreferredCardID); // TODO: special ((BYTE*)p+p->dwCardListOffset), p->dwCardListSize if (p->dwCardListOffset!=0 || p->dwCardListSize!=0) debug("tapi_LINETRANSLATECAPS: CardList : %08lx %08lx\n", p->dwCardListOffset, p->dwCardListSize); // TODO: special ((BYTE*)p+p->dwLocationListOffset), p->dwLocationListSize if (p->dwLocationListOffset!=0 || p->dwLocationListSize!=0) debug("tapi_LINETRANSLATECAPS: LocationList : %08lx %08lx\n", p->dwLocationListOffset, p->dwLocationListSize); } // result of lineGetLineDevStatus void log_tapi_linedevstatus(HLINE hLine, const LINEDEVSTATUS *p) { debug("tapi_LINEDEVSTATUS(hLine=%08lx)\n", hLine); debug("tapi_LINEDEVSTATUS: dwNumOpens=%08lx\n", p->dwNumOpens); debug("tapi_LINEDEVSTATUS: dwOpenMediaModes=%hs\n", LineMediaModeString(p->dwOpenMediaModes).c_str()); debug("tapi_LINEDEVSTATUS: dwNumActiveCalls=%08lx\n", p->dwNumActiveCalls); debug("tapi_LINEDEVSTATUS: dwNumOnHoldCalls=%08lx\n", p->dwNumOnHoldCalls); debug("tapi_LINEDEVSTATUS: dwNumOnHoldPendCalls=%08lx\n", p->dwNumOnHoldPendCalls); debug("tapi_LINEDEVSTATUS: dwLineFeatures=%hs\n", LineFeatureString(p->dwLineFeatures).c_str()); debug("tapi_LINEDEVSTATUS: dwNumCallCompletions=%08lx\n", p->dwNumCallCompletions); debug("tapi_LINEDEVSTATUS: dwRingMode=%08lx\n", p->dwRingMode); debug("tapi_LINEDEVSTATUS: dwSignalLevel=%08lx\n", p->dwSignalLevel); debug("tapi_LINEDEVSTATUS: dwBatteryLevel=%08lx\n", p->dwBatteryLevel); debug("tapi_LINEDEVSTATUS: dwRoamMode=%hs\n", LineRoamModeString(p->dwRoamMode).c_str()); debug("tapi_LINEDEVSTATUS: dwDevStatusFlags=%hs\n", LineDevStatusFlagsString(p->dwDevStatusFlags).c_str()); debug("tapi_LINEDEVSTATUS: dwAvailableMediaModes=%hs\n", LineMediaModeString(p->dwAvailableMediaModes).c_str()); debug("tapi_LINEDEVSTATUS: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); // TODO: special ((BYTE*)p+p->dwTerminalModesOffset), p->dwTerminalModesSize if (p->dwTerminalModesOffset!=0 || p->dwTerminalModesSize!=0) debug("tapi_LINEDEVSTATUS: TerminalModes : %08lx %08lx\n", p->dwTerminalModesOffset, p->dwTerminalModesSize); DWORD *q= (DWORD*)((BYTE*)p+p->dwTerminalModesOffset); for (DWORD i=0; idwTerminalModesSize/sizeof(DWORD) ; i++) debug(" terminal %d: %hs\n", i, LineTermModeString(q[i]).c_str()); debug("tapi_LINEDEVSTATUS: AppInfo : %hs\n", AppInfoString((BYTE*)p+p->dwAppInfoOffset, p->dwAppInfoSize).c_str()); } // result of phoneInitializeEx void log_tapi_phoneinitializeexparams(HINSTANCE hInstance, PHONECALLBACK lpfnCallback, LPCWSTR lpszFriendlyAppName, const PHONEINITIALIZEEXPARAMS *p) { debug("tapi_PHONEINITIALIZEEXPARAMS(hInstance=%08lx, lpfnCallback=%08lx, lpszFriendlyAppName=%08lx)\n", hInstance, lpfnCallback, lpszFriendlyAppName); debug("tapi_PHONEINITIALIZEEXPARAMS: dwOptions=%08lx\n", p->dwOptions); // TODO: unhandled type: HANDLE p->Handles.hEvent debug("tapi_PHONEINITIALIZEEXPARAMS: dwCompletionKey=%08lx\n", p->dwCompletionKey); } // result of lineGetProviderList void log_tapi_lineproviderlist(DWORD dwAPIVersion, const LINEPROVIDERLIST *p) { debug("tapi_LINEPROVIDERLIST(dwAPIVersion=%08lx)\n", dwAPIVersion); debug("tapi_LINEPROVIDERLIST: dwNumProviders=%08lx\n", p->dwNumProviders); // TODO: special ((BYTE*)p+p->dwProviderListOffset), p->dwProviderListSize if (p->dwProviderListOffset!=0 || p->dwProviderListSize!=0) debug("tapi_LINEPROVIDERLIST: ProviderList : %08lx %08lx\n", p->dwProviderListOffset, p->dwProviderListSize); } // result of lineGetAddressCaps // XXX : added 'sf' parameter void log_tapi_lineaddresscaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAddressID, DWORD dwAPIVersion, DWORD dwExtVersion, const LINEADDRESSCAPS *p, DWORD sf) { debug("tapi_LINEADDRESSCAPS(hLineApp=%08lx, dwDeviceID=%08lx, dwAddressID=%08lx, dwAPIVersion=%08lx, dwExtVersion=%08lx)\n", hLineApp, dwDeviceID, dwAddressID, dwAPIVersion, dwExtVersion); debug("tapi_LINEADDRESSCAPS: dwLineDeviceID=%08lx\n", p->dwLineDeviceID); debug("tapi_LINEADDRESSCAPS: dwAddressSharing=%hs\n", LineAddressSharingString(p->dwAddressSharing).c_str()); debug("tapi_LINEADDRESSCAPS: dwAddressStates=%hs\n", LineAddressStateString(p->dwAddressStates).c_str()); debug("tapi_LINEADDRESSCAPS: dwCallInfoStates=%hs\n", LineCallInfoStateString(p->dwCallInfoStates).c_str()); debug("tapi_LINEADDRESSCAPS: dwCallerIDFlags=%hs\n", LineCallPartyIDString(p->dwCallerIDFlags).c_str()); debug("tapi_LINEADDRESSCAPS: dwCalledIDFlags=%hs\n", LineCallPartyIDString(p->dwCalledIDFlags).c_str()); debug("tapi_LINEADDRESSCAPS: dwConnectedIDFlags=%hs\n", LineCallPartyIDString(p->dwConnectedIDFlags).c_str()); debug("tapi_LINEADDRESSCAPS: dwRedirectionIDFlags=%hs\n", LineCallPartyIDString(p->dwRedirectionIDFlags).c_str()); debug("tapi_LINEADDRESSCAPS: dwRedirectingIDFlags=%hs\n", LineCallPartyIDString(p->dwRedirectingIDFlags).c_str()); debug("tapi_LINEADDRESSCAPS: dwCallStates=%hs\n", LineCallStateString(p->dwCallStates).c_str()); debug("tapi_LINEADDRESSCAPS: dwDialToneModes=%hs\n", LineDialToneModeString(p->dwDialToneModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwBusyModes=%hs\n", LineBusyModeString(p->dwBusyModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwSpecialInfo=%hs\n", LineSpecialInfoString(p->dwSpecialInfo).c_str()); debug("tapi_LINEADDRESSCAPS: dwDisconnectModes=%hs\n", LineDisconnectModeString(p->dwDisconnectModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwMaxNumActiveCalls=%08lx\n", p->dwMaxNumActiveCalls); debug("tapi_LINEADDRESSCAPS: dwMaxNumOnHoldCalls=%08lx\n", p->dwMaxNumOnHoldCalls); debug("tapi_LINEADDRESSCAPS: dwMaxNumOnHoldPendingCalls=%08lx\n", p->dwMaxNumOnHoldPendingCalls); debug("tapi_LINEADDRESSCAPS: dwMaxNumConference=%08lx\n", p->dwMaxNumConference); debug("tapi_LINEADDRESSCAPS: dwMaxNumTransConf=%08lx\n", p->dwMaxNumTransConf); debug("tapi_LINEADDRESSCAPS: dwAddrCapFlags=%hs\n", LineAddrCapFlagsString(p->dwAddrCapFlags).c_str()); debug("tapi_LINEADDRESSCAPS: dwCallFeatures=%hs\n", LineCallFeatureString(p->dwCallFeatures).c_str()); debug("tapi_LINEADDRESSCAPS: dwRemoveFromConfCaps=%hs\n", LineRemoveFromConfString(p->dwRemoveFromConfCaps).c_str()); debug("tapi_LINEADDRESSCAPS: dwRemoveFromConfState=%hs\n", LineCallStateString(p->dwRemoveFromConfState).c_str()); debug("tapi_LINEADDRESSCAPS: dwTransferModes=%hs\n", LineTransferModeString(p->dwTransferModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwParkModes=%hs\n", LineParkModeString(p->dwParkModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwForwardModes=%hs\n", LineForwardModeString(p->dwForwardModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwMaxForwardEntries=%08lx\n", p->dwMaxForwardEntries); debug("tapi_LINEADDRESSCAPS: dwMaxSpecificEntries=%08lx\n", p->dwMaxSpecificEntries); debug("tapi_LINEADDRESSCAPS: dwMinFwdNumRings=%08lx\n", p->dwMinFwdNumRings); debug("tapi_LINEADDRESSCAPS: dwMaxFwdNumRings=%08lx\n", p->dwMaxFwdNumRings); debug("tapi_LINEADDRESSCAPS: dwMaxCallCompletions=%08lx\n", p->dwMaxCallCompletions); debug("tapi_LINEADDRESSCAPS: dwCallCompletionConds=%hs\n", LineCallComplCondString(p->dwCallCompletionConds).c_str()); debug("tapi_LINEADDRESSCAPS: dwCallCompletionModes=%hs\n", LineCallComplModeString(p->dwCallCompletionModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwNumCompletionMessages=%08lx\n", p->dwNumCompletionMessages); debug("tapi_LINEADDRESSCAPS: dwAddressFeatures=%hs\n", LineAddrFeatureString(p->dwAddressFeatures).c_str()); debug("tapi_LINEADDRESSCAPS: dwPredictiveAutoTransferStates=%hs\n", LineCallStateString(p->dwPredictiveAutoTransferStates).c_str()); debug("tapi_LINEADDRESSCAPS: dwNumCallTreatments=%08lx\n", p->dwNumCallTreatments); debug("tapi_LINEADDRESSCAPS: dwCallFeatures2=%hs\n", LineCallFeature2String(p->dwCallFeatures2).c_str()); debug("tapi_LINEADDRESSCAPS: dwMaxNoAnswerTimeout=%08lx\n", p->dwMaxNoAnswerTimeout); debug("tapi_LINEADDRESSCAPS: dwConnectedModes=%hs\n", LineConnectedModeString(p->dwConnectedModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwOfferingModes=%hs\n", LineOfferingModeString(p->dwOfferingModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwAvailableMediaModes=%hs\n", LineMediaModeString(p->dwAvailableMediaModes).c_str()); debug("tapi_LINEADDRESSCAPS: dwCompletionMsgTextEntrySize=%08lx\n", p->dwCompletionMsgTextEntrySize); debug("tapi_LINEADDRESSCAPS: dwMaxCallDataSize=%08lx\n", p->dwMaxCallDataSize); debug("tapi_LINEADDRESSCAPS: Address : %hs\n", AddressString((BYTE*)p+p->dwAddressOffset, p->dwAddressSize).c_str()); // TODO: special ((BYTE*)p+p->dwCompletionMsgTextOffset), p->dwCompletionMsgTextSize if (p->dwCompletionMsgTextOffset!=0 || p->dwCompletionMsgTextSize!=0) debug("tapi_LINEADDRESSCAPS: CompletionMsgText : %08lx %08lx\n", p->dwCompletionMsgTextOffset, p->dwCompletionMsgTextSize); debug("tapi_LINEADDRESSCAPS: CompletionMsgText: %hs\n", LStringListString(sf, p->dwCompletionMsgTextEntrySize, (BYTE*)p+p->dwCompletionMsgTextOffset, p->dwCompletionMsgTextSize).c_str()); debug("tapi_LINEADDRESSCAPS: DevSpecific : %hs\n", DevSpecificString((BYTE*)p+p->dwDevSpecificOffset, p->dwDevSpecificSize).c_str()); // TODO: special ((BYTE*)p+p->dwCallTreatmentListOffset), p->dwCallTreatmentListSize if (p->dwCallTreatmentListOffset!=0 || p->dwCallTreatmentListSize!=0) debug("tapi_LINEADDRESSCAPS: CallTreatmentList : %08lx %08lx\n", p->dwCallTreatmentListOffset, p->dwCallTreatmentListSize); LINECALLTREATMENTENTRY *lct= (LINECALLTREATMENTENTRY*)((BYTE*)p+p->dwCallTreatmentListOffset); for (DWORD i=0 ; idwNumCallTreatments; i++) debug("tapi_LINEADDRESSCAPS: CallTreatment %d: %hs %hs\n", i, LineCallTreatmentString(lct[i].dwCallTreatmentID).c_str(), SZString((BYTE*)p+lct[i].dwCallTreatmentNameOffset, lct[i].dwCallTreatmentNameSize).c_str()); debug("tapi_LINEADDRESSCAPS: DeviceClasses: %hs\n", SZStringListString((BYTE*)p+p->dwDeviceClassesOffset,p->dwDeviceClassesSize).c_str()); } // result of lineGetDevCaps void log_tapi_linedevcaps(HLINEAPP hLineApp, DWORD dwDeviceID, DWORD dwAPIVersion, DWORD dwExtVersion, const LINEDEVCAPS *p) { debug("tapi_LINEDEVCAPS(hLineApp=%08lx, dwDeviceID=%08lx, dwAPIVersion=%08lx, dwExtVersion=%08lx)\n", hLineApp, dwDeviceID, dwAPIVersion, dwExtVersion); debug("tapi_LINEDEVCAPS: dwPermanentLineID=%08lx\n", p->dwPermanentLineID); debug("tapi_LINEDEVCAPS: dwStringFormat=%hs\n", StringFormatString(p->dwStringFormat).c_str()); debug("tapi_LINEDEVCAPS: dwAddressModes=%hs\n", LineAddressModeString(p->dwAddressModes).c_str()); debug("tapi_LINEDEVCAPS: dwNumAddresses=%08lx\n", p->dwNumAddresses); debug("tapi_LINEDEVCAPS: dwBearerModes=%hs\n", LineBearerModeString(p->dwBearerModes).c_str()); debug("tapi_LINEDEVCAPS: dwMaxRate=%08lx\n", p->dwMaxRate); debug("tapi_LINEDEVCAPS: dwMediaModes=%hs\n", LineMediaModeString(p->dwMediaModes).c_str()); debug("tapi_LINEDEVCAPS: dwGenerateToneModes=%08lx\n", p->dwGenerateToneModes); debug("tapi_LINEDEVCAPS: dwGenerateToneMaxNumFreq=%08lx\n", p->dwGenerateToneMaxNumFreq); debug("tapi_LINEDEVCAPS: dwGenerateDigitModes=%08lx\n", p->dwGenerateDigitModes); debug("tapi_LINEDEVCAPS: dwMonitorToneMaxNumFreq=%08lx\n", p->dwMonitorToneMaxNumFreq); debug("tapi_LINEDEVCAPS: dwMonitorToneMa