ntwkdevice.cpp

Conferencing code using Dialogic hardware

// Relax cnf        

    { S_RELAXCNF,       GCEV_BLOCKED,              A_DEVDISCONNECTNTWK },
    { S_RELAXCNF,       USREV_EXIT_REQUEST,        A_DEVDISCONNECTNTWK },
    { S_RELAXCNF,       GCEV_DISCONNECTED,         A_DEVDISCONNECTNTWK },
    { S_RELAXCNF,       USREV_LEAVE_CNF,           A_DEVDISCONNECTNTWK },

    { S_RELAXCNF,       GCEV_REQ_MODIFY_CALL,      A_MODIFYCALL },

// Dev disconnect    
    { S_DEVDISCONNECTNTWK, DMEV_DISCONNECT,        A_DEVDISCONNECTCNF },
    { S_DEVDISCONNECTNTWK, DMEV_DISCONNECT_FAIL,   A_DEVDISCONNECTCNF },
    { S_DEVDISCONNECTNTWK, USREV_TIMEOUT,          A_DEVDISCONNECTCNF },

    { S_DEVDISCONNECTCNF, DMEV_DISCONNECT,         A_REMOVEPARTY },
    { S_DEVDISCONNECTCNF, DMEV_DISCONNECT_FAIL,    A_REMOVEPARTY },
    { S_DEVDISCONNECTCNF, USREV_TIMEOUT,           A_REMOVEPARTY },


    { S_REMOVEPARTY,     CNFEV_REMOVE_PARTY,       A_CLOSEPARTY },
    { S_REMOVEPARTY,     CNFEV_REMOVE_PARTY_FAIL,  A_CLOSEPARTY },
    { S_REMOVEPARTY,     USREV_TIMEOUT,            A_CLOSEPARTY },

// No timeouts in Relax state
    { S_RELAX,          USREV_TIMEOUT,             A_NONE       },
    { S_RELAXCNF,       USREV_TIMEOUT,             A_NONE       },

// Drop & release
    { S_DROP,           GCEV_DROPCALL,             A_RELEASE    },
    { S_DROP,           USREV_TIMEOUT,             A_RELEASE    },
    { S_DROP,           GCEV_TASKFAIL,             A_FATAL      },
    
    { S_RELEASE,        GCEV_RELEASECALL,          A_RELAX      },
    { S_RELEASE,        USREV_TIMEOUT,             A_FATAL      },
    { S_RELEASE,        GCEV_RELEASECALL_FAIL,     A_RESET      },

// This is a way to ignore events in any state:
    { S_ANY,          IPMEV_QOS_ALARM,              A_NONE       },
    { S_ANY,          TDX_CST,                      A_NONE     },

    //Anything else falls here
    { S_ANY,          EVENT_ANY,                   A_ERROR      },
    { S_END,   0,    0  } 
}; // End of ntwk_event_stru[]


//*****************************************************************************
// Purpose	: 
//    Execute next step from state machine
//     Anything related to srl handle (gc_ or dx_) should happen here (except open and maybe close)
//     To request action from other thread, send user defined event (such as USREV_EXIT_REQUEST in this app)
// Parameters:	
//    [in] action
// Returns:	
//    true = success 
//    false = failure 
//*****************************************************************************
bool CNtwkDevice::Execute(int action){
bool brc = true;

  SetDfltTimer(NTWK_TMO); // reset back default timeout if it has been changed

  switch(action) {
      case A_ERROR:
           // Indicate error
           StateMachineError();
           break;

      case A_GIVEUP:  // do nothing but advance state machine
           SetSrlState(SRLSTATE_ALL, RESET_SRL_STATE);
           SetCurrentState(S_FINAL);
           break;      

      case A_NONE:					// do nothing
      case A_EXIT:					// do nothing but advance state machine
      case A_MOVE:					// .... to next 
      case A_MOVE_UNBLOCKED:		// .... to S_WAIT_UNBLOCKED
      case A_MOVE_OPENEX:			// .... to S_OPENEX
      case A_MOVE_OPEN:				// .... to S_OPEN
      case A_MOVE_DEVCONNECT2_EXIT: // .... to S_DEVDESCONNECT2_EXIT

           break;

      case A_CLOSE:
           brc = Close();
           break;

      case A_FATAL:  
           SetSrlState(SRLSTATE_FAILED_FATAL);
           Close();
           break;

      case A_ROUTE:
           brc = RouteVoice();
           break;

      case A_RESET:
           brc = ResetLineDev();
           break;

      case A_ANSWER:
           brc = AnswerCall();
           break;

      case A_ACCEPT:
           brc = AcceptCall();
           break;

      case A_DROP:
           brc = DropCall();
           break;

      case A_RELEASE:
           brc = ReleaseCall();
           break;

      case A_PLAYGREET:
           brc = PlayFile(m_pCommonParams->m_welcome_file);
           break;

      case A_PLAYINVALID:
           brc = PlayFile(m_pCommonParams->m_bad_passcode_file);
           break;

      case A_PLAYBYE:
           brc = PlayFile(m_pCommonParams->m_goodbye_file);
           break;

      case A_GETDIGITS:
           brc = GetDigits();
           break;

      case A_STOP_DX:
           brc = StopDx();
           break;
    
      case A_CHECK_CNF:
           CheckForValidConference();
           break;

      case A_UNLISTEN:
           UnListen();
           break;

      case A_CHECK_DNIS:
           CheckDnis();
           break;

      case A_RELAXCNF:
           m_pCnfConf->PutEvent(USREV_BEEP_IN, GetName());
           break;

      case A_RELAX:
           SetSrlState(SRLSTATE_INIT_COMPLETE);
           brc = WaitCall();
           break;

      case A_OPENPARTY: 
           brc = OpenParty();
           break;

      case A_ADDPARTY: 
           brc = AddParty();
           break;

      case A_DEVCONNECT: 
           brc = DevConnect(DEV_NTWK_PARTY);
           break;

      case A_DEVDISCONNECTNTWK: 
           m_pCnfConf->PutEvent(USREV_BEEP_OUT, GetName());
           brc = DevDisconnect(DEV_NTWK_PARTY);
           break;

      case A_DEVDISCONNECTCNF: 
           brc = DevDisconnect(DEV_CNF_PARTY);
           break;

      case A_REMOVEPARTY: 
           brc = RemoveParty();
           break;
   
      case A_CLOSEPARTY: 
           CloseParty();
           brc = DropCall();
           break;
        
      case A_SETPARTYATTR: 
           SetPartyAttributes(m_pCnfConf->GetClamping());
           break;

      case A_MODIFYCALL:
           ModifyCall();        // IP Request modify call
           break;

      default:
           LOG( LOG_ERR1, GetName(),
                "NtwkDevice: App error. Missing case to handle action #%d %s",
                 action, action_name(action));
           break;
  } // switch action
 return brc;
} // End of Execute()
//*****************************************************************************
// Purpose	: 
//    Handle GCEV_REQ_MODIFY_CALL
// Parameters:	
// Returns:	
//    success flag
//*****************************************************************************
bool CNtwkDevice::ModifyCall(){
  // Actual implementation is im IptDevice.cpp
    return true;
}
//*****************************************************************************
// Purpose	: 
//    Handle events
// Parameters:	
//   [in] event
//   [in] event data
//   [in] data length
//   [in] METAEVENT
// Returns:	
//    none
//*****************************************************************************
void CNtwkDevice::HandleEvent(int event,
                              void *evtdata, int evtlen,
                              METAEVENT *metaeventp){
int rc;
    switch ( event ){

        case CNFEV_ADD_PARTY:
             LOG(LOG_APP, GetName(), ">> Join conference %d %s",
                          m_pCnfConf->GetId(), m_pCnfConf->GetName());
             break;

        case CNFEV_REMOVE_PARTY:
          // Indicate party was removed
             if (m_pCnfConf){
                 m_pCnfConf->PutEvent(USREV_PARTY_REMOVED,GetName() , sizeof (this),this);
             }
             LOG(LOG_APP, GetName(), "<< Leave conference %d %s",
                          m_pCnfConf->GetId(), m_pCnfConf->GetName());
             break;   

        case GCEV_OPENEX_FAIL:
             SetSrlState(SRLSTATE_FAILED_FATAL);
             break;

        case GCEV_OPENEX:
             break;

        case TDX_RECORD:
        case TDX_PLAY:
             CloseVoiceFile();
             GetTermReason();
             break;

        case TDX_ERROR:
             CloseVoiceFile();
             break;    

        case TDX_GETDIG:
             GetTermReason();
            { // trim trailing # (if exist)
               char *ch = strchr(m_digits.dg_value,'#');
               if (ch) *ch = 0;
            }
             ClearDigits();
             LOG( LOG_APP,GetName(), 
                  "Digits received: %s",m_digits.dg_value);
             break; 
             
        case CNFEV_OPEN_PARTY:
            {
             PCNF_OPEN_PARTY_RESULT pResult = (PCNF_OPEN_PARTY_RESULT) evtdata;
             cnf_dump(pResult);
            }
             break;
        
        case GCEV_OFFERED:
            // retrieve common call data: crn, ani, dnis
             SetSrlState(SRLSTATE_CALL_ACTIVE);
             rc = gc_GetCRN(&m_crn, metaeventp);
             LOG( RC(rc),GetName(),
                  "%d = gc_GetCrn(m_crn :=0x%x)",
                  rc, m_crn);

             rc = gc_GetCallInfo(m_crn, ORIGINATION_ADDRESS, m_ani);
             LOG( RC(rc),GetName(),
                  "%d = gc_GetCallInfo(m_crn=0x%x, ORIGINATION_ADDRESS, m_ani:='%s')",
                  rc, m_crn, m_ani);

             rc = gc_GetCallInfo(m_crn, DESTINATION_ADDRESS, m_dnis );
             LOG( RC(rc),GetName(),
                  "%d = gc_GetCallInfo(m_crn=0x%x, DESTINATION_ADDRESS, m_dnis:='%s')",
                  rc, m_crn, m_dnis);

             LOG( LOG_APP, GetName(),
                  "*** New call from %s calling %s", m_ani, m_dnis);
             break;

        case GCEV_RESETLINEDEV: 
             SetSrlState(SRLSTATE_CALL_ACTIVE,RESET_SRL_STATE);
             OnInitComplete();
             break;

        case GCEV_RELEASECALL:
             SetSrlState(SRLSTATE_CALL_ACTIVE,RESET_SRL_STATE);
             break;

        case GCEV_DISCONNECTED:
             LOG( LOG_APP, GetName(), "*** Disconnected from %s", m_ani);
            // Drop!
        case GCEV_TASKFAIL:
             ProcessEventInfo(metaeventp);
             break;
    } // switch event

    CSrlDevice::HandleEvent(event, evtdata, evtlen, metaeventp);

  return ;
}  // End of HandleEvent()

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
//*****************************************************************************
// Purpose	: 
//    Constructor
// Parameters:	
//    [in] Device type (DEV_IPT or DEV_DTI)
//    [in] Configuration parameters (from configuration file)
//    [in] Optional name. When name is 0, use any available from specified type
// Returns:	
//    none
//*****************************************************************************
CNtwkDevice::CNtwkDevice(DLG_DEVICE_TYPE devtype,
                         PCommonParams pCommonParams, 
                         const char *name)
                        : CSrlDevice(devtype, pCommonParams, name) {
    m_crn = 0;
    *m_dnis=0;
    *m_ani=0;

    m_num_inv_passcode = 0;               // number of invalid pass codes

	memset(&m_digits, 0, sizeof(m_digits));

    m_do_waitcall = true;

    memset(&m_gc_info,0,sizeof(m_gc_info));

    SetExitCode(EXIT_OK);

    if (! SetStateMachine(ntwk_event_stru, ntwk_action_stru) ) {
        SetExitCode(EXIT_VALIDATE);
    }

    SetDfltTimer(NTWK_TMO);

    m_pCnfConf = 0;
 return;
}  // End of Constructor()

//*****************************************************************************
// Purpose	: 
//    Destructor
// Parameters:	
//    none
// Returns:	
//    none
//*****************************************************************************
CNtwkDevice::~CNtwkDevice() {

   // Close dx
   close_dx();
   CloseVoiceFile(); 

   // Close Device
   Close();
 return;