cstatst32.cpp

csta协议的开发

								1,
								TRUE);
		                      

	
		eventString.Format("   ESR Reset ( eventCounter : %d)",eventCountedByEsr);

	}
	DisplayString (eventString);
	return TRUE;

}

/*
 *
 * AcsOpenStream : this function opens a communications session (ACS message
 * stream) to the telephony server. It also install the event service routine
 * with the acsSetEsr primitive.
 *
 */
 
BOOL CMainWind::AcsOpenStream (StreamType_t apiLevel) {
	//char tcpbuf[60];
	//pPrivateData = (PrivateData_t*) tcpbuf;
	//memcpy (pPrivateData->data,"TCP_NODELAY",12);
  m_nRetCode = acsOpenStream (&m_acsHandle,
                LIB_GEN_ID,
                0,
				// Changed by G.L. 11 february 98
				apiLevel,
                //ST_CSTA2,
                (ServerID_t FAR*)m_sServerName.operator const char *(),
                (LoginID_t FAR*)m_sLoginName.operator const char *(),
                (Passwd_t FAR*)m_sPassword.operator const char *(),
                (AppName_t FAR*)m_sProgName.operator const char *(),
                m_nACSLevel,
                (Version_t *)CSTA_API_VERSION,
                0,
                0,
                0,
                0,
                pPrivateData);
  TryToReconnect();	/*YB 240800*/

/*Test+*/
  DisplayEventTitle ("ACS REQUEST Open Stream");
  if (m_nRetCode < 0) {
//    MessageBoxError ("acsOpenStream", m_nRetCode);
  DisplayEventTitle ("ACS REQUEST Open Stream ERROR");
	AcsCloseStream();
/*Test-*/
    return (FALSE);
  }
/*YB 240800+*/
	AcsGetEventBlock(0,0);	//once to receive the ACS_OPEN_STREAM_CONF
/*YB 240800-*/
  m_nRetCode = acsEventNotify (m_acsHandle, m_hWnd, WM_ACSEVENT, TRUE);
  if (m_nRetCode != ACSPOSITIVE_ACK)
    DisplayTheEvent ("ACS Event Notify Error");

  return (TRUE);
}

/*
 *
 * AcsOpenStreamConf : this function is the confirmation of the AcsOpenStream
 * primitive.
 *
 */
 
void CMainWind::AcsOpenStreamConfEvent () {
  ACSOpenStreamConfEvent_t *pEvent;
  CString eventString;
  
  eventString = "CSTA Application. Connected to ";
  eventString += m_sServerName;
  SetWindowText(eventString);
  pEvent = &m_cstaEvent.event.acsConfirmation.u.acsopen;
  eventString = "ACS CONFIRM Open Stream";
  DisplayTheEvent (eventString);
  eventString = "           API Version: ";
  eventString += pEvent->apiVer;
  DisplayString (eventString);
  eventString = "           Library Version: ";
  eventString += pEvent->libVer;
  DisplayString (eventString);
  eventString = "           TSERVER Version: ";
  eventString += pEvent->tsrvVer;
  DisplayString (eventString);
  eventString = "           Driver Version: ";
  eventString += pEvent->drvrVer;
  DisplayString (eventString);
  theApp.m_bPhoneOn = TRUE;
  m_bOpenedStream = TRUE;
  /*YB 240800+*/
  ::KillTimer(NULL, my_reconnectTimer);
  m_bAutoReconnect = FALSE;
  /*YB 240800-*/

  // Start the AutoKeepalive;
  AutoKeepalive();
  return;
}

/*
 *
 * AcsCloseStream : this function inhibits the event service routine function
 * and closes an opened stream.
 *
 */
                              
void CMainWind::AcsCloseStream () {
  if (m_bOpenedStream) {
    m_nRetCode = acsCloseStream (m_acsHandle,
              (InvokeID_t) 0,
              pPrivateData);
    if (m_nRetCode < 0) {
/*Essai+*/
//      MessageBoxError ("acsCloseStream", m_nRetCode);
    DisplayTheEvent ("ACS REQUEST Close Stream ERROR");
/*Essai-*/
      return;
    }
    DisplayTheEvent ("ACS REQUEST Close Stream");
    theApp.m_bPhoneOn = FALSE;
    m_bOpenedStream = FALSE;
    SetWindowText("CSTA Application. Not Connected");
  }
  return;
}                                             

void CMainWind::AcsCloseStreamConfEvent () {
  DisplayTheEvent ("ACS CONFIRM Close Stream");
  theApp.m_bPhoneOn = FALSE;
  m_bOpenedStream = FALSE;
  return;
}

void CMainWind::AcsAbortStream () {
  acsEventNotify (m_acsHandle, NULL, WM_ACSEVENT, TRUE);
  if (m_bOpenedStream) {
    acsFlushEventQueue (m_acsHandle);
    m_nRetCode = acsAbortStream (m_acsHandle,
              pPrivateData);
    if (m_nRetCode < 0) {
      MessageBoxError ("acsAbortStream", m_nRetCode);
      return;
    }
    DisplayTheEvent ("ACS REQUEST Abort Stream");
    m_bOpenedStream = FALSE;
    theApp.m_bPhoneOn = FALSE;
    SetWindowText("CSTA Application. Not Connected");
  }
  return;
}

/*
 *
 * AcsUniversalFailureConf : this event can occur at any time in place of a
 * confirmation event for any of the CSTA functions which have their own
 * confirmation event and indicates a problem in the process of the requested
 * function.
 *
 */
 
void CMainWind::AcsUniversalFailureConfEvent (ACSUniversalFailure_t error, int i) {
  CString eventString;
  char str1 [40];

  if (i)
    eventString = "ACS CONFIRMATION Failure ";
  else
    eventString = "ACS UNSOLITED Failure ";
  switch (error) {
    case TSERVER_STREAM_FAILED :
      eventString += "TSERVER_STREAM_FAILED";
      break;
    case TSERVER_NO_THREAD :
      eventString += "TSERVER_NO_THREAD";
      break;
    case TSERVER_BAD_DRIVER_ID :
      eventString += "TSERVER_BAD_DRIVER_ID";
      break;
    case TSERVER_DEAD_DRIVER :
      eventString += "TSERVER_DEAD_DRIVER";
      break;
    case TSERVER_MESSAGE_HIGH_WATER_MARK :
      eventString += "TSERVER_MESSAGE_HIGH_WATER_MARK";
      break;
    case TSERVER_FREE_BUFFER_FAILED :
      eventString += "TSERVER_FREE_BUFFER_FAILED";
      break;
    case TSERVER_SEND_TO_DRIVER :
      eventString += "TSERVER_SEND_TO_DRIVER";
      break;
    case TSERVER_RECEIVE_FROM_DRIVER :
      eventString += "TSERVER_RECEIVE_FROM_DRIVER";
      break;
    case TSERVER_REGISTRATION_FAILED :
      eventString += "TSERVER_REGISTRATION_FAILED";
      break;
    case TSERVER_SPX_FAILED :
      eventString += "TSERVER_SPX_FAILED";
      break;
    case TSERVER_TRACE :
      eventString += "TSERVER_TRACE";
      break;
    case TSERVER_NO_MEMORY :
      eventString += "TSERVER_NO_MEMORY";
      break;
    case TSERVER_ENCODE_FAILED :
      eventString += "TSERVER_ENCODE_FAILED";
      break;
    case TSERVER_DECODE_FAILED :
      eventString += "TSERVER_DECODE_FAILED";
      break;
    case TSERVER_BAD_CONNECTION :
      eventString += "TSERVER_BAD_CONNECTION";
      break;
    case TSERVER_BAD_PDU :
      eventString += "TSERVER_BAD_PDU";
      break;
    case TSERVER_NO_VERSION :
      eventString += "TSERVER_NO_VERSION";
      break;
    case TSERVER_ECB_MAX_EXCEEDED :
      eventString += "TSERVER_ECB_MAX_EXCEEDED";
      break;
    case TSERVER_NO_ECBS :
      eventString += "TSERVER_NO_ECBS";
      break;
    case TSERVER_NO_SDB :
      eventString += "TSERVER_NO_SDB";
      break;
    case TSERVER_NO_SDB_CHECK_NEEDED :
      eventString += "TSERVER_NO_SDB_CHECK_NEEDED";
      break;
    case TSERVER_SDB_CHECK_NEEDED :
      eventString += "TSERVER_SDB_CHECK_NEEDED";
      break;
    case TSERVER_BAD_SDB_LEVEL :
      eventString += "TSERVER_BAD_SDB_LEVEL";
      break;
    case TSERVER_BAD_SERVERID :
      eventString += "TSERVER_BAD_SERVERID";
      DisplayEventTitle (eventString);
      OnAbortstream ();
      return;
    case TSERVER_BAD_STREAM_TYPE :
      eventString += "TSERVER_BAD_STREAM_TYPE";
      DisplayEventTitle (eventString);
      OnAbortstream ();
      return;
    case TSERVER_BAD_PASSWORD_OR_LOGIN :
      eventString += "TSERVER_BAD_PASSWORD_OR_LOGIN";
      DisplayTheEvent (eventString);
      OnAbortstream ();
      return;
    case TSERVER_NO_USER_RECORD :
      eventString += "TSERVER_NO_USER_RECORD";
      DisplayEventTitle (eventString);
      OnAbortstream ();
      return;
    case TSERVER_NO_DEVICE_RECORD :
      eventString += "TSERVER_NO_DEVICE_RECORD";
      break;
    case TSERVER_DEVICE_NOT_ON_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_LIST";
      break;
    case TSERVER_USERS_RESTRICTED_HOME :
      eventString += "TSERVER_USERS_RESTRICTED_HOME";
      break;
    case TSERVER_NO_AWAYPERMISSION :
      eventString += "TSERVER_NO_AWAYPERMISSION";
      break;
    case TSERVER_NO_HOMEPERMISSION :
      eventString += "TSERVER_NO_HOMEPERMISSION";
      break;
    case TSERVER_NO_AWAY_WORKTOP :
      eventString += "TSERVER_NO_AWAY_WORKTOP";
      break;
    case TSERVER_BAD_DEVICE_RECORD :
      eventString += "TSERVER_BAD_DEVICE_RECORD";
      break;
    case TSERVER_DEVICE_NOT_SUPPORTED :
      eventString += "TSERVER_DEVICE_NOT_SUPPORTED";
      break;
    case TSERVER_INSUFFICIENT_PERMISSION :
      eventString += "TSERVER_INSUFFICIENT_PERMISSION";
      break;
    case TSERVER_NO_RESOURCE_TAG :
      eventString += "TSERVER_NO_RESOURCE_TAG";
      break;
    case TSERVER_INVALID_MESSAGE :
      eventString += "TSERVER_INVALID_MESSAGE";
      break;
    case TSERVER_EXCEPTION_LIST :
      eventString += "TSERVER_EXCEPTION_LIST";
      break;
    case TSERVER_NOT_ON_OAM_LIST :
      eventString += "TSERVER_NOT_ON_OAM_LIST";
      break;
    case TSERVER_PBX_ID_NOT_IN_SDB :
      eventString += "TSERVER_PBX_ID_NOT_IN_SDB";
      break;
    case TSERVER_USER_LICENSES_EXCEEDED :
      eventString += "TSERVER_USER_LICENSES_EXCEEDED";
      break;
    case TSERVER_OAM_DROP_CONNECTION :
      eventString += "TSERVER_OAM_DROP_CONNECTION";
      break;
    case TSERVER_NO_VERSION_RECORD :
      eventString += "TSERVER_NO_VERSION_RECORD";
      break;
    case TSERVER_OLD_VERSION_RECORD :
      eventString += "TSERVER_OLD_VERSION_RECORD";
      break;
    case TSERVER_BAD_PACKET :
      eventString += "TSERVER_BAD_PACKET";
      break;
    case TSERVER_OPEN_FAILED :
      eventString += "TSERVER_OPEN_FAILED";
      break;
    case TSERVER_OAM_IN_USE :
      eventString += "TSERVER_OAM_IN_USE";
      break;
    case TSERVER_DEVICE_NOT_ON_HOME_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_HOME_LIST";
      break;
    case TSERVER_DEVICE_NOT_ON_CALL_CONTROL_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_CALL_CONTROL_LIST";
      break;
    case TSERVER_DEVICE_NOT_ON_AWAY_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_AWAY_LIST";
      break;
    case TSERVER_DEVICE_NOT_ON_ROUTE_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_AWAY_LIST";
      break;
    case TSERVER_DEVICE_NOT_ON_MONITOR_DEVICE_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_MONITOR_DEVICE_LIST";
      break;
    case TSERVER_DEVICE_NOT_ON_MONITOR_CALL_DEVICE_LIST :
      eventString += "TSERVER_DEVICE_NOT_ON_MONITOR_CALL_DEVICE_LIST";
      break;
    case TSERVER_NO_CALL_CALL_MONITOR_PERMISSION :
      eventString += "TSERVER_NO_CALL_CALL_MONITOR_PERMISSION";
      break;
    case TSERVER_HOME_DEVICE_LIST_EMPTY :
      eventString += "TSERVER_HOME_DEVICE_LIST_EMPTY";
      break;
    case TSERVER_CALL_CONTROL_LIST_EMPTY :
      eventString += "TSERVER_CALL_CONTROL_LIST_EMPTY";
      break;
    case TSERVER_AWAY_LIST_EMPTY :
      eventString += "TSERVER_AWAY_LIST_EMPTY";
      break;
    case TSERVER_ROUTE_LIST_EMPTY :
      eventString += "TSERVER_ROUTE_LIST_EMPTY";
      break;
    case TSERVER_MONITOR_DEVICE_LIST_EMPTY :
      eventString += "TSERVER_MONITOR_DEVICE_LIST_EMPTY";
      break;
    case TSERVER_MONITOR_CALL_DEVICE_LIST_EMPTY :
      eventString += "TSERVER_MONITOR_CALL_DEVICE_LIST_EMPTY";
      break;
    case TSERVER_USER_AT_HOME_WORKTOP :
      eventString += "TSERVER_USER_AT_HOME_WORKTOP";
      break;
    case TSERVER_DEVICE_LIST_EMPTY :
      eventString += "TSERVER_DEVICE_LIST_EMPTY";
      break;
    case TSERVER_BAD_GET_DEVICE_LEVEL :
      eventString += "TSERVER_BAD_GET_DEVICE_LEVEL";
      break;
    case TSERVER_DRIVER_UNREGISTERED :
      eventString += "TSERVER_DRIVER_UNREGISTERED";
      break;
    case TSERVER_NO_ACS_STREAM :
      eventString += "TSERVER_NO_ACS_STREAM";
      break;
    case TSERVER_DROP_OAM :
      eventString += "TSERVER_DROP_OAM";
      break;
    case TSERVER_ECB_TIMEOUT :
      eventString += "TSERVER_ECB_TIMEOUT";
      break;
    case TSERVER_BAD_ECB :
      eventString += "TSERVER_BAD_ECB";
      break;
    case TSERVER_ADVERTISE_FAILED :
      eventString += "TSERVER_ADVERTISE_FAILED";
      break;
    case TSERVER_NETWARE_FAILURE :
      eventString += "TSERVER_NETWARE_FAILURE";
      break;
    case TSERVER_TDI_QUEUE_FAULT :
      eventString += "TSERVER_TDI_QUEUE_FAULT";
      break;
    case TSERVER_DRIVER_CONGESTION :
      eventString += "TSERVER_DRIVER_CONGESTION";
      break;
    case TSERVER_NO_TDI_BUFFERS :
      eventString += "TSERVER_NO_TDI_BUFFERS";
      break;
    case TSERVER_OLD_INVOKEID :
      eventString += "TSERVER_OLD_INVOKEID";
      break;
    case TSERVER_HWMARK_TO_LARGE :
      eventString += "TSERVER_HWMARK_TO_LARGE";
      break;
    case TSERVER_SET_ECB_TO_LOW :
      eventString += "TSERVER_SET_ECB_TO_LOW";
      break;
    case TSERVER_NO_RECORD_IN_FILE :
      eventString += "TSERVER_NO_RECORD_IN_FILE";
      break;
    case TSERVER_ECB_OVERDUE :
      eventString += "TSERVER_ECB_OVERDUE";
      break;
    case DRIVER_DUPLICATE_ACSHANDLE :
      eventString += "DRIVER_DUPLICATE_ACSHANDLE";
      DisplayEventTitle (eventString);
      OnAbortstream ();
      return;
    case DRIVER_INVALID_ACS_REQUEST :
      eventString += "DRIVER_INVALID_ACS_REQUEST";
      break;
    case DRIVER_ACS_HANDLE_REJECTION :
      eventString += "DRIVER_ACS_HANDLE_REJECTION";
      break;
    case DRIVER_INVALID_CLASS_REJECTION :
      eventString += "DRIVER_INVALID_CLASS_REJECTION";
      break;
    case DRIVER_GENERIC_REJECTION :
      eventString += "DRIVER_GENERIC_REJECTION";
      break;
    case DRIVER_RESOURCE_LIMITATION :
      eventString += "DRIVER_RESOURCE_LIMITATION";
      break;
    case DRIVER_ACSHANDLE_TERMINATION :
      eventString += "DRIVER_ACSHANDLE_TERMINATION";
      DisplayEventTitle (eventString);
      OnAbortstream ();