ntwkdevice.cpp

Conferencing code using Dialogic hardware

/**********@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********************************
* DIALOGIC CONFIDENTIAL
*
* Copyright (C) 2006-2007 Dialogic Corporation. All Rights Reserved.
* The source code contained or described herein and all documents related
* to the source code ("Material") are owned by Dialogic Corporation or its
* suppliers or licensors. Title to the Material remains with Dialogic Corporation
* or its suppliers and licensors. The Material contains trade secrets and
* proprietary and confidential information of Dialogic or its suppliers and
* licensors. The Material is protected by worldwide copyright and trade secret
* laws and treaty provisions. No part of the Material may be used, copied,
* reproduced, modified, published, uploaded, posted, transmitted, distributed,
* or disclosed in any way without Dialogic's prior express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Dialogic in writing.
*
***********************************@@@SOFT@@@WARE@@@COPY@@@RIGHT@@@**********/
//***********************************************************************
//***********************************************************************
// IptDevice.cpp: implementation of the CIptDevice class.
//
//////////////////////////////////////////////////////////////////////
#include "pdl.h"

#define MAX_RETRY 3         // max retry in case of invalid pass code

        
const char * dx_get_termination(int termno){
    static NAME_TABLE term_table_stru[] = {
	    { 	"TM_NORMTERM",TM_NORMTERM   },
 	    { 	"TM_MAXDTMF", TM_MAXDTMF    },
	    { 	"TM_MAXSIL",  TM_MAXSIL		},
 	    { 	"TM_MAXNOSIL",TM_MAXNOSIL	},
 	    { 	"TM_LCOFF",   TM_LCOFF		},
 	    { 	"TM_IDDTIME", TM_IDDTIME	},
 	    { 	"TM_MAXTIME", TM_MAXTIME	},
 	    {   "TM_DIGIT",   TM_DIGIT		},
 	    { 	"TM_PATTERN", TM_PATTERN	},
 	    { 	"TM_USRSTOP", TM_USRSTOP	},
 	    { 	"TM_EOD",     TM_EOD		},
 	    { 	"TM_TONE",    TM_TONE		},
 	    { 	"TM_BARGEIN", TM_BARGEIN	},
	    { 	"TM_ERROR",   TM_ERROR		},
	    { 	"TM_MAXDATA", TM_MAXDATA	},
        { 0,0}
    };  // End of term_table[]
    static CNameTable term_table(term_table_stru);

  return term_table.find_name(termno);
} // End of dx_get_termination()

//
// Call State machine
//
enum {
// Initialization
   S_WAIT_UNBLOCKED,   // OpenEx received, wait Unblocked  
   S_WAIT_OPENEX,      // Unblocked received, wait OpenEx

   S_RESET,            // ...ResetLineDev
   S_RESET_EXIT,       // ...ResetLineDev, exit request

// S_RELAX

// Call
   S_ROUTE,            // In process of routing dx to ntwk device
   S_ROUTE_EXIT,       // In process of routing dx, exit request

   S_ANSWER,           // In process of Answering the call 
   S_ANSWER_EXIT,      // In process of Answering the call (exit)

   S_ACCEPT,           // In process of Accepting the call 
   S_ACCEPT_EXIT,      // In process of Accepting the call (exit)
                      
   S_DROP,             // ...Drop call
   S_RELEASE,          // ...Release Call

   S_CHECK_DNIS,       // ...check if DNIS is associated with conference
   S_CHECK_DNIS_EXIT,  // ...check if DNIS is associated with conference

// Conversation
   S_PLAYGREET,        // ...Play Greeting
   S_PLAYBYE,          // ...Play bye
   S_PLAYCALLLATER,    // ...Play Call Later 

   S_GETDIGITS,        // ...Get digits

   S_STOP_DX,          // ...Cancel dx (exiting any voice function)
   S_CHECK_CNF,        // ...Check conference password

// UnListen 
   S_UNLISTEN,         // .. UnListen  from dx device

// Conference
   S_OPENPARTY,        // ...cnf_PartyOpen  
   S_OPENPARTY_EXIT,   // ...cnf_PartyOpen  exiting

   S_ADDPARTY,         // ...cnf_addParty
   S_ADDPARTY_EXIT,    // ...cnf_addParty exiting

   S_SETPARTYATTR,     // ... set party attributes
   S_SETPARTYATTR_EXIT,// ... set party attributes - exit

   S_DEVCONNECT1,      // ...dev_Connect ( first event)
   S_DEVCONNECT1_EXIT, // ...dev_Connect ( first event) exit

   S_DEVCONNECT2,      // ...dev_Connect ( second event)
   S_DEVCONNECT2_EXIT, // ...dev_Connect ( second event) exit

// S_RELAXCNF
   
   S_REMOVEPARTY,       // ...cnf_RemoveFromConference
   S_DEVDISCONNECTNTWK, // dev_Disconnect
   S_DEVDISCONNECTCNF,  // dev_Disconnect cnf party
};

//*****************************************************************************
// Purpose	: 
//    return state name for given value
// Parameters:	
//    state
// Returns:	
//    name 
//*****************************************************************************
const char * CNtwkDevice::state_name(int state){
    static NAME_TABLE state_tbl[] ={
        {"S_WAIT_UNBLOCKED",   S_WAIT_UNBLOCKED  },
        {"S_WAIT_OPENEX",      S_WAIT_OPENEX     },

        {"S_RESET",            S_RESET           },
        {"S_RESET_EXIT",       S_RESET_EXIT      },

        {"S_ANSWER",           S_ANSWER          },
        {"S_ANSWER_EXIT",      S_ANSWER_EXIT     },

        {"S_ACCEPT",           S_ACCEPT          },
        {"S_ACCEPT_EXIT",      S_ACCEPT_EXIT     },

        {"S_ROUTE",            S_ROUTE           },
        {"S_ROUTE_EXIT",       S_ROUTE_EXIT      },

        {"S_CHECK_DNIS",       S_CHECK_DNIS      },
        {"S_CHECK_DNIS_EXIT",  S_CHECK_DNIS_EXIT },

        {"S_DROP",             S_DROP            },
        {"S_RELEASE",          S_RELEASE         },

        {"S_PLAYGREET",        S_PLAYGREET       },
        {"S_PLAYBYE",          S_PLAYBYE         },
        {"S_PLAYCALLLATER",    S_PLAYCALLLATER   },

        {"S_GETDIGITS",        S_GETDIGITS       },
        {"S_STOP_DX",          S_STOP_DX         },

        {"S_CHECK_CNF",        S_CHECK_CNF       },
        {"S_UNLISTEN",         S_UNLISTEN        },

        {"S_OPENPARTY",        S_OPENPARTY       },
        {"S_OPENPARTY_EXIT",   S_OPENPARTY_EXIT  },

        {"S_ADDPARTY",         S_ADDPARTY        },
        {"S_ADDPARTY_EXIT",    S_ADDPARTY_EXIT   },

        {"S_SETPARTYATTR",      S_SETPARTYATTR       },
        {"S_SETPARTYATTR_EXIT", S_SETPARTYATTR_EXIT  },

        {"S_DEVCONNECT1",      S_DEVCONNECT1         },
        {"S_DEVCONNECT1_EXIT", S_DEVCONNECT1_EXIT    },

        {"S_DEVCONNECT2",      S_DEVCONNECT2         },
        {"S_DEVCONNECT2_EXIT", S_DEVCONNECT2_EXIT    },

        {"S_REMOVEPARTY",       S_REMOVEPARTY        },
        {"S_DEVDISCONNECTNTWK", S_DEVDISCONNECTNTWK  },
        {"S_DEVDISCONNECTCNF",  S_DEVDISCONNECTCNF   },

   
        {0, 0}
    };   // End of state_tbl[]
    const char *name;
    if (! str_findname(state, &name, state_tbl) ){
          name = common_state_name(state);
    }
  return name;
}   // End of state_name()

// Actions
// Derived:
// A_NONE                 // do nothing, ignore exit request
// A_RELAX                // relax (outside conference, ex. wait a call)
// A_RELAXCNF             // relax (in conference)
// A_CLOSE                // close this device
// A_ERROR                // Indicate state machine error
// A_EXIT                 // Exit - advance to appropriate .._exit state
// A_GIVEUP				  // Error while closing, advance to final state

enum { 
    A_FATAL,                 // Fatal error, close & request exit
    A_MOVE_UNBLOCKED,        // do nothing,  Advance to s_wait_unblocked
    A_MOVE_OPENEX,           // do nothing,  Advance to s_wait_openex
    A_MOVE_OPEN,             // do nothing,  Advance to s_open
    A_MOVE,                  // do nothing,  Advance to next

    A_ROUTE,                 // Route  
    A_RESET,                 // Reset line dev  

// A_RELAX is wait call

    A_ANSWER,                // Answer the call
    A_ACCEPT,                // Accept the call

    A_DROP,                  // Drop Call
    A_RELEASE,               // Release call

    A_PLAYGREET,             // Play greeting
    A_PLAYINVALID,           // Play invalid password 
    A_PLAYBYE,               // Play bye file  

    A_CHECK_DNIS,            // Check DNIS
    A_GETDIGITS,             // Get Digits

    A_STOP_DX,               // Stop dx 

    A_CHECK_CNF,             // Check conference password

    A_UNLISTEN,              // UnListen
    A_OPENPARTY,             // cnf_OpenParty 

    A_ADDPARTY,              // cnf_AddParty 
    A_DEVCONNECT,            // dev_Connect 
    A_MOVE_DEVCONNECT2_EXIT, // do nothing, Advance to s_devdisconnect2_exit

    A_DEVDISCONNECTNTWK,     // dev_DisConnect 
    A_DEVDISCONNECTCNF,      // dev_DisConnect 
    A_REMOVEPARTY,           // cnf_RemoveParty 
    A_CLOSEPARTY,            // cnf_CloseParty 
    A_SETPARTYATTR,
    A_MODIFYCALL,            // ReqModifyCall
};


//*****************************************************************************
// Purpose	: 
//    return action name for given value
// Parameters:	
//    [in] action code
// Returns:	
//    name 
//*****************************************************************************
const char * CNtwkDevice::action_name(int action){
    static NAME_TABLE ac_tbl[] = {

        { "A_FATAL",            A_FATAL           },
        { "A_MOVE_UNBLOCKED",   A_MOVE_UNBLOCKED  },
        { "A_MOVE_OPENEX",      A_MOVE_OPENEX     },
        { "A_MOVE_OPEN",        A_MOVE_OPEN       },
        { "A_ROUTE",            A_ROUTE           }, 
        { "A_RESET",            A_RESET           }, 

        { "A_ANSWER",           A_ANSWER          }, 
        { "A_ACCEPT",           A_ACCEPT          }, 

        { "A_CHECK_DNIS",       A_CHECK_DNIS      }, 
   
        { "A_DROP",             A_DROP            }, 
        { "A_RELEASE",          A_RELEASE         },
    
        { "A_PLAYGREET",        A_PLAYGREET       }, 
        { "A_PLAYINVALID",      A_PLAYINVALID     }, 
        { "A_PLAYBYE",          A_PLAYBYE         }, 

        { "A_GETDIGITS",        A_GETDIGITS       }, 
        { "A_STOP_DX",          A_STOP_DX         }, 

        { "A_CHECK_CNF",        A_CHECK_CNF       }, 
        { "A_UNLISTEN",         A_UNLISTEN       }, 

        { "A_OPENPARTY",        A_OPENPARTY       }, 
        { "A_ADDPARTY",         A_ADDPARTY        }, 
        { "A_DEVCONNECT",       A_DEVCONNECT      },    
        { "A_MOVE_DEVCONNECT2_EXIT",   A_MOVE_DEVCONNECT2_EXIT   },    

        { "A_DEVDISCONNECTNTWK", A_DEVDISCONNECTNTWK }, 
        { "A_DEVDISCONNECTCNF",  A_DEVDISCONNECTCNF  }, 
        { "A_REMOVEPARTY",       A_REMOVEPARTY       }, 
        { "A_CLOSEPARTY",        A_CLOSEPARTY        }, 
        { "A_SETPARTYATTR",      A_SETPARTYATTR      }, 
        { "A_MODIFYCALL",        A_MODIFYCALL        },
       { 0,0 }     
    };   // End of ac_tbl[]
 const char *name;
    if (! str_findname(action, &name, ac_tbl) ){
          name = common_action_name(action);
    }
  return name;
}  // End of action_name()

/////////////////////////////////////////////////////////////
// State machine
//===========================================================
static ACTION_STRU ntwk_action_stru[] = {
// Example:
//  { S_ANSWER,       A_PLAYGREET,    S_PLAYGREET,    A_DROP        },
//  In state S_ANSWER, Action A_PLAYGREET was executed
//     Then advance to state S_PLAYGREET if A_PLAYGREET was successful
//       or execute A_DROP as a recover procedure if A_PLAYGREET failed
//       How to continue after A_DROP in state S_ANSWER, see same table:
//  { S_ANY,          A_DROP,         S_DROP,         S_CLOSE },
//   Note:
//     In any state, there is no recover on recover.
//     if recover procedure fails, close and exit.

//  current_state   action           state_if_pass   action_if_fail 

    { S_OPEN,           A_MOVE_OPENEX,    S_WAIT_OPENEX,    A_NONE    },
    { S_OPEN,           A_EXIT,           S_OPEN_EXIT,      A_NONE    },

    { S_WAIT_UNBLOCKED, A_RESET,          S_RESET,          A_CLOSE   },
    { S_WAIT_OPENEX,    A_RESET,          S_RESET,          A_CLOSE   },
    { S_WAIT_OPENEX,    A_EXIT,           S_OPEN_EXIT,      A_NONE    },
    { S_WAIT_OPENEX,    A_MOVE_OPEN,      S_OPEN,           A_NONE    },

// ResetLineDev
    { S_RESET,          A_EXIT,           S_RESET_EXIT,     A_NONE    },
    { S_RESET,          A_RELAX,          S_RELAX,          A_CLOSE   },

// Incoming call 
/*
// --- This is for ANSWER call only
    { S_RELAX,          A_ANSWER,         S_ANSWER,         A_DROP    },


// --- end This is for ANSWER call  
*/

// --- This is for ACCEPT and ANSWER the call
// Incoming call 
    { S_RELAX,          A_ACCEPT,         S_ACCEPT,         A_DROP    },

    { S_ACCEPT,         A_ANSWER,         S_ANSWER,         A_DROP    },
    { S_ACCEPT,         A_EXIT,           S_ACCEPT_EXIT,    A_NONE    },
// --- End This is for ACCEPT and ANSWER the call


    { S_ANSWER,         A_ROUTE,          S_ROUTE,          A_DROP    },
    { S_ANSWER,         A_EXIT,           S_ANSWER_EXIT,    A_NONE    },

// Route 
    { S_ROUTE,          A_EXIT,           S_ROUTE_EXIT,     A_NONE    },
    { S_ROUTE,          A_CHECK_DNIS,     S_CHECK_DNIS,     A_DROP    },

// Check dnis 
    { S_CHECK_DNIS,     A_PLAYGREET,      S_PLAYGREET,      A_DROP    },
    { S_CHECK_DNIS,     A_OPENPARTY,      S_OPENPARTY,      A_PLAYBYE },

// Play/get
    { S_PLAYGREET,      A_GETDIGITS,      S_GETDIGITS,      A_DROP    },
    { S_PLAYGREET,      A_GETDIGITS,      S_GETDIGITS,      A_DROP    },
    { S_ANY,            A_PLAYBYE,        S_PLAYBYE,        A_DROP    },

    { S_GETDIGITS,      A_GETDIGITS,      S_GETDIGITS,      A_DROP    },
    { S_GETDIGITS,      A_CHECK_CNF,      S_CHECK_CNF,      A_DROP    },

    { S_CHECK_CNF,      A_PLAYGREET,      S_PLAYGREET,      A_DROP    },
    { S_CHECK_CNF,      A_PLAYINVALID,    S_PLAYGREET,      A_DROP    },
//Unlisten
    { S_CHECK_CNF,      A_UNLISTEN,       S_UNLISTEN,       A_DROP    },
     
// Add party
    { S_UNLISTEN,       A_OPENPARTY,      S_OPENPARTY,      A_PLAYBYE },

//Conference
    { S_OPENPARTY,      A_EXIT,           S_OPENPARTY_EXIT, A_NONE    },
  // case 2:
    { S_OPENPARTY,      A_ADDPARTY,       S_ADDPARTY,       A_CLOSEPARTY },
  // case 1:
    { S_OPENPARTY,      A_DEVCONNECT,     S_DEVCONNECT1,    A_CLOSEPARTY },