tapierr.cpp

串口调试助手的源代码

{
	_T("Unknown LINEDISCONNECTED information"),
	_T("LINEDISCONNECTMODE_NORMAL"),
	_T("LINEDISCONNECTMODE_UNKNOWN"),
	_T("LINEDISCONNECTMODE_REJECT"),
	_T("LINEDISCONNECTMODE_PICKUP"),
	_T("LINEDISCONNECTMODE_FORWARDED"),
	_T("LINEDISCONNECTMODE_BUSY"),
	_T("LINEDISCONNECTMODE_NOANSWER"),
	_T("LINEDISCONNECTMODE_BADADDRESS"),
	_T("LINEDISCONNECTMODE_UNREACHABLE"),
	_T("LINEDISCONNECTMODE_CONGESTION"),
	_T("LINEDISCONNECTMODE_INCOMPATIBLE"),
	_T("LINEDISCONNECTMODE_UNAVAIL"),
	_T("LINEDISCONNECTMODE_NODIALTONE")
};


LPCTSTR	pszfLINECALLPRIVILEGE[] =
{
	_T("No change to LINECALLPRIVILEGE"),
	_T("LINECALLPRIVILEGE_NONE"),
	_T("LINECALLPRIVILEGE_MONITOR"),
	_T("LINECALLPRIVILEGE_OWNER")
};

LPCTSTR	pszfLINEGATHERTERM[] =
{
	_T("Unknown LINEGATHERTERM message"),
	_T("LINEGATHERTERM_BUFFERFULL"),
	_T("LINEGATHERTERM_TERMDIGIT"),
	_T("LINEGATHERTERM_FIRSTTIMEOUT"),
	_T("LINEGATHERTERM_INTERTIMEOUT"),
	_T("LINEGATHERTERM_CANCEL")
};


LPCTSTR	pszfLINEGENERATETERM[] = 
{
	_T("Unknown LINEGENERATETERM message"),
	_T("LINEGENERATETERM_DONE"),
	_T("LINEGENERATETERM_CANCEL")
};


LPCTSTR	pszfLINEDEVSTATE[] =
{    
	_T("Unknown LINEDEVESTATE state"),
	_T("LINEDEVSTATE_OTHER"),
	_T("LINEDEVSTATE_RINGING"),
	_T("LINEDEVSTATE_CONNECTED"),
	_T("LINEDEVSTATE_DISCONNECTED"),
	_T("LINEDEVSTATE_MSGWAITON"),
	_T("LINEDEVSTATE_MSGWAITOFF"),
	_T("LINEDEVSTATE_INSERVICE"),
	_T("LINEDEVSTATE_OUTOFSERVICE"),
	_T("LINEDEVSTATE_MAINTENANCE"),
	_T("LINEDEVSTATE_OPEN"),
	_T("LINEDEVSTATE_CLOSE"),
	_T("LINEDEVSTATE_NUMCALLS"),
	_T("LINEDEVSTATE_NUMCOMPLETIONS"),
	_T("LINEDEVSTATE_TERMINALS"),
	_T("LINEDEVSTATE_ROAMMODE"),
	_T("LINEDEVSTATE_BATTERY"),
	_T("LINEDEVSTATE_SIGNAL"),
	_T("LINEDEVSTATE_DEVSPECIFIC"),
	_T("LINEDEVSTATE_REINIT"),
	_T("LINEDEVSTATE_LOCK"),
	_T("LINEDEVSTATE_CAPSCHANGE"),
	_T("LINEDEVSTATE_CONFIGCHANGE"),
	_T("LINEDEVSTATE_TRANSLATECHANGE"),
	_T("LINEDEVSTATE_COMPLCANCEL"),
	_T("LINEDEVSTATE_REMOVED")
};


LPCTSTR	pszfLINEDIGITMODE[] =
{
	_T("Unknown LINEDIGITMODE mode"),
	_T("LINEDIGITMODE_PULSE"),
	_T("LINEDIGITMODE_DTMF"),
	_T("LINEDIGITMODE_DTMFEND")
};
    

LPCTSTR	pszfLINEMEDIAMODE[] =
{
	_T("Unknown LINEMEDIAMODE mode"),
	_T("UnUsed LINEMEDIAMODE mode, ERROR!!"),
	_T("LINEMEDIAMODE_UNKNOWN"),
	_T("LINEMEDIAMODE_INTERACTIVEVOICE"),
	_T("LINEMEDIAMODE_AUTOMATEDVOICE"),
	_T("LINEMEDIAMODE_DATAMODEM"),
	_T("LINEMEDIAMODE_G3FAX"),
	_T("LINEMEDIAMODE_TDD"),
	_T("LINEMEDIAMODE_G4FAX"),
	_T("LINEMEDIAMODE_DIGITALDATA"),
	_T("LINEMEDIAMODE_TELETEX"),
	_T("LINEMEDIAMODE_VIDEOTEX"),
	_T("LINEMEDIAMODE_TELEX"),
	_T("LINEMEDIAMODE_MIXED"),
	_T("LINEMEDIAMODE_ADSI"),
	_T("LINEMEDIAMODE_VOICEVIEW")
};

LPCTSTR	pszfLINEREQUESTMODE[] =
{
	_T("Unknown LINEREQUESTMODE message"),
	_T("LINEREQUESTMODE_MAKECALL"),
	_T("LINEREQUESTMODE_MEDIACALL"),
	_T("LINEREQUESTMODE_DROP")
};

// Pretty print a message passed into a lineCallbackFunc.
// This function takes all of the parameters passed into a
// lineCallbackFunc callback function, and pretty prints the
// meaning of the message. It then prints the result to
// the debugging output.
void	CTAPIError::OutputDebugLineCallback(
	DWORD  dwDevice, DWORD  dwMsg, DWORD  dwCallbackInstance,
	DWORD  dwParam1, DWORD  dwParam2, DWORD  dwParam3)
{
	const int	MAXOUTPUTSTRINGLENGTH = 4096;
	TCHAR	szOutputBuff[MAXOUTPUTSTRINGLENGTH];

	FormatLineCallback(szOutputBuff, MAXOUTPUTSTRINGLENGTH,
		dwDevice, dwMsg, dwCallbackInstance, 
		dwParam1, dwParam2, dwParam3);

	::lstrcat(szOutputBuff,"\r\n");
	TRACE0(szOutputBuff);
}

// Pretty prints into a buffer a lineCallbackFunc message.
// This function takes all of the parameters passed into a
// lineCallbackFunc callback function, and pretty prints the
// meaning of the message.  It then returns the pointer to
// the buffer containing this string.
LPTSTR	CTAPIError::FormatLineCallback(LPTSTR  szOutputBuffer, int  nBufLen,
	DWORD  dwDevice, DWORD  dwMsg, DWORD  dwCallbackInstance,
	DWORD  dwParam1, DWORD  dwParam2, DWORD  dwParam3)
{
	long  lBufferIndex = 0;

	DWORD	nMsg = sizeof(psz_dwMsg) / sizeof(psz_dwMsg[0]);
	int	nLineAddressState = sizeof(pszfLINEADDRESSSTATE) / sizeof(pszfLINEADDRESSSTATE[0]);
	int	nLineCallInfoState = sizeof(pszfLINECALLINFOSTATE) / sizeof(pszfLINECALLINFOSTATE[0]);
	int	nLineCallPrivilege = sizeof(pszfLINECALLPRIVILEGE) / sizeof(pszfLINECALLPRIVILEGE[0]);
	int	nLineCallState = sizeof(pszfLINECALLSTATE) / sizeof(pszfLINECALLSTATE[0]);
	int	nLineDialToneMode = sizeof(pszfLINEDIALTONEMODE) / sizeof(pszfLINEDIALTONEMODE[0]);
	int	nLineBusyMode = sizeof(pszfLINEBUSYMODE) / sizeof(pszfLINEBUSYMODE[0]);
	int	nLineSpecialInfo = sizeof(pszfLINESPECIALINFO) / sizeof(pszfLINESPECIALINFO[0]);
	int	nLineDisconnected = sizeof(pszfLINEDISCONNECTED) / sizeof(pszfLINEDISCONNECTED[0]);
	int	nLineGatherTerm = sizeof(pszfLINEGATHERTERM) / sizeof(pszfLINEGATHERTERM[0]);
	int	nLineGenerateTerm = sizeof(pszfLINEGENERATETERM) / sizeof(pszfLINEGENERATETERM[0]);
	int	nLineDevState = sizeof(pszfLINEDEVSTATE) / sizeof(pszfLINEDEVSTATE[0]);
	int	nLineDigitMode = sizeof(pszfLINEDIGITMODE) / sizeof(pszfLINEDIGITMODE[0]);
	int	nLineMediaMode = sizeof(pszfLINEMEDIAMODE) / sizeof(pszfLINEMEDIAMODE[0]);

	int	nLineRequestMode = sizeof(pszfLINEREQUESTMODE) / sizeof(pszfLINEREQUESTMODE[0]);

	// Is this a known message?
	if (dwMsg >= nMsg)
	{
		wsprintf(szOutputBuffer, "lineCallback: Unknown dwMsg: '0x%lx', "
			"dwDevice: '0x%lx', dwCallbackInstance: '0x%lx', "
			"dwParam1: '0x%lx', dwParam2: '0x%lx', dwParam3: '0x%lx'", dwMsg, 
			dwDevice, dwCallbackInstance, dwParam1, dwParam2, dwParam3);
		return  szOutputBuffer;
	}

	// Lets start pretty printing.
	lBufferIndex += wsprintf(szOutputBuffer, "lineCallback: %s; dwDevice: '0x%lx'; ",
		psz_dwMsg[dwMsg], dwDevice);

	// Which message was it?  And start decoding it!
	// How the message is decoded depends entirely on the message.
	// READ THE HELP FILES if you more information on this.
	switch(dwMsg)
	{
	case LINE_ADDRESSSTATE:
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
			"Address ID: 0x%lx, Address State: ", dwParam1);

		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam2,
			pszfLINEADDRESSSTATE, nLineAddressState);
		break;

	case LINE_CALLINFO:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINECALLINFOSTATE, nLineCallInfoState);
		break;

	case LINE_CALLSTATE:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam3,
			pszfLINECALLPRIVILEGE, nLineCallPrivilege);
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]), "; ");

		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINECALLSTATE, nLineCallState);
    
		switch (dwParam1)
		{
		case LINECALLSTATE_DIALTONE:
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]), ": ");

			lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
				dwParam2,
				pszfLINEDIALTONEMODE, nLineDialToneMode);
			break;

		case LINECALLSTATE_BUSY:
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]), ": ");
			lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
				dwParam2,
				pszfLINEBUSYMODE, nLineBusyMode);
			break;

		case LINECALLSTATE_SPECIALINFO:
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]), ": ");
			lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
				dwParam2,
				pszfLINESPECIALINFO, nLineSpecialInfo);
			break;

		case LINECALLSTATE_DISCONNECTED:
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]), ": ");
			lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
				dwParam2,
				pszfLINEDISCONNECTED, nLineDisconnected);
			break;

		case LINECALLSTATE_CONFERENCED:
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
				": Parent conference call handle: 0x%lx", dwParam2);
			break;
		}
		break;

	case LINE_CLOSE:
		break;

	case LINE_DEVSPECIFIC:
		break;

	case LINE_DEVSPECIFICFEATURE:
		break;

	case LINE_GATHERDIGITS:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINEGATHERTERM, nLineGatherTerm);
		break;

	case LINE_GENERATE:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINEGENERATETERM, nLineGenerateTerm);
		break;

	case LINE_LINEDEVSTATE:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINEDEVSTATE, nLineDevState);

		switch (dwParam1)
		{
		case LINEDEVSTATE_RINGING:
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
				"; Ring Mode: 0x%lx, Ring Count: %lu",
				dwParam2, dwParam3);
			break;

		case LINEDEVSTATE_REINIT:
			switch(dwParam2)
			{
			case LINE_CREATE:
				lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
					"; ReInit reason: LINE_CREATE, "
					"New Line Device ID '0x%lx'", dwParam3);
				break;
                            
			case LINE_LINEDEVSTATE:
				lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
					"; ReInit reason: LINE_LINEDEVSTATE, ");

				lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
					dwParam3,
					pszfLINEDEVSTATE, nLineDevState);
				break;
                        
			case 0:
				break;

			default:
				lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
					"; ReInit reason: %s, dwParam3: 0x%lx",
					psz_dwMsg[dwParam2], dwParam3);
				break;
			}
			break;

		default:
			break;
		}
		break;

	case LINE_MONITORDIGITS:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam2,
			pszfLINEDIGITMODE, nLineDigitMode);
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
			", Received: '%c'", LOBYTE(LOWORD(dwParam1)));            
		break;

	case LINE_MONITORMEDIA:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINEMEDIAMODE, nLineMediaMode);
		break;

	case LINE_MONITORTONE:
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
			"AppSpecific tone '%lu'", dwParam1);
		break;

	case LINE_REPLY:
		if (dwParam2 == 0)
		{
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
				"Request ID: 0x%lx; Successful reply!", dwParam1);
		}
		else
		{
			char	szTmpBuff[256];
			FormatLineError((long)dwParam2, szTmpBuff, 255);

			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
				"Request ID: 0x%lx; UnSuccessful reply; %s",
				dwParam1, szTmpBuff);
		}
		break;

	case LINE_REQUEST:
		lBufferIndex += StrBinaryArrayAppend(&(szOutputBuffer[lBufferIndex]),
			dwParam1,
			pszfLINEREQUESTMODE, nLineRequestMode);

		switch(dwParam1)
		{
		case LINEREQUESTMODE_DROP:	// ???
		{
			char	szHwndName[1024];
			SendMessage((HWND)dwParam2, WM_GETTEXT, 1024, (long) szHwndName);

			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
					": hwnd dropping = 0x%lx, \"%s\"; wRequestID = %u",
					dwParam2, szHwndName, LOWORD(dwParam3));
			break;
		}

		default:
			break;
		}
		break;

	case LINE_CREATE:
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
			"New Line Device ID '0x%lx'", dwParam1);
		break;

	case PHONE_CREATE:
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
			"New Phone Device ID '0x%lx'", dwParam1);
		break;

	default:
		lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
			"dwParam1: 0x%lx , dwParam2: 0x%lx , dwParam3: 0x%lx",
			dwParam1, dwParam2, dwParam3);
		break;
	} // End switch(dwMsg)

    return  szOutputBuffer;
}

// Takes a bitmapped DWORD, an array representing that
// binary mapping, and pretty prints it to a buffer.
// This function takes dwFlags and checks each bit.  If the
// bit is set, the appropriate string (taken from szStringArray)
// is printed to the szOutputBuffer string buffer.  If there were
// more bits set in the string than elements in the array, and error
// is also tagged on the end.
long	CTAPIError::StrBinaryArrayAppend(LPTSTR  szOutputBuffer, DWORD  dwFlags,
	LPCTSTR  szStringArray[], DWORD  dwSizeofStringArray)
{
	long	lBufferIndex = 0;

	// The zeroth element in every bitmapped array is the "unknown" or
	// "unchanged" message.
	if (dwFlags == 0)
	{
		lBufferIndex = wsprintf(szOutputBuffer, "%s", szStringArray[0]);
		return  lBufferIndex;
	}

	BOOL	bFirst = TRUE;
	DWORD	dwPower = 1;
	// iterate through the flags and check each one.
	for (DWORD  dwIndex = 1; dwIndex < dwSizeofStringArray; ++ dwIndex)
	{
		// If we find one, print it.
		if (dwFlags & dwPower)
			// Seporate each printing with a ", " except the first one.
			if (bFirst)
			{
				lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
					"%s", szStringArray[dwIndex]);
				bFirst = FALSE;
			}
			else
				lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
					", %s", szStringArray[dwIndex]);

		dwFlags &= ~dwPower;	// clear it so we know we checked it.
		dwPower *= 2;
	}

	// If there are any flags left, they were not in the array.
	if (dwFlags)
	{
		if (bFirst)
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
				"Unknown flags '0x%lx'", dwFlags);
		else
			lBufferIndex += wsprintf(&(szOutputBuffer[lBufferIndex]),
				", Unknown flags '0x%lx'", dwFlags);
	}
	// how many did we print into the buffer?
	return  lBufferIndex;
}

// Pretty print a line error to a string.
// If szOutputBuffer isn't big enough to hold the whole string,
// then the string gets truncated to fit the buffer.
//
// If szOutputBuffer == NULL, then dwSizeofOutputBuffer
// is ignored, a buffer 'big enough' is LocalAlloc()d and
// a pointer to it is returned.  However, its *very* important
// that this pointer be LocalFree()d by the calling application.
LPSTR	CTAPIError::FormatLineError(long  dwLineError,
	LPSTR  szOutputBuffer, DWORD  dwSizeofOutputBuffer)
{
	char	szUnknownLineError[256];
	LPCTSTR	szLineError;
	int	nSizeofLineError;

	// Strip off the high bit to make the error code positive.
	DWORD*	pdwLineError = (DWORD*)&dwLineError;
	long	lErrorIndex = (long)(0x7FFFFFFF & *pdwLineError);

	// Is it an unknown error?
	if ((lErrorIndex >= (sizeof(pszLineErrorNameArray) / sizeof(pszLineErrorNameArray[0]))) ||
		(lErrorIndex < 0))
	{
		nSizeofLineError = wsprintf(szUnknownLineError, "Unknown TAPI line error code: 0x%lx", dwLineError);
		szLineError = szUnknownLineError;
	}
	else
	{
		szLineError = pszLineErrorNameArray[lErrorIndex];
		nSizeofLineError = strlen(szLineError);
	}

	// allocate a buffer if necessary
	if (szOutputBuffer == NULL)
	{
		szOutputBuffer = (LPSTR)::LocalAlloc(LPTR, nSizeofLineError + 1);
		if (szOutputBuffer == NULL)
			return  NULL;
	}
	else	// truncate string if it won't fit in the specified buffer.
	{
		if ((DWORD)nSizeofLineError >= dwSizeofOutputBuffer)
			nSizeofLineError = dwSizeofOutputBuffer - 1;
	}

	// Put the string into the buffer and null terminate.
	memcpy(szOutputBuffer, szLineError, nSizeofLineError);
	szOutputBuffer[nSizeofLineError] = '\0';

	return  szOutputBuffer;
}