cstatst32.cpp

csta协议的开发

      return;
    case DRIVER_LINK_UNAVAILABLE :
      eventString += "DRIVER_LINK_UNAVAILABLE";
      break;
    case DRIVER_OAM_IN_USE :
      eventString += "DRIVE_OAM_IN_USE";
      break;
	case TSERVER_VERSION_MISMATCH:
      eventString += "TSERVER_VERSION_MISMATCH";
      break;
    default :
      sprintf (str1, "%d", error);
      eventString += str1;
      break;
  }
  DisplayEventTitle (eventString);
  return;
}

/////////////////////////////////////////////////////////////////////////////
// This function is called when the ID_MY_SERVICE_ROUTINE message (sended by
// the event service routine) is received by Windows. 


LRESULT CMainWind::OnServiceRoutine (WPARAM wParam, LPARAM lParam) {

  CString eventString;
  //char    evtData[200];
  
  AcsGetEventBlock (0, 0);
  if (((PrivateData_t*)recPrivateData)->length != 0)
  {
	  DisplayPrivateData((PrivateData_t*)recPrivateData);
  }
  return(0);
}

/*
 *
 * AcsGetEventBlock : this function blocks until an event is received.
 *
 */

LRESULT CMainWind::AcsGetEventBlock (WPARAM wParam, LPARAM lParam) {
  unsigned short  cstaEventSize;
  unsigned short  numEvents;
  CErrorDlg errorDlg;
  CString eventString;
  char str1 [100];

  cstaEventSize = sizeof (m_cstaEvent);
  //((PrivateData_t*)recPrivateData)->length = 73;
  ((PrivateData_t*)recPrivateData)->length = SIZE_OF_ALCATEL_PRIVATE_DATA; // changed by g.l. 29 july 98 for viola.
  ((PrivateData_t*)recPrivateData)->data[0] = '\0';
  m_nRetCode = acsGetEventBlock (m_acsHandle,
              (void FAR *)&m_cstaEvent,
			  (unsigned short FAR *)&cstaEventSize,
              (PrivateData_t FAR *)&recPrivateData,
              (unsigned short FAR *)&numEvents);
  if (m_nRetCode < 0) {
    MessageBoxError ("acsGetEventBlock", m_nRetCode);
    return (0);
  }

//  mdump ((unsigned char *)&m_cstaEvent);

  switch (m_cstaEvent.eventHeader.eventClass) {
    case ACSREQUEST :
      eventString = "ACS REQUEST";
      switch (m_cstaEvent.eventHeader.eventType) {
        case ACS_OPEN_STREAM :
          eventString += "Open Stream";
          break;
        case ACS_CLOSE_STREAM :
          eventString += "Close Stream";
          break;
        case ACS_ABORT_STREAM :
          eventString += "Abort Stream";
          break;
        case ACS_UNIVERSAL_FAILURE :
          eventString += "Universal Failure";
          break;
        case ACS_KEY_REQUEST :
          eventString += "Key Request";
          break;
        case ACS_KEY_REPLY :
          eventString += "Key Reply";
          break;
        default :
          sprintf (str1, "unknowFailureType : %d",
               m_cstaEvent.eventHeader.eventType);
          eventString += str1;
          break;
      }
      break;
    case ACSUNSOLICITED :
      AcsUniversalFailureConfEvent (m_cstaEvent.event.acsUnsolicited.u.failureEvent.error, 0);
      return (0);
    case ACSCONFIRMATION :
      eventString = "ACS CONFIRM ";
      switch (m_cstaEvent.eventHeader.eventType) {
        case ACS_OPEN_STREAM :
          eventString += "Open Stream";
          break;
        case ACS_OPEN_STREAM_CONF :
          AcsOpenStreamConfEvent ();
          return (0);
        case ACS_CLOSE_STREAM :
          eventString += "Close Stream";
          break;
        case ACS_CLOSE_STREAM_CONF :
          AcsCloseStreamConfEvent ();
          return (0);
        case ACS_ABORT_STREAM :
          eventString += "Abort Stream";
          break;
        case ACS_UNIVERSAL_FAILURE_CONF :
          AcsUniversalFailureConfEvent (m_cstaEvent.event.acsConfirmation.u.failureEvent.error, 1);
          return (0);
        case ACS_UNIVERSAL_FAILURE :
          eventString += "Universal Failure";
          break;
        case ACS_KEY_REQUEST :
          eventString += "Key Request";
          break;
        case ACS_KEY_REPLY :
          eventString += "Key Reply";
          break;
        default :
          sprintf (str1, "unknowFailureType : %d",
               m_cstaEvent.eventHeader.eventType);
          eventString += str1;
          break;
      }
      break;
    case CSTAREQUEST :
      eventString = "CSTA REQUEST ";
      switch (m_cstaEvent.eventHeader.eventType) {
        case CSTA_ESCAPE_SVC_REQ :
          CstaEscapeServiceReq ();
          return (0);
        case CSTA_SYS_STAT_REQ :
          CstaSysStatReqEvent ();
          return (0);
		// Changed by G.L. 10 March for Computing services (_EXT)
		case CSTA_ROUTE_REQUEST_EXT :
		// End Changed
          CstaRouteRequestEvent();
          return (0);
        case CSTA_RE_ROUTE_REQUEST :
          CstaReRouteEvent();
          return (0);
        default :
          sprintf (str1, "unknow Type : %d",
               m_cstaEvent.eventHeader.eventType);
          eventString += str1;
          break;
      }
      break;
    case CSTAUNSOLICITED :
      eventString = "CSTA UNSOLICITED EVENT ";
      switch (m_cstaEvent.eventHeader.eventType) {
        case CSTA_CALL_CLEARED :
          CstaCallClearedEvent ();
          return (0);
        case CSTA_CONFERENCED :
          CstaConferencedEvent ();
          return (0);
        case CSTA_CONNECTION_CLEARED :
          CstaConnectionClearedEvent ();
          return (0);
        case CSTA_DELIVERED :
          CstaDeliveredEvent ();
          return (0);
        case CSTA_DIVERTED :
          CstaDivertedEvent ();
          return (0);
        case CSTA_ESTABLISHED :
          CstaEstablishedEvent ();
          return (0);
        case CSTA_FAILED :
          CstaFailedEvent ();
          return (0);
        case CSTA_HELD :
          CstaHeldEvent ();
          return (0);
        case CSTA_NETWORK_REACHED :
          CstaNetworkReachedEvent ();
          return (0);
        case CSTA_ORIGINATED :
          CstaOriginatedEvent ();
          return (0);
        case CSTA_QUEUED :
          CstaQueuedEvent ();
          return (0);
        case CSTA_RETRIEVED :
          CstaRetrieveEvent ();
          return (0);
        case CSTA_SERVICE_INITIATED :
          CstaServiceInitiatedEvent ();
          return (0);
        case CSTA_TRANSFERRED :
          CstaTransferredEvent ();
          return (0);
        case CSTA_CALL_INFORMATION :
          CstaCallInfoEvent ();
          return (0);
        case CSTA_DO_NOT_DISTURB :
          CstaDoNotDisturbEvent ();
          return (0);
        case CSTA_FORWARDING :
          CstaForwardingEvent ();
          return (0);
        case CSTA_MESSAGE_WAITING :
          CstaMessageWaitingEvent ();
          return (0);
        case CSTA_LOGGED_ON :
          CstaLoggedOnEvent ();
          return (0);
        case CSTA_LOGGED_OFF :
          CstaLoggedOffEvent ();
          return (0);
        case CSTA_NOT_READY :
          CstaNotReadyEvent ();
          return (0);
        case CSTA_READY :
          CstaReadyEvent ();
          return (0);
        case CSTA_WORK_NOT_READY :
		  CstaWorkNotReady ();
		  return (0);
          break;
        case CSTA_WORK_READY :
			CstaWorkReady ();
			return (0);
          break;
        case CSTA_PRIVATE_STATUS :
          CstaPrivateStatusEvent ();
          return (0);
        case CSTA_BACK_IN_SERVICE :
          CstaBackInServiceEvent ();
          return (0);
        case CSTA_OUT_OF_SERVICE :
          CstaOutOfServiceEvent ();
          return (0);
        case CSTA_MONITOR_ENDED :
          CstaMonitorEnded ();
          return (0);
        case CSTA_RECORD_EVENT :
          CstaRecordEvent();
          return (0);
        case CSTA_STOP_EVENT :
          CstaStopEvent();
          return (0);
        default :
          eventString += "unknown type";
          break;
      }
      break;
    case CSTACONFIRMATION :
      eventString = "CSTA CONFIRM ";
      switch (m_cstaEvent.eventHeader.eventType) {
        case CSTA_ALTERNATE_CALL_CONF :
          CstaAlternateCallConfEvent ();
          return (0);
		case CSTA_ASSOCIATE_DATA_CONF:
			CstaAssociateDataConfEvent();
			return(0);
        case CSTA_ANSWER_CALL_CONF :
          CstaAnswerCallConfEvent ();
          return (0);
        case CSTA_CALL_COMPLETION_CONF : 
          CstaCallCompletionConfEvent ();
          return (0);
        case CSTA_CLEAR_CALL_CONF :
          CstaClearCallConfEvent ();
          return (0);
        case CSTA_CLEAR_CONNECTION_CONF :
          CstaClearConnectionConfEvent ();
          return (0);
        case CSTA_CONFERENCE_CALL_CONF :
          CstaConferenceCallConfEvent ();
          return (0);
        case CSTA_CONSULTATION_CALL_CONF :
          CstaConsultationCallConfEvent ();
          return (0);
        case CSTA_DEFLECT_CALL_CONF :
          CstaDeflectCallConfEvent ();
          return (0);
        case CSTA_PARK_CALL_CONF :
          CstaParkCallConfEvent ();
          return (0);
        case CSTA_PICKUP_CALL_CONF :
          CstaPickupCallConfEvent ();
          return (0);
        case CSTA_GROUP_PICKUP_CALL_CONF :
          CstaGroupPickupCallConfEvent ();
          return (0);
        case CSTA_HOLD_CALL_CONF :
          CstaHoldCallConfEvent ();
          return (0);
        case CSTA_MAKE_CALL_CONF :
          CstaMakeCallConfEvent ();
          return (0);
        case CSTA_MAKE_PREDICTIVE_CALL_CONF :
          CstaMakePredictiveCallConfEvent ();
          return (0);
        case CSTA_QUERY_MWI_CONF :
          CstaQueryMsgWaitingIndConfEvent ();
          return (0);
        case CSTA_QUERY_DND_CONF :
          CstaQueryDoNotDisturbConfEvent ();
          return (0);
        case CSTA_QUERY_FWD_CONF :
          CstaQueryForwardingConfEvent ();
          return (0);
        case CSTA_QUERY_AGENT_STATE_CONF :
          CstaQueryAgentStateConfEvent ();
          return (0);
        case CSTA_QUERY_LAST_NUMBER_CONF :
          CstaQueryLastNumberConfEvent ();
          return (0);
        case CSTA_QUERY_DEVICE_INFO_CONF :
          CstaQueryDeviceInfoConfEvent ();
          return (0);
        case CSTA_RECONNECT_CALL_CONF :
          CstaReconnectCallConfEvent ();
          return (0);
        case CSTA_RETRIEVE_CALL_CONF :
          CstaRetrieveCallConfEvent ();
          return (0);
        case CSTA_SET_MWI_CONF :
          CstaSetMsgWaitingIndConfEvent ();
          return (0);
        case CSTA_SET_DND_CONF :
          CstaSetDoNotDisturbConfEvent ();
          return (0);
        case CSTA_SET_FWD_CONF :
          CstaSetForwardingConfEvent ();
          return (0);
        case CSTA_SET_AGENT_STATE_CONF :
          CstaSetAgentStateConfEvent ();
          return (0);
        case CSTA_TRANSFER_CALL_CONF :
          CstaTransferCallConfEvent ();
          return (0);
        case CSTA_UNIVERSAL_FAILURE_CONF :
          CstaUniversalFailureConfEvent (m_cstaEvent.event.cstaConfirmation.u.universalFailure.error);
          return (0);
        case CSTA_ROUTE_REGISTER_REQ :
          eventString += "Route Register Req";
          break;
        case CSTA_ROUTE_REGISTER_REQ_CONF :
          CstaRouteRegisterReqConfEvent();
          return (0);
        case CSTA_ROUTE_REGISTER_CANCEL :
          eventString += "Route Register Cancel";
          break;
        case CSTA_ROUTE_REGISTER_CANCEL_CONF :
          CstaRouteRegisterCancelConfEvent();
          return(0);
        case CSTA_ROUTE_REGISTER_ABORT :
          eventString += "Route Register Abort";
          break;
        case CSTA_ROUTE_REQUEST :
          eventString += "Route Request";
          break;
        case CSTA_ROUTE_SELECT_REQUEST :
          eventString += "Route Select Request";
          break;
        case CSTA_RE_ROUTE_REQUEST :
          eventString += "Re Route Request";
          break;
        case CSTA_ROUTE_USED :
          eventString += "Route Used";
          break;
        case CSTA_ROUTE_END :
          eventString += "Route End";
          break;
        case CSTA_ROUTE_END_REQUEST :
          eventString += "Route End Request";
          break;

		// Added by G.L. 23 March 98
        case CSTA_SEND_DTMF_TONES_CONF :
          CstaSendDTMFTonesConfEvent();
          return(0);

        case CSTA_SINGLE_STEP_CONFERENCE_CALL_CONF :
          CstaSingleStepConfEvent();
          return(0);

        case CSTA_RECORD_MESSAGE_CALL_CONF :
          CstaRecordMessageConfEvent();
          return(0);

        case CSTA_STOP_CALL_CONF :
          CstaStopCallConfEvent();
          return(0);
		// end added

        case CSTA_ESCAPE_SVC_CONF :
          CstaEscapeServiceConfEvent ();
          return (0);
		case CSTA_IVR_STATUS_CONF:
			CstaIvrStatusConfEvent();
			return (0);
        case CSTA_SYS_STAT_REQ_CONF :
          CstaSysStatReqConfEvent ();
          return (0);
        case CSTA_SYS_STAT_START_CONF :
          CstaSysStatStartConfEvent ();
          return (0);
        case CSTA_SYS_STAT_STOP_CONF :
          CstaSysStatStopConfEvent ();
          return (0);
        case CSTA_CHANGE_SYS_STAT_FILTER_CONF :
          CstaChangeSysStatFilterConfEvent ();
          return (0);
        case CSTA_MONITOR_CONF :
          CstaMonitorConfEvent ();
          return (0);
        case CSTA_CHANGE_MONITOR_FILTER_CONF :
          CstaChangeMonitorFilterConfEvent ();
          return (0);
        case CSTA_MONITOR_STOP_CONF :
          CstaMonitorStopConfEvent ();
          return (0);
        case CSTA_SNAPSHOT_CALL_CONF :
          CstaSnapshotCallConfEvent();
          return(0);
        case CSTA_SNAPSHOT_DEVICE_CONF :
          CstaSnapshotDeviceConfEvent();
          return(0);
        case CSTA_GETAPI_CAPS_CONF :
          CstaGetApiCapsConfEvent ();
          return (0);
        case CSTA_GET_DEVICE_LIST :
          CstaGetDeviceListConfEvent ();
          return (0);
        case CSTA_GET_DEVICE_LIST_CONF :
          CstaGetDeviceListConfEvent ();
          return (0);