www.pudn.com > TsapiCallRouting.rar > utilities.cpp

#include "stdafx.h" 
 
#include  
#include  
#include  
#include  
#include  
#include "utilities.h" 
#include "global.h" 
 
void outputACSevent( char *func, CSTAEvent_t *eventBufPtr ) 
{ 
	if ( ! DBG1 ) return; 
 
	CString retrievedStr; 
	CString *cs = new CString; 
	CString *csPtr; 
	CString *csEventType = makeACSEventTypeStr( eventBufPtr->eventHeader.eventType ); 
	switch( eventBufPtr->eventHeader.eventClass ) 
	{ 
		case ACSCONFIRMATION: 
			(void) (void) retrieveFromHashMap( eventBufPtr->event.acsConfirmation.invokeID, retrievedStr ); 
			cs->Format( "ACSCONFIRMATION: invokeID=%d %s\n   %s", eventBufPtr->event.acsConfirmation.invokeID, retrievedStr.GetString(), csEventType->GetString() ); 
			switch( eventBufPtr->eventHeader.eventType ) 
			{ 
				case ACS_OPEN_STREAM: 
				{ 
					break; 
				} 
				case ACS_OPEN_STREAM_CONF: 
				{ 
					*cs += "\n   apiVer="; 
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.apiVer; 
					*cs += " drvrVer="; 
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.drvrVer; 
					*cs += " libVer="; 
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.libVer; 
					*cs += " tsrvVer=";  
					*cs += eventBufPtr->event.acsConfirmation.u.acsopen.tsrvVer; 
					break; 
				} 
				case ACS_CLOSE_STREAM: 
				{ 
					break; 
				} 
				case ACS_CLOSE_STREAM_CONF: 
				{ 
					break; 
				} 
				case ACS_ABORT_STREAM: 
				{ 
					break; 
				} 
				case ACS_UNIVERSAL_FAILURE: 
				case ACS_UNIVERSAL_FAILURE_CONF: 
				{ 
					*cs += "\n   error="; 
					csPtr = makeACSUFStr( eventBufPtr->event.acsConfirmation.u.failureEvent.error ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break;  
				} 
				case ACS_KEY_REQUEST: 
				{ 
					break; 
				} 
				case ACS_KEY_REPLY: 
				{ 
					break; 
				} 
				case ACS_NAME_SRV_REQUEST: 
				{ 
					break; 
				} 
				case ACS_NAME_SRV_REPLY: 
				{ 
					break; 
				} 
				case ACS_AUTH_REPLY: 
				{ 
					break; 
				} 
				case ACS_AUTH_REPLY_TWO: 
				{ 
					break; 
				} 
				default: 
				{ 
					*cs += "\n   Invalid eventType Context"; 
					break; 
				} 
			} 
			break; 
		case ACSUNSOLICITED: 
			cs->Format( "ACSUNSOLICITED:\n   %s", csEventType->GetString() ); 
			switch( eventBufPtr->eventHeader.eventType ) 
			{ 
				case ACS_UNIVERSAL_FAILURE: 
				case ACS_UNIVERSAL_FAILURE_CONF: 
				{ 
					*cs += "\n   "; 
					csPtr = makeACSUFStr( eventBufPtr->event.acsUnsolicited.u.failureEvent.error ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break;  
				} 
				default: 
				{ 
					*cs += "\n   Invalid eventType Context"; 
				} 
			} 
			break; 
		default: 
			csPtr = new CString; 
			csPtr->Format( "unknown eventClass=%d:\n   %s", eventBufPtr->eventHeader.eventClass, csEventType->GetString() ); 
			*cs += csPtr->GetString(); 
			delete csPtr; 
			break; 
	} 
	DBG1_OUT( func, "%s", cs->GetString() ); 
	delete cs; 
	delete csEventType; 
} 
 
void outputCSTAevent( char *func, CSTAEvent_t *eventBufPtr, ATTEvent_t *attEvent ) 
{ 
	if ( ! DBG1 ) return; 
 
	CString retrievedStr; 
	CString *cs = new CString; 
	CString *csPtr; 
	CString *csEventType = makeCSTAEventTypeStr( eventBufPtr->eventHeader.eventType ); 
	switch( eventBufPtr->eventHeader.eventClass ) 
	{ 
		case CSTACONFIRMATION: 
			(void) (void) retrieveFromHashMap( eventBufPtr->event.cstaConfirmation.invokeID, retrievedStr ); 
			cs->Format( "CSTACONFIRMATION: invokeID=%d %s\n   %s", eventBufPtr->event.cstaConfirmation.invokeID, retrievedStr.GetString(), csEventType->GetString() ); 
			switch( eventBufPtr->eventHeader.eventType ) 
			{ 
				case CSTA_ALTERNATE_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_ANSWER_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_CALL_COMPLETION_CONF: 
				{ 
					break; 
				} 
				case CSTA_CLEAR_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_CLEAR_CONNECTION_CONF: 
				{ 
					break; 
				} 
				case CSTA_CONFERENCE_CALL_CONF: 
				{ 
					*cs += "\n   newCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaConfirmation.u.conferenceCall.newCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   connList="; 
					csPtr = makeConnectionListStr( &eventBufPtr->event.cstaConfirmation.u.conferenceCall.connList ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_CONSULTATION_CALL_CONF: 
				{ 
					*cs += "\n   newCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaConfirmation.u.consultationCall.newCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_DEFLECT_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_PICKUP_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_GROUP_PICKUP_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_HOLD_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_MAKE_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_MAKE_PREDICTIVE_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_MWI_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_DND_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_FWD_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_AGENT_STATE_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_LAST_NUMBER_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_DEVICE_INFO_CONF: 
				{ 
					break; 
				} 
				case CSTA_RECONNECT_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_RETRIEVE_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_SET_MWI_CONF: 
				{ 
					break; 
				} 
				case CSTA_SET_DND_CONF: 
				{ 
					break; 
				} 
				case CSTA_SET_FWD_CONF: 
				{ 
					break; 
				} 
				case CSTA_SET_AGENT_STATE_CONF: 
				{ 
					break; 
				} 
				case CSTA_TRANSFER_CALL_CONF: 
				{ 
					break; 
				} 
				case CSTA_UNIVERSAL_FAILURE_CONF: 
				{ 
					*cs += "\n   "; 
					csPtr = makeCSTAUFStr( eventBufPtr->event.cstaConfirmation.u.universalFailure.error ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break;  
				} 
				case CSTA_QUEUED: 
				{ 
					break; 
				} 
				case CSTA_CALL_INFORMATION: 
				{ 
					break; 
				} 
				case CSTA_DO_NOT_DISTURB: 
				{ 
					break; 
				} 
				case CSTA_FORWARDING: 
				{ 
					break; 
				} 
				case CSTA_MESSAGE_WAITING: 
				{ 
					break; 
				} 
				case CSTA_LOGGED_ON: 
				{ 
					break; 
				} 
				case CSTA_LOGGED_OFF: 
				{ 
					break; 
				} 
				case CSTA_NOT_READY: 
				{ 
					break; 
				} 
				case CSTA_READY: 
				{ 
					break; 
				} 
				case CSTA_WORK_NOT_READY: 
				{ 
					break; 
				} 
				case CSTA_WORK_READY: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_REGISTER_REQ_CONF: 
				{ 
					csPtr = new CString; 
					csPtr->Format( "\n   registerReqID=%ld", eventBufPtr->event.cstaConfirmation.u.routeRegister.registerReqID ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_ROUTE_REGISTER_CANCEL_CONF: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_REGISTER_ABORT: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_SELECT_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_RE_ROUTE_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_USED: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_END: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_END_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ESCAPE_SVC_CONF: 
				{ 
					break; 
				} 
				case CSTA_ESCAPE_SVC_REQ_CONF: 
				{ 
					break; 
				} 
				case CSTA_PRIVATE: 
				{ 
					break; 
				} 
				case CSTA_PRIVATE_STATUS: 
				{ 
					break; 
				} 
				case CSTA_SEND_PRIVATE: 
				{ 
					break; 
				} 
				case CSTA_BACK_IN_SERVICE: 
				{ 
					break; 
				} 
				case CSTA_OUT_OF_SERVICE: 
				{ 
					break; 
				} 
				case CSTA_REQ_SYS_STAT_CONF: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_START_CONF: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_STOP_CONF: 
				{ 
					break; 
				} 
				case CSTA_CHANGE_SYS_STAT_FILTER_CONF: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_ENDED: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_REQ_CONF: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_EVENT_SEND: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_DEVICE: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_CALL: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_CALLS_VIA_DEVICE: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_CONF: 
				{ 
					csPtr = new CString; 
					csPtr->Format( "\n   monitorCrossRefID=%d", eventBufPtr->event.cstaConfirmation.u.monitorStart.monitorCrossRefID ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   monitorFilter="; 
					csPtr = makeCSTAMonitorFilterStr( &eventBufPtr->event.cstaConfirmation.u.monitorStart.monitorFilter ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_CHANGE_MONITOR_FILTER_CONF: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_STOP_CONF: 
				{ 
					break; 
				} 
				case CSTA_SNAPSHOT_CALL_CONF: 
				{ 
					*cs += "\n   snapshotData="; 
					csPtr = makeCSTASnapshotCallDataStr( &eventBufPtr->event.cstaConfirmation.u.snapshotCall.snapshotData ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_SNAPSHOT_DEVICE: 
				{ 
					break; 
				} 
				case CSTA_SNAPSHOT_DEVICE_CONF: 
				{ 
					*cs += "\n   snapshotData="; 
					csPtr = makeCSTASnapshotDeviceDataStr( &eventBufPtr->event.cstaConfirmation.u.snapshotDevice.snapshotData ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_GETAPI_CAPS_CONF: 
				{ 
					break; 
				} 
				case CSTA_GET_DEVICE_LIST_CONF: 
				{ 
					break; 
				} 
				case CSTA_QUERY_CALL_MONITOR_CONF: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_REQUEST_EXT: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_USED_EXT: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_SELECT_INV_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_END_INV_REQUEST: 
				{ 
					break; 
				} 
				default: 
				{ 
					*cs += "\n   Invalid eventType Context"; 
					break; 
				} 
			} 
			break; 
		case CSTAUNSOLICITED: 
			cs->Format( "CSTAUNSOLICITED: monitorCrossRefId=%d\n   %s", eventBufPtr->event.cstaUnsolicited.monitorCrossRefId, csEventType->GetString() ); 
			switch( eventBufPtr->eventHeader.eventType ) 
			{ 
				case CSTA_CONFERENCE_CALL: 
				{ 
					break; 
				} 
				case CSTA_CALL_CLEARED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.callCleared.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   clearedCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.callCleared.clearedCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_CONFERENCED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.conferenced.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.conferenced.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   primaryOldCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.conferenced.primaryOldCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   secondaryOldCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.conferenced.secondaryOldCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   addedParty="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.conferenced.addedParty ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   confController="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.conferenced.confController ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   conferenceConnections="; 
					csPtr = makeConnectionListStr( &eventBufPtr->event.cstaUnsolicited.u.conferenced.conferenceConnections ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_CONNECTION_CLEARED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.connectionCleared.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.connectionCleared.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   droppedConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.connectionCleared.droppedConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   releasingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.connectionCleared.releasingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_DELIVERED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.delivered.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.delivered.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   connection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.delivered.connection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   alertingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.delivered.alertingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   lastRedirectionDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.delivered.lastRedirectionDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   calledDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.delivered.calledDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   callingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.delivered.callingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_DIVERTED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.diverted.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.diverted.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   connection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.diverted.connection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   divertingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.diverted.divertingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   newDestination="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.diverted.newDestination ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_ESTABLISHED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.established.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.established.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   establishedConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.established.establishedConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   answeringDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.established.answeringDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   lastRedirectionDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.established.lastRedirectionDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   calledDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.established.calledDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   callingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.established.callingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_FAILED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.failed.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.failed.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   failedConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.failed.failedConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   calledDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.failed.calledDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   failingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.failed.failingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_HELD: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.held.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.held.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   heldConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.held.heldConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   holdingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.held.holdingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_NETWORK_REACHED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.networkReached.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.networkReached.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   connection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.networkReached.connection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   calledDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.networkReached.calledDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   trunkUsed="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.networkReached.trunkUsed ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_ORIGINATED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.originated.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.originated.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   originatedConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.originated.originatedConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   calledDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.originated.calledDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   callingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.originated.callingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_QUEUED: 
				{ 
					break; 
				} 
				case CSTA_RETRIEVED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.retrieved.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.retrieved.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   retrievedConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.retrieved.retrievedConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   retrievingDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.retrieved.retrievingDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_SERVICE_INITIATED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.serviceInitiated.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.serviceInitiated.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   initiatedConnection="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.serviceInitiated.initiatedConnection ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_TRANSFERRED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.transferred.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   localConnectionInfo="; 
					csPtr = makeLocalConnectionStateStr( eventBufPtr->event.cstaUnsolicited.u.transferred.localConnectionInfo ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   primaryOldCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.transferred.primaryOldCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   secondaryOldCall="; 
					csPtr = makeConnectionIDStr( &eventBufPtr->event.cstaUnsolicited.u.transferred.secondaryOldCall ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   transferredDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.transferred.transferredDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   transferringDevice="; 
					csPtr = makeExtendedDeviceIDStr( &eventBufPtr->event.cstaUnsolicited.u.transferred.transferringDevice ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					*cs += "\n   transferredConnections="; 
					csPtr = makeConnectionListStr( &eventBufPtr->event.cstaUnsolicited.u.transferred.transferredConnections ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_CALL_INFORMATION: 
				{ 
					break; 
				} 
				case CSTA_DO_NOT_DISTURB: 
				{ 
					break; 
				} 
				case CSTA_FORWARDING: 
				{ 
					break; 
				} 
				case CSTA_MESSAGE_WAITING: 
				{ 
					break; 
				} 
				case CSTA_LOGGED_ON: 
				{ 
					break; 
				} 
				case CSTA_LOGGED_OFF: 
				{ 
					break; 
				} 
				case CSTA_NOT_READY: 
				{ 
					break; 
				} 
				case CSTA_READY: 
				{ 
					break; 
				} 
				case CSTA_WORK_NOT_READY: 
				{ 
					break; 
				} 
				case CSTA_WORK_READY: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_REGISTER_ABORT: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_SELECT_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_RE_ROUTE_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_USED: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_END: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_END_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_PRIVATE: 
				{ 
					break; 
				} 
				case CSTA_PRIVATE_STATUS: 
				{ 
					break; 
				} 
				case CSTA_SEND_PRIVATE: 
				{ 
					break; 
				} 
				case CSTA_BACK_IN_SERVICE: 
				{ 
					break; 
				} 
				case CSTA_OUT_OF_SERVICE: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_ENDED: 
				{ 
					break; 
				} 
				case CSTA_SYS_STAT_EVENT_SEND: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_DEVICE: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_CALL: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_CALLS_VIA_DEVICE: 
				{ 
					break; 
				} 
				case CSTA_MONITOR_ENDED: 
				{ 
					*cs += "\n   cause="; 
					csPtr = makeCSTAEventCauseStr( eventBufPtr->event.cstaUnsolicited.u.monitorEnded.cause ); 
					*cs += csPtr->GetString(); 
					delete csPtr; 
					break; 
				} 
				case CSTA_ROUTE_REQUEST_EXT: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_USED_EXT: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_SELECT_INV_REQUEST: 
				{ 
					break; 
				} 
				case CSTA_ROUTE_END_INV_REQUEST: 
				{ 
					break; 
				} 
				default: 
				{ 
					*cs += "\n   Invalid eventType Context"; 
					break; 
				} 
			} 
			break; 
		default: 
			csPtr = new CString; 
			csPtr->Format( "unknown eventClass=%d:\n   %s", eventBufPtr->eventHeader.eventClass, csEventType->GetString() ); 
			*cs += csPtr->GetString(); 
			delete csPtr; 
			break; 
	} 
	csPtr = makeATTEventStr( attEvent ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	DBG1_OUT( func, "%s", cs->GetString() ); 
	delete cs; 
	delete csEventType; 
} 
 
CString * makeACSEventTypeStr( EventType_t eventType ) 
{ 
	CString *cs = new CString; 
	switch ( eventType ) 
	{ 
	case ACS_OPEN_STREAM: 
		*cs = "ACS_OPEN_STREAM"; 
		break; 
	case ACS_OPEN_STREAM_CONF: 
		*cs = "ACS_OPEN_STREAM_CONF"; 
		break; 
	case ACS_CLOSE_STREAM: 
		*cs = "ACS_CLOSE_STREAM"; 
		break; 
	case ACS_CLOSE_STREAM_CONF: 
		*cs = "ACS_CLOSE_STREAM_CONF"; 
		break; 
	case ACS_ABORT_STREAM: 
		*cs = "ACS_ABORT_STREAM"; 
		break; 
	case ACS_UNIVERSAL_FAILURE_CONF: 
		*cs = "ACS_UNIVERSAL_FAILURE_CONF"; 
		break; 
	case ACS_UNIVERSAL_FAILURE: 
		*cs = "ACS_UNIVERSAL_FAILURE"; 
		break; 
	case ACS_KEY_REQUEST: 
		*cs = "ACS_KEY_REQUEST"; 
		break; 
	case ACS_KEY_REPLY: 
		*cs = "ACS_KEY_REPLY"; 
		break; 
	case ACS_NAME_SRV_REQUEST: 
		*cs = "ACS_NAME_SRV_REQUEST"; 
		break; 
	case ACS_NAME_SRV_REPLY: 
		*cs = "ACS_NAME_SRV_REPLY"; 
		break; 
	case ACS_AUTH_REPLY: 
		*cs = "ACS_AUTH_REPLY"; 
		break; 
	case ACS_AUTH_REPLY_TWO: 
		*cs = "ACS_AUTH_REPLY_TWO"; 
		break; 
	default: 
		cs->Format( "ACSeventType=%d", eventType ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeCSTAEventTypeStr( EventType_t eventType ) 
{ 
	CString *cs = new CString; 
	switch ( eventType ) 
	{ 
	case CSTA_ALTERNATE_CALL: 
		*cs = "CSTA_ALTERNATE_CALL"; 
		break; 
	case CSTA_ALTERNATE_CALL_CONF: 
		*cs = "CSTA_ALTERNATE_CALL_CONF"; 
		break; 
	case CSTA_ANSWER_CALL: 
		*cs = "CSTA_ANSWER_CALL"; 
		break; 
	case CSTA_ANSWER_CALL_CONF: 
		*cs = "CSTA_ANSWER_CALL_CONF"; 
		break; 
	case CSTA_BACK_IN_SERVICE: 
		*cs = "CSTA_BACK_IN_SERVICE"; 
		break; 
	case CSTA_CALL_CLEARED: 
		*cs = "CSTA_CALL_CLEARED"; 
		break; 
	case CSTA_CALL_COMPLETION: 
		*cs = "CSTA_CALL_COMPLETION"; 
		break; 
	case CSTA_CALL_COMPLETION_CONF: 
		*cs = "CSTA_CALL_COMPLETION_CONF"; 
		break; 
	case CSTA_CALL_INFORMATION: 
		*cs = "CSTA_CALL_INFORMATION"; 
		break; 
	case CSTA_CHANGE_MONITOR_FILTER: 
		*cs = "CSTA_CHANGE_MONITOR_FILTER"; 
		break; 
	case CSTA_CHANGE_MONITOR_FILTER_CONF: 
		*cs = "CSTA_CHANGE_MONITOR_FILTER_CONF"; 
		break; 
	case CSTA_CHANGE_SYS_STAT_FILTER: 
		*cs = "CSTA_CHANGE_SYS_STAT_FILTER"; 
		break; 
	case CSTA_CHANGE_SYS_STAT_FILTER_CONF: 
		*cs = "CSTA_CHANGE_SYS_STAT_FILTER_CONF"; 
		break; 
	case CSTA_CLEAR_CALL: 
		*cs = "CSTA_CLEAR_CALL"; 
		break; 
	case CSTA_CLEAR_CALL_CONF: 
		*cs = "CSTA_CLEAR_CALL_CONF"; 
		break; 
	case CSTA_CLEAR_CONNECTION: 
		*cs = "CSTA_CLEAR_CONNECTION"; 
		break; 
	case CSTA_CLEAR_CONNECTION_CONF: 
		*cs = "CSTA_CLEAR_CONNECTION_CONF"; 
		break; 
	case CSTA_CONFERENCED: 
		*cs = "CSTA_CONFERENCED"; 
		break; 
	case CSTA_CONFERENCE_CALL: 
		*cs = "CSTA_CONFERENCE_CALL"; 
		break; 
	case CSTA_CONFERENCE_CALL_CONF: 
		*cs = "CSTA_CONFERENCE_CALL_CONF"; 
		break; 
	case CSTA_CONNECTION_CLEARED: 
		*cs = "CSTA_CONNECTION_CLEARED"; 
		break; 
	case CSTA_CONSULTATION_CALL: 
		*cs = "CSTA_CONSULTATION_CALL"; 
		break; 
	case CSTA_CONSULTATION_CALL_CONF: 
		*cs = "CSTA_CONSULTATION_CALL_CONF"; 
		break; 
	case CSTA_DEFLECT_CALL: 
		*cs = "CSTA_DEFLECT_CALL"; 
		break; 
	case CSTA_DEFLECT_CALL_CONF: 
		*cs = "CSTA_DEFLECT_CALL_CONF"; 
		break; 
	case CSTA_DELIVERED: 
		*cs = "CSTA_DELIVERED"; 
		break; 
	case CSTA_DIVERTED: 
		*cs = "CSTA_DIVERTED"; 
		break; 
	case CSTA_DO_NOT_DISTURB: 
		*cs = "CSTA_DO_NOT_DISTURB"; 
		break; 
	case CSTA_ESCAPE_SVC: 
		*cs = "CSTA_ESCAPE_SVC"; 
		break; 
	case CSTA_ESCAPE_SVC_CONF: 
		*cs = "CSTA_ESCAPE_SVC_CONF"; 
		break; 
	case CSTA_ESCAPE_SVC_REQ: 
		*cs = "CSTA_ESCAPE_SVC_REQ"; 
		break; 
	case CSTA_ESCAPE_SVC_REQ_CONF: 
		*cs = "CSTA_ESCAPE_SVC_REQ_CONF"; 
		break; 
	case CSTA_ESTABLISHED: 
		*cs = "CSTA_ESTABLISHED"; 
		break; 
	case CSTA_FAILED: 
		*cs = "CSTA_FAILED"; 
		break; 
	case CSTA_FORWARDING: 
		*cs = "CSTA_FORWARDING"; 
		break; 
	case CSTA_GETAPI_CAPS: 
		*cs = "CSTA_GETAPI_CAPS"; 
		break; 
	case CSTA_GETAPI_CAPS_CONF: 
		*cs = "CSTA_GETAPI_CAPS_CONF"; 
		break; 
	case CSTA_GET_DEVICE_LIST: 
		*cs = "CSTA_GET_DEVICE_LIST"; 
		break; 
	case CSTA_GET_DEVICE_LIST_CONF: 
		*cs = "CSTA_GET_DEVICE_LIST_CONF"; 
		break; 
	case CSTA_GROUP_PICKUP_CALL: 
		*cs = "CSTA_GROUP_PICKUP_CALL"; 
		break; 
	case CSTA_GROUP_PICKUP_CALL_CONF: 
		*cs = "CSTA_GROUP_PICKUP_CALL_CONF"; 
		break; 
	case CSTA_HELD: 
		*cs = "CSTA_HELD"; 
		break; 
	case CSTA_HOLD_CALL: 
		*cs = "CSTA_HOLD_CALL"; 
		break; 
	case CSTA_HOLD_CALL_CONF: 
		*cs = "CSTA_HOLD_CALL_CONF"; 
		break; 
	case CSTA_LOGGED_OFF: 
		*cs = "CSTA_LOGGED_OFF"; 
		break; 
	case CSTA_LOGGED_ON: 
		*cs = "CSTA_LOGGED_ON"; 
		break; 
	case CSTA_MAKE_CALL: 
		*cs = "CSTA_MAKE_CALL"; 
		break; 
	case CSTA_MAKE_CALL_CONF: 
		*cs = "CSTA_MAKE_CALL_CONF"; 
		break; 
	case CSTA_MAKE_PREDICTIVE_CALL: 
		*cs = "CSTA_MAKE_PREDICTIVE_CALL"; 
		break; 
	case CSTA_MAKE_PREDICTIVE_CALL_CONF: 
		*cs = "CSTA_MAKE_PREDICTIVE_CALL_CONF"; 
		break; 
	case CSTA_MESSAGE_WAITING: 
		*cs = "CSTA_MESSAGE_WAITING"; 
		break; 
	case CSTA_MONITOR_CALL: 
		*cs = "CSTA_MONITOR_CALL"; 
		break; 
	case CSTA_MONITOR_CALLS_VIA_DEVICE: 
		*cs = "CSTA_MONITOR_CALLS_VIA_DEVICE"; 
		break; 
	case CSTA_MONITOR_CONF: 
		*cs = "CSTA_MONITOR_CONF"; 
		break; 
	case CSTA_MONITOR_DEVICE: 
		*cs = "CSTA_MONITOR_DEVICE"; 
		break; 
	case CSTA_MONITOR_ENDED: 
		*cs = "CSTA_MONITOR_ENDED"; 
		break; 
	case CSTA_MONITOR_STOP: 
		*cs = "CSTA_MONITOR_STOP"; 
		break; 
	case CSTA_MONITOR_STOP_CONF: 
		*cs = "CSTA_MONITOR_STOP_CONF"; 
		break; 
	case CSTA_NETWORK_REACHED: 
		*cs = "CSTA_NETWORK_REACHED"; 
		break; 
	case CSTA_NOT_READY: 
		*cs = "CSTA_NOT_READY"; 
		break; 
	case CSTA_ORIGINATED: 
		*cs = "CSTA_ORIGINATED"; 
		break; 
	case CSTA_OUT_OF_SERVICE: 
		*cs = "CSTA_OUT_OF_SERVICE"; 
		break; 
	case CSTA_PICKUP_CALL: 
		*cs = "CSTA_PICKUP_CALL"; 
		break; 
	case CSTA_PICKUP_CALL_CONF: 
		*cs = "CSTA_PICKUP_CALL_CONF"; 
		break; 
	case CSTA_PRIVATE: 
		*cs = "CSTA_PRIVATE"; 
		break; 
	case CSTA_PRIVATE_STATUS: 
		*cs = "CSTA_PRIVATE_STATUS"; 
		break; 
	case CSTA_QUERY_AGENT_STATE: 
		*cs = "CSTA_QUERY_AGENT_STATE"; 
		break; 
	case CSTA_QUERY_AGENT_STATE_CONF: 
		*cs = "CSTA_QUERY_AGENT_STATE_CONF"; 
		break; 
	case CSTA_QUERY_CALL_MONITOR: 
		*cs = "CSTA_QUERY_CALL_MONITOR"; 
		break; 
	case CSTA_QUERY_CALL_MONITOR_CONF: 
		*cs = "CSTA_QUERY_CALL_MONITOR_CONF"; 
		break; 
	case CSTA_QUERY_DEVICE_INFO: 
		*cs = "CSTA_QUERY_DEVICE_INFO"; 
		break; 
	case CSTA_QUERY_DEVICE_INFO_CONF: 
		*cs = "CSTA_QUERY_DEVICE_INFO_CONF"; 
		break; 
	case CSTA_QUERY_DND: 
		*cs = "CSTA_QUERY_DND"; 
		break; 
	case CSTA_QUERY_DND_CONF: 
		*cs = "CSTA_QUERY_DND_CONF"; 
		break; 
	case CSTA_QUERY_FWD: 
		*cs = "CSTA_QUERY_FWD"; 
		break; 
	case CSTA_QUERY_FWD_CONF: 
		*cs = "CSTA_QUERY_FWD_CONF"; 
		break; 
	case CSTA_QUERY_LAST_NUMBER: 
		*cs = "CSTA_QUERY_LAST_NUMBER"; 
		break; 
	case CSTA_QUERY_LAST_NUMBER_CONF: 
		*cs = "CSTA_QUERY_LAST_NUMBER_CONF"; 
		break; 
	case CSTA_QUERY_MWI: 
		*cs = "CSTA_QUERY_MWI"; 
		break; 
	case CSTA_QUERY_MWI_CONF: 
		*cs = "CSTA_QUERY_MWI_CONF"; 
		break; 
	case CSTA_QUEUED: 
		*cs = "CSTA_QUEUED"; 
		break; 
	case CSTA_READY: 
		*cs = "CSTA_READY"; 
		break; 
	case CSTA_RECONNECT_CALL: 
		*cs = "CSTA_RECONNECT_CALL"; 
		break; 
	case CSTA_RECONNECT_CALL_CONF: 
		*cs = "CSTA_RECONNECT_CALL_CONF"; 
		break; 
	case CSTA_REQ_SYS_STAT: 
		*cs = "CSTA_REQ_SYS_STAT"; 
		break; 
	case CSTA_REQ_SYS_STAT_CONF: 
		*cs = "CSTA_REQ_SYS_STAT_CONF"; 
		break; 
	case CSTA_RETRIEVED: 
		*cs = "CSTA_RETRIEVED"; 
		break; 
	case CSTA_RETRIEVE_CALL: 
		*cs = "CSTA_RETRIEVE_CALL"; 
		break; 
	case CSTA_RETRIEVE_CALL_CONF: 
		*cs = "CSTA_RETRIEVE_CALL_CONF"; 
		break; 
	case CSTA_RE_ROUTE_REQUEST: 
		*cs = "CSTA_RE_ROUTE_REQUEST"; 
		break; 
	case CSTA_ROUTE_END: 
		*cs = "CSTA_ROUTE_END"; 
		break; 
	case CSTA_ROUTE_END_INV_REQUEST: 
		*cs = "CSTA_ROUTE_END_INV_REQUEST"; 
		break; 
	case CSTA_ROUTE_END_REQUEST: 
		*cs = "CSTA_ROUTE_END_REQUEST"; 
		break; 
	case CSTA_ROUTE_REGISTER_ABORT: 
		*cs = "CSTA_ROUTE_REGISTER_ABORT"; 
		break; 
	case CSTA_ROUTE_REGISTER_CANCEL: 
		*cs = "CSTA_ROUTE_REGISTER_CANCEL"; 
		break; 
	case CSTA_ROUTE_REGISTER_CANCEL_CONF: 
		*cs = "CSTA_ROUTE_REGISTER_CANCEL_CONF"; 
		break; 
	case CSTA_ROUTE_REGISTER_REQ: 
		*cs = "CSTA_ROUTE_REGISTER_REQ"; 
		break; 
	case CSTA_ROUTE_REGISTER_REQ_CONF: 
		*cs = "CSTA_ROUTE_REGISTER_REQ_CONF"; 
		break; 
	case CSTA_ROUTE_REQUEST: 
		*cs = "CSTA_ROUTE_REQUEST"; 
		break; 
	case CSTA_ROUTE_REQUEST_EXT: 
		*cs = "CSTA_ROUTE_REQUEST_EXT"; 
		break; 
	case CSTA_ROUTE_SELECT_INV_REQUEST: 
		*cs = "CSTA_ROUTE_SELECT_INV_REQUEST"; 
		break; 
	case CSTA_ROUTE_SELECT_REQUEST: 
		*cs = "CSTA_ROUTE_SELECT_REQUEST"; 
		break; 
	case CSTA_ROUTE_USED: 
		*cs = "CSTA_ROUTE_USED"; 
		break; 
	case CSTA_ROUTE_USED_EXT: 
		*cs = "CSTA_ROUTE_USED_EXT"; 
		break; 
	case CSTA_SEND_PRIVATE: 
		*cs = "CSTA_SEND_PRIVATE"; 
		break; 
	case CSTA_SERVICE_INITIATED: 
		*cs = "CSTA_SERVICE_INITIATED"; 
		break; 
	case CSTA_SET_AGENT_STATE: 
		*cs = "CSTA_SET_AGENT_STATE"; 
		break; 
	case CSTA_SET_AGENT_STATE_CONF: 
		*cs = "CSTA_SET_AGENT_STATE_CONF"; 
		break; 
	case CSTA_SET_DND: 
		*cs = "CSTA_SET_DND"; 
		break; 
	case CSTA_SET_DND_CONF: 
		*cs = "CSTA_SET_DND_CONF"; 
		break; 
	case CSTA_SET_FWD: 
		*cs = "CSTA_SET_FWD"; 
		break; 
	case CSTA_SET_FWD_CONF: 
		*cs = "CSTA_SET_FWD_CONF"; 
		break; 
	case CSTA_SET_MWI: 
		*cs = "CSTA_SET_MWI"; 
		break; 
	case CSTA_SET_MWI_CONF: 
		*cs = "CSTA_SET_MWI_CONF"; 
		break; 
	case CSTA_SNAPSHOT_CALL: 
		*cs = "CSTA_SNAPSHOT_CALL"; 
		break; 
	case CSTA_SNAPSHOT_CALL_CONF: 
		*cs = "CSTA_SNAPSHOT_CALL_CONF"; 
		break; 
	case CSTA_SNAPSHOT_DEVICE: 
		*cs = "CSTA_SNAPSHOT_DEVICE"; 
		break; 
	case CSTA_SNAPSHOT_DEVICE_CONF: 
		*cs = "CSTA_SNAPSHOT_DEVICE_CONF"; 
		break; 
	case CSTA_SYS_STAT: 
		*cs = "CSTA_SYS_STAT"; 
		break; 
	case CSTA_SYS_STAT_ENDED: 
		*cs = "CSTA_SYS_STAT_ENDED"; 
		break; 
	case CSTA_SYS_STAT_EVENT_SEND: 
		*cs = "CSTA_SYS_STAT_EVENT_SEND"; 
		break; 
	case CSTA_SYS_STAT_REQ: 
		*cs = "CSTA_SYS_STAT_REQ"; 
		break; 
	case CSTA_SYS_STAT_REQ_CONF: 
		*cs = "CSTA_SYS_STAT_REQ_CONF"; 
		break; 
	case CSTA_SYS_STAT_START: 
		*cs = "CSTA_SYS_STAT_START"; 
		break; 
	case CSTA_SYS_STAT_START_CONF: 
		*cs = "CSTA_SYS_STAT_START_CONF"; 
		break; 
	case CSTA_SYS_STAT_STOP: 
		*cs = "CSTA_SYS_STAT_STOP"; 
		break; 
	case CSTA_SYS_STAT_STOP_CONF: 
		*cs = "CSTA_SYS_STAT_STOP_CONF"; 
		break; 
	case CSTA_TRANSFERRED: 
		*cs = "CSTA_TRANSFERRED"; 
		break; 
	case CSTA_TRANSFER_CALL: 
		*cs = "CSTA_TRANSFER_CALL"; 
		break; 
	case CSTA_TRANSFER_CALL_CONF: 
		*cs = "CSTA_TRANSFER_CALL_CONF"; 
		break; 
	case CSTA_UNIVERSAL_FAILURE_CONF: 
		*cs = "CSTA_UNIVERSAL_FAILURE_CONF"; 
		break; 
	case CSTA_WORK_NOT_READY: 
		*cs = "CSTA_WORK_NOT_READY"; 
		break; 
	case CSTA_WORK_READY: 
		*cs = "CSTA_WORK_READY"; 
		break; 
	default: 
		cs->Format( "CSTAeventType=%d", eventType ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeACSUFStr( ACSUniversalFailure_t error ) 
{ 
	CString *cs = new CString; 
	switch( error ) 
	{ 
	case TSERVER_STREAM_FAILED: 
		*cs = "TSERVER_STREAM_FAILED"; 
		break; 
	case TSERVER_NO_THREAD: 
		*cs = "TSERVER_NO_THREAD"; 
		break; 
	case TSERVER_BAD_DRIVER_ID: 
		*cs = "TSERVER_BAD_DRIVER_ID"; 
		break; 
	case TSERVER_DEAD_DRIVER: 
		*cs = "TSERVER_DEAD_DRIVER"; 
		break; 
	case TSERVER_MESSAGE_HIGH_WATER_MARK: 
		*cs = "TSERVER_MESSAGE_HIGH_WATER_MARK"; 
		break; 
	case TSERVER_FREE_BUFFER_FAILED: 
		*cs = "TSERVER_FREE_BUFFER_FAILED"; 
		break; 
	case TSERVER_SEND_TO_DRIVER: 
		*cs = "TSERVER_SEND_TO_DRIVER"; 
		break; 
	case TSERVER_RECEIVE_FROM_DRIVER: 
		*cs = "TSERVER_RECEIVE_FROM_DRIVER"; 
		break; 
	case TSERVER_REGISTRATION_FAILED: 
		*cs = "TSERVER_REGISTRATION_FAILED"; 
		break; 
	case TSERVER_SPX_FAILED: 
		*cs = "TSERVER_SPX_FAILED"; 
		break; 
	case TSERVER_TRACE: 
		*cs = "TSERVER_TRACE"; 
		break; 
	case TSERVER_NO_MEMORY: 
		*cs = "TSERVER_NO_MEMORY"; 
		break; 
	case TSERVER_ENCODE_FAILED: 
		*cs = "TSERVER_ENCODE_FAILED"; 
		break; 
	case TSERVER_DECODE_FAILED: 
		*cs = "TSERVER_DECODE_FAILED"; 
		break; 
	case TSERVER_BAD_CONNECTION: 
		*cs = "TSERVER_BAD_CONNECTION"; 
		break; 
	case TSERVER_BAD_PDU: 
		*cs = "TSERVER_BAD_PDU"; 
		break; 
	case TSERVER_NO_VERSION: 
		*cs = "TSERVER_NO_VERSION"; 
		break; 
	case TSERVER_ECB_MAX_EXCEEDED: 
		*cs = "TSERVER_ECB_MAX_EXCEEDED"; 
		break; 
	case TSERVER_NO_ECBS: 
		*cs = "TSERVER_NO_ECBS"; 
		break; 
	case TSERVER_NO_SDB: 
		*cs = "TSERVER_NO_SDB"; 
		break; 
	case TSERVER_NO_SDB_CHECK_NEEDED: 
		*cs = "TSERVER_NO_SDB_CHECK_NEEDED"; 
		break; 
	case TSERVER_SDB_CHECK_NEEDED: 
		*cs = "TSERVER_SDB_CHECK_NEEDED"; 
		break; 
	case TSERVER_BAD_SDB_LEVEL: 
		*cs = "TSERVER_BAD_SDB_LEVEL"; 
		break; 
	case TSERVER_BAD_SERVERID: 
		*cs = "TSERVER_BAD_SERVERID"; 
		break; 
	case TSERVER_BAD_STREAM_TYPE: 
		*cs = "TSERVER_BAD_STREAM_TYPE"; 
		break; 
	case TSERVER_BAD_PASSWORD_OR_LOGIN: 
		*cs = "TSERVER_BAD_PASSWORD_OR_LOGIN"; 
		break; 
	case TSERVER_NO_USER_RECORD: 
		*cs = "TSERVER_NO_USER_RECORD"; 
		break; 
	case TSERVER_NO_DEVICE_RECORD: 
		*cs = "TSERVER_NO_DEVICE_RECORD"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_LIST"; 
		break; 
	case TSERVER_USERS_RESTRICTED_HOME: 
		*cs = "TSERVER_USERS_RESTRICTED_HOME"; 
		break; 
	case TSERVER_NO_AWAYPERMISSION: 
		*cs = "TSERVER_NO_AWAYPERMISSION"; 
		break; 
	case TSERVER_NO_HOMEPERMISSION: 
		*cs = "TSERVER_NO_HOMEPERMISSION"; 
		break; 
	case TSERVER_NO_AWAY_WORKTOP: 
		*cs = "TSERVER_NO_AWAY_WORKTOP"; 
		break; 
	case TSERVER_BAD_DEVICE_RECORD: 
		*cs = "TSERVER_BAD_DEVICE_RECORD"; 
		break; 
	case TSERVER_DEVICE_NOT_SUPPORTED: 
		*cs = "TSERVER_DEVICE_NOT_SUPPORTED"; 
		break; 
	case TSERVER_INSUFFICIENT_PERMISSION: 
		*cs = "TSERVER_INSUFFICIENT_PERMISSION"; 
		break; 
	case TSERVER_NO_RESOURCE_TAG: 
		*cs = "TSERVER_NO_RESOURCE_TAG"; 
		break; 
	case TSERVER_INVALID_MESSAGE: 
		*cs = "TSERVER_INVALID_MESSAGE"; 
		break; 
	case TSERVER_EXCEPTION_LIST: 
		*cs = "TSERVER_EXCEPTION_LIST"; 
		break; 
	case TSERVER_NOT_ON_OAM_LIST: 
		*cs = "TSERVER_NOT_ON_OAM_LIST"; 
		break; 
	case TSERVER_PBX_ID_NOT_IN_SDB: 
		*cs = "TSERVER_PBX_ID_NOT_IN_SDB"; 
		break; 
	case TSERVER_USER_LICENSES_EXCEEDED: 
		*cs = "TSERVER_USER_LICENSES_EXCEEDED"; 
		break; 
	case TSERVER_OAM_DROP_CONNECTION: 
		*cs = "TSERVER_OAM_DROP_CONNECTION"; 
		break; 
	case TSERVER_NO_VERSION_RECORD: 
		*cs = "TSERVER_NO_VERSION_RECORD"; 
		break; 
	case TSERVER_OLD_VERSION_RECORD: 
		*cs = "TSERVER_OLD_VERSION_RECORD"; 
		break; 
	case TSERVER_BAD_PACKET: 
		*cs = "TSERVER_BAD_PACKET"; 
		break; 
	case TSERVER_OPEN_FAILED: 
		*cs = "TSERVER_OPEN_FAILED"; 
		break; 
	case TSERVER_OAM_IN_USE: 
		*cs = "TSERVER_OAM_IN_USE"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_HOME_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_HOME_LIST"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_CALL_CONTROL_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_CALL_CONTROL_LIST"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_AWAY_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_AWAY_LIST"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_ROUTE_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_ROUTE_LIST"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_MONITOR_DEVICE_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_MONITOR_DEVICE_LIST"; 
		break; 
	case TSERVER_DEVICE_NOT_ON_MONITOR_CALL_DEVICE_LIST: 
		*cs = "TSERVER_DEVICE_NOT_ON_MONITOR_CALL_DEVICE_LIST"; 
		break; 
	case TSERVER_NO_CALL_CALL_MONITOR_PERMISSION: 
		*cs = "TSERVER_NO_CALL_CALL_MONITOR_PERMISSION"; 
		break; 
	case TSERVER_HOME_DEVICE_LIST_EMPTY: 
		*cs = "TSERVER_HOME_DEVICE_LIST_EMPTY"; 
		break; 
	case TSERVER_CALL_CONTROL_LIST_EMPTY: 
		*cs = "TSERVER_CALL_CONTROL_LIST_EMPTY"; 
		break; 
	case TSERVER_AWAY_LIST_EMPTY: 
		*cs = "TSERVER_AWAY_LIST_EMPTY"; 
		break; 
	case TSERVER_ROUTE_LIST_EMPTY: 
		*cs = "TSERVER_ROUTE_LIST_EMPTY"; 
		break; 
	case TSERVER_MONITOR_DEVICE_LIST_EMPTY: 
		*cs = "TSERVER_MONITOR_DEVICE_LIST_EMPTY"; 
		break; 
	case TSERVER_MONITOR_CALL_DEVICE_LIST_EMPTY: 
		*cs = "TSERVER_MONITOR_CALL_DEVICE_LIST_EMPTY"; 
		break; 
	case TSERVER_USER_AT_HOME_WORKTOP: 
		*cs = "TSERVER_USER_AT_HOME_WORKTOP"; 
		break; 
	case TSERVER_DEVICE_LIST_EMPTY: 
		*cs = "TSERVER_DEVICE_LIST_EMPTY"; 
		break; 
	case TSERVER_BAD_GET_DEVICE_LEVEL: 
		*cs = "TSERVER_BAD_GET_DEVICE_LEVEL"; 
		break; 
	case TSERVER_DRIVER_UNREGISTERED: 
		*cs = "TSERVER_DRIVER_UNREGISTERED"; 
		break; 
	case TSERVER_NO_ACS_STREAM: 
		*cs = "TSERVER_NO_ACS_STREAM"; 
		break; 
	case TSERVER_DROP_OAM: 
		*cs = "TSERVER_DROP_OAM"; 
		break; 
	case TSERVER_ECB_TIMEOUT: 
		*cs = "TSERVER_ECB_TIMEOUT"; 
		break; 
	case TSERVER_BAD_ECB: 
		*cs = "TSERVER_BAD_ECB"; 
		break; 
	case TSERVER_ADVERTISE_FAILED: 
		*cs = "TSERVER_ADVERTISE_FAILED"; 
		break; 
	case TSERVER_NETWARE_FAILURE: 
		*cs = "TSERVER_NETWARE_FAILURE"; 
		break; 
	case TSERVER_TDI_QUEUE_FAULT: 
		*cs = "TSERVER_TDI_QUEUE_FAULT"; 
		break; 
	case TSERVER_DRIVER_CONGESTION: 
		*cs = "TSERVER_DRIVER_CONGESTION"; 
		break; 
	case TSERVER_NO_TDI_BUFFERS: 
		*cs = "TSERVER_NO_TDI_BUFFERS"; 
		break; 
	case TSERVER_OLD_INVOKEID: 
		*cs = "TSERVER_OLD_INVOKEID"; 
		break; 
	case TSERVER_HWMARK_TO_LARGE: 
		*cs = "TSERVER_HWMARK_TO_LARGE"; 
		break; 
	case TSERVER_SET_ECB_TO_LOW: 
		*cs = "TSERVER_SET_ECB_TO_LOW"; 
		break; 
	case TSERVER_NO_RECORD_IN_FILE: 
		*cs = "TSERVER_NO_RECORD_IN_FILE"; 
		break; 
	case TSERVER_ECB_OVERDUE: 
		*cs = "TSERVER_ECB_OVERDUE"; 
		break; 
	case TSERVER_BAD_PW_ENCRYPTION: 
		*cs = "TSERVER_BAD_PW_ENCRYPTION"; 
		break; 
	case TSERVER_BAD_TSERV_PROTOCOL: 
		*cs = "TSERVER_BAD_TSERV_PROTOCOL"; 
		break; 
	case TSERVER_BAD_DRIVER_PROTOCOL: 
		*cs = "TSERVER_BAD_DRIVER_PROTOCOL"; 
		break; 
	case TSERVER_BAD_TRANSPORT_TYPE: 
		*cs = "TSERVER_BAD_TRANSPORT_TYPE"; 
		break; 
	case TSERVER_PDU_VERSION_MISMATCH: 
		*cs = "TSERVER_PDU_VERSION_MISMATCH"; 
		break; 
	case TSERVER_VERSION_MISMATCH: 
		*cs = "TSERVER_VERSION_MISMATCH"; 
		break; 
	case TSERVER_LICENSE_MISMATCH: 
		*cs = "TSERVER_LICENSE_MISMATCH"; 
		break; 
	case TSERVER_BAD_ATTRIBUTE_LIST: 
		*cs = "TSERVER_BAD_ATTRIBUTE_LIST"; 
		break; 
	case TSERVER_BAD_TLIST_TYPE: 
		*cs = "TSERVER_BAD_TLIST_TYPE"; 
		break; 
	case TSERVER_BAD_PROTOCOL_FORMAT: 
		*cs = "TSERVER_BAD_PROTOCOL_FORMAT"; 
		break; 
	case TSERVER_OLD_TSLIB: 
		*cs = "TSERVER_OLD_TSLIB"; 
		break; 
	case TSERVER_BAD_LICENSE_FILE: 
		*cs = "TSERVER_BAD_LICENSE_FILE"; 
		break; 
	case TSERVER_NO_PATCHES: 
		*cs = "TSERVER_NO_PATCHES"; 
		break; 
	case TSERVER_SYSTEM_ERROR: 
		*cs = "TSERVER_SYSTEM_ERROR"; 
		break; 
	case TSERVER_OAM_LIST_EMPTY: 
		*cs = "TSERVER_OAM_LIST_EMPTY"; 
		break; 
	case TSERVER_TCP_FAILED: 
		*cs = "TSERVER_TCP_FAILED"; 
		break; 
	case TSERVER_SPX_DISABLED: 
		*cs = "TSERVER_SPX_DISABLED"; 
		break; 
	case TSERVER_TCP_DISABLED: 
		*cs = "TSERVER_TCP_DISABLED"; 
		break; 
	case TSERVER_REQUIRED_MODULES_NOT_LOADED: 
		*cs = "TSERVER_REQUIRED_MODULES_NOT_LOADED"; 
		break; 
	case TSERVER_TRANSPORT_IN_USE_BY_OAM: 
		*cs = "TSERVER_TRANSPORT_IN_USE_BY_OAM"; 
		break; 
	case TSERVER_NO_NDS_OAM_PERMISSION: 
		*cs = "TSERVER_NO_NDS_OAM_PERMISSION"; 
		break; 
	case TSERVER_OPEN_SDB_LOG_FAILED: 
		*cs = "TSERVER_OPEN_SDB_LOG_FAILED"; 
		break; 
	case TSERVER_INVALID_LOG_SIZE: 
		*cs = "TSERVER_INVALID_LOG_SIZE"; 
		break; 
	case TSERVER_WRITE_SDB_LOG_FAILED: 
		*cs = "TSERVER_WRITE_SDB_LOG_FAILED"; 
		break; 
	case TSERVER_NT_FAILURE: 
		*cs = "TSERVER_NT_FAILURE"; 
		break; 
	case TSERVER_LOAD_LIB_FAILED: 
		*cs = "TSERVER_LOAD_LIB_FAILED"; 
		break; 
	case TSERVER_INVALID_DRIVER: 
		*cs = "TSERVER_INVALID_DRIVER"; 
		break; 
	case TSERVER_REGISTRY_ERROR: 
		*cs = "TSERVER_REGISTRY_ERROR"; 
		break; 
	case TSERVER_DUPLICATE_ENTRY: 
		*cs = "TSERVER_DUPLICATE_ENTRY"; 
		break; 
	case TSERVER_DRIVER_LOADED: 
		*cs = "TSERVER_DRIVER_LOADED"; 
		break; 
	case TSERVER_DRIVER_NOT_LOADED: 
		*cs = "TSERVER_DRIVER_NOT_LOADED"; 
		break; 
	case TSERVER_NO_LOGON_PERMISSION: 
		*cs = "TSERVER_NO_LOGON_PERMISSION"; 
		break; 
	case TSERVER_ACCOUNT_DISABLED: 
		*cs = "TSERVER_ACCOUNT_DISABLED"; 
		break; 
	case TSERVER_NO_NETLOGON: 
		*cs = "TSERVER_NO_NETLOGON"; 
		break; 
	case TSERVER_ACCT_RESTRICTED: 
		*cs = "TSERVER_ACCT_RESTRICTED"; 
		break; 
	case TSERVER_INVALID_LOGON_TIME: 
		*cs = "TSERVER_INVALID_LOGON_TIME"; 
		break; 
	case TSERVER_INVALID_WORKSTATION: 
		*cs = "TSERVER_INVALID_WORKSTATION"; 
		break; 
	case TSERVER_ACCT_LOCKED_OUT: 
		*cs = "TSERVER_ACCT_LOCKED_OUT"; 
		break; 
	case TSERVER_PASSWORD_EXPIRED: 
		*cs = "TSERVER_PASSWORD_EXPIRED"; 
		break; 
	case DRIVER_DUPLICATE_ACSHANDLE: 
		*cs = "DRIVER_DUPLICATE_ACSHANDLE"; 
		break; 
	case DRIVER_INVALID_ACS_REQUEST: 
		*cs = "DRIVER_INVALID_ACS_REQUEST"; 
		break; 
	case DRIVER_ACS_HANDLE_REJECTION: 
		*cs = "DRIVER_ACS_HANDLE_REJECTION"; 
		break; 
	case DRIVER_INVALID_CLASS_REJECTION: 
		*cs = "DRIVER_INVALID_CLASS_REJECTION"; 
		break; 
	case DRIVER_GENERIC_REJECTION: 
		*cs = "DRIVER_GENERIC_REJECTION"; 
		break; 
	case DRIVER_RESOURCE_LIMITATION: 
		*cs = "DRIVER_RESOURCE_LIMITATION"; 
		break; 
	case DRIVER_ACSHANDLE_TERMINATION: 
		*cs = "DRIVER_ACSHANDLE_TERMINATION"; 
		break; 
	case DRIVER_LINK_UNAVAILABLE: 
		*cs = "DRIVER_LINK_UNAVAILABLE"; 
		break; 
	case DRIVER_OAM_IN_USE: 
		*cs = "DRIVER_OAM_IN_USE"; 
		break; 
	default: 
		cs->Format( "error=%d", error ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeLocalConnectionStateStr( LocalConnectionState_t localConnectionState ) 
{ 
	CString *cs = new CString; 
	switch( localConnectionState ) 
	{ 
	case CS_NONE: 
		*cs = "None"; 
		break; 
	case CS_NULL: 
		*cs = "Null"; 
		break; 
	case CS_INITIATE: 
		*cs = "Initiated"; 
		break; 
	case CS_ALERTING: 
		*cs = "Alerting"; 
		break; 
	case CS_CONNECT: 
		*cs = "Connected"; 
		break; 
	case CS_HOLD: 
		*cs = "Held"; 
		break;	 
	case CS_QUEUED: 
		*cs = "Queued"; 
		break; 
	case CS_FAIL: 
		*cs = "Failed"; 
		break;	 
	default: 
		cs->Format( "%d", localConnectionState ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeDeviceIDStatusStr( DeviceIDStatus_t deviceIDStatus ) 
{ 
	CString *cs = new CString; 
	switch( deviceIDStatus ) 
	{ 
	case ID_PROVIDED: 
		*cs = "ID_PROVIDED"; 
		break; 
	case ID_NOT_KNOWN: 
		*cs = "ID_NOT_KNOWN"; 
		break; 
	case ID_NOT_REQUIRED: 
		*cs = "ID_NOT_REQUIRED"; 
		break; 
	default: 
		cs->Format( "%d", deviceIDStatus ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeConnectionStr( Connection_t *connection ) 
{ 
	CString *cs = new CString; 
	CString *csCID = makeConnectionIDStr( &connection->party ); 
	CString *csEDID = makeExtendedDeviceIDStr( &connection->staticDevice ); 
	cs->Format( "{ party=%s staticDevice=%s }", csCID->GetString(), csEDID->GetString() ); 
	delete csCID; 
	delete csEDID; 
	return cs; 
} 
 
CString * makeConnectionListStr( ConnectionList_t *connectionList ) 
{ 
	CString *cs = new CString; 
	cs->Format( "%d", connectionList->count ); 
	for ( int i=0; icount; i++ ) 
	{ 
        CString *csC = makeConnectionStr( &connectionList->connection[i] ); 
		CString tmp_cs; 
		tmp_cs.Format( "\n      conn%d=%s", i, csC->GetString() ); 
		delete csC; 
		*cs += tmp_cs; 
	} 
	return cs; 
} 
 
 
CString * makeExtendedDeviceIDStr( ExtendedDeviceID_t *extendedDeviceID ) 
{ 
	CString *cs = new CString; 
	CString *csDIDT = makeDeviceIDTypeStr( extendedDeviceID->deviceIDType ); 
	CString *csDIDS = makeDeviceIDStatusStr( extendedDeviceID->deviceIDStatus ); 
	cs->Format( "{ deviceID='%s' deviceIDType=%s deviceIDStatus=%s }", 
		extendedDeviceID->deviceID, csDIDT->GetString(), csDIDS->GetString() ); 
	delete csDIDT; 
	delete csDIDS; 
	return cs; 
} 
 
CString * makeDeviceIDTypeStr( DeviceIDType_t deviceIDType ) 
{ 
	CString *cs = new CString; 
	switch( deviceIDType ) 
	{ 
	case DEVICE_IDENTIFIER: 
		*cs = "DEVICE_IDENTIFIER"; 
		break; 
	case IMPLICIT_PUBLIC: 
		*cs = "IMPLICIT_PUBLIC"; 
		break; 
	case EXPLICIT_PUBLIC_UNKNOWN: 
		*cs = "EXPLICIT_PUBLIC_UNKNOWN"; 
		break; 
	case EXPLICIT_PUBLIC_INTERNATIONAL: 
		*cs = "EXPLICIT_PUBLIC_INTERNATIONAL"; 
		break; 
	case EXPLICIT_PUBLIC_NATIONAL: 
		*cs = "EXPLICIT_PUBLIC_NATIONAL"; 
		break; 
	case EXPLICIT_PUBLIC_NETWORK_SPECIFIC: 
		*cs = "EXPLICIT_PUBLIC_NETWORK_SPECIFIC"; 
		break; 
	case EXPLICIT_PUBLIC_SUBSCRIBER: 
		*cs = "EXPLICIT_PUBLIC_SUBSCRIBER"; 
		break; 
	case EXPLICIT_PUBLIC_ABBREVIATED: 
		*cs = "EXPLICIT_PUBLIC_ABBREVIATED"; 
		break; 
	case IMPLICIT_PRIVATE: 
		*cs = "IMPLICIT_PRIVATE"; 
		break; 
	case EXPLICIT_PRIVATE_UNKNOWN: 
		*cs = "EXPLICIT_PRIVATE_UNKNOWN"; 
		break; 
	case EXPLICIT_PRIVATE_LEVEL3_REGIONAL_NUMBER: 
		*cs = "EXPLICIT_PRIVATE_LEVEL3_REGIONAL_NUMBER"; 
		break; 
	case EXPLICIT_PRIVATE_LEVEL2_REGIONAL_NUMBER: 
		*cs = "EXPLICIT_PRIVATE_LEVEL2_REGIONAL_NUMBER"; 
		break; 
	case EXPLICIT_PRIVATE_LEVEL1_REGIONAL_NUMBER: 
		*cs = "EXPLICIT_PRIVATE_LEVEL1_REGIONAL_NUMBER"; 
		break; 
	case EXPLICIT_PRIVATE_PTN_SPECIFIC_NUMBER: 
		*cs = "EXPLICIT_PRIVATE_PTN_SPECIFIC_NUMBER"; 
		break; 
	case EXPLICIT_PRIVATE_LOCAL_NUMBER: 
		*cs = "EXPLICIT_PRIVATE_LOCAL_NUMBER"; 
		break; 
	case EXPLICIT_PRIVATE_ABBREVIATED: 
		*cs = "EXPLICIT_PRIVATE_ABBREVIATED"; 
		break; 
	case OTHER_PLAN: 
		*cs = "OTHER_PLAN"; 
		break; 
	case TRUNK_IDENTIFIER: 
		*cs = "TRUNK_IDENTIFIER"; 
		break; 
	case TRUNK_GROUP_IDENTIFIER: 
		*cs = "TRUNK_GROUP_IDENTIFIER"; 
		break; 
	default: 
		cs->Format( "%d", deviceIDType ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeConnectionID_DeviceStr( ConnectionID_Device_t connectionID_Device ) 
{ 
	CString *cs = new CString; 
	switch( connectionID_Device ) 
	{ 
	case STATIC_ID: 
		*cs = "Static"; 
		break; 
	case DYNAMIC_ID: 
		*cs = "Dynamic"; 
		break; 
	default: 
		cs->Format( "%d", connectionID_Device ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeConnectionIDStr( ConnectionID_t *connectionID ) 
{ 
	CString *cs = new CString; 
	CString *csCID = makeConnectionID_DeviceStr( connectionID->devIDType ); 
	cs->Format( "{ callID=%d deviceID='%s' devIDType=%s }",  
		connectionID->callID, connectionID->deviceID, csCID->GetString() ); 
	delete csCID; 
	return cs; 
} 
 
CString * makeCSTACallStateStr( CSTACallState_t *cstaCallState ) 
{ 
	CString *cs = new CString; 
	cs->Format( "{ %d: ", cstaCallState->count ); 
	for ( int i=0; icount; i++ ) 
	{ 
        CString *csLCS = makeLocalConnectionStateStr( cstaCallState->state[i] ); 
		CString tmp_cs; 
		tmp_cs.Format( "%s ", csLCS->GetString() ); 
		delete csLCS; 
		*cs += tmp_cs; 
	} 
	*cs += "}"; 
	return cs; 
} 
 
CString * makeCSTASnapshotCallResponseInfoStr( CSTASnapshotCallResponseInfo_t *cstaSnapshotCallResponseInfo ) 
{ 
	CString *cs = new CString; 
	CString *csCID = makeConnectionIDStr( &cstaSnapshotCallResponseInfo->callIdentifier ); 
	CString *csEDID = makeExtendedDeviceIDStr( &cstaSnapshotCallResponseInfo->deviceOnCall ); 
	CString *csLCS = makeLocalConnectionStateStr( cstaSnapshotCallResponseInfo->localConnectionState ); 
	cs->Format( "{ callIdentifier=%s deviceOnCall=%s localConnectionState=%s }", 
		csCID->GetString(), csEDID->GetString(), csLCS->GetString() ); 
	delete csCID; 
	delete csEDID; 
	delete csLCS; 
	return cs; 
} 
 
CString * makeCSTASnapshotDeviceResponseInfoStr( CSTASnapshotDeviceResponseInfo_t *cstaSnapshotDeviceResponseInfo ) 
{ 
	CString *cs = new CString; 
	CString *csCID = makeConnectionIDStr( &cstaSnapshotDeviceResponseInfo->callIdentifier ); 
	CString *csCCS = makeCSTACallStateStr( &cstaSnapshotDeviceResponseInfo->localCallState ); 
	cs->Format( "{ callIdentifier=%s localCallState=%s }", 
		csCID->GetString(), csCCS->GetString() ); 
	delete csCID; 
	delete csCCS; 
	return cs; 
} 
 
CString * makeCSTASnapshotCallDataStr( CSTASnapshotCallData_t *snapshotCallData ) 
{ 
	CString *cs = new CString; 
	cs->Format( "%d", snapshotCallData->count ); 
	for ( int i=0; icount; i++ ) 
	{ 
        CString *csCSCRI = makeCSTASnapshotCallResponseInfoStr( &snapshotCallData->info[i] ); 
		CString tmp_cs; 
		tmp_cs.Format( "\n      snap%d=%s", i, csCSCRI->GetString() ); 
		delete csCSCRI; 
		*cs += tmp_cs; 
	} 
	return cs; 
} 
 
CString * makeCSTASnapshotDeviceDataStr( CSTASnapshotDeviceData_t *snapshotDeviceData ) 
{ 
	CString *cs = new CString; 
	cs->Format( "%d", snapshotDeviceData->count ); 
	for ( int i=0; icount; i++ ) 
	{ 
        CString *csCSDRI = makeCSTASnapshotDeviceResponseInfoStr( &snapshotDeviceData->info[i] ); 
		CString tmp_cs; 
		tmp_cs.Format( "\n      snap%d=%s", i, csCSDRI->GetString() ); 
		delete csCSDRI; 
		*cs += tmp_cs; 
	} 
	return cs; 
} 
 
 
CString * makeCSTAMonitorFilterStr( CSTAMonitorFilter_t *monitorFilter ) 
{ 
	CString *cs = new CString; 
	cs->Format( "{ agent=0x%x call=0x%x feature=0x%x maintenance=0x%x privateFilter=0x%x }",  
		monitorFilter->agent, monitorFilter->call, monitorFilter->feature,  
		monitorFilter->maintenance, monitorFilter->privateFilter ); 
	return cs; 
} 
 
CString * makeCSTAEventCauseStr( CSTAEventCause_t cause ) 
{ 
	CString *cs = new CString; 
	switch( cause ) 
	{ 
	case EC_NONE: 
		*cs = "EC_NONE"; 
		break; 
	case EC_ACTIVE_MONITOR: 
		*cs = "EC_ACTIVE_MONITOR"; 
		break; 
	case EC_ALTERNATE: 
		*cs = "EC_ALTERNATE"; 
		break; 
	case EC_BUSY: 
		*cs = "EC_BUSY"; 
		break; 
	case EC_CALL_BACK: 
		*cs = "EC_CALL_BACK"; 
		break; 
	case EC_CALL_CANCELLED: 
		*cs = "EC_CALL_CANCELLED"; 
		break; 
	case EC_CALL_FORWARD_ALWAYS: 
		*cs = "EC_CALL_FORWARD_ALWAYS"; 
		break; 
	case EC_CALL_FORWARD_BUSY: 
		*cs = "EC_CALL_FORWARD_BUSY"; 
		break; 
	case EC_CALL_FORWARD_NO_ANSWER: 
		*cs = "EC_CALL_FORWARD_NO_ANSWER"; 
		break; 
	case EC_CALL_FORWARD: 
		*cs = "EC_CALL_FORWARD"; 
		break; 
	case EC_CALL_NOT_ANSWERED: 
		*cs = "EC_CALL_NOT_ANSWERED"; 
		break; 
	case EC_CALL_PICKUP: 
		*cs = "EC_CALL_PICKUP"; 
		break; 
	case EC_CAMP_ON: 
		*cs = "EC_CAMP_ON"; 
		break; 
	case EC_DEST_NOT_OBTAINABLE: 
		*cs = "EC_DEST_NOT_OBTAINABLE"; 
		break; 
	case EC_DO_NOT_DISTURB: 
		*cs = "EC_DO_NOT_DISTURB"; 
		break; 
	case EC_INCOMPATIBLE_DESTINATION: 
		*cs = "EC_INCOMPATIBLE_DESTINATION"; 
		break; 
	case EC_INVALID_ACCOUNT_CODE: 
		*cs = "EC_INVALID_ACCOUNT_CODE"; 
		break; 
	case EC_KEY_CONFERENCE: 
		*cs = "EC_KEY_CONFERENCE"; 
		break; 
	case EC_LOCKOUT: 
		*cs = "EC_LOCKOUT"; 
		break; 
	case EC_MAINTENANCE: 
		*cs = "EC_MAINTENANCE"; 
		break; 
	case EC_NETWORK_CONGESTION: 
		*cs = "EC_NETWORK_CONGESTION"; 
		break; 
	case EC_NETWORK_NOT_OBTAINABLE: 
		*cs = "EC_NETWORK_NOT_OBTAINABLE"; 
		break; 
	case EC_NEW_CALL: 
		*cs = "EC_NEW_CALL"; 
		break; 
	case EC_NO_AVAILABLE_AGENTS: 
		*cs = "EC_NO_AVAILABLE_AGENTS"; 
		break; 
	case EC_OVERRIDE: 
		*cs = "EC_OVERRIDE"; 
		break; 
	case EC_PARK: 
		*cs = "EC_PARK"; 
		break; 
	case EC_OVERFLOW: 
		*cs = "EC_OVERFLOW"; 
		break; 
	case EC_RECALL: 
		*cs = "EC_RECALL"; 
		break; 
	case EC_REDIRECTED: 
		*cs = "EC_REDIRECTED"; 
		break; 
	case EC_REORDER_TONE: 
		*cs = "EC_REORDER_TONE"; 
		break; 
	case EC_RESOURCES_NOT_AVAILABLE: 
		*cs = "EC_RESOURCES_NOT_AVAILABLE"; 
		break; 
	case EC_SILENT_MONITOR: 
		*cs = "EC_SILENT_MONITOR"; 
		break; 
	case EC_TRANSFER: 
		*cs = "EC_TRANSFER"; 
		break; 
	case EC_TRUNKS_BUSY: 
		*cs = "EC_TRUNKS_BUSY"; 
		break; 
	case EC_VOICE_UNIT_INITIATOR: 
		*cs = "EC_VOICE_UNIT_INITIATOR"; 
		break; 
	case EC_NETWORKSIGNAL: 
		*cs = "EC_NETWORKSIGNAL"; 
		break; 
	case EC_ALERTTIMEEXPIRED: 
		*cs = "EC_ALERTTIMEEXPIRED"; 
		break; 
	case EC_DESTOUTOFORDER: 
		*cs = "EC_DESTOUTOFORDER"; 
		break; 
	case EC_NOTSUPPORTEDBEARERSERVICE: 
		*cs = "EC_NOTSUPPORTEDBEARERSERVICE"; 
		break; 
	case EC_UNASSIGNED_NUMBER: 
		*cs = "EC_UNASSIGNED_NUMBER"; 
		break; 
	case EC_INCOMPATIBLE_BEARER_SERVICE: 
		*cs = "EC_INCOMPATIBLE_BEARER_SERVICE"; 
		break; 
	default: 
		cs->Format( "%d", cause ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeCSTAUFStr( CSTAUniversalFailure_t error ) 
{ 
	CString *cs = new CString; 
	switch( error ) 
	{ 
	case GENERIC_UNSPECIFIED: 
		*cs = "GENERIC_UNSPECIFIED"; 
		break; 
	case GENERIC_OPERATION: 
		*cs = "GENERIC_OPERATION"; 
		break; 
	case REQUEST_INCOMPATIBLE_WITH_OBJECT: 
		*cs = "REQUEST_INCOMPATIBLE_WITH_OBJECT"; 
		break; 
	case VALUE_OUT_OF_RANGE: 
		*cs = "VALUE_OUT_OF_RANGE"; 
		break; 
	case OBJECT_NOT_KNOWN: 
		*cs = "OBJECT_NOT_KNOWN"; 
		break; 
	case INVALID_CALLING_DEVICE: 
		*cs = "INVALID_CALLING_DEVICE"; 
		break; 
	case INVALID_CALLED_DEVICE: 
		*cs = "INVALID_CALLED_DEVICE"; 
		break; 
	case INVALID_FORWARDING_DESTINATION: 
		*cs = "INVALID_FORWARDING_DESTINATION"; 
		break; 
	case PRIVILEGE_VIOLATION_ON_SPECIFIED_DEVICE: 
		*cs = "PRIVILEGE_VIOLATION_ON_SPECIFIED_DEVICE"; 
		break; 
	case PRIVILEGE_VIOLATION_ON_CALLED_DEVICE: 
		*cs = "PRIVILEGE_VIOLATION_ON_CALLED_DEVICE"; 
		break; 
	case PRIVILEGE_VIOLATION_ON_CALLING_DEVICE: 
		*cs = "PRIVILEGE_VIOLATION_ON_CALLING_DEVICE"; 
		break; 
	case INVALID_CSTA_CALL_IDENTIFIER: 
		*cs = "INVALID_CSTA_CALL_IDENTIFIER"; 
		break; 
	case INVALID_CSTA_DEVICE_IDENTIFIER: 
		*cs = "INVALID_CSTA_DEVICE_IDENTIFIER"; 
		break; 
	case INVALID_CSTA_CONNECTION_IDENTIFIER: 
		*cs = "INVALID_CSTA_CONNECTION_IDENTIFIER"; 
		break; 
	case INVALID_DESTINATION: 
		*cs = "INVALID_DESTINATION"; 
		break; 
	case INVALID_FEATURE: 
		*cs = "INVALID_FEATURE"; 
		break; 
	case INVALID_ALLOCATION_STATE: 
		*cs = "INVALID_ALLOCATION_STATE"; 
		break; 
	case INVALID_CROSS_REF_ID: 
		*cs = "INVALID_CROSS_REF_ID"; 
		break; 
	case INVALID_OBJECT_TYPE: 
		*cs = "INVALID_OBJECT_TYPE"; 
		break; 
	case SECURITY_VIOLATION: 
		*cs = "SECURITY_VIOLATION"; 
		break; 
	case GENERIC_STATE_INCOMPATIBILITY: 
		*cs = "GENERIC_STATE_INCOMPATIBILITY"; 
		break; 
	case INVALID_OBJECT_STATE: 
		*cs = "INVALID_OBJECT_STATE"; 
		break; 
	case INVALID_CONNECTION_ID_FOR_ACTIVE_CALL: 
		*cs = "INVALID_CONNECTION_ID_FOR_ACTIVE_CALL"; 
		break; 
	case NO_ACTIVE_CALL: 
		*cs = "NO_ACTIVE_CALL"; 
		break; 
	case NO_HELD_CALL: 
		*cs = "NO_HELD_CALL"; 
		break; 
	case NO_CALL_TO_CLEAR: 
		*cs = "NO_CALL_TO_CLEAR"; 
		break; 
	case NO_CONNECTION_TO_CLEAR: 
		*cs = "NO_CONNECTION_TO_CLEAR"; 
		break; 
	case NO_CALL_TO_ANSWER: 
		*cs = "NO_CALL_TO_ANSWER"; 
		break; 
	case NO_CALL_TO_COMPLETE: 
		*cs = "NO_CALL_TO_COMPLETE"; 
		break; 
	case GENERIC_SYSTEM_RESOURCE_AVAILABILITY: 
		*cs = "GENERIC_SYSTEM_RESOURCE_AVAILABILITY"; 
		break; 
	case SERVICE_BUSY: 
		*cs = "SERVICE_BUSY"; 
		break; 
	case RESOURCE_BUSY: 
		*cs = "RESOURCE_BUSY"; 
		break; 
	case RESOURCE_OUT_OF_SERVICE: 
		*cs = "RESOURCE_OUT_OF_SERVICE"; 
		break; 
	case NETWORK_BUSY: 
		*cs = "NETWORK_BUSY"; 
		break; 
	case NETWORK_OUT_OF_SERVICE: 
		*cs = "NETWORK_OUT_OF_SERVICE"; 
		break; 
	case OVERALL_MONITOR_LIMIT_EXCEEDED: 
		*cs = "OVERALL_MONITOR_LIMIT_EXCEEDED"; 
		break; 
	case CONFERENCE_MEMBER_LIMIT_EXCEEDED: 
		*cs = "CONFERENCE_MEMBER_LIMIT_EXCEEDED"; 
		break; 
	case GENERIC_SUBSCRIBED_RESOURCE_AVAILABILITY: 
		*cs = "GENERIC_SUBSCRIBED_RESOURCE_AVAILABILITY"; 
		break; 
	case OBJECT_MONITOR_LIMIT_EXCEEDED: 
		*cs = "OBJECT_MONITOR_LIMIT_EXCEEDED"; 
		break; 
	case EXTERNAL_TRUNK_LIMIT_EXCEEDED: 
		*cs = "EXTERNAL_TRUNK_LIMIT_EXCEEDED"; 
		break; 
	case OUTSTANDING_REQUEST_LIMIT_EXCEEDED: 
		*cs = "OUTSTANDING_REQUEST_LIMIT_EXCEEDED"; 
		break; 
	case GENERIC_PERFORMANCE_MANAGEMENT: 
		*cs = "GENERIC_PERFORMANCE_MANAGEMENT"; 
		break; 
	case PERFORMANCE_LIMIT_EXCEEDED: 
		*cs = "PERFORMANCE_LIMIT_EXCEEDED"; 
		break; 
	case UNSPECIFIED_SECURITY_ERROR: 
		*cs = "UNSPECIFIED_SECURITY_ERROR"; 
		break; 
	case SEQUENCE_NUMBER_VIOLATED: 
		*cs = "SEQUENCE_NUMBER_VIOLATED"; 
		break; 
	case TIME_STAMP_VIOLATED: 
		*cs = "TIME_STAMP_VIOLATED"; 
		break; 
	case PAC_VIOLATED: 
		*cs = "PAC_VIOLATED"; 
		break; 
	case SEAL_VIOLATED: 
		*cs = "SEAL_VIOLATED"; 
		break; 
	case GENERIC_UNSPECIFIED_REJECTION: 
		*cs = "GENERIC_UNSPECIFIED_REJECTION"; 
		break; 
	case GENERIC_OPERATION_REJECTION: 
		*cs = "GENERIC_OPERATION_REJECTION"; 
		break; 
	case DUPLICATE_INVOCATION_REJECTION: 
		*cs = "DUPLICATE_INVOCATION_REJECTION"; 
		break; 
	case UNRECOGNIZED_OPERATION_REJECTION: 
		*cs = "UNRECOGNIZED_OPERATION_REJECTION"; 
		break; 
	case MISTYPED_ARGUMENT_REJECTION: 
		*cs = "MISTYPED_ARGUMENT_REJECTION"; 
		break; 
	case RESOURCE_LIMITATION_REJECTION: 
		*cs = "RESOURCE_LIMITATION_REJECTION"; 
		break; 
	case ACS_HANDLE_TERMINATION_REJECTION: 
		*cs = "ACS_HANDLE_TERMINATION_REJECTION"; 
		break; 
	case SERVICE_TERMINATION_REJECTION: 
		*cs = "SERVICE_TERMINATION_REJECTION"; 
		break; 
	case REQUEST_TIMEOUT_REJECTION: 
		*cs = "REQUEST_TIMEOUT_REJECTION"; 
		break; 
	case REQUESTS_ON_DEVICE_EXCEEDED_REJECTION: 
		*cs = "REQUESTS_ON_DEVICE_EXCEEDED_REJECTION"; 
		break; 
	case UNRECOGNIZED_APDU_REJECTION: 
		*cs = "UNRECOGNIZED_APDU_REJECTION"; 
		break; 
	case MISTYPED_APDU_REJECTION: 
		*cs = "MISTYPED_APDU_REJECTION"; 
		break; 
	case BADLY_STRUCTURED_APDU_REJECTION: 
		*cs = "BADLY_STRUCTURED_APDU_REJECTION"; 
		break; 
	case INITIATOR_RELEASING_REJECTION: 
		*cs = "INITIATOR_RELEASING_REJECTION"; 
		break; 
	case UNRECOGNIZED_LINKEDID_REJECTION: 
		*cs = "UNRECOGNIZED_LINKEDID_REJECTION"; 
		break; 
	case LINKED_RESPONSE_UNEXPECTED_REJECTION: 
		*cs = "LINKED_RESPONSE_UNEXPECTED_REJECTION"; 
		break; 
	case UNEXPECTED_CHILD_OPERATION_REJECTION: 
		*cs = "UNEXPECTED_CHILD_OPERATION_REJECTION"; 
		break; 
	case MISTYPED_RESULT_REJECTION: 
		*cs = "MISTYPED_RESULT_REJECTION"; 
		break; 
	case UNRECOGNIZED_ERROR_REJECTION: 
		*cs = "UNRECOGNIZED_ERROR_REJECTION"; 
		break; 
	case UNEXPECTED_ERROR_REJECTION: 
		*cs = "UNEXPECTED_ERROR_REJECTION"; 
		break; 
	case MISTYPED_PARAMETER_REJECTION: 
		*cs = "MISTYPED_PARAMETER_REJECTION"; 
		break; 
	case NON_STANDARD: 
		*cs = "NON_STANDARD"; 
		break; 
	default: 
		cs->Format( "error=%d", error ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeACSERRStr( RetCode_t rc, CString &request ) 
{ 
	CString *cs = new CString; 
	switch ( rc ) 
	{ 
	case ACSERR_APIVERDENIED: 
		cs->Format( "%s failed: ACSERR_APIVERDENIED", request.GetString() ); 
		break; 
	case ACSERR_BADPARAMETER: 
		cs->Format( "%s failed: ACSERR_BADPARAMETER", request.GetString() ); 
		break; 
	case ACSERR_DUPSTREAM: 
		cs->Format( "%s failed: ACSERR_DUPSTREAM", request.GetString() ); 
		break; 
	case ACSERR_NODRIVER: 
		cs->Format( "%s failed: ACSERR_NODRIVER", request.GetString() ); 
		break; 
	case ACSERR_NOSERVER: 
		cs->Format( "%s failed: ACSERR_NOSERVER", request.GetString() ); 
		break; 
	case ACSERR_NORESOURCE: 
		cs->Format( "%s failed: ACSERR_NORESOURCE", request.GetString() ); 
		break; 
	case ACSERR_UBUFSMALL: 
		cs->Format( "%s failed: ACSERR_UBUFSMALL", request.GetString() ); 
		break; 
	case ACSERR_NOMESSAGE: 
		cs->Format( "%s failed: ACSERR_NOMESSAGE", request.GetString() ); 
		break; 
	case ACSERR_UNKNOWN: 
		cs->Format( "%s failed: ACSERR_UNKNOWN", request.GetString() ); 
		break; 
	case ACSERR_BADHDL: 
		cs->Format( "%s failed: ACSERR_BADHDL", request.GetString() ); 
		break; 
	case ACSERR_STREAM_FAILED: 
		cs->Format( "%s failed: ACSERR_STREAM_FAILED", request.GetString() ); 
		break; 
	case ACSERR_NOBUFFERS: 
		cs->Format( "%s failed: ACSERR_NOBUFFERS", request.GetString() ); 
		break; 
	case ACSERR_QUEUE_FULL: 
		cs->Format( "%s failed: ACSERR_QUEUE_FULL", request.GetString() ); 
		break; 
	default: 
		cs->Format( "%s failed: rc=%d", request.GetString(), rc ); 
		break;	 
	} 
	return cs; 
} 
 
CString * makeATTEventStr( ATTEvent_t * ATTEvent ) 
{ 
	CString *cs = new CString; 
	CString *csPtr; 
 
	if ( ATTEvent->eventType == 0 ) 
	{ 
		// no private data 
		return cs; 
	} 
 
	*cs += "\n   ============== Private Data =============="; 
	 
	switch( ATTEvent->eventType ) 
	{ 
	case ATTV5_CLEAR_CONNECTION: 
		*cs += "\n   ATTV5_CLEAR_CONNECTION"; 
		break; 
	case ATTV5_CONSULTATION_CALL: 
		*cs += "\n   ATTV5_CONSULTATION_CALL"; 
		break; 
	case ATTV5_MAKE_CALL: 
		*cs += "\n   ATTV5_MAKE_CALL"; 
		break; 
	case ATTV5_DIRECT_AGENT_CALL: 
		*cs += "\n   ATTV5_DIRECT_AGENT_CALL"; 
		break; 
	case ATTV5_MAKE_PREDICTIVE_CALL: 
		*cs += "\n   ATTV5_MAKE_PREDICTIVE_CALL"; 
		break; 
	case ATTV5_SUPERVISOR_ASSIST_CALL: 
		*cs += "\n   ATTV5_SUPERVISOR_ASSIST_CALL"; 
		break; 
	case ATTV5_RECONNECT_CALL: 
		*cs += "\n   ATTV5_RECONNECT_CALL"; 
		break; 
	case ATTV4_SENDDTMF_TONE: 
		*cs += "\n   ATTV4_SENDDTMF_TONE"; 
		break; 
	case ATT_SENDDTMF_TONE_CONF: 
		*cs += "\n   ATT_SENDDTMF_TONE_CONF"; 
		break; 
	case ATTV4_SET_AGENT_STATE: 
		*cs += "\n   ATTV4_SET_AGENT_STATE"; 
		break; 
	case ATT_QUERY_ACD_SPLIT: 
		*cs += "\n   ATT_QUERY_ACD_SPLIT"; 
		break; 
	case ATT_QUERY_ACD_SPLIT_CONF: 
		*cs += "\n   ATT_QUERY_ACD_SPLIT_CONF"; 
		break; 
	case ATT_QUERY_AGENT_LOGIN: 
		*cs += "\n   ATT_QUERY_AGENT_LOGIN"; 
		break; 
	case ATT_QUERY_AGENT_LOGIN_CONF: 
		*cs += "\n   ATT_QUERY_AGENT_LOGIN_CONF"; 
		break; 
	case ATT_QUERY_AGENT_LOGIN_RESP: 
		*cs += "\n   ATT_QUERY_AGENT_LOGIN_RESP"; 
		break; 
	case ATT_QUERY_AGENT_STATE: 
		*cs += "\n   ATT_QUERY_AGENT_STATE"; 
		break; 
	case ATTV4_QUERY_AGENT_STATE_CONF: 
		*cs += "\n   ATTV4_QUERY_AGENT_STATE_CONF"; 
		break; 
	case ATT_QUERY_CALL_CLASSIFIER: 
		*cs += "\n   ATT_QUERY_CALL_CLASSIFIER"; 
		break; 
	case ATT_QUERY_CALL_CLASSIFIER_CONF: 
		*cs += "\n   ATT_QUERY_CALL_CLASSIFIER_CONF"; 
		break; 
	case ATTV4_QUERY_DEVICE_INFO_CONF: 
		*cs += "\n   ATTV4_QUERY_DEVICE_INFO_CONF"; 
		break; 
	case ATT_QUERY_MWI_CONF: 
		*cs += "\n   ATT_QUERY_MWI_CONF"; 
		break; 
	case ATT_QUERY_STATION_STATUS: 
		*cs += "\n   ATT_QUERY_STATION_STATUS"; 
		break; 
	case ATT_QUERY_STATION_STATUS_CONF: 
		*cs += "\n   ATT_QUERY_STATION_STATUS_CONF"; 
		break; 
	case ATT_QUERY_TOD: 
		*cs += "\n   ATT_QUERY_TOD"; 
		break; 
	case ATT_QUERY_TOD_CONF: 
		*cs += "\n   ATT_QUERY_TOD_CONF"; 
		break; 
	case ATT_QUERY_TG: 
		*cs += "\n   ATT_QUERY_TG"; 
		break; 
	case ATT_QUERY_TG_CONF: 
		*cs += "\n   ATT_QUERY_TG_CONF"; 
		break; 
	case ATTV4_SNAPSHOT_DEVICE_CONF: 
		*cs += "\n   ATTV4_SNAPSHOT_DEVICE_CONF"; 
		break; 
	case ATTV4_MONITOR_FILTER: 
		*cs += "\n   ATTV4_MONITOR_FILTER"; 
		break; 
	case ATTV4_MONITOR_CONF: 
		*cs += "\n   ATTV4_MONITOR_CONF"; 
		break; 
	case ATT_MONITOR_STOP_ON_CALL: 
		*cs += "\n   ATT_MONITOR_STOP_ON_CALL"; 
		break; 
	case ATT_MONITOR_STOP_ON_CALL_CONF: 
		*cs += "\n   ATT_MONITOR_STOP_ON_CALL_CONF"; 
		break; 
	case ATTV4_MONITOR_CALL_CONF: 
		*cs += "\n   ATTV4_MONITOR_CALL_CONF"; 
		break; 
	case ATT_CALL_CLEARED: 
		*cs += "\n   ATT_CALL_CLEARED"; 
		break; 
	case ATTV3_CONFERENCED: 
		*cs += "\n   ATTV3_CONFERENCED"; 
		break; 
	case ATTV5_CONNECTION_CLEARED: 
		*cs += "\n   ATTV5_CONNECTION_CLEARED"; 
		break; 
	case ATTV3_DELIVERED: 
		*cs += "\n   ATTV3_DELIVERED"; 
		break; 
	case ATT_ENTERED_DIGITS: 
		*cs += "\n   ATT_ENTERED_DIGITS"; 
		break; 
	case ATTV3_ESTABLISHED: 
		*cs += "\n   ATTV3_ESTABLISHED"; 
		break; 
	case ATTV4_NETWORK_REACHED: 
		*cs += "\n   ATTV4_NETWORK_REACHED"; 
		break; 
	case ATTV3_TRANSFERRED: 
		*cs += "\n   ATTV3_TRANSFERRED"; 
		break; 
	case ATTV4_ROUTE_REQUEST: 
		*cs += "\n   ATTV4_ROUTE_REQUEST"; 
		break; 
	case ATTV5_ROUTE_SELECT: 
		*cs += "\n   ATTV5_ROUTE_SELECT"; 
		break; 
	case ATT_ROUTE_USED: 
		*cs += "\n   ATT_ROUTE_USED"; 
		break; 
	case ATT_SYS_STAT: 
		*cs += "\n   ATT_SYS_STAT"; 
		break; 
	case ATTV3_LINK_STATUS: 
		*cs += "\n   ATTV3_LINK_STATUS"; 
		break; 
	case ATTV5_ORIGINATED: 
		*cs += "\n   ATTV5_ORIGINATED"; 
		break; 
	case ATT_LOGGED_ON: 
		*cs += "\n   ATT_LOGGED_ON"; 
		break; 
	case ATT_QUERY_DEVICE_NAME: 
		*cs += "\n   ATT_QUERY_DEVICE_NAME"; 
		break; 
	case ATTV4_QUERY_DEVICE_NAME_CONF: 
		*cs += "\n   ATTV4_QUERY_DEVICE_NAME_CONF"; 
		break; 
	case ATT_QUERY_AGENT_MEASUREMENTS: 
		*cs += "\n   ATT_QUERY_AGENT_MEASUREMENTS"; 
		break; 
	case ATT_QUERY_AGENT_MEASUREMENTS_CONF: 
		*cs += "\n   ATT_QUERY_AGENT_MEASUREMENTS_CONF"; 
		break; 
	case ATT_QUERY_SPLIT_SKILL_MEASUREMENTS: 
		*cs += "\n   ATT_QUERY_SPLIT_SKILL_MEASUREMENTS"; 
		break; 
	case ATT_QUERY_SPLIT_SKILL_MEASUREMENTS_CONF: 
		*cs += "\n   ATT_QUERY_SPLIT_SKILL_MEASUREMENTS_CONF"; 
		break; 
	case ATT_QUERY_TRUNK_GROUP_MEASUREMENTS: 
		*cs += "\n   ATT_QUERY_TRUNK_GROUP_MEASUREMENTS"; 
		break; 
	case ATT_QUERY_TRUNK_GROUP_MEASUREMENTS_CONF: 
		*cs += "\n   ATT_QUERY_TRUNK_GROUP_MEASUREMENTS_CONF"; 
		break; 
	case ATT_QUERY_VDN_MEASUREMENTS: 
		*cs += "\n   ATT_QUERY_VDN_MEASUREMENTS"; 
		break; 
	case ATT_QUERY_VDN_MEASUREMENTS_CONF: 
		*cs += "\n   ATT_QUERY_VDN_MEASUREMENTS_CONF"; 
		break; 
	case ATTV4_CONFERENCED: 
		*cs += "\n   ATTV4_CONFERENCED"; 
		break; 
	case ATTV4_DELIVERED: 
		*cs += "\n   ATTV4_DELIVERED"; 
		break; 
	case ATTV4_ESTABLISHED: 
		*cs += "\n   ATTV4_ESTABLISHED"; 
		break; 
	case ATTV4_TRANSFERRED: 
		*cs += "\n   ATTV4_TRANSFERRED"; 
		break; 
	case ATTV4_LINK_STATUS: 
		*cs += "\n   ATTV4_LINK_STATUS"; 
		break; 
	case ATTV4_GETAPI_CAPS_CONF: 
		*cs += "\n   ATTV4_GETAPI_CAPS_CONF"; 
		break; 
	case ATT_SINGLE_STEP_CONFERENCE_CALL: 
		*cs += "\n   ATT_SINGLE_STEP_CONFERENCE_CALL"; 
		break; 
	case ATT_SINGLE_STEP_CONFERENCE_CALL_CONF: 
		*cs += "\n   ATT_SINGLE_STEP_CONFERENCE_CALL_CONF"; 
		break; 
	case ATT_SELECTIVE_LISTENING_HOLD: 
		*cs += "\n   ATT_SELECTIVE_LISTENING_HOLD"; 
		break; 
	case ATT_SELECTIVE_LISTENING_HOLD_CONF: 
		*cs += "\n   ATT_SELECTIVE_LISTENING_HOLD_CONF"; 
		break; 
	case ATT_SELECTIVE_LISTENING_RETRIEVE: 
		*cs += "\n   ATT_SELECTIVE_LISTENING_RETRIEVE"; 
		break; 
	case ATT_SELECTIVE_LISTENING_RETRIEVE_CONF: 
		*cs += "\n   ATT_SELECTIVE_LISTENING_RETRIEVE_CONF"; 
		break; 
	case ATT_SENDDTMF_TONE: 
		*cs += "\n   ATT_SENDDTMF_TONE"; 
		break; 
	case ATT_SNAPSHOT_DEVICE_CONF: 
		*cs += "\n   ATT_SNAPSHOT_DEVICE_CONF"; 
		*cs += "\n   snapshotData="; 
		csPtr = new CString; 
		csPtr->Format( "%d", ATTEvent->u.snapshotDevice.count ); 
		for ( int i=0; iu.snapshotDevice.count; i++ ) 
		{ 
			CString *csASD = makeATTSnapshotDeviceStr( &ATTEvent->u.snapshotDevice.pSnapshotDevice[i] ); 
			CString tmp_cs; 
			tmp_cs.Format( "\n      snap%d=%s", i, csASD->GetString() ); 
			delete csASD; 
			*csPtr += tmp_cs; 
		} 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_LINK_STATUS: 
		*cs += "\n   ATT_LINK_STATUS"; 
		break; 
	case ATT_SET_BILL_RATE: 
		*cs += "\n   ATT_SET_BILL_RATE"; 
		break; 
	case ATT_SET_BILL_RATE_CONF: 
		*cs += "\n   ATT_SET_BILL_RATE_CONF"; 
		break; 
	case ATT_QUERY_UCID: 
		*cs += "\n   ATT_QUERY_UCID"; 
		break; 
	case ATT_QUERY_UCID_CONF: 
		*cs += "\n   ATT_QUERY_UCID_CONF"; 
		break; 
	case ATTV5_CONFERENCED: 
		*cs += "\n   ATTV5_CONFERENCED"; 
		break; 
	case ATT_LOGGED_OFF: 
		*cs += "\n   ATT_LOGGED_OFF"; 
		break; 
	case ATTV5_DELIVERED: 
		*cs += "\n   ATTV5_DELIVERED"; 
		break; 
	case ATTV5_ESTABLISHED: 
		*cs += "\n   ATTV5_ESTABLISHED"; 
		break; 
	case ATTV5_TRANSFERRED: 
		*cs += "\n   ATTV5_TRANSFERRED"; 
		break; 
	case ATTV5_ROUTE_REQUEST: 
		*cs += "\n   ATTV5_ROUTE_REQUEST"; 
		break; 
	case ATT_CONSULTATION_CALL_CONF: 
		*cs += "\n   ATT_CONSULTATION_CALL_CONF"; 
		csPtr = new CString; 
		csPtr->Format( "\n   ucid='%s'", ATTEvent->u.consultationCall.ucid ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_MAKE_CALL_CONF: 
		*cs += "\n   ATT_MAKE_CALL_CONF";	 
		csPtr = new CString; 
		csPtr->Format( "\n   ucid='%s'", ATTEvent->u.makeCall.ucid ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_MAKE_PREDICTIVE_CALL_CONF: 
		*cs += "\n   ATT_MAKE_PREDICTIVE_CALL_CONF"; 
		break; 
	case ATTV5_SET_AGENT_STATE: 
		*cs += "\n   ATTV5_SET_AGENT_STATE"; 
		break; 
	case ATTV5_QUERY_AGENT_STATE_CONF: 
		*cs += "\n   ATTV5_QUERY_AGENT_STATE_CONF"; 
		break; 
	case ATT_QUERY_DEVICE_NAME_CONF: 
		*cs += "\n   ATT_QUERY_DEVICE_NAME_CONF"; 
		break; 
	case ATT_CONFERENCE_CALL_CONF: 
		*cs += "\n   ATT_CONFERENCE_CALL_CONF"; 
		break; 
	case ATT_TRANSFER_CALL_CONF: 
		*cs += "\n   ATT_TRANSFER_CALL_CONF"; 
		break; 
	case ATT_MONITOR_FILTER: 
		*cs += "\n   ATT_MONITOR_FILTER"; 
		break; 
	case ATT_MONITOR_CONF: 
		*cs += "\n   ATT_MONITOR_CONF"; 
		csPtr = new CString; 
		csPtr->Format( "\n   usedFilter=0x%2.2x", ATTEvent->u.monitorStart.usedFilter ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_MONITOR_CALL_CONF: 
		*cs += "\n   ATT_MONITOR_CALL_CONF"; 
		break; 
	case ATT_SERVICE_INITIATED: 
		*cs += "\n   ATT_SERVICE_INITIATED"; 
		csPtr = new CString; 
		csPtr->Format( "\n   ucid='%s'", ATTEvent->u.serviceInitiated.ucid ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_CHARGE_ADVICE: 
		*cs += "\n   ATT_CHARGE_ADVICE"; 
		break; 
	case ATT_GETAPI_CAPS_CONF: 
		*cs += "\n   ATT_GETAPI_CAPS_CONF"; 
		break; 
	case ATT_QUERY_DEVICE_INFO_CONF: 
		*cs += "\n   ATT_QUERY_DEVICE_INFO_CONF"; 
		break; 
	case ATT_SET_ADVICE_OF_CHARGE: 
		*cs += "\n   ATT_SET_ADVICE_OF_CHARGE"; 
		break; 
	case ATT_SET_ADVICE_OF_CHARGE_CONF: 
		*cs += "\n   ATT_SET_ADVICE_OF_CHARGE_CONF"; 
		break; 
	case ATT_NETWORK_REACHED: 
		*cs += "\n   ATT_NETWORK_REACHED"; 
		break; 
	case ATT_SET_AGENT_STATE: 
		*cs += "\n   ATT_SET_AGENT_STATE"; 
		break; 
	case ATT_SET_AGENT_STATE_CONF: 
		*cs += "\n   ATT_SET_AGENT_STATE_CONF"; 
		break; 
	case ATT_QUERY_AGENT_STATE_CONF: 
		*cs += "\n   ATT_QUERY_AGENT_STATE_CONF"; 
		break; 
	case ATT_ROUTE_REQUEST: 
		*cs += "\n   ATT_ROUTE_REQUEST"; 
		break; 
	case ATT_TRANSFERRED: 
		*cs += "\n   ATT_TRANSFERRED"; 
		break; 
	case ATT_CONFERENCED: 
		*cs += "\n   ATT_CONFERENCED"; 
		*cs += "\n   OCI (originalCallInfo):"; 
		csPtr = makeATTOriginalCallInfoStr( &ATTEvent->u.conferencedEvent.originalCallInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   distributingDevice="; 
		csPtr = makeExtendedDeviceIDStr( &ATTEvent->u.conferencedEvent.distributingDevice ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   ucid='%s'", ATTEvent->u.conferencedEvent.ucid ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   trunkList="; 
		csPtr = makeATTTrunkListStr( &ATTEvent->u.conferencedEvent.trunkList ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_CLEAR_CONNECTION: 
		*cs += "\n   ATT_CLEAR_CONNECTION"; 
		break; 
	case ATT_CONSULTATION_CALL: 
		*cs += "\n   ATT_CONSULTATION_CALL"; 
		break; 
	case ATT_MAKE_CALL: 
		*cs += "\n   ATT_MAKE_CALL"; 
		break; 
	case ATT_DIRECT_AGENT_CALL: 
		*cs += "\n   ATT_DIRECT_AGENT_CALL"; 
		break; 
	case ATT_MAKE_PREDICTIVE_CALL: 
		*cs += "\n   ATT_MAKE_PREDICTIVE_CALL"; 
		break; 
	case ATT_SUPERVISOR_ASSIST_CALL: 
		*cs += "\n   ATT_SUPERVISOR_ASSIST_CALL"; 
		break; 
	case ATT_RECONNECT_CALL: 
		*cs += "\n   ATT_RECONNECT_CALL"; 
		break; 
	case ATT_CONNECTION_CLEARED: 
		*cs += "\n   ATT_CONNECTION_CLEARED"; 
		break; 
	case ATT_ROUTE_SELECT: 
		*cs += "\n   ATT_ROUTE_SELECT"; 
		break; 
	case ATT_DELIVERED: 
		*cs += "\n   ATT_DELIVERED"; 
		*cs += "\n   deliveredType="; 
		csPtr = makeATTDeliveredTypeStr( ATTEvent->u.deliveredEvent.deliveredType ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   trunkGroup='%s'", ATTEvent->u.deliveredEvent.trunkGroup ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   trunkMember='%s'", ATTEvent->u.deliveredEvent.trunkMember ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   split='%s'", ATTEvent->u.deliveredEvent.split ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   lookaheadInfo="; 
		csPtr = makeATTLookaheadInfoStr( &ATTEvent->u.deliveredEvent.lookaheadInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   userEnteredCode="; 
		csPtr = makeATTUserEnteredCodeStr( &ATTEvent->u.deliveredEvent.userEnteredCode ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   userInfo="; 
		csPtr = makeATTUserToUserInfoStr( &ATTEvent->u.deliveredEvent.userInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   reason="; 
		csPtr = makeATTReasonCodeStr( ATTEvent->u.deliveredEvent.reason ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   OCI (originalCallInfo):"; 
		csPtr = makeATTOriginalCallInfoStr( &ATTEvent->u.deliveredEvent.originalCallInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   distributingDevice="; 
		csPtr = makeExtendedDeviceIDStr( &ATTEvent->u.deliveredEvent.distributingDevice ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   ucid='%s'", ATTEvent->u.deliveredEvent.ucid ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   callOriginatorInfo="; 
		csPtr = makeATTCallOriginatorInfoStr( &ATTEvent->u.deliveredEvent.callOriginatorInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   flexibleBilling=%d", ATTEvent->u.deliveredEvent.flexibleBilling ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_ESTABLISHED: 
		*cs += "\n   ATT_ESTABLISHED"; 
		csPtr = new CString; 
		csPtr->Format( "\n   trunkGroup='%s'", ATTEvent->u.establishedEvent.trunkGroup ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   trunkMember='%s'", ATTEvent->u.establishedEvent.trunkMember ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   split='%s'", ATTEvent->u.establishedEvent.split ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   lookaheadInfo="; 
		csPtr = makeATTLookaheadInfoStr( &ATTEvent->u.establishedEvent.lookaheadInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   userEnteredCode="; 
		csPtr = makeATTUserEnteredCodeStr( &ATTEvent->u.establishedEvent.userEnteredCode ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   userInfo="; 
		csPtr = makeATTUserToUserInfoStr( &ATTEvent->u.establishedEvent.userInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   reason="; 
		csPtr = makeATTReasonCodeStr( ATTEvent->u.establishedEvent.reason ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   OCI (originalCallInfo):"; 
		csPtr = makeATTOriginalCallInfoStr( &ATTEvent->u.establishedEvent.originalCallInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   distributingDevice="; 
		csPtr = makeExtendedDeviceIDStr( &ATTEvent->u.establishedEvent.distributingDevice ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   ucid='%s'", ATTEvent->u.establishedEvent.ucid ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		*cs += "\n   callOriginatorInfo="; 
		csPtr = makeATTCallOriginatorInfoStr( &ATTEvent->u.establishedEvent.callOriginatorInfo ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		csPtr = new CString; 
		csPtr->Format( "\n   flexibleBilling=%d", ATTEvent->u.establishedEvent.flexibleBilling ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	case ATT_ORIGINATED: 
		*cs += "\n   ATT_ORIGINATED"; 
		break; 
	default: 
		csPtr = new CString; 
		csPtr->Format( "\n   ATTeventType=%d", ATTEvent->eventType ); 
		*cs += csPtr->GetString(); 
		delete csPtr; 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTSnapshotDeviceStr( ATTSnapshotDevice_t *snapshotDevice ) 
{ 
	CString *cs = new CString; 
	CString *csCID = makeConnectionIDStr( &snapshotDevice->call ); 
	CString *csALCS = makeATTLocalCallStateStr( snapshotDevice->state ); 
	cs->Format( "{ call=%s state=%s }", 
		csCID->GetString(), csALCS->GetString() ); 
	delete csCID; 
	delete csALCS; 
	return cs; 
} 
 
CString * makeATTLocalCallStateStr( ATTLocalCallState_t localCallState ) 
{ 
	CString *cs = new CString; 
	switch( localCallState ) 
	{ 
	case ATT_CS_INITIATED: 
		*cs = "Initiated"; 
		break; 
	case ATT_CS_ALERTING: 
		*cs = "Alerting"; 
		break; 
	case ATT_CS_CONNECTED: 
		*cs = "Connected"; 
		break; 
	case ATT_CS_HELD: 
		*cs = "Held"; 
		break;	 
	case ATT_CS_BRIDGED: 
		*cs = "Bridged"; 
		break; 
	case ATT_CS_OTHER: 
		*cs = "Other"; 
		break;	 
	default: 
		cs->Format( "%d", localCallState ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTCallOriginatorInfoStr( ATTCallOriginatorInfo_t *callOriginatorInfo ) 
{ 
	CString *cs = new CString; 
	cs->Format( "{ hasInfo=%d callOriginatorType=%d }", 
		callOriginatorInfo->hasInfo, callOriginatorInfo->callOriginatorType ); 
	return cs; 
} 
 
CString * makeATTDeliveredTypeStr( ATTDeliveredType_t deliveredType ) 
{ 
	CString *cs = new CString; 
	switch( deliveredType ) 
	{ 
	case DELIVERED_TO_ACD: 
		*cs = "ToACD"; 
		break; 
	case DELIVERED_TO_STATION: 
		*cs = "ToStation"; 
		break; 
	case DELIVERED_OTHER: 
		*cs = "Other"; 
		break; 
	default: 
		cs->Format( "%d", deliveredType ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTLookaheadInfoStr( ATTLookaheadInfo_t *lookaheadInfo ) 
{ 
	CString *cs = new CString; 
	CString *csAP = makeATTPriorityStr( lookaheadInfo->priority ); 
	CString *csAI = makeATTInterflowStr( lookaheadInfo->type ); 
	CString *csAUDID = makeATTUnicodeDeviceIDStr( &lookaheadInfo->uSourceVDN ); 
	cs->Format( "{ type=%s priority=%s %2.2d:%2.2d:%2.2d uSourceVDN=%s }",  
		csAI->GetString(), csAP->GetString(), 
        lookaheadInfo->hours, lookaheadInfo->minutes, lookaheadInfo->seconds, 
		csAUDID->GetString() ); 
	delete csAP; 
	delete csAI; 
	delete csAUDID; 
	return cs; 
} 
 
CString * makeATTOriginalCallInfoStr( ATTOriginalCallInfo_t *originalCallInfo ) 
{ 
	CString *cs = new CString; 
	CString *csPtr; 
	*cs += "\n      OCI reason="; 
	csPtr = makeATTReasonForCallInfoStr( originalCallInfo->reason ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	*cs += "\n      OCI callingDevice="; 
	csPtr = makeExtendedDeviceIDStr( &originalCallInfo->callingDevice ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	*cs += "\n      OCI calledDevice="; 
	csPtr = makeExtendedDeviceIDStr( &originalCallInfo->calledDevice ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	csPtr = new CString; 
	csPtr->Format( "\n      OCI trunkGroup='%s'", originalCallInfo->trunkGroup ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	csPtr = new CString; 
	csPtr->Format( "\n      OCI trunkMember='%s'", originalCallInfo->trunkMember ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	*cs += "\n      OCI lookaheadInfo="; 
	csPtr = makeATTLookaheadInfoStr( &originalCallInfo->lookaheadInfo ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	*cs += "\n      OCI userEnteredCode="; 
	csPtr = makeATTUserEnteredCodeStr( &originalCallInfo->userEnteredCode ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	*cs += "\n      OCI userInfo="; 
	csPtr = makeATTUserToUserInfoStr( &originalCallInfo->userInfo ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	csPtr = new CString; 
	csPtr->Format( "\n      OCI ucid='%s'", originalCallInfo->ucid ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	*cs += "\n      OCI callOriginatorInfo="; 
	csPtr = makeATTCallOriginatorInfoStr( &originalCallInfo->callOriginatorInfo ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	csPtr = new CString; 
	csPtr->Format( "\n      OCI flexibleBilling=%d", originalCallInfo->flexibleBilling ); 
	*cs += csPtr->GetString(); 
	delete csPtr; 
	return cs; 
} 
 
CString * makeATTReasonCodeStr( ATTReasonCode_t reasonCode ) 
{ 
	CString *cs = new CString; 
	switch( reasonCode ) 
	{ 
	case AR_NONE: 
		*cs = "None"; 
		break; 
	case AR_ANSWER_NORMAL: 
		*cs = "AnswerNormal"; 
		break; 
	case AR_ANSWER_TIMED: 
		*cs = "AnswerTimed"; 
		break; 
	case AR_ANSWER_VOICE_ENERGY: 
		*cs = "AnswerVoiceEnergy"; 
		break; 
	case AR_ANSWER_MACHINE_DETECTED: 
		*cs = "MachineDetected"; 
		break; 
	case AR_SIT_REORDER: 
		*cs = "SitReorder"; 
		break; 
	case AR_SIT_NO_CIRCUIT: 
		*cs = "SitNoCircuit"; 
		break; 
	case AR_SIT_INTERCEPT: 
		*cs = "Intercept"; 
		break; 
	case AR_SIT_VACANT_CODE: 
		*cs = "VacantCode"; 
		break; 
	case AR_SIT_INEFFECTIVE_OTHER: 
		*cs = "IneffectiveOther"; 
		break; 
	case AR_SIT_UNKNOWN: 
		*cs = "Unknown"; 
		break; 
	case AR_IN_QUEUE: 
		*cs = "InQueue"; 
		break; 
	case AR_SERVICE_OBSERVER: 
		*cs = "ServiceObserver"; 
		break; 
	default: 
		cs->Format( "%d", reasonCode ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTUserEnteredCodeStr( ATTUserEnteredCode_t *userEnteredCode ) 
{ 
	CString *cs = new CString; 
	CString *csAUECT = makeATTUserEnteredCodeTypeStr( userEnteredCode->type ); 
	CString *csAUECI = makeATTUserEnteredCodeIndicatorStr( userEnteredCode->indicator ); 
	cs->Format( "{ type=%s indicator=%s data='%s' collectVDN='%s' }", 
		csAUECT->GetString(), csAUECI->GetString(), 
		userEnteredCode->data, userEnteredCode->collectVDN ); 
	delete csAUECT; 
	delete csAUECI; 
	return cs; 
} 
 
CString * makeATTUserToUserInfoStr( ATTUserToUserInfo_t *userToUserInfo ) 
{ 
	CString *cs = new CString; 
	int i; 
	char ucStr[3]; 
	switch ( userToUserInfo->type ) 
	{ 
	case UUI_NONE: 
		cs->Format( "{ None[%d] }", userToUserInfo->data.length ); 
		break; 
	case UUI_USER_SPECIFIC: 
		cs->Format( "{ UserSpecific[%d] 0x: ", userToUserInfo->data.length ); 
		for (i=0; idata.length; i++) 
		{ 
			sprintf( ucStr, "%2.2x ", userToUserInfo->data.value[i] ); 
			*cs += ucStr; 
		} 
		*cs += "}"; 
		break; 
	case UUI_IA5_ASCII: 
		cs->Format( "{ Ia5Ascii[%d]: ", userToUserInfo->data.length ); 
		for (i=0; idata.length; i++) 
		{ 
			sprintf( ucStr, "%c", userToUserInfo->data.value[i] ); 
			*cs += ucStr; 
		} 
		*cs += " }"; 
		break; 
	default: 
		cs->Format( "{ %d[%d] }", userToUserInfo->type, userToUserInfo->data.length ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTPriorityStr( ATTPriority_t priority ) 
{ 
	CString *cs = new CString; 
	switch( priority ) 
	{ 
	case LAI_NOT_IN_QUEUE: 
		*cs = "NotInQueue"; 
		break; 
	case LAI_LOW: 
		*cs = "Low"; 
		break; 
	case LAI_MEDIUM: 
		*cs = "Medium"; 
		break; 
	case LAI_HIGH: 
		*cs = "High"; 
		break; 
	case LAI_TOP: 
		*cs = "Top"; 
		break; 
	default: 
		cs->Format( "%d", priority ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTInterflowStr( ATTInterflow_t interflow ) 
{ 
	CString *cs = new CString; 
	switch( interflow ) 
	{ 
	case LAI_NO_INTERFLOW: 
		*cs = "NoInterflow"; 
		break; 
	case LAI_ALL_INTERFLOW: 
		*cs = "AllInterflow"; 
		break; 
	case LAI_THRESHOLD_INTERFLOW: 
		*cs = "ThresholdInterflow"; 
		break; 
	case LAI_VECTORING_INTERFLOW: 
		*cs = "VectoringInterflow"; 
		break; 
	default: 
		cs->Format( "%d", interflow ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTUnicodeDeviceIDStr( ATTUnicodeDeviceID_t *unicodeDeviceID ) 
{ 
	CString *cs = new CString; 
	if ( unicodeDeviceID->count == 0 ) 
	{ 
		*cs += "{}"; 
		return cs; 
	} 
	int i; 
	char usStr[33]; 
	cs->Format( "{ [%d] 0x: ", unicodeDeviceID->count ); 
	for (i=0; icount; i++) 
	{ 
		sprintf( usStr, "%4.4x ", unicodeDeviceID->value[i] ); 
		*cs += usStr; 
	} 
	*cs += "}"; 
	return cs; 
} 
 
CString * makeATTReasonForCallInfoStr( ATTReasonForCallInfo_t reasonForCallInfo ) 
{ 
	CString *cs = new CString; 
	switch( reasonForCallInfo ) 
	{ 
	case OR_NONE: 
		*cs = "None"; 
		break; 
	case OR_CONSULTATION: 
		*cs = "Consultation"; 
		break; 
	case OR_CONFERENCED: 
		*cs = "Conferenced"; 
		break; 
	case OR_TRANSFERRED: 
		*cs = "Transferred"; 
		break; 
	case OR_NEW_CALL: 
		*cs = "NewCall"; 
		break; 
	default: 
		cs->Format( "%d", reasonForCallInfo ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTUserEnteredCodeTypeStr( ATTUserEnteredCodeType_t userEnteredCodeType ) 
{ 
	CString *cs = new CString; 
	switch( userEnteredCodeType ) 
	{ 
	case UE_NONE: 
		*cs = "None"; 
		break; 
	case UE_ANY: 
		*cs = "Any"; 
		break; 
	case UE_LOGIN_DIGITS: 
		*cs = "LoginDigits"; 
		break; 
	case UE_CALL_PROMPTER: 
		*cs = "CallPrompter"; 
		break; 
	case UE_DATA_BASE_PROVIDED: 
		*cs = "DataBaseProvided"; 
		break; 
	case UE_TONE_DETECTOR: 
		*cs = "ToneDetector"; 
		break; 
	default: 
		cs->Format( "%d", userEnteredCodeType ); 
		break; 
	} 
	return cs; 
} 
 
CString * makeATTUserEnteredCodeIndicatorStr( ATTUserEnteredCodeIndicator_t userEnteredCodeIndicator ) 
{ 
	CString *cs = new CString; 
	switch( userEnteredCodeIndicator ) 
	{ 
	case UE_COLLECT: 
		*cs = "Collect"; 
		break; 
	case UE_ENTERED: 
		*cs = "Entered"; 
		break; 
	default: 
		cs->Format( "%d", userEnteredCodeIndicator ); 
		break; 
	} 
	return cs; 
} 
 
 
CString * makeATTTrunkListStr( ATTTrunkList_t *trunkList ) 
{ 
	CString *cs = new CString; 
	cs->Format( "%d", trunkList->count ); 
	for ( int i=0; icount; i++ ) 
	{ 
		trunkList->trunks ; 
        CString *csATI = makeATTTrunkInfoStr( &trunkList->trunks[i] ); 
		CString tmp_cs; 
		tmp_cs.Format( "\n      trunk%d=%s", i, csATI->GetString() ); 
		delete csATI; 
		*cs += tmp_cs; 
	} 
	return cs; 
} 
 
CString * makeATTTrunkInfoStr( ATTTrunkInfo_t *trunkInfo ) 
{ 
	CString *cs = new CString; 
	CString *csCID = makeConnectionIDStr( &trunkInfo->connection ); 
	cs->Format( "{ connection=%s trunkGroup='%s' trunkMember='%s' }", 
		csCID->GetString(), trunkInfo->trunkGroup, trunkInfo->trunkMember ); 
	delete csCID; 
	return cs; 
} 
 
char * TimeStamp( char *timeStamp )                   /* buffer for printing time string */ 
{ 
 
		struct __timeb64 tstruct; 
        struct tm *tm;                   /* local time info */ 
 
		_ftime64( &tstruct ); 
 
        tm = _localtime64( &(tstruct.time) ); 
 
        (void) sprintf( timeStamp,  
                                "%.2d/%.2d/%.4d %.2d:%.2d:%.2d.%3.3ld", 
                                tm->tm_mon+1, tm->tm_mday, tm->tm_year+1900, 
                                tm->tm_hour, tm->tm_min, tm->tm_sec, tstruct.millitm ); 
 
        return( timeStamp ); 
} /* end TimeStamp() */ 
 
void OutputToConsole(char *func, char *format, ...) 
{ 
	char string1[ OTC_STANDARD_MESSAGE ]; 
	char string2[ OTC_SMALL_MESSAGE ]; 
	char *string1p; 
 
	va_list argv; 
	va_start(argv, format); 
 
#ifdef TICKCOUNT 
	_snprintf( string2, sizeof(string2), "%u T=0x%4.4X %s \n   ", GetTickCount(), GetCurrentThreadId(), func ); 
#else // TICKCOUNT 
	char timeStamp[50]; 
	_snprintf( string2, sizeof(string2), "%s T=0x%4.4X %s \n   ", TimeStamp( timeStamp ), GetCurrentThreadId(), func ); 
#endif // TICKCOUNT 
	string2[sizeof(string2)-1] = '\0';	// make sure the string is null terminated 
	BasicString bls = string2; 
	int rc1; 
	rc1 = _vsnprintf(string1, sizeof(string1), format, argv); 
	if (rc1 < 0) 
	{ 
		// the string will not fit within the STANDARD_MESSAGE length 
		if ((string1p = (char *)malloc(OTC_LARGE_MESSAGE)) == NULL) 
		{ 
			// malloc failed ... do the best we can 
			string1[sizeof(string1)-1] = '\0';	// make sure the string is null terminated 
			bls += string1; 
			bls += "\n************ OutputToConsole warning: preceeding message was truncated to standard message length! ************\n"; 
		} 
		else 
		{ 
			try 
			{ 
				// malloc worked ... see if we can fit now 
				rc1 = _vsnprintf(string1p, OTC_LARGE_MESSAGE, format, argv); 
				if (rc1 < 0) 
				{ 
					// the string will not fit within the LARGEST_MESSAGE length 
					string1p[ OTC_LARGE_MESSAGE-1 ] = '\0';	// make sure the string is null terminated 
					bls += string1p; 
					bls += "\n************ OutputToConsole warning: preceeding message was truncated to largest message length! ************\n"; 
				} 
				else 
				{ 
					// the string fits within the LARGEST_MESSAGE length 
					bls += string1p; 
				} 
			} 
			catch (...) 
			{ 
				char s[ 2 * OTC_SMALL_MESSAGE ]; 
 
				_snprintf(s, sizeof(s), "%sOutputToConsole ... exception handler\n", string2); 
				s[sizeof(s)-1] = '\0'; 
				OutputDebugString(s); 
			} 
			free(string1p); 
		} 
	} 
	else 
	{ 
		// the string fits within the STANDARD_MESSAGE length 
		bls += string1; 
	} 
 
	// make sure the message has a newline at the end 
	BasicStringIterator blsIter = bls.end(); 
	blsIter--; 
	if ( *blsIter != '\n' ) { 
		bls.append( "\n" ); 
	} 
 
	// finally we can output the message 
	OutputDebugString(bls.c_str()); 
 
	return;  
} 
 
InvokeID_t insertIntoHashMap( CString &cs ) 
{ 
	Mtx.Lock(); 
	InvokeID_t invokeID; 
 
	if ( HashMap.empty() ) 
	{ 
		// the hash map is empty ... start with a key of 1 
		// note: do not use 0 as a key. 
		// removeFromHashMap() and retrieveFromHashMap() both return 0 to indicate that 
		//  no key match was found! 
		invokeID = 1; 
	} 
	else 
	{ 
		// the hash map is NOT empty 
		// get the key of the last item on the map and increment it by 1 
		HashMapIter = HashMap.end();		// this takes you past the end of the map 
		HashMapIter--;						// move back 1 and you are at the last item 
		invokeID = HashMapIter->first + 1;	// increment the last key by 1 
	} 
    HashMap.insert( HashPair ( invokeID, cs ) ); 
	Mtx.Unlock(); 
	return invokeID; 
} 
 
InvokeID_t removeFromHashMap( InvokeID_t invokeID, CString &removedStr ) 
{ 
	InvokeID_t rc; 
	Mtx.Lock(); 
	HashMapIter = HashMap.find( invokeID ); 
	if ( HashMapIter == HashMap.end() ) 
	{ 
		rc = 0;	// this assumes that we will never have a real invokeID of 0 
		removedStr = "no request found"; 
	} 
	else 
	{ 
		rc = invokeID; 
		removedStr = "request: " + HashMapIter->second; 
		HashMap.erase(HashMapIter); 
	} 
	Mtx.Unlock(); 
	return rc; 
} 
 
InvokeID_t retrieveFromHashMap( InvokeID_t invokeID, CString &retrievedStr ) 
{ 
	InvokeID_t rc; 
	Mtx.Lock(); 
	HashMapIter = HashMap.find( invokeID ); 
	if ( HashMapIter == HashMap.end() ) 
	{ 
		rc = 0;	// this assumes that we will never have a real invokeID of 0 
		retrievedStr = "no request found"; 
	} 
	else 
	{ 
		rc = invokeID; 
		retrievedStr = "request: " + HashMapIter->second; 
	} 
	Mtx.Unlock(); 
	return rc; 
}