diff options
Diffstat (limited to 'data/mnet/GP10/Host/jcc/src')
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/JCC_ED.cpp | 397 | ||||
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/LUDBMmMsgProc.cpp | 470 | ||||
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/LUDBOamMsgProc.cpp | 88 | ||||
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/LUDBTask.cpp | 207 | ||||
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/LUDBTimerProc.cpp | 84 | ||||
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/LUDBVoipMsgProc.cpp | 714 | ||||
| -rw-r--r-- | data/mnet/GP10/Host/jcc/src/Makefile | 52 |
7 files changed, 2012 insertions, 0 deletions
diff --git a/data/mnet/GP10/Host/jcc/src/JCC_ED.cpp b/data/mnet/GP10/Host/jcc/src/JCC_ED.cpp new file mode 100644 index 0000000..095839d --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/JCC_ED.cpp @@ -0,0 +1,397 @@ +// *******************************************************************
+//
+// (c) Copyright Cisco 2000
+// All Rights Reserved
+//
+// *******************************************************************
+
+// *******************************************************************
+//
+// Version : 1.0
+// Status : Under development
+// File : JCC_ED.cpp
+// Author(s) : Bhava Nelakanti
+// Create Date : 11-01-98
+// Description : message and ie interface among Application (Layer 3)
+// modules.
+//
+// *******************************************************************
+
+// *******************************************************************
+// Include Files.
+// *******************************************************************
+
+#include <vxworks.h>
+#include <stdio.h>
+
+#include "JCC_ED.h"
+#include "lapdm/lapdm_l3intf.h"
+#include "lapdm/lapdm_config.h"
+#include "RIL3/ril3irt.h"
+#include "CC/CCconfig.h"
+
+// *******************************************************************
+// Local function prototypes
+// *******************************************************************
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeAlerting (T_CNI_RIL3CC_MSG_ALERTING &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeCallConfirmed(T_CNI_RIL3CC_MSG_CALL_CONFIRMED &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeConnect (T_CNI_RIL3CC_MSG_CONNECT &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeConnectAck (T_CNI_RIL3CC_MSG_CONNECT_ACK &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeSetup (T_CNI_RIL3CC_MSG_SETUP &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeDisconnect (T_CNI_RIL3CC_MSG_DISCONNECT &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeRelease (T_CNI_RIL3CC_MSG_RELEASE &);
+T_CNI_RIL3_RESULT JCC_RIL3SMS_DecodeCpData (T_CNI_RIL3SMS_MSG_CP_DATA &);
+T_CNI_RIL3_RESULT JCC_RIL3SMS_DecodeCpAck (T_CNI_RIL3SMS_MSG_CP_ACK &);
+T_CNI_RIL3_RESULT JCC_RIL3SMS_DecodeCpError (T_CNI_RIL3SMS_MSG_CP_ERROR &);
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeReleaseComplete (T_CNI_RIL3CC_MSG_RELEASE_COMPLETE &);
+T_CNI_RIL3_RESULT JCC_RIL3MM_DecodeLocationUpdateRequest(T_CNI_RIL3MM_MSG_LOCATION_UPDATE_REQUEST &);
+T_CNI_RIL3_RESULT JCC_RIL3MM_DecodeCMServiceRequest (T_CNI_RIL3MM_MSG_CM_SERVICE_REQUEST &);
+
+
+T_CNI_RIL3_IE_MOBILE_ID testIMSI[CC_MAX_CC_CALLS_DEF_VAL];
+
+short testIMSIindex;
+
+short origSoftMobDialedNumIndex;
+
+T_CNI_RIL3_IE_CALLED_PARTY_BCD_NUMBER testDialedNum[CC_MAX_CC_CALLS_DEF_VAL];
+
+T_CNI_IRT_ID softMobEntryId[CC_MAX_CC_CALLS_DEF_VAL]
+= {200, 201, 202, 203, 204, 205, 206};
+
+T_CNI_LAPDM_OID softMobLapdmOid[CC_MAX_CC_CALLS_DEF_VAL]
+= {200, 201, 202, 203, 204, 205, 206};
+
+int termSoftMobIndex = 1,
+ origSoftMobIndex = 0;
+
+// The only message that needs any data right now is the Called Party Number
+
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeAlerting(
+ T_CNI_RIL3CC_MSG_ALERTING &alerting
+ )
+{
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeCallConfirmed(
+ T_CNI_RIL3CC_MSG_CALL_CONFIRMED &callConfirmed
+ ) {
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeConnect(
+ T_CNI_RIL3CC_MSG_CONNECT &connect
+ ) {
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeConnectAck(
+ T_CNI_RIL3CC_MSG_CONNECT_ACK &connectAck
+ ) {
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeSetup(
+ T_CNI_RIL3CC_MSG_SETUP &setup
+ ) {
+
+ setup.calledBCD = testDialedNum[origSoftMobDialedNumIndex];
+
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeDisconnect(
+ T_CNI_RIL3CC_MSG_DISCONNECT &disconnect
+ ) {
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeRelease(
+ T_CNI_RIL3CC_MSG_RELEASE &release
+ ) {
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3CC_DecodeReleaseComplete(
+ T_CNI_RIL3CC_MSG_RELEASE_COMPLETE &releaseComplete
+ ) {
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3MM_DecodeLocationUpdateRequest(
+ T_CNI_RIL3MM_MSG_LOCATION_UPDATE_REQUEST &locationUpdateRequest
+ ) {
+ // mandatory IEs
+
+ //T_CNI_RIL3_IE_LOCATION_UPDATE_TYPE
+ locationUpdateRequest.locationUpdateType.locationUpdateType = CNI_RIL3_LOCATION_UPDATE_TYPE_NORMAL;
+
+ // 10.5.3.5
+ // T_CNI_RIL3_IE_CIPHER_KEY
+ locationUpdateRequest.cipherKey.keySeq = CNI_RIL3_NO_KEY_AVAILABLE;
+
+ // 10.5.1.2
+ // T_CNI_RIL3_IE_LOCATION_AREA_ID
+ locationUpdateRequest.locationId.mcc[0] = 2 ;
+ locationUpdateRequest.locationId.mcc[1] = 1 ;
+ locationUpdateRequest.locationId.mcc[2] = 2 ;
+
+ locationUpdateRequest.locationId.mnc[0] = 1;
+ locationUpdateRequest.locationId.mnc[1] = 3;
+
+ locationUpdateRequest.locationId.lac = 5 ;
+
+ // 10.5.1.3
+ // T_CNI_RIL3_IE_MS_CLASSMARK_1
+ locationUpdateRequest.classmark1.revLevel = CNI_RIL3_REV_LEVEL_PHASE1;
+ locationUpdateRequest.classmark1.esInd = CNI_RIL3_EARLY_CLASSMARK_SENDING_NOT_IMPLEMENTED;
+ locationUpdateRequest.classmark1.a51 = CNI_RIL3_A51_AVAILABLE;
+ locationUpdateRequest.classmark1.rfPowerCap = CNI_RIL3_GSM_CLASS_1;
+
+ // 10.5.1.5
+ // T_CNI_RIL3_IE_MOBILE_ID
+ locationUpdateRequest.mobileId = testIMSI[testIMSIindex];
+
+ // 10.5.1.4
+
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+T_CNI_RIL3_RESULT JCC_RIL3MM_DecodeCMServiceRequest(
+ T_CNI_RIL3MM_MSG_CM_SERVICE_REQUEST &cmServiceRequest
+ ) {
+ // mandatory IEs
+
+ // T_CNI_RIL3_IE_CM_SERVICE_TYPE
+ cmServiceRequest.cmServiceType.serviceType =
+ CNI_RIL3_CM_SERVICE_TYPE_MO_CALL_OR_PACKET_MODE;
+ // 10.5.3.3
+
+ // T_CNI_RIL3_IE_CIPHER_KEY
+ cmServiceRequest.cipherKey.keySeq = CNI_RIL3_NO_KEY_AVAILABLE;
+ // 10.5.1.2
+
+ // T_CNI_RIL3_IE_MS_CLASSMARK_2
+ cmServiceRequest.classmark2.revLevel = CNI_RIL3_REV_LEVEL_PHASE1;
+ cmServiceRequest.classmark2.esInd = CNI_RIL3_EARLY_CLASSMARK_SENDING_NOT_IMPLEMENTED;
+ cmServiceRequest.classmark2.a51 = CNI_RIL3_A51_AVAILABLE;
+ cmServiceRequest.classmark2.rfPowerCap = CNI_RIL3_GSM_CLASS_1;
+ cmServiceRequest.classmark2.psCap = CNI_RIL3_PS_CAPABILITY_NOT_PRESENT;
+ cmServiceRequest.classmark2.ssScreening = CNI_RIL3_SS_SCREENING_PHASE1_DEFAULT;
+ cmServiceRequest.classmark2.smCap = CNI_RIL3_SM_MT_PTP_NOT_SUPPORTED;
+ cmServiceRequest.classmark2.fcFreqCap = CNI_RIL3_GSM_EXTENTION_BAND_G1_NOT_SUPPORTED;
+ cmServiceRequest.classmark2.classmark3 = CNI_RIL3_CLASSMARK3_INFO_NOTAVAILABLE;
+
+ /* Classmark3 not available
+ cmServiceRequest.classmark2.cmsp = 0;
+ cmServiceRequest.classmark2.a53 = 0;
+ cmServiceRequest.classmark2.a52 = 0;
+ */
+ // 10.5.1.6
+
+ // T_CNI_RIL3_IE_MOBILE_ID
+ cmServiceRequest.mobileId = testIMSI[testIMSIindex];
+ // 10.5.1.4
+
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+
+// SMS-PP CP-messages
+T_CNI_RIL3_RESULT JCC_RIL3SMS_DecodeCpData (T_CNI_RIL3SMS_MSG_CP_DATA &cp_data )
+{
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+
+T_CNI_RIL3_RESULT JCC_RIL3SMS_DecodeCpAck (T_CNI_RIL3SMS_MSG_CP_ACK &cp_ack )
+{
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+
+T_CNI_RIL3_RESULT JCC_RIL3SMS_DecodeCpError (T_CNI_RIL3SMS_MSG_CP_ERROR &cp_error)
+{
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+
+T_CNI_RIL3_RESULT
+JCC_RIL3CC_Decode(
+ bool isSoftMob,
+ T_CNI_LAPDM_L3MessageUnit *l3MsgUnit, T_CNI_RIL3CC_MSG *ccMsg)
+{
+ if (isSoftMob == false)
+ return (CNI_RIL3CC_Decode(l3MsgUnit,ccMsg));
+
+ unsigned char *buffer = l3MsgUnit->buffer;
+ int length = l3MsgUnit->msgLength;
+
+ if (length < 2) return CNI_RIL3_INCORRECT_LENGTH;
+
+ // zap the output ccMsg
+ CNI_RIL3_ZAPMSG(ccMsg, sizeof(T_CNI_RIL3CC_MSG));
+
+ // get skip indicator
+ ccMsg->header.si_ti =
+ (T_CNI_RIL3_SI_TI) (buffer[0] >> 4);
+
+ // get message type
+ ccMsg->header.message_type =
+ (T_CNI_RIL3_MESSAGE_TYPE) (buffer[1] & 0x3f);
+
+ switch (ccMsg->header.message_type)
+ {
+ case CNI_RIL3CC_MSGID_ALERTING:
+ return JCC_RIL3CC_DecodeAlerting(
+ ccMsg->alerting
+ );
+ case CNI_RIL3CC_MSGID_CALL_CONFIRMED:
+ return JCC_RIL3CC_DecodeCallConfirmed(
+ ccMsg->callConfirmed
+ );
+ case CNI_RIL3CC_MSGID_CONNECT:
+ return JCC_RIL3CC_DecodeConnect(
+ ccMsg->connect
+ );
+ case CNI_RIL3CC_MSGID_CONNECT_ACKNOWLEDGE:
+ return JCC_RIL3CC_DecodeConnectAck(
+ ccMsg->connectAck
+ );
+ case CNI_RIL3CC_MSGID_EMERGENCY_SETUP:
+ return CNI_RIL3_RESULT_SUCCESS;
+ case CNI_RIL3CC_MSGID_SETUP:
+ return JCC_RIL3CC_DecodeSetup(
+ ccMsg->setup
+ );
+ case CNI_RIL3CC_MSGID_MODIFY:
+ case CNI_RIL3CC_MSGID_MODIFY_COMPLETE:
+ case CNI_RIL3CC_MSGID_MODIFY_REJECT:
+ return CNI_RIL3_RESULT_SUCCESS;
+ case CNI_RIL3CC_MSGID_DISCONNECT:
+ return JCC_RIL3CC_DecodeDisconnect(
+ ccMsg->disconnect
+ );
+ case CNI_RIL3CC_MSGID_RELEASE:
+ return JCC_RIL3CC_DecodeRelease(
+ ccMsg->release
+ );
+ case CNI_RIL3CC_MSGID_RELEASE_COMPLETE:
+ return JCC_RIL3CC_DecodeReleaseComplete(
+ ccMsg->releaseComplete
+ );
+ case CNI_RIL3CC_MSGID_CONGESTION_CONTROL:
+ case CNI_RIL3CC_MSGID_NOTIFY:
+ case CNI_RIL3CC_MSGID_STATUS:
+ case CNI_RIL3CC_MSGID_STATUS_ENQUIRY:
+ default:
+ return CNI_RIL3_UNKNOWN_MESSAGE_TYPE;
+ }
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+
+T_CNI_RIL3_RESULT
+JCC_RIL3MM_Decode(
+ bool isSoftMob,
+ T_CNI_LAPDM_L3MessageUnit *l3MsgUnit, T_CNI_RIL3MM_MSG *mmMsg)
+{
+ if (isSoftMob == false)
+ return (CNI_RIL3MM_Decode(l3MsgUnit,mmMsg));
+
+ unsigned char *buffer = l3MsgUnit->buffer;
+ int length = l3MsgUnit->msgLength;
+
+ if (length < 2) return CNI_RIL3_INCORRECT_LENGTH;
+
+ // zap the output mmMsg
+ CNI_RIL3_ZAPMSG(mmMsg, sizeof(T_CNI_RIL3MM_MSG));
+
+ // get message type
+ mmMsg->header.message_type =
+ (T_CNI_RIL3_MESSAGE_TYPE) (buffer[1] & 0x3f);
+
+ switch (mmMsg->header.message_type)
+ {
+ case CNI_RIL3MM_MSGID_IMSI_DETACH_INDICATION:
+ case CNI_RIL3MM_MSGID_LOCATION_UPDATING_REQUEST:
+ return JCC_RIL3MM_DecodeLocationUpdateRequest(
+ mmMsg->locationUpdateRequest
+ );
+ case CNI_RIL3MM_MSGID_AUTHENTICATION_RESPONSE:
+ case CNI_RIL3MM_MSGID_IDENTITY_RESPONSE:
+ case CNI_RIL3MM_MSGID_TMSI_REALLOCATION_COMPLETE:
+ return CNI_RIL3_RESULT_SUCCESS;
+
+ case CNI_RIL3MM_MSGID_CM_SERVICE_ABORT:
+ return CNI_RIL3_RESULT_SUCCESS;
+
+ case CNI_RIL3MM_MSGID_CM_SERVICE_REQUEST:
+ return JCC_RIL3MM_DecodeCMServiceRequest(
+ mmMsg->cmServiceRequest
+ );
+ case CNI_RIL3MM_MSGID_CM_REESTABLISHMENT_REQUEST:
+ case CNI_RIL3MM_MSGID_MM_NULL:
+ default:
+ return CNI_RIL3_UNKNOWN_MESSAGE_TYPE;
+ }
+ return CNI_RIL3_RESULT_SUCCESS;
+}
+
+
+T_CNI_RIL3_RESULT JCC_RIL3SMS_Decode (bool isSoftMob,
+ T_CNI_LAPDM_L3MessageUnit *l3MsgUnit,
+ T_CNI_RIL3SMS_CP_MSG *smsMsg )
+{
+ T_CNI_RIL3_RESULT retVal;
+
+ if (isSoftMob == false)
+ {
+ retVal = CNI_RIL3SMS_CP_Decode (l3MsgUnit, smsMsg); //Real Mode
+ }
+ else
+ {
+ // Test mode
+ unsigned char *buffer = l3MsgUnit->buffer ;
+ int length = l3MsgUnit->msgLength;
+
+ if (length < 2)
+ retVal = CNI_RIL3_INCORRECT_LENGTH;
+ else
+ {
+ // zap the output ccMsg
+ CNI_RIL3_ZAPMSG (smsMsg, sizeof(T_CNI_RIL3SMS_CP_MSG));
+
+ // get skip indicator
+ smsMsg->header.si_ti = (T_CNI_RIL3_SI_TI) (buffer[0] >> 4);
+
+ // get message type
+ smsMsg->header.message_type = (T_CNI_RIL3_CP_MESSAGE_TYPE) (buffer[1] & 0x3f);
+
+ switch (smsMsg->header.message_type)
+ {
+ case CNI_RIL3SMS_MSGID_CP_DATA :
+ retVal = JCC_RIL3SMS_DecodeCpData (smsMsg->cp_data );
+ break;
+
+ case CNI_RIL3SMS_MSGID_CP_ACK :
+ retVal = JCC_RIL3SMS_DecodeCpAck (smsMsg->cp_ack );
+ break;
+
+ case CNI_RIL3SMS_MSGID_CP_ERROR:
+ retVal = JCC_RIL3SMS_DecodeCpError (smsMsg->cp_error);
+ break;
+
+ default:
+ retVal = CNI_RIL3_UNKNOWN_MESSAGE_TYPE;
+ break;
+ }
+ }
+ }
+
+ return (retVal);
+}
+
+
diff --git a/data/mnet/GP10/Host/jcc/src/LUDBMmMsgProc.cpp b/data/mnet/GP10/Host/jcc/src/LUDBMmMsgProc.cpp new file mode 100644 index 0000000..b973902 --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/LUDBMmMsgProc.cpp @@ -0,0 +1,470 @@ +// *******************************************************************
+//
+// (c) Copyright Cisco 2000
+// All Rights Reserved
+//
+// *******************************************************************
+
+// *******************************************************************
+//
+// Version : 1.0
+// Status : Under development
+// File : LUDBMmMsgProc.cpp
+// Author(s) : Kevin S. Lim
+// Create Date : 07-31-99
+// Description :
+//
+// *******************************************************************
+
+// *******************************************************************
+// Include Files.
+// *******************************************************************
+
+#include "stdLib.h"
+#include "vxWorks.h"
+#include "taskLib.h"
+#include "usrLib.h"
+#include "errnoLib.h"
+#include "string.h"
+
+// from common vob
+#include "subsc/SubscInfoType.h"
+#include "subsc/SubscInfoUtil.h"
+
+#include "LOGGING/vcmodules.h"
+#include "LOGGING/vclogging.h"
+
+// included L3 Message header for messages from other Layer 3 modules
+#include "JCC/JCCL3Msg.h"
+
+#include "JCC/JCCUtil.h"
+#include "JCC/JCCTimer.h"
+#include "JCC/LUDB.h"
+#include "JCC/LUDBapi.h"
+#include "JCC/LUDBConfig.h"
+
+#include "JCC/LUDBMmMsgProc.h"
+#include "LUDBVoipMsgProc.h"
+
+// Global variable for Message Queue
+extern MSG_Q_ID mmMsgQId;
+extern LUDB gLUDB;
+extern short ludb_auth_required;
+
+// ****************************************************************************
+bool sendLudbRspToMM(LudbMsgStruct *rsp)
+{
+ DBG_FUNC("sendLudbRspToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ rsp->module_id = MODULE_LUDB;
+ STATUS stat = msgQSend(mmMsgQId, (char *) rsp,
+ sizeof(LudbMsgStruct),
+ NO_WAIT, MSG_PRI_NORMAL);
+ if(stat == ERROR){
+ DBG_ERROR("msgQSend Error\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileRelReqToMM(short mmId)
+{
+ DBG_FUNC("sendMobileRelReqToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_REL_REQ;
+ LudbResponse.mm_id = mmId;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileRegCnfToMM(short mmId, short ludbId, short forceAuth)
+{
+ DBG_FUNC("sendMobileRegCnfToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ gLUDB.update(ludbId, LUDBEntry::ACTIVE);
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_REG_CNF;
+ LudbResponse.mm_id = mmId;
+ LudbResponse.ludb_id = ludbId;
+ LudbResponse.forceAuth = forceAuth;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendEmergRspToMM(short mmId, short ludbId)
+{
+ DBG_FUNC("sendEmergRspToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ gLUDB.update(ludbId, LUDBEntry::EMERGENCY);
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_EMERG_RSP;
+ LudbResponse.mm_id = mmId;
+ LudbResponse.ludb_id = ludbId;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendRemEmergRspToMM(short mmId)
+{
+ DBG_FUNC("sendRemEmergRspToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_REM_EMERG_CNF;
+ LudbResponse.mm_id = mmId;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileSecRspToMM(short mmId, short ludbId)
+{
+ DBG_FUNC("sendMobileSecRspToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ gLUDB.update(ludbId, LUDBEntry::ACTIVE);
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_SEC_RSP;
+ LudbResponse.mm_id = mmId;
+ LudbResponse.ludb_id = ludbId;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileRegRejToMM(short mmId, T_CNI_RIL3_REJECT_CAUSE_VALUE cause)
+{
+ DBG_FUNC("sendMobileRegRejToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_REG_REJ;
+ LudbResponse.mm_id = mmId;
+ LudbResponse.cause = cause;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileUnRegCnfToMM(short mmId)
+{
+ DBG_FUNC("sendMobileUnRegCnfToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_UNREG_CNF;
+ LudbResponse.mm_id = mmId;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileUnRegRejToMM(short mmId)
+{
+ DBG_FUNC("sendMobileUnRegRejToMM", LUDB_LAYER);
+ DBG_ENTER();
+
+ LudbMsgStruct LudbResponse;
+ LudbResponse.msg_type = LUDB_MM_UNREG_REJ;
+ LudbResponse.mm_id = mmId;
+
+ bool status = sendLudbRspToMM(&LudbResponse);
+ if(!status) {
+ DBG_ERROR("LudbRespsonse send unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+void LUDB_MM_EmergReqProc(T_CNI_RIL3_IE_MOBILE_ID& mobile_id, short mmId)
+{
+ DBG_FUNC("LUDB_MM_RegReqProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = gLUDB.registerUser(mobile_id);
+ if(ludb_id != -1){
+ T_SUBSC_INFO subsc;
+ char msisdn[MAX_NUM_SUBSC_ISDN];
+ char imsi[MAX_NUM_SUBSC_IMSI];
+ int i, len;
+
+ subscInfoInitialize(&subsc);
+ switch(mobile_id.mobileIdType){
+ case CNI_RIL3_IMSI:
+ len = (mobile_id.numDigits > MAX_NUM_SUBSC_IMSI)?
+ MAX_NUM_SUBSC_IMSI:mobile_id.numDigits;
+ for(i=0; i<len; i++)
+ imsi[i] = mobile_id.digits[i] + '0';
+ imsi[i] = '\0';
+ subscSetIMSI(&subsc, imsi);
+ case CNI_RIL3_IMEI:
+ case CNI_RIL3_IMEISV:
+ len = (mobile_id.numDigits > MAX_NUM_SUBSC_ISDN)?
+ MAX_NUM_SUBSC_ISDN:mobile_id.numDigits;
+ for(i=0; i<len; i++)
+ msisdn[i] = mobile_id.digits[i] + '0';
+ msisdn[i] = '\0';
+ break;
+ default:
+ DBG_ERROR("unsupported mobile id for EmergencyReq %d\n",
+ mobile_id.mobileIdType);
+ msisdn[0] = '\0';
+ }
+ subscSetMSISDN(&subsc, msisdn);
+ subscSetUserInfo(&subsc, "ViperCell");
+ ludbSetSubscInfoExists(ludb_id, true);
+ gLUDB.update(ludb_id, subsc);
+
+ bool status = sendEmergRspToMM(mmId, ludb_id);
+ if(!status){
+ ludbEntryInit(ludb_id);
+ }
+ }
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_MM_RemEmergReqProc(short mmId, short ludb_id)
+{
+ DBG_FUNC("LUDB_MM_RemEmergReqProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ if(ludb_id != -1){
+ LUDBEntry::LUDBState state = gLUDB.getState(ludb_id);
+ if(state == LUDBEntry::EMERGENCY){
+ ludbEntryInit(ludb_id);
+ }
+ else{
+ DBG_ERROR("ludb entry not expecting REM_EMERG_REQ %d\n", ludb_id);
+ }
+ }
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_MM_RegReqProc(T_CNI_RIL3_IE_MOBILE_ID& mobile_id, short mmId)
+{
+ DBG_FUNC("LUDB_MM_RegReqProc", LUDB_LAYER);
+ DBG_ENTER();
+ short ludb_id = gLUDB.getEntry(mobile_id);
+
+ if(ludb_id == JCC_ERROR){ // mobile doesn't exist in LUDB
+ ludb_id = gLUDB.registerUser(mobile_id);
+ if(ludb_id != JCC_ERROR){
+ bool status = sendMobileRegReq(mobile_id, mmId, ludb_id, ludb_auth_required);
+ if(!status){
+ ludbEntryInit(ludb_id);
+ sendMobileRegRejToMM(mmId, CNI_RIL3_REJECT_NETWORK_FAILURE);
+ }
+ }
+ else{
+ DBG_ERROR("registerUser failed\n");
+ sendMobileRegRejToMM(mmId, CNI_RIL3_REJECT_CONGESTION);
+ }
+ }
+ else{ // mobile exists in LUDB
+ LUDBEntry::LUDBState state = gLUDB.getState(ludb_id);
+// if(state == LUDBEntry::ACTIVE){
+// sendMobileRegCnfToMM(mmId, ludb_id);
+// }
+// else if((state == LUDBEntry::INACTIVE)||
+// (state == LUDBEntry::LUUNREGISTRJ)){
+ if((state == LUDBEntry::ACTIVE)||
+ (state == LUDBEntry::UNREGREQ) ||
+ (state == LUDBEntry::INACTIVE)){
+ bool status = sendMobileRegReq(mobile_id, mmId, ludb_id, ludb_auth_required);
+ if(!status){
+ ludbEntryInit(ludb_id);
+ sendMobileRegRejToMM(mmId, CNI_RIL3_REJECT_NETWORK_FAILURE);
+ }
+ }
+ else{
+ DBG_ERROR("Ignored: LUDB entry %d was waiting for Network response.\n", ludb_id);
+ sendMobileRelReqToMM(mmId);
+ }
+ }
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_MM_UnRegReqProc(T_CNI_RIL3_IE_MOBILE_ID& mobile_id, short mmId)
+{
+ DBG_FUNC("LUDB_MM_UnRegReqProc", LUDB_LAYER);
+ DBG_ENTER();
+ short ludb_id = gLUDB.getEntry(mobile_id);
+
+ if(ludb_id != JCC_ERROR){ // mobile exists in LUDB
+ LUDBEntry::LUDBState state = gLUDB.getState(ludb_id);
+
+ if((state == LUDBEntry::UNREGREQ) ||
+ (state == LUDBEntry::INACTIVE)) {
+ sendMobileUnRegRejToMM(mmId);
+ }
+ else{
+ ludbStartPurgeTimer(ludb_id);
+ gLUDB.update(ludb_id, LUDBEntry::INACTIVE);
+ bool status = sendMobileUnRegCnfToMM(mmId);
+ if(!status) {
+ DBG_ERROR("UnRegistration Confirm send to MM failed\n");
+ }
+
+ // VOIP_MOBILE_HANDLE mobile_handle = gLUDB.getMobileHandle(ludb_id);
+ // DBG_TRACE("Unregister mobile handle %d\n", (int)mobile_handle);
+ // bool status = sendMobileUnRegReq(mobile_handle, mmId, ludb_id);
+ // if(!status){
+ // sendMobileUnRegRejToMM(mmId);
+ // }
+ }
+ }
+ else{ // mobile doesn't exist in LUDB
+ DBG_ERROR("Received IMSI Detach but Mobile not in LUDB\n");
+ sendMobileUnRegRejToMM(mmId);
+ }
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_MM_SecReqProc(short mm_id, short ludb_id)
+{
+ DBG_FUNC("LUDB_MM_SecReqProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ T_CNI_RIL3_IE_MOBILE_ID mobile_id = ludbGetMobileId(ludb_id);
+ ludbSetMMId(ludb_id, mm_id);
+
+ bool status = sendMobileSecInfoReq(mobile_id, mm_id, ludb_id, 0);
+ if(!status) {
+ DBG_ERROR("Security Request send to VB failed\n");
+ }
+
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_MM_CipherSetProc(short mm_id, short ludb_id, short algo)
+{
+ DBG_FUNC("LUDB_MM_CipherSetProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ ludbSetCipherAlgo(ludb_id, algo);
+
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_MM_MsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_MM_MsgProc", LUDB_LAYER);
+ DBG_ENTER();
+ short mmId = inMsg->mm_id;
+ T_CNI_RIL3_IE_MOBILE_ID mobile_id;
+
+ switch(inMsg->msg_type)
+ {
+ case LUDB_MM_REG_REQ:
+ DBG_TRACE("LUDB_MM_REG_REQ Received mmId %d\n", mmId);
+ mobile_id = inMsg->mobile_id;
+ LUDB_MM_RegReqProc(mobile_id, mmId);
+ break;
+
+ case LUDB_MM_UNREG_REQ:
+ DBG_TRACE("LUDB_MM_UNREG_REQ Received mmId %d\n", mmId);
+ mobile_id = inMsg->mobile_id;
+ LUDB_MM_UnRegReqProc(mobile_id, mmId);
+ break;
+
+ case LUDB_MM_SEC_REQ:
+ DBG_TRACE("LUDB_MM_SEC_REQ Received mmId %d\n", mmId);
+ LUDB_MM_SecReqProc(mmId, inMsg->ludb_id);
+ break;
+
+ case LUDB_MM_EMERG_REQ:
+ DBG_TRACE("LUDB_MM_EMERG_REQ Received mmId %d\n", mmId);
+ mobile_id = inMsg->mobile_id;
+ LUDB_MM_EmergReqProc(mobile_id, mmId);
+ break;
+
+ case LUDB_MM_REM_EMERG_REQ:
+ DBG_TRACE("LUDB_MM_REM_EMERG_REQ Received mmId %d\n", mmId);
+ LUDB_MM_RemEmergReqProc(mmId, inMsg->ludb_id);
+ break;
+
+ case LUDB_MM_CIPHER_SET:
+ DBG_TRACE("LUDB_MM_CIPHER_SET Received ludbId %d\n", inMsg->ludb_id);
+ LUDB_MM_CipherSetProc(mmId, inMsg->ludb_id, inMsg->algo);
+ break;
+
+
+
+ default:
+ DBG_ERROR("Ludb Error:Unexpected message type %d\n", inMsg->msg_type);
+ }
+ DBG_LEAVE();
+}
+
diff --git a/data/mnet/GP10/Host/jcc/src/LUDBOamMsgProc.cpp b/data/mnet/GP10/Host/jcc/src/LUDBOamMsgProc.cpp new file mode 100644 index 0000000..adcec7d --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/LUDBOamMsgProc.cpp @@ -0,0 +1,88 @@ +// *******************************************************************
+//
+// (c) Copyright Cisco 2000
+// All Rights Reserved
+//
+// *******************************************************************
+
+// *******************************************************************
+//
+// Version : 1.0
+// Status : Under development
+// File : LudbOamMsgProc.cpp
+// Author(s) : Kevin Lim
+// Create Date : 09-09-99
+// Description :
+//
+// *******************************************************************
+
+// *******************************************************************
+// Include Files.
+// *******************************************************************
+
+#include "stdio.h"
+#include "string.h"
+#include "LOGGING/vcmodules.h"
+#include "LOGGING/vclogging.h"
+#include "oam_api.h"
+
+// Ludb Message Constants
+#include "LudbOamMsgProc.h"
+#include "JCC/LudbApi.h"
+
+// OAM Config Data
+
+// Global variable for Message Queue
+extern MSG_Q_ID ludbMsgQId;
+
+
+// ****************************************************************************
+void ludbHandleOpStChanged(INT32 value)
+{
+ DBG_FUNC("ludbHandleOpStChange", LUDB_LAYER);
+ DBG_ENTER();
+ if(value){
+ }
+ else{
+ ludbDataInit();
+ }
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void ludbHandleAuthFreqChanged(INT32 value)
+{
+ DBG_FUNC("ludbHandleAuthFreqChange", LUDB_LAYER);
+ DBG_ENTER();
+ ludbSetAuthFreq((int)value);
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+void LUDB_OAM_MsgProc(TrapMsg *trapMsg)
+{
+ DBG_FUNC("LUDB_OAM_MsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ if(trapMsg->valType != VT_VALUE){
+ DBG_ERROR("Unexpected valType from OAM trap message: %d\n", trapMsg->valType);
+ DBG_LEAVE();
+ return;
+ }
+
+ switch(trapMsg->mibTag)
+ {
+ case MIB_bts_operationalState:
+ DBG_TRACE("ludbOpStatus MIB Trap received : %d\n", trapMsg->val.varVal);
+ ludbHandleOpStChanged(trapMsg->val.varVal);
+ break;
+ case MIB_rm_nim_0_7:
+ DBG_TRACE("ludbOpStatus MIB Trap received : %d\n", trapMsg->val.varVal);
+ ludbHandleAuthFreqChanged(trapMsg->val.varVal);
+ break;
+
+ default:
+ DBG_ERROR("Unexpected mib tag %d\n", trapMsg->mibTag);
+ }
+ DBG_LEAVE();
+}
diff --git a/data/mnet/GP10/Host/jcc/src/LUDBTask.cpp b/data/mnet/GP10/Host/jcc/src/LUDBTask.cpp new file mode 100644 index 0000000..6dee184 --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/LUDBTask.cpp @@ -0,0 +1,207 @@ +// *******************************************************************
+//
+// (c) Copyright Cisco 2000
+// All Rights Reserved
+//
+// *******************************************************************
+
+// *******************************************************************
+//
+// Version : 1.0
+// Status : Under development
+// File : LUDBTask.cpp
+// Author(s) : Kevin S. Lim
+// Create Date : 04-27-99
+// Description :
+//
+// *******************************************************************
+
+// *******************************************************************
+// Include Files.
+// *******************************************************************
+
+#include "stdLib.h"
+#include "vxWorks.h"
+#include "taskLib.h"
+#include "usrLib.h"
+#include "errnoLib.h"
+#include "string.h"
+
+#include "Os/JCTask.h"
+#include "Os/JCModule.h"
+#include "GP10OsTune.h"
+#include "LOGGING//vcmodules.h"
+#include "LOGGING/vclogging.h"
+#include "oam_api.h"
+
+// included L3 Message header for messages from other Layer 3 modules
+#include "JCC/JCCL3Msg.h"
+
+#include "JCC/JCCUtil.h"
+#include "JCC/JCCTimer.h"
+
+#include "JCC/Ludb.h"
+#include "JCC/LUDBConfig.h"
+#include "JCC/LUDBApi.h"
+#include "JCC/LUDBMmMsgProc.h"
+
+#include "LUDBVoipMsgProc.h"
+#include "LUDBOamMsgProc.h"
+#include "LUDBTimerProc.h"
+#include "LudbHashTbl.h"
+
+extern LudbHashTbl *ludbImsiHash;
+
+extern MSG_Q_ID ludbMsgQId;
+JCTask ludbTaskObj("LUDBTask");
+
+// function forward declaration
+int ludbTaskMain();
+void ludbTaskInit();
+
+
+// ****************************************************************************
+int SysCommand_Ludb(T_SYS_CMD action)
+{
+ int tid;
+
+ switch(action){
+ case SYS_SHUTDOWN:
+ printf("[LUDB] Received system shutdown notification\n");
+ ludbDataPrint();
+ break;
+ case SYS_START:
+ printf("[LUDB] Received task start notification\n");
+ ludbTaskInit();
+ tid = ludbTaskObj.JCTaskSpawn(
+ LUDB_TASK_PRIORITY,
+ LUDB_TASK_OPTION,
+ LUDB_TASK_STACK_SIZE,
+ (FUNCPTR)ludbTaskMain,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ MODULE_LUDB, JC_CRITICAL_TASK);
+ break;
+ case SYS_REBOOT:
+ delete ludbImsiHash;
+ printf("[LUDB] Reboot ready.\n");
+ break;
+ default:
+ printf("[LUDB] Unknown system command received\n");
+ }
+ return 0;
+}
+
+// *******************************************************************
+void ludbCfgRead()
+{
+ INT_32_T oam_freq;
+ DBG_FUNC("ludbCfgRead", MM_LAYER);
+ DBG_ENTER();
+
+ STATUS ret;
+
+ if(ret = oam_getMibIntVar(MIB_rm_nim_0_7, &oam_freq)){
+ DBG_ERROR("Failed to initialize auth_freq with OAM:%d\n", ret);
+ DBG_ERROR("Initialized with hard coded default values.\n");
+ }
+ else{
+ ludbHandleAuthFreqChanged(oam_freq);
+ }
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void ludbSetOAMTraps()
+{
+ DBG_FUNC("ludbSetOAMTraps", LUDB_LAYER);
+ DBG_ENTER();
+ STATUS oamStatus;
+
+ if((oamStatus = oam_setTrap(MODULE_LUDB, ludbMsgQId, MIB_bts_operationalState))
+ != STATUS_OK){
+ DBG_ERROR("oam_setTrap failed (stauts=%d) on MIB_bts_operationalState\n", oamStatus);
+ }
+ if((oamStatus = oam_setTrap(MODULE_LUDB, ludbMsgQId, MIB_rm_nim_0_7))
+ != STATUS_OK){
+ DBG_ERROR("oam_setTrap failed (stauts=%d) on MIB_rm_nim_0_7\n", oamStatus);
+ }
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void ludbTaskInit()
+{
+ DBG_FUNC("ludbTaskInit", LUDB_LAYER);
+ DBG_ENTER();
+
+ ludbCfgRead();
+
+ ludbDataInit();
+
+ ludbImsiHash = new LudbHashTbl(LUDB_IMSI_HASH_NUM_BUCKET, LUDB_MAX_IMSI_KEY_LEN);
+
+ // create message queue
+ ludbMsgQId = msgQCreate(LUDB_MAX_INCOMING_MSG,
+ LUDB_MAX_MSG_LENGTH,
+ MSG_Q_FIFO);
+
+ if(ludbMsgQId == NULL){
+ DBG_ERROR("Fatal Error on msgQCreate : %d\n", errnoGet());
+ return;
+ }
+
+ ludbSetOAMTraps();
+
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+int ludbTaskMain()
+{
+ DBG_FUNC("ludbTaskMain", LUDB_LAYER);
+ DBG_ENTER();
+
+ char inMsg[LUDB_MAX_MSG_LENGTH];
+
+ ludbTaskObj.JCTaskEnterLoop();
+
+ while(true)
+ {
+ if(msgQReceive( ludbMsgQId, inMsg,
+ LUDB_MAX_MSG_LENGTH,
+ WAIT_FOREVER)
+ == ERROR)
+ {
+ DBG_ERROR("Fatal Error on msgQReceive : %d\n", errnoGet());
+ DBG_LEAVE();
+ return ERROR;
+ }
+
+ switch(inMsg[0]){
+ case MODULE_MM:
+ LUDB_MM_MsgProc((LudbMsgStruct *)inMsg);
+ break;
+
+ case MODULE_H323:
+ LUDB_VBLINK_MsgProc((LudbMsgStruct *)inMsg);
+ break;
+
+ case MODULE_OAM:
+ LUDB_OAM_MsgProc((TrapMsg *)inMsg);
+ break;
+
+ case MODULE_LUDB:
+ LudbTimerMsgProc((LudbMsgStruct *)inMsg);
+ break;
+
+ default:
+ DBG_ERROR("Message from unexpected Module: %d\n", inMsg[0]);
+ DBG_LEAVE();
+ return ERROR;
+ }
+ }
+ ludbTaskObj.JCTaskNormExit();
+ DBG_LEAVE();
+ return 0;
+}
+
diff --git a/data/mnet/GP10/Host/jcc/src/LUDBTimerProc.cpp b/data/mnet/GP10/Host/jcc/src/LUDBTimerProc.cpp new file mode 100644 index 0000000..fff946c --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/LUDBTimerProc.cpp @@ -0,0 +1,84 @@ +// *******************************************************************
+//
+// (c) Copyright Cisco 2000
+// All Rights Reserved
+//
+// *******************************************************************
+
+// *******************************************************************
+//
+// Version : 1.0
+// Status : Under development
+// File : LudbTimerProc.cpp
+// Author(s) : Kevin Lim
+// Create Date : 07-26-99
+// Description :
+//
+// *******************************************************************
+
+// #define DEBUG_MM_HANDOVER
+// #define DEBUG_MM_HANDOVER_EFR
+
+// *******************************************************************
+// Include Files.
+// *******************************************************************
+
+#include "taskLib.h"
+#include "stdLib.h"
+#include "string.h"
+#include "LOGGING/vcmodules.h"
+#include "LOGGING/vclogging.h"
+#include "oam_api.h"
+
+// included L3 Message header for messages from other Layer 3 modules (CC, RR)
+#include "JCC/JCCL3Msg.h"
+
+#include "JCC/JCCUtil.h"
+#include "JCC/JCCTimer.h"
+
+// MM Message Constants
+#include "JCC/LUDB.h"
+#include "JCC/LUDBApi.h"
+#include "JCC/LUDBMMMsgProc.h"
+#include "LUDBVoipMsgProc.h"
+
+extern LUDB gLUDB;
+
+// ****************************************************************************
+void LudbTimerMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_Timer_MsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = inMsg->ludb_id;
+ short mmId = ludbGetMMId(ludb_id);
+ bool status;
+ switch(inMsg->msg_type)
+ {
+ case LUDB_VBREQ_TIMEOUT:
+ DBG_TRACE("ludb %d vb request timeout\n", ludb_id);
+ status = sendMobileRegRejToMM(mmId, CNI_RIL3_REJECT_NETWORK_FAILURE);
+ if(!status) {
+ DBG_ERROR("Registration Reject send to MM failed\n");
+ }
+ if(gLUDB.getState(ludb_id) == LUDBEntry::SECREQ)
+ gLUDB.update(ludb_id, LUDBEntry::ACTIVE);
+ else
+ ludbEntryInit(ludb_id);
+ break;
+ case LUDB_PURGE_TIMEOUT:
+ DBG_TRACE("ludb %d purge timeout\n", ludb_id);
+
+ T_CNI_RIL3_IE_MOBILE_ID mobile_id = ludbGetMobileId(ludb_id);
+ status = sendMobileUnRegReq(mobile_id, mmId, ludb_id);
+ if(!status){
+ DBG_ERROR("UnRegistration Request send to VB failed\n");
+ }
+ // ludbEntryInit(ludb_id);
+ break;
+ default:
+ DBG_TRACE("Unknown message received from Timer, Msg Type: %d\n", inMsg->msg_type);
+ }
+ DBG_LEAVE();
+}
+
diff --git a/data/mnet/GP10/Host/jcc/src/LUDBVoipMsgProc.cpp b/data/mnet/GP10/Host/jcc/src/LUDBVoipMsgProc.cpp new file mode 100644 index 0000000..270f438 --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/LUDBVoipMsgProc.cpp @@ -0,0 +1,714 @@ +// *******************************************************************
+//
+// (c) Copyright Cisco 2000
+// All Rights Reserved
+//
+// *******************************************************************
+
+// *******************************************************************
+//
+// Version : 1.0
+// Status : Under development
+// File : LUDBVoipMsgProc.cpp
+// Author(s) : Kevin S. Lim
+// Create Date : 07-31-99
+// Description :
+//
+// *******************************************************************
+
+// *******************************************************************
+// Include Files.
+// *******************************************************************
+
+#include "stdLib.h"
+#include "vxWorks.h"
+#include "taskLib.h"
+#include "sysLib.h"
+#include "usrLib.h"
+#include "errnoLib.h"
+#include "string.h"
+
+#include "LOGGING/vcmodules.h"
+#include "LOGGING/vclogging.h"
+
+// included L3 Message header for messages from other Layer 3 modules
+#include "JCC/JCCL3Msg.h"
+
+#include "JCC/JCCUtil.h"
+#include "JCC/JCCTimer.h"
+
+#include "JCC/LUDB.h"
+#include "JCC/LUDBConfig.h"
+#include "JCC/LUDBApi.h"
+#include "JCC/LUDBMMMsgProc.h"
+
+#include "LUDBVoipMsgProc.h"
+
+#include "voip/vblink.h"
+#include "cc/cc_util_ext.h"
+
+extern LUDB gLUDB;
+extern short ludb_auth_required;
+
+extern void ludbMakeDefaultSubscMsg(char *msg, short *size);
+
+bool ludbRunRegTest = false;
+T_CNI_RIL3_IE_MOBILE_ID ludbRunRegTestMob;
+WDOG_ID ludbRunRegTestWID;
+int ludbRunRegTestTick;
+
+bool ludbAutoLog = false;
+
+bool ludb_auth_testmode = false;
+char ludb_auth_testcksn = 0;
+T_AUTH_TRIPLET cipher_testtriplet;
+
+// ****************************************************************************
+// StartAuthMode sets test mode for Authentication testing.
+// ****************************************************************************
+int StartAuthMode(int cksn, unsigned char lsb)
+{
+ int i;
+ if(ludb_auth_testmode){
+ printf("[LUDB] Test Authentication Mode already turned on.\n");
+ return -1;
+ }
+ else{
+ ludb_auth_testmode = 1;
+ ludb_auth_required = 1;
+ if(cksn >= 7)
+ printf(" CKSN value should be smaller than 7\n");
+ else
+ ludb_auth_testcksn = cksn;
+
+ for(i=0; i<SEC_RAND_LEN; i++) cipher_testtriplet.RAND[i] = 0xFF;
+ cipher_testtriplet.RAND[SEC_RAND_LEN-1] = lsb;
+
+ printf("\n[LUDB] Test Authentication Mode is now turned on.\n");
+ printf("(Mobile Location Update will initiate authentication without VB auth.)\n\n");
+ printf("StartAuthMode(cksn=%d, Random LSB=0x%x)\n", cksn, lsb);
+ printf("Random is set to: 0x");
+ for(i=0; i<SEC_RAND_LEN; i++) printf("%02x", cipher_testtriplet.RAND[i]);
+ printf("\n");
+ return 0;
+ }
+}
+
+// ****************************************************************************
+int StopAuthMode()
+{
+ if(!ludb_auth_testmode){
+ printf("[LUDB] Test Authentication Mode already turned off.\n");
+ return -1;
+ }
+ else{
+ ludb_auth_testmode = 0;
+ ludb_auth_required = 0;
+ printf("[LUDB] Test Authentication Mode is now turned off.\n");
+ printf(" (Mobile Location Update will work normal.)\n");
+ return 0;
+ }
+}
+
+// ****************************************************************************
+void ludbSendRegTest()
+{
+ if(!ludbRunRegTest) return;
+
+ short ludbId = ludbGetEntryByMobileId(ludbRunRegTestMob);
+
+ bool status;
+ if(ludbId > -1){
+ printf("\n[LUDB] Sending UnReg Request.\n");
+ status = VBLinkUnregisterMobile(ludbRunRegTestMob);
+ if(!status) {
+ printf("UnRegistration API call unsuccessful\n");
+ }
+ else{
+ printf("ludb %d ->VBLink MobileUnRegRequest\n", ludbId);
+ ludbStartVBReqTimer(ludbId);
+ gLUDB.update(ludbId, LUDBEntry::UNREGREQ);
+ }
+ }
+ else{
+ ludbId = gLUDB.registerUser(ludbRunRegTestMob);
+ printf("\n[LUDB] Sending Reg Request.\n");
+ status = VBLinkRegisterMobile(ludbRunRegTestMob);
+ if(!status) {
+ printf("Registration API call unsuccessful\n");
+ }
+ else{
+ printf("ludb %d ->VBLink MobileRegRequest\n", ludbId);
+ ludbStartVBReqTimer(ludbId);
+ gLUDB.update(ludbId, LUDBEntry::REGREQ);
+ }
+ }
+
+ if(ludbRunRegTest){
+ if(wdStart(ludbRunRegTestWID, ludbRunRegTestTick,
+ (FUNCPTR)ludbSendRegTest, ludbId)){
+ printf("[LUDB] wdStart Error!\n");
+ }
+ }
+
+}
+
+// ****************************************************************************
+int ludbRegTestStart(char *imsi, int interval)
+{
+ if(imsi == 0){
+ printf("usage: ludbRegTestStart(char *imsi, int interval) - interval in seconds\n");
+ return -1;
+ }
+ if(interval == 0){
+ printf("usage: ludbRegTestStart(char *imsi, int interval) - interval in seconds\n");
+ return -1;
+ }
+ if(ludbRunRegTest){
+ printf("[LUDB] RegTest already started.\n");
+ return -1;
+ }
+ else{
+ printf("[LUDB] RegTest is now started.\n");
+ printf("[LUDB] IMSI: %s\n", imsi);
+ printf("[LUDB] every %d seconds\n", interval);
+ int len = strlen(imsi);
+
+ ludbRunRegTestMob.mobileIdType = CNI_RIL3_IMSI;
+ ludbRunRegTestMob.ie_present = true;
+ ludbRunRegTestMob.numDigits = len;
+ for(int i=0; i<len; i++){
+ ludbRunRegTestMob.digits[i] = imsi[i] - '0';
+ }
+ ludbRunRegTest = true;
+ ludbRunRegTestWID = wdCreate();
+ ludbRunRegTestTick = interval * sysClkRateGet();
+ ludbSendRegTest();
+ return 0;
+ }
+}
+
+// ****************************************************************************
+int ludbRegTestStop()
+{
+ if(!ludbRunRegTest){
+ printf("[LUDB] RegTest already stopped.\n");
+ return -1;
+ }
+ else{
+ printf("[LUDB] RegTest is now stopped.\n");
+ ludbRunRegTest = false;
+
+ return 0;
+ }
+}
+
+// ****************************************************************************
+// message sent to vblink
+// RRQ
+// URQ
+// SRQ
+// ****************************************************************************
+bool sendMobileRegReq( T_CNI_RIL3_IE_MOBILE_ID& mobileId, short mmId, short ludbId, short fSec)
+{
+ DBG_FUNC("sendMobileRegReq", LUDB_LAYER);
+ DBG_ENTER();
+
+ ludbStopPurgeTimer(ludbId); // stop purge timer if it was running
+
+ ludbSetMMId(ludbId, mmId);
+
+ bool status = VBLinkRegisterMobile(mobileId);
+ if(!status) {
+ DBG_ERROR("Registration API call unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ else{
+ DBG_TRACE("ludb %d ->VBLink MobileRegRequest\n", ludbId);
+ ludbStartVBReqTimer(ludbId);
+ if(fSec)
+ gLUDB.update(ludbId, LUDBEntry::REGTHENSEC);
+ else
+ gLUDB.update(ludbId, LUDBEntry::REGREQ);
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileUnRegReq( T_CNI_RIL3_IE_MOBILE_ID& mobileId, short mmId, short ludbId)
+{
+ DBG_FUNC("sendMobileUnRegReq", LUDB_LAYER);
+ DBG_ENTER();
+
+ bool status = VBLinkUnregisterMobile(mobileId);
+ if(!status) {
+ DBG_ERROR("UnRegistration API call unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ else{
+ DBG_TRACE("ludb %d ->VBLink MobileUnRegRequest\n", ludbId);
+ ludbStartVBReqTimer(ludbId);
+ gLUDB.update(ludbId, LUDBEntry::UNREGREQ);
+ }
+ DBG_LEAVE();
+ return true;
+}
+
+// ****************************************************************************
+bool sendMobileSecInfoReq( T_CNI_RIL3_IE_MOBILE_ID& mobileId, short mmId, short ludbId, short fReg)
+{
+ DBG_FUNC("sendMobileSecInfoReq", LUDB_LAYER);
+ DBG_ENTER();
+
+ ludbSetMMId(ludbId, mmId);
+
+ bool status = VBLinkSecurityRequest(mobileId);
+ if(!status) {
+ DBG_ERROR("Security Info Req API call unsuccessful\n");
+ DBG_LEAVE();
+ return false;
+ }
+ else{
+ DBG_TRACE("ludb %d ->VBLink SecurityInfoRequest\n", ludbId);
+ ludbStartVBReqTimer(ludbId);
+ if(fReg)
+ gLUDB.update(ludbId, LUDBEntry::SECINREG);
+ else
+ gLUDB.update(ludbId, LUDBEntry::SECREQ);
+ }
+
+ DBG_LEAVE();
+ return true;
+}
+
+// *******************************************************************
+// message received from vblink
+// RCF
+// RRJ
+// UCF
+// URJ
+// SPI
+// SRS
+// URQ
+// *******************************************************************
+void LUDB_VBLINK_RCFMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_RCFMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received RCF on entry that can't be found by mobile_id\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ DBG_TRACE("ludb %d registration confirmed\n", ludb_id);
+ ludbStopVBReqTimer(ludb_id);
+
+ if(ludbRunRegTest){
+ printf("[LUDB] Registration Confirm Received.\n");
+ gLUDB.update(ludb_id, LUDBEntry::ACTIVE);
+ return;
+ }
+
+/* shmin 08/20 changed mcpla: this funtion to Profile function
+
+ short mmId = ludbGetMMId(ludb_id);
+ if(mmId == -1){
+ DBG_ERROR("Received RCF on entry that has no mm_id set\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ LUDBEntry::LUDBState state = gLUDB.getState(ludb_id);
+ bool status;
+ if(state == LUDBEntry::REGREQ){
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 0);
+ if(!status) {
+ DBG_ERROR("Registration Confirm send to MM failed\n");
+ }
+ }
+ else if(state == LUDBEntry::REGTHENSEC){
+ if(ludb_auth_testmode){
+ DBG_TRACE("auth_testmode encountered. bypass sec req to VB.\n");
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 0);
+ DBG_LEAVE();
+ return;
+ }
+
+ short ret = ludbCheckAuthCount(ludb_id);
+ if(ret == 0){ // okay to use the cureent security key
+ DBG_TRACE("Reuse Security Key for ludb %d\n", ludb_id);
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 0);
+ if(!status) {
+ DBG_ERROR("Registration Confirm send to MM failed\n");
+ }
+ }
+ else if(ret == 1){ // get a new set
+ DBG_TRACE("Get a new Security Key for ludb %d\n", ludb_id);
+ status = sendMobileSecInfoReq(inMsg->mobile_id, mmId, ludb_id, 1);
+ if(!status) {
+ DBG_ERROR("SecReq after RegCnf to VB failed\n");
+ }
+ }
+ else if(ret == -1){
+ DBG_ERROR("possible error: ludb_id out of bound\n");
+ }
+ }
+ else{
+ DBG_ERROR("unknown state in RegCnf: %d\n", state);
+ }
+*/
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void LUDB_VBLINK_RRJMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_RRJMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received RRJ on entry that can't be found by mobile_id\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ DBG_TRACE("ludb %d registration rejected by VBLINK\n", ludb_id);
+ ludbStopVBReqTimer(ludb_id);
+
+ if(ludbRunRegTest){
+ printf("[LUDB] Registration Reject Received. ludb_id %d\n", ludb_id);
+ ludbEntryInit(ludb_id);
+ return;
+ }
+
+ short mmId = ludbGetMMId(ludb_id);
+ if(mmId == -1){
+ DBG_ERROR("Received RRJ on entry that has no mm_id set\n");
+ DBG_LEAVE();
+ return;
+ }
+ bool status = sendMobileRegRejToMM(mmId, CNI_RIL3_REJECT_NATIONAL_ROAMING_NOT_ALLOWED);
+ if(!status) {
+ DBG_ERROR("Registration Reject send to MM failed\n");
+ }
+
+ ludbEntryInit(ludb_id);
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void LUDB_VBLINK_UCFMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_UCFMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received UCF on entry that can't be found by mobile_id\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ DBG_TRACE("ludb %d unregistration confirmed\n", ludb_id);
+ ludbStopVBReqTimer(ludb_id);
+
+// VOIP_MOBILE_HANDLE mobile_handle = VOIP_NULL_MOBILE_HANDLE;
+// gLUDB.update(ludb_id, mobile_handle);
+// ludbStartPurgeTimer(ludb_id);
+// gLUDB.update(ludb_id, LUDBEntry::INACTIVE);
+
+// short mmId = ludbGetMMId(ludb_id);
+// bool status = sendMobileUnRegCnfToMM(mmId);
+// if(!status) {
+// DBG_ERROR("UnRegistration Confirm send to MM failed\n");
+// }
+
+ ludbEntryInit(ludb_id);
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void LUDB_VBLINK_URJMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_URJMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received URJ on entry that can't be found by mobile_id\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ DBG_TRACE("ludb %d unregistration rejected by VBLINK\n", ludb_id);
+ ludbStopVBReqTimer(ludb_id);
+
+ short mmId = ludbGetMMId(ludb_id);
+
+ bool status = sendMobileUnRegRejToMM(mmId);
+ if(!status) {
+ DBG_ERROR("UnRegistration Reject send to MM failed\n");
+ }
+
+ ludbEntryInit(ludb_id);
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void LUDB_VBLINK_SPIMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_PRSMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received SPI on entry that can't be found by mobile_id\n");
+ ludb_id = gLUDB.registerUser(inMsg->mobile_id);
+ if(ludb_id < 0){
+ DBG_LEAVE();
+ return;
+ }
+ ludbStopVBReqTimer(ludb_id);
+ gLUDB.update(ludb_id, LUDBEntry::ACTIVE);
+ }
+
+ DBG_TRACE("ludb %d user profile received\n", ludb_id);
+
+ short size = (short)inMsg->vb_msg_size;
+ char vb_msg[400];
+ char *msg;
+
+ if(size > VB_MAX_MSG_LENGTH){
+ DBG_ERROR("Profile from ViperBase is too large\n");
+ DBG_LEAVE();
+ return;
+ }
+ else if(size == 0) {
+ msg = vb_msg;
+ ludbMakeDefaultSubscMsg(msg, &size);
+ }
+ else{
+ msg = inMsg->vb_msg;
+ }
+
+ short ret = ludbSetDecodeSubscInfo(ludb_id, (unsigned char *)msg, size);
+ if(ret){
+ DBG_ERROR("ludbSetDecodeSubscInfo returned Error\n");
+ printSubscMsg((unsigned char *)msg, size);
+ }
+ else{
+ ludbSetSubscInfoExists(ludb_id, true);
+ }
+ short mmId = ludbGetMMId(ludb_id);
+ if(mmId == -1){
+ DBG_ERROR("Received RCF on entry that has no mm_id set\n");
+ DBG_LEAVE();
+ return;
+ }
+
+// shmin 08/20 mcpla function change the RegCnfToMM message to here
+
+ LUDBEntry::LUDBState state = gLUDB.getState(ludb_id);
+ bool status;
+ if(state == LUDBEntry::REGREQ){
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 0);
+ if(!status) {
+ DBG_ERROR("Registration Confirm send to MM failed\n");
+ }
+ }
+ else if(state == LUDBEntry::REGTHENSEC){
+ if(ludb_auth_testmode){
+ DBG_TRACE("auth_testmode encountered. bypass sec req to VB.\n");
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 0);
+ DBG_LEAVE();
+ return;
+ }
+
+ short ret = ludbCheckAuthCount(ludb_id);
+ if(ret == 0){ // okay to use the cureent security key
+ DBG_TRACE("Reuse Security Key for ludb %d\n", ludb_id);
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 0);
+ if(!status) {
+ DBG_ERROR("Registration Confirm send to MM failed\n");
+ }
+ }
+ else if(ret == 1){ // get a new set
+ DBG_TRACE("Get a new Security Key for ludb %d\n", ludb_id);
+ status = sendMobileSecInfoReq(inMsg->mobile_id, mmId, ludb_id, 1);
+ if(!status) {
+ DBG_ERROR("SecReq after RegCnf to VB failed\n");
+ }
+ }
+ else if(ret == -1){
+ DBG_ERROR("possible error: ludb_id out of bound\n");
+ }
+ }
+ else{
+ DBG_ERROR("unknown state in RegCnf: %d\n", state);
+ }
+
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void LUDB_VBLINK_SRSMsgProc(LudbMsgStruct *inMsg)
+{
+ short AuC_failure = 0;
+
+ DBG_FUNC("LUDB_VBLINK_SRSMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received SRS on entry that can't be found by mobile_id\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ DBG_TRACE("ludb %d security info received\n", ludb_id);
+ ludbStopVBReqTimer(ludb_id);
+
+ if(inMsg->vb_msg_size == 1){
+ T_AUTH_TRIPLET triplet;
+ memcpy((char *)&triplet, inMsg->vb_msg, sizeof(T_AUTH_TRIPLET));
+ gLUDB.update(ludb_id, triplet);
+ }
+ else{
+ AuC_failure = 1;
+ DBG_TRACE("!!!!zero SRS!!!!\n");
+ }
+
+ short mmId = ludbGetMMId(ludb_id);
+ if(mmId == -1){
+ DBG_ERROR("No mmId in ludb entry for SRS\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ LUDBEntry::LUDBState state = gLUDB.getState(ludb_id);
+ bool status;
+ if(state == LUDBEntry::SECINREG){
+ if(AuC_failure){
+ status = sendMobileRegRejToMM(mmId, CNI_RIL3_REJECT_NETWORK_FAILURE);
+ if(!status) {
+ DBG_ERROR("Registration Reject send to MM failed\n");
+ }
+ status = sendMobileUnRegReq(inMsg->mobile_id, mmId, ludb_id);
+ if(!status){
+ DBG_ERROR("UnRegistration Request send to VB failed\n");
+ }
+ }
+ else{
+ status = sendMobileRegCnfToMM(mmId, ludb_id, 1);
+ if(!status) {
+ DBG_ERROR("Registration Confirm send to MM failed\n");
+ }
+ }
+ }
+ else if(state == LUDBEntry::SECREQ){
+ status = sendMobileSecRspToMM(mmId, ludb_id);
+ if(!status) {
+ DBG_ERROR("Security Info Response send to MM failed\n");
+ }
+ }
+ else{
+ DBG_ERROR("unknown state in SRS\n");
+ }
+ DBG_LEAVE();
+}
+
+// *******************************************************************
+void LUDB_VBLINK_URQMsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_URQMsgProc", LUDB_LAYER);
+ DBG_ENTER();
+
+ short ludb_id = ludbGetEntryByMobileId(inMsg->mobile_id);
+ if(ludb_id == -1){
+ DBG_ERROR("Received URQ on entry that can't be found by mobile_id\n");
+ DBG_LEAVE();
+ return;
+ }
+
+ // <Igal: 04-10-01>
+ // Notify affected CC Sessions
+ CcNotifyPurge (ludb_id);
+ DBG_TRACE("ludb %d unregistered by VBLINK request\n", ludb_id);
+ ludbEntryInit(ludb_id);
+ DBG_LEAVE();
+}
+
+// ****************************************************************************
+// ****************************************************************************
+int ludbAutoLogStart()
+{
+ if(ludbAutoLog){
+ printf("[LUDB] AutoLog already started.\n");
+ return -1;
+ }
+ else{
+ printf("[LUDB] AutoLog is now started.\n");
+ ludbAutoLog = true;
+ return 0;
+ }
+}
+
+// ****************************************************************************
+int ludbAutoLogStop()
+{
+ if(!ludbAutoLog){
+ printf("[LUDB] AutoLog already stopped.\n");
+ return -1;
+ }
+ else{
+ printf("[LUDB] AutoLog is now stopped.\n");
+ ludbAutoLog = false;
+ return 0;
+ }
+}
+
+// *******************************************************************
+void LUDB_VBLINK_MsgProc(LudbMsgStruct *inMsg)
+{
+ DBG_FUNC("LUDB_VBLINK_MsgProc", LUDB_LAYER);
+ DBG_ENTER();
+ // force mobile_id type fields
+ inMsg->mobile_id.ie_present = 1;
+ inMsg->mobile_id.mobileIdType = CNI_RIL3_IMSI;
+ switch(inMsg->msg_type){
+ case VOIP_LUDB_REG_CNF:
+ LUDB_VBLINK_RCFMsgProc(inMsg);
+ break;
+ case VOIP_LUDB_REG_REJ:
+ LUDB_VBLINK_RRJMsgProc(inMsg);
+ break;
+ case VOIP_LUDB_UNREG_CNF:
+ LUDB_VBLINK_UCFMsgProc(inMsg);
+ break;
+ case VOIP_LUDB_UNREG_REJ:
+ LUDB_VBLINK_URJMsgProc(inMsg);
+ break;
+ case VOIP_LUDB_SPI_IND:
+ LUDB_VBLINK_SPIMsgProc(inMsg);
+ break;
+ case VOIP_LUDB_SEC_RSP:
+ LUDB_VBLINK_SRSMsgProc(inMsg);
+ break;
+ case VOIP_LUDB_UNREG_REQ:
+ LUDB_VBLINK_URQMsgProc(inMsg);
+ break;
+ default:
+ DBG_ERROR("Received unknown message type from VOIP: %d\n",
+ inMsg->msg_type);
+ }
+ if((ludbRunRegTest)||(ludbAutoLog)) ludbDataPrint();
+ DBG_LEAVE();
+}
+
diff --git a/data/mnet/GP10/Host/jcc/src/Makefile b/data/mnet/GP10/Host/jcc/src/Makefile new file mode 100644 index 0000000..50a370e --- /dev/null +++ b/data/mnet/GP10/Host/jcc/src/Makefile @@ -0,0 +1,52 @@ +##########################################################
+#
+# (c) Copyright Cisco 2000
+# All Rights Reserved
+#
+##########################################################
+
+# TOP_OF_VOB must be defined before including l3defs.mk
+TOP_OF_VOB = ..\..\..
+
+# These Must be Properly Defined
+THIS_APP_DIR = jcc
+THIS_DIRECTORY = src
+MY_OUTPUT = $(OBJDIR)\$(THIS_APP_DIR).out
+
+# Name(s) of Common VOB directories to include
+COMMON_BLD_DIR =
+
+include $(TOP_OF_VOB)\l3defs.mk
+
+all: makeCommonObjs $(MY_OUTPUT)
+
+# Adds the .o file(s) list needed from the Common VOB
+makeCommonObjs:
+ifneq ($(COMMON_BLD_DIR),)
+ @for %f in ($(COMMON_BLD_DIR)) do \
+ make -C $(COMMON_VOB_APP_DIR)\%f \
+ all VOB=$(VOBNAME) APPDIR=Host\$(THIS_APP_DIR)\$(THIS_DIRECTORY)
+endif
+
+# If Common VOB directories to include get the .o files from bin
+$(MY_OUTPUT): $(MODULE_OBJS)
+ifneq ($(COMMON_BLD_DIR),)
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS) $(wildcard ./bin/*.o)
+else
+ $(LD) -r -o $@.tmp $() $(MODULE_OBJS)
+endif
+ $(NM) $@.tmp | munch > _ctdt.c
+ $(CC) -traditional $(CC_ARCH_SPEC) -c _ctdt.c
+ $(LD) -r -o $@ _ctdt.o $@.tmp
+ $(RM)$(subst /,$(DIRCHAR), _ctdt.c _ctdt.o $@.tmp)
+
+cleanall:
+ @for %f in ($(notdir $(MODULE_OBJS))) do \
+ $(RM) ..\bin\%f
+
+ $(RM) $(MY_OUTPUT)
+
+ifneq ($(COMMON_BLD_DIR),)
+ $(RM) bin\*.o
+ $(RM) bin\*.out
+endif
\ No newline at end of file |