/*=========================================================================== FILE: Gobi3000TranslationWDS.cpp DESCRIPTION: QUALCOMM Translation for Gobi 3000 (WDS Service) Copyright (c) 2011, Code Aurora Forum. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of Code Aurora Forum nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ==========================================================================*/ //--------------------------------------------------------------------------- // Include Files //--------------------------------------------------------------------------- #include "Gobi3000Translation.h" /*=========================================================================== METHOD: ParseGetSessionState DESCRIPTION: This function returns the state of the current packet data session PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pState [ O ] - State of the current packet session RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetSessionState( ULONG inLen, const BYTE * pIn, ULONG * pState ) { // Validate arguments if (pIn == 0 || pState == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the TLV const sWDSGetPacketServiceStatusResponse_Status * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc != eGOBI_ERR_NONE) { return rc; } // Is the TLV large enough? if (outLenx01 < sizeof( sWDSGetPacketServiceStatusResponse_Status )) { return eGOBI_ERR_MALFORMED_RSP; } *pState = pTLVx01->mConnectionStatus; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetSessionDuration DESCRIPTION: This function returns the duration of the current packet data session PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pDuration [ O ] - Duration of the current packet session RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetSessionDuration( ULONG inLen, const BYTE * pIn, ULONGLONG * pDuration ) { // Validate arguments if (pIn == 0 || pDuration == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the TLV const sWDSGetDataSessionDurationResponse_Duration * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc != eGOBI_ERR_NONE) { return rc; } // Is the TLV large enough? if (outLenx01 < sizeof( sWDSGetDataSessionDurationResponse_Duration )) { return eGOBI_ERR_MALFORMED_RSP; } *pDuration = pTLVx01->mDataSessionDuration; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetDormancyState DESCRIPTION: This function returns the dormancy state of the current packet data session (when connected) PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pState [ O ] - Dormancy state of the current packet session RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetDormancyState( ULONG inLen, const BYTE * pIn, ULONG * pState ) { // Validate arguments if (pIn == 0 || pState == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the TLV const sWDSGetDormancyResponse_DormancyStatus * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc != eGOBI_ERR_NONE) { return rc; } // Is the TLV large enough? if (outLenx01 < sizeof( sWDSGetDormancyResponse_DormancyStatus )) { return eGOBI_ERR_MALFORMED_RSP; } *pState = pTLVx01->mDormancyStatus; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetEnhancedAutoconnect DESCRIPTION: This function returns the current autoconnect data session setting PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pSetting [ O ] - NDIS autoconnect setting pRoamSetting [ O ] - NDIS autoconnect roam setting RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetEnhancedAutoconnect( ULONG inLen, const BYTE * pIn, ULONG * pSetting, ULONG * pRoamSetting ) { // Validate arguments if (pIn == 0 || pSetting == 0 || pRoamSetting == 0) { return eGOBI_ERR_INVALID_ARG; } *pSetting = 0xffffffff; *pRoamSetting = 0xffffffff; // Find the first TLV const sWDSGetAutoconnectSettingResponse_Autoconnect * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc != eGOBI_ERR_NONE) { return rc; } // Is the TLV large enough? if (outLenx01 < sizeof( sWDSGetAutoconnectSettingResponse_Autoconnect )) { return eGOBI_ERR_MALFORMED_RSP; } *pSetting = pTLVx01->mAutoconnectSetting; // Find the second TLV (optional) const sWDSGetAutoconnectSettingResponse_Roam * pTLVx10; ULONG outLenx10; rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc == eGOBI_ERR_NONE) { // Is the TLV large enough? if (outLenx10 < sizeof( sWDSGetAutoconnectSettingResponse_Roam )) { return eGOBI_ERR_MALFORMED_RSP; } *pRoamSetting = pTLVx10->mAutoconnectRoamSetting; } return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackSetEnhancedAutoconnect DESCRIPTION: This function sets the autoconnect data session setting PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer setting [ I ] - NDIS autoconnect setting pRoamSetting [ I ] - (Optional) NDIS autoconnect roam setting RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetEnhancedAutoconnect( ULONG * pOutLen, BYTE * pOut, ULONG setting, ULONG * pRoamSetting ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Add setting // Check size WORD tlvx01Sz = sizeof( sWDSSetAutoconnectSettingRequest_Autoconnect ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSSetAutoconnectSettingRequest_Autoconnect * pTLVx01; pTLVx01 = (sWDSSetAutoconnectSettingRequest_Autoconnect*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the value pTLVx01->mAutoconnectSetting = (eQMIWDSAutoconnectSettings)setting; offset += tlvx01Sz; // Add roam setting, if specified if (pRoamSetting != 0) { // Check size WORD tlvx10Sz = sizeof( sWDSSetAutoconnectSettingRequest_Roam ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetAutoconnectSettingRequest_Roam * pTLVx10; pTLVx10 = (sWDSSetAutoconnectSettingRequest_Roam*)(pOut + offset); memset( pTLVx10, 0, tlvx10Sz ); // Set the value pTLVx10->mAutoconnectRoamSetting = (eQMIWDSAutoconnectRoamSettings)*pRoamSetting; offset += tlvx10Sz; } *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackSetDefaultProfile DESCRIPTION: This function writes the default profile settings to the device, the default profile is used during autoconnect pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer profileType [ I ] - Profile type being written pPDPType [ I ] - (Optional) PDP type pIPAddress [ I ] - (Optional) Preferred assigned IPv4 address pPrimaryDNS [ I ] - (Optional) Primary DNS IPv4 address pSecondaryDNS [ I ] - (Optional) Secondary DNS IPv4 address pAuthentication [ I ] - (Optional) Authentication algorithm bitmap pName [ I ] - (Optional) The profile name or description pAPNName [ I ] - (Optional) Access point name pUsername [ I ] - (Optional) Username used during authentication pPassword [ I ] - (Optional) Password used during authentication RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetDefaultProfile( ULONG * pOutLen, BYTE * pOut, ULONG profileType, ULONG * pPDPType, ULONG * pIPAddress, ULONG * pPrimaryDNS, ULONG * pSecondaryDNS, ULONG * pAuthentication, CHAR * pName, CHAR * pAPNName, CHAR * pUsername, CHAR * pPassword ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Add profileType // Check size WORD tlvx01Sz = sizeof( sWDSModifyProfileRequest_ProfileIdentifier ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSModifyProfileRequest_ProfileIdentifier * pTLVx01; pTLVx01 = (sWDSModifyProfileRequest_ProfileIdentifier*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the value pTLVx01->mProfileType = (eQMIProfileTypes)profileType; pTLVx01->mProfileIndex = 1; offset += tlvx01Sz; // Add name, if specified if (pName != 0) { std::string name( pName ); // Check size WORD tlvx10Sz = (WORD)name.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( pOut + offset, name.c_str(), name.size() ); offset += tlvx10Sz; } // Add PDP type, if specified if (pPDPType != 0) { // Check size WORD tlvx11Sz = sizeof( sWDSModifyProfileRequest_PDPType ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx11Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x11; pHeader->mLength = tlvx11Sz; offset += sizeof( sQMIRawContentHeader ); sWDSModifyProfileRequest_PDPType * pTLVx11; pTLVx11 = (sWDSModifyProfileRequest_PDPType*)(pOut + offset); memset( pTLVx11, 0, tlvx11Sz ); // Set the value pTLVx11->mPDPType = (eQMIPDPTypes)*pPDPType; offset += tlvx11Sz; } // Add APN Name, if specified if (pAPNName != 0) { std::string apnName( pAPNName ); // Check size WORD tlvx14Sz = (WORD)apnName.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx14Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x14; pHeader->mLength = tlvx14Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), apnName.c_str(), apnName.size() ); offset += tlvx14Sz; } // Add Primary DNS, if specified if (pPrimaryDNS != 0) { // Check size WORD tlvx15Sz = sizeof( sWDSModifyProfileRequest_PrimaryDNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx15Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x15; pHeader->mLength = tlvx15Sz; offset += sizeof( sQMIRawContentHeader ); sWDSModifyProfileRequest_PrimaryDNS * pTLVx15; pTLVx15 = (sWDSModifyProfileRequest_PrimaryDNS*)(pOut + offset); memset( pTLVx15, 0, tlvx15Sz ); ULONG ip0 = (*pPrimaryDNS & 0x000000FF); ULONG ip1 = (*pPrimaryDNS & 0x0000FF00) >> 8; ULONG ip2 = (*pPrimaryDNS & 0x00FF0000) >> 16; ULONG ip3 = (*pPrimaryDNS & 0xFF000000) >> 24; // Set the value pTLVx15->mIPV4Address[0] = (INT8)ip0; pTLVx15->mIPV4Address[1] = (INT8)ip1; pTLVx15->mIPV4Address[2] = (INT8)ip2; pTLVx15->mIPV4Address[3] = (INT8)ip3; offset += tlvx15Sz; } // Add Secondary DNS, if specified if (pSecondaryDNS != 0) { // Check size WORD tlvx16Sz = sizeof( sWDSModifyProfileRequest_SecondaryDNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx16Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x16; pHeader->mLength = tlvx16Sz; offset += sizeof( sQMIRawContentHeader ); sWDSModifyProfileRequest_SecondaryDNS * pTLVx16; pTLVx16 = (sWDSModifyProfileRequest_SecondaryDNS*)(pOut + offset); memset( pTLVx16, 0, tlvx16Sz ); ULONG ip0 = (*pSecondaryDNS & 0x000000FF); ULONG ip1 = (*pSecondaryDNS & 0x0000FF00) >> 8; ULONG ip2 = (*pSecondaryDNS & 0x00FF0000) >> 16; ULONG ip3 = (*pSecondaryDNS & 0xFF000000) >> 24; // Set the value pTLVx16->mIPV4Address[0] = (INT8)ip0; pTLVx16->mIPV4Address[1] = (INT8)ip1; pTLVx16->mIPV4Address[2] = (INT8)ip2; pTLVx16->mIPV4Address[3] = (INT8)ip3; offset += tlvx16Sz; } // Add Username, if specified if (pUsername != 0) { std::string username( pUsername ); // Check size WORD tlvx1BSz = (WORD)username.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx1BSz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x1B; pHeader->mLength = tlvx1BSz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), username.c_str(), username.size() ); offset += tlvx1BSz; } // Add Password, if specified if (pPassword != 0) { std::string password( pPassword ); // Check size WORD tlvx1CSz = (WORD)password.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx1CSz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x1C; pHeader->mLength = tlvx1CSz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), password.c_str(), password.size() ); offset += tlvx1CSz; } // Add Authentication, if specified if (pAuthentication != 0) { // Check size WORD tlvx1DSz = sizeof( sWDSModifyProfileRequest_Authentication ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx1DSz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x1D; pHeader->mLength = tlvx1DSz; offset += sizeof( sQMIRawContentHeader ); sWDSModifyProfileRequest_Authentication * pTLVx1D; pTLVx1D = (sWDSModifyProfileRequest_Authentication*)(pOut + offset); memset( pTLVx1D, 0, tlvx1DSz ); // Set the value pTLVx1D->mEnablePAP = ((*pAuthentication & 0x00000001) != 0); pTLVx1D->mEnableCHAP = ((*pAuthentication & 0x00000002) != 0); offset += tlvx1DSz; } // Add IP Address, if specified if (pIPAddress != 0) { // Check size WORD tlvx1ESz = sizeof( sWDSModifyProfileRequest_IPAddress ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx1ESz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x1E; pHeader->mLength = tlvx1ESz; offset += sizeof( sQMIRawContentHeader ); sWDSModifyProfileRequest_IPAddress * pTLVx1E; pTLVx1E = (sWDSModifyProfileRequest_IPAddress*)(pOut + offset); memset( pTLVx1E, 0, tlvx1ESz ); ULONG ip0 = (*pIPAddress & 0x000000FF); ULONG ip1 = (*pIPAddress & 0x0000FF00) >> 8; ULONG ip2 = (*pIPAddress & 0x00FF0000) >> 16; ULONG ip3 = (*pIPAddress & 0xFF000000) >> 24; // Set the value pTLVx1E->mIPV4Address[0] = (INT8)ip0; pTLVx1E->mIPV4Address[1] = (INT8)ip1; pTLVx1E->mIPV4Address[2] = (INT8)ip2; pTLVx1E->mIPV4Address[3] = (INT8)ip3; offset += tlvx1ESz; } // At least one of the optional parameters must have been set if (offset <= sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_INVALID_ARG; } *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackGetDefaultProfile DESCRIPTION: This function reads the default profile settings from the device, the default profile is used during autoconnect PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer profileType [ I ] - Profile type being read RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackGetDefaultProfile( ULONG * pOutLen, BYTE * pOut, ULONG profileType ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Add profileType // Check size WORD tlvx01Sz = sizeof( sWDSGetDefaultSettingsRequest_ProfileType ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSGetDefaultSettingsRequest_ProfileType * pTLVx01; pTLVx01 = (sWDSGetDefaultSettingsRequest_ProfileType*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the value pTLVx01->mProfileType = (eQMIProfileTypes)profileType; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetDefaultProfile DESCRIPTION: This function reads the default profile settings from the device, the default profile is used during autoconnect PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pPDPType [ O ] - PDP type pIPAddress [ O ] - Preferred assigned IPv4 address pPrimaryDNS [ O ] - Primary DNS IPv4 address pSecondaryDNS [ O ] - Secondary DNS IPv4 address pAuthentication [ O ] - Authentication algorithm bitmap nameSize [ I ] - The maximum number of characters (including NULL terminator) that the profile name array can contain pName [ O ] - The profile name or description apnSize [ I ] - The maximum number of characters (including NULL terminator) that the APN name array can contain pAPNName [ O ] - Access point name represented as a NULL terminated string (empty string returned when unknown) userSize [ I ] - The maximum number of characters (including NULL terminator) that the username array can contain pUsername [ O ] - Username used during authentication RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetDefaultProfile( ULONG inLen, const BYTE * pIn, ULONG * pPDPType, ULONG * pIPAddress, ULONG * pPrimaryDNS, ULONG * pSecondaryDNS, ULONG * pAuthentication, BYTE nameSize, CHAR * pName, BYTE apnSize, CHAR * pAPNName, BYTE userSize, CHAR * pUsername ) { // Validate arguments if (pIn == 0 || pPDPType == 0 || pIPAddress == 0 || pPrimaryDNS == 0 || pSecondaryDNS == 0 || pAuthentication == 0 || nameSize == 0 || pName == 0 || apnSize == 0 || pAPNName == 0 || userSize == 0 || pUsername == 0) { return eGOBI_ERR_INVALID_ARG; } // Set defaults *pPDPType = 0xffffffff; *pIPAddress = 0xffffffff; *pPrimaryDNS = 0xffffffff; *pSecondaryDNS = 0xffffffff; *pAuthentication = 0xffffffff; pName[0] = 0; pAPNName[0] = 0; pUsername[0] = 0; // Find the name const sWDSGetDefaultSettingsResponse_ProfileName * pTLVx10; ULONG outLenx10; ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc == eGOBI_ERR_NONE) { if (nameSize < outLenx10 + 1) { return eGOBI_ERR_BUFFER_SZ; } memcpy( pName, (const BYTE *)pTLVx10, outLenx10 ); // Null terminate pName[outLenx10] = 0; } // Find the PDP type const sWDSGetDefaultSettingsResponse_PDPType * pTLVx11; ULONG outLenx11; rc = GetTLV( inLen, pIn, 0x11, &outLenx11, (const BYTE **)&pTLVx11 ); if (rc == eGOBI_ERR_NONE) { if (outLenx11 < sizeof( sWDSGetDefaultSettingsResponse_PDPType )) { return eGOBI_ERR_MALFORMED_RSP; } *pPDPType = pTLVx11->mPDPType; } // Find the APN name const sWDSGetDefaultSettingsResponse_APNName * pTLVx14; ULONG outLenx14; rc = GetTLV( inLen, pIn, 0x14, &outLenx14, (const BYTE **)&pTLVx14 ); if (rc == eGOBI_ERR_NONE) { if (apnSize < outLenx14 + 1) { return eGOBI_ERR_BUFFER_SZ; } memcpy( pAPNName, (const BYTE *)pTLVx14, outLenx14 ); // Null terminate pAPNName[outLenx14] = 0; } // Find the Primary DNS const sWDSGetDefaultSettingsResponse_PrimaryDNS * pTLVx15; ULONG outLenx15; rc = GetTLV( inLen, pIn, 0x15, &outLenx15, (const BYTE **)&pTLVx15 ); if (rc == eGOBI_ERR_NONE) { if (outLenx15 < sizeof( sWDSGetDefaultSettingsResponse_PrimaryDNS )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx15->mIPV4Address[0]; ULONG ip1 = pTLVx15->mIPV4Address[1] << 8; ULONG ip2 = pTLVx15->mIPV4Address[2] << 16; ULONG ip3 = pTLVx15->mIPV4Address[3] << 24; *pPrimaryDNS = (ip0 | ip1 | ip2 | ip3); } // Find the Secondary DNS const sWDSGetDefaultSettingsResponse_SecondaryDNS * pTLVx16; ULONG outLenx16; rc = GetTLV( inLen, pIn, 0x16, &outLenx16, (const BYTE **)&pTLVx16 ); if (rc == eGOBI_ERR_NONE) { if (outLenx16 < sizeof( sWDSGetDefaultSettingsResponse_SecondaryDNS )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx16->mIPV4Address[0]; ULONG ip1 = pTLVx16->mIPV4Address[1] << 8; ULONG ip2 = pTLVx16->mIPV4Address[2] << 16; ULONG ip3 = pTLVx16->mIPV4Address[3] << 24; *pSecondaryDNS = (ip0 | ip1 | ip2 | ip3); } // Find the Username const sWDSGetDefaultSettingsResponse_APNName * pTLVx1B; ULONG outLenx1B; rc = GetTLV( inLen, pIn, 0x1B, &outLenx1B, (const BYTE **)&pTLVx1B ); if (rc == eGOBI_ERR_NONE) { if (userSize < outLenx1B + 1) { return eGOBI_ERR_BUFFER_SZ; } memcpy( pAPNName, (const BYTE *)pTLVx1B, outLenx1B ); // Null terminate pAPNName[outLenx1B] = 0; } // Find the Authentication const sWDSGetDefaultSettingsResponse_Authentication * pTLVx1D; ULONG outLenx1D; rc = GetTLV( inLen, pIn, 0x1D, &outLenx1D, (const BYTE **)&pTLVx1D ); if (rc == eGOBI_ERR_NONE) { if (outLenx1D < sizeof( sWDSGetDefaultSettingsResponse_Authentication )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG pap = pTLVx1D->mEnablePAP; ULONG chap = pTLVx1D->mEnableCHAP << 1; *pAuthentication = (pap | chap); } // Find the IP Address const sWDSGetDefaultSettingsResponse_IPAddress * pTLVx1E; ULONG outLenx1E; rc = GetTLV( inLen, pIn, 0x1E, &outLenx1E, (const BYTE **)&pTLVx1E ); if (rc == eGOBI_ERR_NONE) { if (outLenx1E < sizeof( sWDSGetDefaultSettingsResponse_IPAddress )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx1E->mIPV4Address[0]; ULONG ip1 = pTLVx1E->mIPV4Address[1] << 8; ULONG ip2 = pTLVx1E->mIPV4Address[2] << 16; ULONG ip3 = pTLVx1E->mIPV4Address[3] << 24; *pIPAddress = (ip0 | ip1 | ip2 | ip3); } return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackStartDataSession DESCRIPTION: This function activates a packet data session PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer pTechnology [ I ] - (Optional) Technology bitmap pPrimaryDNS [ I ] - (Optional) Primary DNS IPv4 address pSecondaryDNS [ I ] - (Optional) Secondary DNS IPv4 address pPrimaryNBNS [ I ] - (Optional) Primary NetBIOS NS IPv4 address pSecondaryNBNS [ I ] - (Optional) Secondary NetBIOS NS IPv4 address pAPNName [ I ] - (Optional) Access point name pIPAddress [ I ] - (Optional) Preferred assigned IPv4 address pAuthentication [ I ] - (Optional) Authentication algorithm bitmap pUsername [ I ] - (Optional) Username used during authentication pPassword [ I ] - (Optional) Password used during authentication RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackStartDataSession( ULONG * pOutLen, BYTE * pOut, ULONG * pTechnology, ULONG * pPrimaryDNS, ULONG * pSecondaryDNS, ULONG * pPrimaryNBNS, ULONG * pSecondaryNBNS, CHAR * pAPNName, ULONG * pIPAddress, ULONG * pAuthentication, CHAR * pUsername, CHAR * pPassword ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } sQMIRawContentHeader * pHeader; ULONG offset = 0; // Add technology, if specified if (pTechnology != 0) { // Check size WORD tlvx30Sz = sizeof( sWDSStartNetworkInterfaceRequest_TechnologyPreference ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx30Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x30; pHeader->mLength = tlvx30Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_TechnologyPreference * pTLVx30; pTLVx30 = (sWDSStartNetworkInterfaceRequest_TechnologyPreference*)(pOut + offset); memset( pTLVx30, 0, tlvx30Sz ); // Set the value pTLVx30->mEnable3GPP = ((*pTechnology & 0x00000001) != 0); pTLVx30->mEnable3GPP2 = ((*pTechnology & 0x00000002) != 0); offset += tlvx30Sz; } // Add Primary DNS, if specified if (pPrimaryDNS != 0) { // Check size WORD tlvx10Sz = sizeof( sWDSStartNetworkInterfaceRequest_PrimaryDNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_PrimaryDNS * pTLVx10; pTLVx10 = (sWDSStartNetworkInterfaceRequest_PrimaryDNS*)(pOut + offset); memset( pTLVx10, 0, tlvx10Sz ); ULONG ip0 = (*pPrimaryDNS & 0x000000FF); ULONG ip1 = (*pPrimaryDNS & 0x0000FF00) >> 8; ULONG ip2 = (*pPrimaryDNS & 0x00FF0000) >> 16; ULONG ip3 = (*pPrimaryDNS & 0xFF000000) >> 24; // Set the value pTLVx10->mIPV4Address[0] = (INT8)ip0; pTLVx10->mIPV4Address[1] = (INT8)ip1; pTLVx10->mIPV4Address[2] = (INT8)ip2; pTLVx10->mIPV4Address[3] = (INT8)ip3; offset += tlvx10Sz; } // Add Secondary DNS, if specified if (pSecondaryDNS != 0) { // Check size WORD tlvx11Sz = sizeof( sWDSStartNetworkInterfaceRequest_SecondaryDNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx11Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x11; pHeader->mLength = tlvx11Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_SecondaryDNS * pTLVx11; pTLVx11 = (sWDSStartNetworkInterfaceRequest_SecondaryDNS*)(pOut + offset); memset( pTLVx11, 0, tlvx11Sz ); ULONG ip0 = (*pSecondaryDNS & 0x000000FF); ULONG ip1 = (*pSecondaryDNS & 0x0000FF00) >> 8; ULONG ip2 = (*pSecondaryDNS & 0x00FF0000) >> 16; ULONG ip3 = (*pSecondaryDNS & 0xFF000000) >> 24; // Set the value pTLVx11->mIPV4Address[0] = (INT8)ip0; pTLVx11->mIPV4Address[1] = (INT8)ip1; pTLVx11->mIPV4Address[2] = (INT8)ip2; pTLVx11->mIPV4Address[3] = (INT8)ip3; offset += tlvx11Sz; } // Add Primary NBNS, if specified if (pPrimaryNBNS != 0) { // Check size WORD tlvx12Sz = sizeof( sWDSStartNetworkInterfaceRequest_PrimaryNBNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx12Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x12; pHeader->mLength = tlvx12Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_PrimaryNBNS * pTLVx12; pTLVx12 = (sWDSStartNetworkInterfaceRequest_PrimaryNBNS*)(pOut + offset); memset( pTLVx12, 0, tlvx12Sz ); ULONG ip0 = (*pPrimaryNBNS & 0x000000FF); ULONG ip1 = (*pPrimaryNBNS & 0x0000FF00) >> 8; ULONG ip2 = (*pPrimaryNBNS & 0x00FF0000) >> 16; ULONG ip3 = (*pPrimaryNBNS & 0xFF000000) >> 24; // Set the value pTLVx12->mIPV4Address[0] = (INT8)ip0; pTLVx12->mIPV4Address[1] = (INT8)ip1; pTLVx12->mIPV4Address[2] = (INT8)ip2; pTLVx12->mIPV4Address[3] = (INT8)ip3; offset += tlvx12Sz; } // Add Secondary NBNS, if specified if (pSecondaryNBNS != 0) { // Check size WORD tlvx13Sz = sizeof( sWDSStartNetworkInterfaceRequest_SecondaryNBNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx13Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x13; pHeader->mLength = tlvx13Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_SecondaryNBNS * pTLVx13; pTLVx13 = (sWDSStartNetworkInterfaceRequest_SecondaryNBNS*)(pOut + offset); memset( pTLVx13, 0, tlvx13Sz ); ULONG ip0 = (*pSecondaryNBNS & 0x000000FF); ULONG ip1 = (*pSecondaryNBNS & 0x0000FF00) >> 8; ULONG ip2 = (*pSecondaryNBNS & 0x00FF0000) >> 16; ULONG ip3 = (*pSecondaryNBNS & 0xFF000000) >> 24; // Set the value pTLVx13->mIPV4Address[0] = (INT8)ip0; pTLVx13->mIPV4Address[1] = (INT8)ip1; pTLVx13->mIPV4Address[2] = (INT8)ip2; pTLVx13->mIPV4Address[3] = (INT8)ip3; offset += tlvx13Sz; } // Add APN Name, if specified if (pAPNName != 0) { std::string apnName( pAPNName ); // Check size WORD tlvx14Sz = (WORD)apnName.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx14Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x14; pHeader->mLength = tlvx14Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), apnName.c_str(), apnName.size() ); offset += tlvx14Sz; } // Add IP Address, if specified if (pIPAddress != 0) { // Check size WORD tlvx15Sz = sizeof( sWDSStartNetworkInterfaceRequest_IPAddress ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx15Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x15; pHeader->mLength = tlvx15Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_IPAddress * pTLVx15; pTLVx15 = (sWDSStartNetworkInterfaceRequest_IPAddress*)(pOut + offset); memset( pTLVx15, 0, tlvx15Sz ); ULONG ip0 = (*pIPAddress & 0x000000FF); ULONG ip1 = (*pIPAddress & 0x0000FF00) >> 8; ULONG ip2 = (*pIPAddress & 0x00FF0000) >> 16; ULONG ip3 = (*pIPAddress & 0xFF000000) >> 24; // Set the value pTLVx15->mIPV4Address[0] = (INT8)ip0; pTLVx15->mIPV4Address[1] = (INT8)ip1; pTLVx15->mIPV4Address[2] = (INT8)ip2; pTLVx15->mIPV4Address[3] = (INT8)ip3; offset += tlvx15Sz; } // Add Authentication, if specified if (pAuthentication != 0) { // Check size WORD tlvx16Sz = sizeof( sWDSStartNetworkInterfaceRequest_Authentication ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx16Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x16; pHeader->mLength = tlvx16Sz; offset += sizeof( sQMIRawContentHeader ); sWDSStartNetworkInterfaceRequest_Authentication * pTLVx16; pTLVx16 = (sWDSStartNetworkInterfaceRequest_Authentication*)(pOut + offset); memset( pTLVx16, 0, tlvx16Sz ); // Set the value pTLVx16->mEnablePAP = ((*pAuthentication & 0x00000001) != 0); pTLVx16->mEnableCHAP = ((*pAuthentication & 0x00000002) != 0); offset += tlvx16Sz; } // Add Username, if specified if (pUsername != 0) { std::string username( pUsername ); // Check size WORD tlvx17Sz = (WORD)username.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx17Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x17; pHeader->mLength = tlvx17Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), username.c_str(), username.size() ); offset += tlvx17Sz; } // Add Password, if specified if (pPassword != 0) { std::string password( pPassword ); // Check size WORD tlvx18Sz = (WORD)password.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx18Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x18; pHeader->mLength = tlvx18Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), password.c_str(), password.size() ); offset += tlvx18Sz; } *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseStartDataSession DESCRIPTION: This function activates a packet data session PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pSessionId [ O ] - The assigned session ID pFailureReason [ O ] - Upon call failure the failure reason provided RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseStartDataSession( ULONG inLen, const BYTE * pIn, ULONG * pSessionId, ULONG * pFailureReason ) { // Validate arguments if (pIn == 0 || pSessionId == 0 || pFailureReason == 0) { return eGOBI_ERR_INVALID_ARG; } // Check mandatory response const sResultCode * pTLVx02; ULONG outLenx02; ULONG rc = GetTLV( inLen, pIn, 0x02, &outLenx02, (const BYTE **)&pTLVx02 ); if (rc != eGOBI_ERR_NONE) { return rc; } if (outLenx02 < sizeof( sResultCode )) { return eGOBI_ERR_MALFORMED_RSP; } if (pTLVx02->mQMIResult != eQMIResults_Success) { rc = pTLVx02->mQMIError + eGOBI_ERR_QMI_OFFSET; } if (rc != eGOBI_ERR_NONE) { // Still parse call end reason, if present const sWDSStartNetworkInterfaceResponse_CallEndReason * pTLVx10; ULONG outLenx10; ULONG rc2 = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc2 == eGOBI_ERR_NONE) { if (outLenx10 >= sizeof( sWDSStartNetworkInterfaceResponse_CallEndReason )) { *pFailureReason = pTLVx10->mCallEnd; } } return rc; } // Find the Session ID const sWDSStartNetworkInterfaceResponse_PacketDataHandle * pTLVx01; ULONG outLenx01; rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc == eGOBI_ERR_NONE) { if (outLenx01 < sizeof( sWDSStartNetworkInterfaceResponse_PacketDataHandle )) { return eGOBI_ERR_MALFORMED_RSP; } *pSessionId = pTLVx01->mPacketDataHandle; } // Session ID is mandatory, if it failed return that error return rc; } /*=========================================================================== METHOD: PackStopDataSession DESCRIPTION: This function stops the current data session PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer sessionId [ I ] - The ID of the session to terminate RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackStopDataSession( ULONG * pOutLen, BYTE * pOut, ULONG sessionId ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Add session ID // Check size WORD tlvx01Sz = sizeof( sWDSStopNetworkInterfaceRequest_PacketDataHandle ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSStopNetworkInterfaceRequest_PacketDataHandle * pTLVx01; pTLVx01 = (sWDSStopNetworkInterfaceRequest_PacketDataHandle*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the value pTLVx01->mPacketDataHandle = sessionId; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackGetIPAddress DESCRIPTION: This function returns the current packet data session IP address PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackGetIPAddress( ULONG * pOutLen, BYTE * pOut ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Request the settings // Check size WORD tlvx10Sz = sizeof( sWDSGetCurrentSettingsRequest_RequestedSettings ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSGetCurrentSettingsRequest_RequestedSettings * pTLVx10; pTLVx10 = (sWDSGetCurrentSettingsRequest_RequestedSettings*)(pOut + offset); memset( pTLVx10, 0, tlvx10Sz ); // Set the value pTLVx10->mIPAddress = true; offset += tlvx10Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetIPAddress DESCRIPTION: This function returns the current packet data session IP address PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pIPAddress [ O ] - Assigned IPv4 address RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetIPAddress( ULONG inLen, const BYTE * pIn, ULONG * pIPAddress ) { // Validate arguments if (pIn == 0 || pIPAddress == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the IP Address const sWDSGetDefaultSettingsResponse_IPAddress * pTLVx1E; ULONG outLenx1E; ULONG rc = GetTLV( inLen, pIn, 0x1E, &outLenx1E, (const BYTE **)&pTLVx1E ); if (rc == eGOBI_ERR_NONE) { if (outLenx1E < sizeof( sWDSGetDefaultSettingsResponse_IPAddress )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx1E->mIPV4Address[0]; ULONG ip1 = pTLVx1E->mIPV4Address[1] << 8; ULONG ip2 = pTLVx1E->mIPV4Address[2] << 16; ULONG ip3 = pTLVx1E->mIPV4Address[3] << 24; *pIPAddress = (ip0 | ip1 | ip2 | ip3); } // If no IP address is found, fail return rc; } /*=========================================================================== METHOD: ParseGetConnectionRate DESCRIPTION: This function returns connection rate information for the packet data connection PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pCurrentChannelTXRate [ O ] - Current channel TX rate (bps) pCurrentChannelRXRate [ O ] - Current channel RX rate (bps) pMaxChannelTXRate [ O ] - Maximum channel TX rate (bps) pMaxChannelRXRate [ O ] - Maximum channel RX rate (bps) RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetConnectionRate( ULONG inLen, const BYTE * pIn, ULONG * pCurrentChannelTXRate, ULONG * pCurrentChannelRXRate, ULONG * pMaxChannelTXRate, ULONG * pMaxChannelRXRate ) { // Validate arguments if (pIn == 0 || pCurrentChannelTXRate == 0 || pCurrentChannelRXRate == 0 || pMaxChannelTXRate == 0 || pMaxChannelRXRate == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the rates const sWDSGetChannelRatesResponse_ChannelRates * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc == eGOBI_ERR_NONE) { if (outLenx01 < sizeof( sWDSGetChannelRatesResponse_ChannelRates )) { return eGOBI_ERR_MALFORMED_RSP; } // Get the values *pCurrentChannelTXRate = pTLVx01->mChannelTXRatebps; *pCurrentChannelRXRate = pTLVx01->mChannelRXRatebps; *pMaxChannelTXRate = pTLVx01->mMaxChannelTXRatebps; *pMaxChannelRXRate = pTLVx01->mMaxChannelRXRatebps; } // If no rates are found, fail return rc; } /*=========================================================================== METHOD: PackGetPacketStatus DESCRIPTION: This function returns the packet data transfer statistics since the start of the current packet data session PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackGetPacketStatus( ULONG * pOutLen, BYTE * pOut ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Request the settings // Check size WORD tlvx01Sz = sizeof( sWDSGetPacketStatisticsRequest_PacketStatsMask ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSGetPacketStatisticsRequest_PacketStatsMask * pTLVx01; pTLVx01 = (sWDSGetPacketStatisticsRequest_PacketStatsMask*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values pTLVx01->mReportTXPacketSuccesses = true; pTLVx01->mReportRXPacketSuccesses = true; pTLVx01->mReportTXPacketErrors = true; pTLVx01->mReportRXPacketErrors = true; pTLVx01->mReportTXOverflows = true; pTLVx01->mReportRXOverflows = true; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetPacketStatus DESCRIPTION: This function returns the packet data transfer statistics since the start of the current packet data session PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pTXPacketSuccesses [ O ] - Packets transmitted without error pRXPacketSuccesses [ O ] - Packets received without error pTXPacketErrors [ O ] - Outgoing packets with framing errors pRXPacketErrors [ O ] - Incoming packets with framing errors pTXPacketOverflows [ O ] - Packets dropped because TX buffer overflowed pRXPacketOverflows [ O ] - Packets dropped because RX buffer overflowed RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetPacketStatus( ULONG inLen, const BYTE * pIn, ULONG * pTXPacketSuccesses, ULONG * pRXPacketSuccesses, ULONG * pTXPacketErrors, ULONG * pRXPacketErrors, ULONG * pTXPacketOverflows, ULONG * pRXPacketOverflows ) { // Validate arguments if (pIn == 0 || pTXPacketSuccesses == 0 || pRXPacketSuccesses == 0 || pTXPacketErrors == 0 || pRXPacketErrors == 0 || pTXPacketOverflows == 0 || pRXPacketOverflows == 0) { return eGOBI_ERR_INVALID_ARG; } // NOTE: All TLVs are required. If any fail then all fail // Find the TX packet sucesses const sWDSGetPacketStatisticsResponse_TXPacketSuccesses * pTLVx10; ULONG outLenx10; ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc == eGOBI_ERR_NONE) { if (outLenx10 < sizeof( sWDSGetPacketStatisticsResponse_TXPacketSuccesses )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Find the RX packet sucesses const sWDSGetPacketStatisticsResponse_RXPacketSuccesses * pTLVx11; ULONG outLenx11; rc = GetTLV( inLen, pIn, 0x11, &outLenx11, (const BYTE **)&pTLVx11 ); if (rc == eGOBI_ERR_NONE) { if (outLenx11 < sizeof( sWDSGetPacketStatisticsResponse_RXPacketSuccesses )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Find the TX packet errors const sWDSGetPacketStatisticsResponse_TXPacketErrors * pTLVx12; ULONG outLenx12; rc = GetTLV( inLen, pIn, 0x12, &outLenx12, (const BYTE **)&pTLVx12 ); if (rc == eGOBI_ERR_NONE) { if (outLenx12 < sizeof( sWDSGetPacketStatisticsResponse_TXPacketErrors )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Find the RX packet errors const sWDSGetPacketStatisticsResponse_RXPacketErrors * pTLVx13; ULONG outLenx13; rc = GetTLV( inLen, pIn, 0x13, &outLenx13, (const BYTE **)&pTLVx13 ); if (rc == eGOBI_ERR_NONE) { if (outLenx13 < sizeof( sWDSGetPacketStatisticsResponse_RXPacketErrors )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Find the TX packet overflows const sWDSGetPacketStatisticsResponse_TXOverflows * pTLVx14; ULONG outLenx14; rc = GetTLV( inLen, pIn, 0x14, &outLenx14, (const BYTE **)&pTLVx14 ); if (rc == eGOBI_ERR_NONE) { if (outLenx14 < sizeof( sWDSGetPacketStatisticsResponse_TXOverflows )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Find the RX packet overflows const sWDSGetPacketStatisticsResponse_RXOverflows * pTLVx15; ULONG outLenx15; rc = GetTLV( inLen, pIn, 0x15, &outLenx15, (const BYTE **)&pTLVx15 ); if (rc == eGOBI_ERR_NONE) { if (outLenx15 < sizeof( sWDSGetPacketStatisticsResponse_RXOverflows )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Populate the statistics *pTXPacketSuccesses = pTLVx10->mTXPacketSuccesses; *pRXPacketSuccesses = pTLVx11->mRXPacketSuccesses; *pTXPacketErrors = pTLVx12->mTXPacketErrors; *pRXPacketErrors = pTLVx13->mRXPacketErrors; *pTXPacketOverflows = pTLVx14->mTXOverflows; *pRXPacketOverflows = pTLVx15->mRXOverflows; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackGetByteTotals DESCRIPTION: This function returns the RX/TX byte counts since the start of the current packet data session PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackGetByteTotals( ULONG * pOutLen, BYTE * pOut ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Request the settings // Check size WORD tlvx01Sz = sizeof( sWDSGetPacketStatisticsRequest_PacketStatsMask ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSGetPacketStatisticsRequest_PacketStatsMask * pTLVx01; pTLVx01 = (sWDSGetPacketStatisticsRequest_PacketStatsMask*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values pTLVx01->mTXByteTotal = true; pTLVx01->mRXByteTotal = true; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetByteTotals DESCRIPTION: This function returns the RX/TX byte counts since the start of the current packet data session PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pTXTotalBytes [ O ] - Bytes transmitted without error pRXTotalBytes [ O ] - Bytes received without error RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetByteTotals( ULONG inLen, const BYTE * pIn, ULONGLONG * pTXTotalBytes, ULONGLONG * pRXTotalBytes ) { // Validate arguments if (pIn == 0 || pTXTotalBytes == 0 || pRXTotalBytes == 0) { return eGOBI_ERR_INVALID_ARG; } // NOTE: All TLVs are required. If any fail then all fail // Find the TX bytes const sWDSGetPacketStatisticsResponse_TXBytes * pTLVx19; ULONG outLenx19; ULONG rc = GetTLV( inLen, pIn, 0x19, &outLenx19, (const BYTE **)&pTLVx19 ); if (rc == eGOBI_ERR_NONE) { if (outLenx19 < sizeof( sWDSGetPacketStatisticsResponse_TXBytes )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Find the RX bytes const sWDSGetPacketStatisticsResponse_RXBytes * pTLVx1A; ULONG outLenx1A; rc = GetTLV( inLen, pIn, 0x1A, &outLenx1A, (const BYTE **)&pTLVx1A ); if (rc == eGOBI_ERR_NONE) { if (outLenx1A < sizeof( sWDSGetPacketStatisticsResponse_RXBytes )) { return eGOBI_ERR_MALFORMED_RSP; } } else { return rc; } // Populate the statistics *pTXTotalBytes = pTLVx19->mTXByteTotal; *pRXTotalBytes = pTLVx1A->mRXByteTotal; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackSetMobileIP DESCRIPTION: This function sets the current mobile IP setting PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer mode [ I ] - Desired mobile IP setting RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetMobileIP( ULONG * pOutLen, BYTE * pOut, ULONG mode ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Set the mode // Check size WORD tlvx01Sz = sizeof( sWDSSetMIPModeRequest_MobileIPMode ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSSetMIPModeRequest_MobileIPMode * pTLVx01; pTLVx01 = (sWDSSetMIPModeRequest_MobileIPMode*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values pTLVx01->mMIPMode = (eQMIMobileIPModes)mode; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetMobileIP DESCRIPTION: This function gets the current mobile IP setting PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pMode [ O ] - Current mobile IP setting RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetMobileIP( ULONG inLen, const BYTE * pIn, ULONG * pMode ) { // Validate arguments if (pIn == 0 || pMode == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the mode const sWDSGetMIPModeResponse_MobileIPMode * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc == eGOBI_ERR_NONE) { if (outLenx01 < sizeof( sWDSGetMIPModeResponse_MobileIPMode )) { return eGOBI_ERR_MALFORMED_RSP; } *pMode = pTLVx01->mMIPMode; } return rc; } /*=========================================================================== METHOD: PackSetActiveMobileIPProfile DESCRIPTION: This function sets the active mobile IP profile index PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer pSPC [ I ] - Six digit service programming code index [ I ] - Desired mobile IP profile index RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetActiveMobileIPProfile( ULONG * pOutLen, BYTE * pOut, CHAR * pSPC, BYTE index ) { // Validate arguments if (pOut == 0 || pSPC == 0 || pSPC[0] == 0) { return eGOBI_ERR_INVALID_ARG; } std::string spc( pSPC ); if (spc.size() > 6) { return eGOBI_ERR_INVALID_ARG; } if (spc.find_first_not_of( "0123456789" ) != std::string::npos ) { return eGOBI_ERR_INVALID_ARG; } // Check size WORD tlvx01Sz = sizeof( sWDSSetActiveMIPProfileRequest_Index ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSSetActiveMIPProfileRequest_Index * pTLVx01; pTLVx01 = (sWDSSetActiveMIPProfileRequest_Index*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values memcpy( &pTLVx01->mSPC[0], spc.c_str(), spc.size() ); pTLVx01->mProfileIndex = index; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetActiveMobileIPProfile DESCRIPTION: This function gets the the active mobile IP profile index PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pIndex [ O ] - Active mobile IP profile index RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetActiveMobileIPProfile( ULONG inLen, const BYTE * pIn, BYTE * pIndex ) { // Validate arguments if (pIn == 0 || pIndex == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the mode const sWDSGetActiveMIPProfileResponse_Index * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc == eGOBI_ERR_NONE) { if (outLenx01 < sizeof( sWDSGetActiveMIPProfileResponse_Index )) { return eGOBI_ERR_MALFORMED_RSP; } *pIndex = pTLVx01->mProfileIndex; } return rc; } /*=========================================================================== METHOD: PackSetMobileIPProfile DESCRIPTION: This function sets the specified mobile IP profile settings PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer pSPC [ I ] - Six digit service programming code index [ I ] - Mobile IP profile ID pEnabled [ I ] - (Optional) Enable MIP profile? pAddress [ I ] - (Optional) Home IPv4 address pPrimaryHA [ I ] - (Optional) Primary home agent IPv4 address pSecondaryHA [ I ] - (Optional) Secondary home agent IPv4 address bRevTunneling [ I ] - (Optional) Enable reverse tunneling? pNAI [ I ] - (Optional) Network access identifier string pHASPI [ I ] - (Optional) HA security parameter index pAAASPI [ I ] - (Optional) AAA security parameter index pMNHA [ I ] - (Optional) MN-HA string pMNAAA [ I ] - (Optional) MN-AAA string RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetMobileIPProfile( ULONG * pOutLen, BYTE * pOut, CHAR * pSPC, BYTE index, BYTE * pEnabled, ULONG * pAddress, ULONG * pPrimaryHA, ULONG * pSecondaryHA, BYTE * pRevTunneling, CHAR * pNAI, ULONG * pHASPI, ULONG * pAAASPI, CHAR * pMNHA, CHAR * pMNAAA ) { // Validate arguments if (pOut == 0 || pSPC == 0 || pSPC[0] == 0) { return eGOBI_ERR_INVALID_ARG; } std::string spc( pSPC ); if (spc.size() > 6) { return eGOBI_ERR_INVALID_ARG; } if (spc.find_first_not_of( "0123456789" ) != std::string::npos ) { return eGOBI_ERR_INVALID_ARG; } // Check size WORD tlvx01Sz = sizeof( sWDSSetMIPProfileRequest_Index ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_Index * pTLVx01; pTLVx01 = (sWDSSetMIPProfileRequest_Index*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values memcpy( &pTLVx01->mSPC[0], spc.c_str(), spc.size() ); pTLVx01->mProfileIndex = index; offset += tlvx01Sz; // Add Enabled, if specified if (pEnabled != 0) { // Check size WORD tlvx10Sz = sizeof( sWDSSetMIPProfileRequest_State ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_State * pTLVx10; pTLVx10 = (sWDSSetMIPProfileRequest_State*)(pOut + offset); memset( pTLVx10, 0, tlvx10Sz ); // Set the value pTLVx10->mEnabled = (*pEnabled == 0 ? 0 : 1); offset += tlvx10Sz; } // Add Home Address, if specified if (pAddress != 0) { // Check size WORD tlvx11Sz = sizeof( sWDSSetMIPProfileRequest_HomeAddress ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx11Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x11; pHeader->mLength = tlvx11Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_HomeAddress * pTLVx11; pTLVx11 = (sWDSSetMIPProfileRequest_HomeAddress*)(pOut + offset); memset( pTLVx11, 0, tlvx11Sz ); ULONG ip0 = (*pAddress & 0x000000FF); ULONG ip1 = (*pAddress & 0x0000FF00) >> 8; ULONG ip2 = (*pAddress & 0x00FF0000) >> 16; ULONG ip3 = (*pAddress & 0xFF000000) >> 24; // Set the value pTLVx11->mIPV4Address[0] = (INT8)ip0; pTLVx11->mIPV4Address[1] = (INT8)ip1; pTLVx11->mIPV4Address[2] = (INT8)ip2; pTLVx11->mIPV4Address[3] = (INT8)ip3; offset += tlvx11Sz; } // Add Primary Home Agent Address, if specified if (pPrimaryHA != 0) { // Check size WORD tlvx12Sz = sizeof( sWDSSetMIPProfileRequest_PrimaryHomeAgentAddress ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx12Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x12; pHeader->mLength = tlvx12Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_PrimaryHomeAgentAddress * pTLVx12; pTLVx12 = (sWDSSetMIPProfileRequest_PrimaryHomeAgentAddress*)(pOut + offset); memset( pTLVx12, 0, tlvx12Sz ); ULONG ip0 = (*pPrimaryHA & 0x000000FF); ULONG ip1 = (*pPrimaryHA & 0x0000FF00) >> 8; ULONG ip2 = (*pPrimaryHA & 0x00FF0000) >> 16; ULONG ip3 = (*pPrimaryHA & 0xFF000000) >> 24; // Set the value pTLVx12->mIPV4Address[0] = (INT8)ip0; pTLVx12->mIPV4Address[1] = (INT8)ip1; pTLVx12->mIPV4Address[2] = (INT8)ip2; pTLVx12->mIPV4Address[3] = (INT8)ip3; offset += tlvx12Sz; } // Add Secondary Home Agent Address, if specified if (pSecondaryHA != 0) { // Check size WORD tlvx13Sz = sizeof( sWDSSetMIPProfileRequest_SecondaryHomeAgentAddress ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx13Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x13; pHeader->mLength = tlvx13Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_SecondaryHomeAgentAddress * pTLVx13; pTLVx13 = (sWDSSetMIPProfileRequest_SecondaryHomeAgentAddress*)(pOut + offset); memset( pTLVx13, 0, tlvx13Sz ); ULONG ip0 = (*pSecondaryHA & 0x000000FF); ULONG ip1 = (*pSecondaryHA & 0x0000FF00) >> 8; ULONG ip2 = (*pSecondaryHA & 0x00FF0000) >> 16; ULONG ip3 = (*pSecondaryHA & 0xFF000000) >> 24; // Set the value pTLVx13->mIPV4Address[0] = (INT8)ip0; pTLVx13->mIPV4Address[1] = (INT8)ip1; pTLVx13->mIPV4Address[2] = (INT8)ip2; pTLVx13->mIPV4Address[3] = (INT8)ip3; offset += tlvx13Sz; } // Add reverse tunneling, if specified if (pRevTunneling != 0) { // Check size WORD tlvx14Sz = sizeof( sWDSSetMIPProfileRequest_ReverseTunneling ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx14Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x14; pHeader->mLength = tlvx14Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_ReverseTunneling * pTLVx14; pTLVx14 = (sWDSSetMIPProfileRequest_ReverseTunneling*)(pOut + offset); memset( pTLVx14, 0, tlvx14Sz ); // Set the value pTLVx14->mReverseTunneling = (*pRevTunneling == 0 ? 0 : 1); offset += tlvx14Sz; } // Add NAI, if specified if (pNAI != 0) { std::string nai( pNAI ); // Check size WORD tlvx15Sz = (WORD)nai.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx15Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x15; pHeader->mLength = tlvx15Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), nai.c_str(), nai.size() ); offset += tlvx15Sz; } // Add HA SPI, if specified if (pHASPI != 0) { // Check size WORD tlvx16Sz = sizeof( sWDSSetMIPProfileRequest_HASPI ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx16Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x16; pHeader->mLength = tlvx16Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequest_HASPI * pTLVx16; pTLVx16 = (sWDSSetMIPProfileRequest_HASPI*)(pOut + offset); memset( pTLVx16, 0, tlvx16Sz ); // Set the value pTLVx16->mHASPI = *pHASPI; offset += tlvx16Sz; } // Add AAA SPI, if specified if (pAAASPI != 0) { // Check size WORD tlvx17Sz = sizeof( sWDSSetMIPProfileRequeste_AAASPI ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx17Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x17; pHeader->mLength = tlvx17Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPProfileRequeste_AAASPI * pTLVx17; pTLVx17 = (sWDSSetMIPProfileRequeste_AAASPI*)(pOut + offset); memset( pTLVx17, 0, tlvx17Sz ); // Set the value pTLVx17->mAAASPI = *pAAASPI; offset += tlvx17Sz; } // Add MN-HA key, if specified if (pMNHA != 0) { std::string mnha( pMNHA ); // Check size WORD tlvx18Sz = (WORD)mnha.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx18Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x18; pHeader->mLength = tlvx18Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), mnha.c_str(), mnha.size() ); offset += tlvx18Sz; } // Add MN-AAA key, if specified if (pMNHA != 0) { std::string mnaaa( pMNAAA ); // Check size WORD tlvx19Sz = (WORD)mnaaa.size(); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx19Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x19; pHeader->mLength = tlvx19Sz; offset += sizeof( sQMIRawContentHeader ); // Set the value memcpy( (pOut + offset), mnaaa.c_str(), mnaaa.size() ); offset += tlvx19Sz; } // At least one of the optional parameters must have been set if (offset <= sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_INVALID_ARG; } *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackGetMobileIPProfile DESCRIPTION: This function gets the specified mobile IP profile settings PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer index [ I ] - Mobile IP profile ID RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackGetMobileIPProfile( ULONG * pOutLen, BYTE * pOut, BYTE index ) { // Validate arguments if (pOut == 0) { return eGOBI_ERR_INVALID_ARG; } // Check size WORD tlvx01Sz = sizeof( sWDSGetMIPProfileRequest_Index ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSGetMIPProfileRequest_Index * pTLVx01; pTLVx01 = (sWDSGetMIPProfileRequest_Index*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values pTLVx01->mProfileIndex = index; offset += tlvx01Sz; *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetMobileIPProfile DESCRIPTION: This function gets the specified mobile IP profile settings PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pEnabled [ O ] - Mobile IP profile enabled? pAddress [ O ] - Home IPv4 address pPrimaryHA [ O ] - Primary home agent IPv4 address pSecondaryHA [ O ] - Secondary home agent IPv4 address pRevTunneling [ O ] - Reverse tunneling enabled? naiSize [ I ] - The maximum number of characters (including NULL terminator) that the NAI array can contain pNAI [ O ] - Network access identifier string pHASPI [ O ] - HA security parameter index pAAASPI [ O ] - AAA security parameter index pHAState [ O ] - HA key state pAAAState [ O ] - AAA key state RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetMobileIPProfile( ULONG inLen, const BYTE * pIn, BYTE * pEnabled, ULONG * pAddress, ULONG * pPrimaryHA, ULONG * pSecondaryHA, BYTE * pRevTunneling, BYTE naiSize, CHAR * pNAI, ULONG * pHASPI, ULONG * pAAASPI, ULONG * pHAState, ULONG * pAAAState ) { // Validate arguments if (pIn == 0 || pEnabled == 0 || pAddress == 0 || pPrimaryHA == 0 || pSecondaryHA == 0 || pRevTunneling == 0 || naiSize == 0 || pNAI == 0 || pHASPI == 0 || pAAASPI == 0 || pHAState == 0 || pAAAState == 0) { return eGOBI_ERR_INVALID_ARG; } // Assume errors *pEnabled = 0xff; *pAddress = 0xffffffff; *pPrimaryHA = 0xffffffff; *pSecondaryHA = 0xffffffff; *pRevTunneling = 0xff; *pHASPI = 0xffffffff; *pAAASPI = 0xffffffff; *pHAState = 0xffffffff; *pAAAState = 0xffffffff; // Find the State const sWDSGetMIPProfileResponse_State * pTLVx10; ULONG outLenx10; ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc == eGOBI_ERR_NONE) { if (outLenx10 < sizeof( sWDSGetMIPProfileResponse_State )) { return eGOBI_ERR_MALFORMED_RSP; } *pEnabled = pTLVx10->mEnabled; } // Find the Home Address const sWDSGetMIPProfileResponse_HomeAddress * pTLVx11; ULONG outLenx11; rc = GetTLV( inLen, pIn, 0x11, &outLenx11, (const BYTE **)&pTLVx11 ); if (rc == eGOBI_ERR_NONE) { if (outLenx11 < sizeof( sWDSGetMIPProfileResponse_HomeAddress )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx11->mIPV4Address[0]; ULONG ip1 = pTLVx11->mIPV4Address[1] << 8; ULONG ip2 = pTLVx11->mIPV4Address[2] << 16; ULONG ip3 = pTLVx11->mIPV4Address[3] << 24; *pAddress = (ip0 | ip1 | ip2 | ip3); } // Find the Primary Home Agent Address const sWDSGetMIPProfileResponse_PrimaryHomeAgentAddress * pTLVx12; ULONG outLenx12; rc = GetTLV( inLen, pIn, 0x12, &outLenx12, (const BYTE **)&pTLVx12 ); if (rc == eGOBI_ERR_NONE) { if (outLenx12 < sizeof( sWDSGetMIPProfileResponse_PrimaryHomeAgentAddress )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx12->mIPV4Address[0]; ULONG ip1 = pTLVx12->mIPV4Address[1] << 8; ULONG ip2 = pTLVx12->mIPV4Address[2] << 16; ULONG ip3 = pTLVx12->mIPV4Address[3] << 24; *pPrimaryHA = (ip0 | ip1 | ip2 | ip3); } // Find the Secondary Home Agent Address const sWDSGetMIPProfileResponse_SecondaryHomeAgentAddress * pTLVx13; ULONG outLenx13; rc = GetTLV( inLen, pIn, 0x13, &outLenx13, (const BYTE **)&pTLVx13 ); if (rc == eGOBI_ERR_NONE) { if (outLenx13 < sizeof( sWDSGetMIPProfileResponse_SecondaryHomeAgentAddress )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx13->mIPV4Address[0]; ULONG ip1 = pTLVx13->mIPV4Address[1] << 8; ULONG ip2 = pTLVx13->mIPV4Address[2] << 16; ULONG ip3 = pTLVx13->mIPV4Address[3] << 24; *pSecondaryHA = (ip0 | ip1 | ip2 | ip3); } // Find the Reverse tunneling, if enabled const sWDSGetMIPProfileResponse_ReverseTunneling * pTLVx14; ULONG outLenx14; rc = GetTLV( inLen, pIn, 0x14, &outLenx14, (const BYTE **)&pTLVx14 ); if (rc == eGOBI_ERR_NONE) { if (outLenx10 < sizeof( sWDSGetMIPProfileResponse_ReverseTunneling )) { return eGOBI_ERR_MALFORMED_RSP; } *pRevTunneling = pTLVx14->mReverseTunneling; } // Find the NAI, if enabled const sWDSGetMIPProfileResponse_NAI * pTLVx15; ULONG outLenx15; rc = GetTLV( inLen, pIn, 0x15, &outLenx15, (const BYTE **)&pTLVx15 ); if (rc == eGOBI_ERR_NONE) { if (naiSize < outLenx15 + 1) { return eGOBI_ERR_BUFFER_SZ; } memcpy( pNAI, (const BYTE *)pTLVx15, outLenx15 ); // Null terminate pNAI[outLenx15] = 0; } // Find the HA SPI const sWDSGetMIPProfileResponse_HASPI * pTLVx16; ULONG outLenx16; rc = GetTLV( inLen, pIn, 0x16, &outLenx16, (const BYTE **)&pTLVx16 ); if (rc == eGOBI_ERR_NONE) { if (outLenx16 < sizeof( sWDSGetMIPProfileResponse_HASPI )) { return eGOBI_ERR_MALFORMED_RSP; } *pHASPI = pTLVx16->mHASPI; } // Find the AAA SPI const sWDSGetMIPProfileResponse_AAASPI * pTLVx17; ULONG outLenx17; rc = GetTLV( inLen, pIn, 0x17, &outLenx17, (const BYTE **)&pTLVx17 ); if (rc == eGOBI_ERR_NONE) { if (outLenx17 < sizeof( sWDSGetMIPProfileResponse_AAASPI )) { return eGOBI_ERR_MALFORMED_RSP; } *pAAASPI = pTLVx17->mAAASPI; } // Find the HA state const sWDSGetMIPProfileResponse_HAState * pTLVx1A; ULONG outLenx1A; rc = GetTLV( inLen, pIn, 0x1A, &outLenx1A, (const BYTE **)&pTLVx1A ); if (rc == eGOBI_ERR_NONE) { if (outLenx1A < sizeof( sWDSGetMIPProfileResponse_HAState )) { return eGOBI_ERR_MALFORMED_RSP; } *pHAState = pTLVx1A->mKeyState; } // Find the AAA state const sWDSGetMIPProfileResponse_AAAState * pTLVx1B; ULONG outLenx1B; rc = GetTLV( inLen, pIn, 0x1B, &outLenx1B, (const BYTE **)&pTLVx1B ); if (rc == eGOBI_ERR_NONE) { if (outLenx1B < sizeof( sWDSGetMIPProfileResponse_AAAState )) { return eGOBI_ERR_MALFORMED_RSP; } *pAAAState = pTLVx1B->mKeyState; } return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackSetMobileIPParameters DESCRIPTION: This function sets the specified mobile IP parameters PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer pSPC [ I ] - Six digit service programming code pMode [ I ] - (Optional) Desired mobile IP setting pRetryLimit [ I ] - (Optional) Retry attempt limit pRetryInterval [ I ] - (Optional) Retry attempt interval pReRegPeriod [ I ] - (Optional) Re-registration period pReRegTraffic [ I ] - (Optional) Re-registration only with traffic? pHAAuthenticator [ I ] - (Optional) MH-HA authenticator calculator? pHA2002bis [ I ] - (Optional) MH-HA RFC 2002bis authentication? RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetMobileIPParameters( ULONG * pOutLen, BYTE * pOut, CHAR * pSPC, ULONG * pMode, BYTE * pRetryLimit, BYTE * pRetryInterval, BYTE * pReRegPeriod, BYTE * pReRegTraffic, BYTE * pHAAuthenticator, BYTE * pHA2002bis ) { // Validate arguments if (pOut == 0 || pSPC == 0 || pSPC[0] == 0) { return eGOBI_ERR_INVALID_ARG; } std::string spc( pSPC ); if (spc.size() > 6) { return eGOBI_ERR_INVALID_ARG; } if (spc.find_first_not_of( "0123456789" ) != std::string::npos ) { return eGOBI_ERR_INVALID_ARG; } // Check size WORD tlvx01Sz = sizeof( sWDSSetMIPParametersRequest_SPC ); if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_BUFFER_SZ; } sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut; pHeader->mTypeID = 0x01; pHeader->mLength = tlvx01Sz; ULONG offset = sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_SPC * pTLVx01; pTLVx01 = (sWDSSetMIPParametersRequest_SPC*)(pOut + offset); memset( pTLVx01, 0, tlvx01Sz ); // Set the values memcpy( &pTLVx01->mSPC[0], spc.c_str(), spc.size() ); offset += tlvx01Sz; // Add Mode, if specified if (pMode != 0) { // Check size WORD tlvx10Sz = sizeof( sWDSSetMIPParametersRequest_MobileIPMode ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_MobileIPMode * pTLVx10; pTLVx10 = (sWDSSetMIPParametersRequest_MobileIPMode*)(pOut + offset); memset( pTLVx10, 0, tlvx10Sz ); // Set the value pTLVx10->mMIPMode = (eQMIMobileIPModes)*pMode; offset += tlvx10Sz; } // Add Retry Limit, if specified if (pRetryLimit != 0) { // Check size WORD tlvx11Sz = sizeof( sWDSSetMIPParametersRequest_RetryAttemptLimit ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx11Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x11; pHeader->mLength = tlvx11Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_RetryAttemptLimit * pTLVx11; pTLVx11 = (sWDSSetMIPParametersRequest_RetryAttemptLimit*)(pOut + offset); memset( pTLVx11, 0, tlvx11Sz ); // Set the value pTLVx11->mRetryAttemptLimit = *pRetryLimit; offset += tlvx11Sz; } // Add Retry interval, if specified if (pRetryInterval != 0) { // Check size WORD tlvx12Sz = sizeof( sWDSSetMIPParametersRequest_RetryAttemptInterval ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx12Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x12; pHeader->mLength = tlvx12Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_RetryAttemptInterval * pTLVx12; pTLVx12 = (sWDSSetMIPParametersRequest_RetryAttemptInterval*)(pOut + offset); memset( pTLVx12, 0, tlvx12Sz ); // Set the value pTLVx12->mRetryAttemptInterval = *pRetryInterval; offset += tlvx12Sz; } // Add Re-registration period, if specified if (pReRegPeriod != 0) { // Check size WORD tlvx13Sz = sizeof( sWDSSetMIPParametersRequest_ReRegistrationPeriod ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx13Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x13; pHeader->mLength = tlvx13Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_ReRegistrationPeriod * pTLVx13; pTLVx13 = (sWDSSetMIPParametersRequest_ReRegistrationPeriod*)(pOut + offset); memset( pTLVx13, 0, tlvx13Sz ); // Set the value pTLVx13->mReRegistrationPeriod = *pReRegPeriod; offset += tlvx13Sz; } // Add Re-registration on traffic flag, if specified if (pReRegTraffic != 0) { // Check size WORD tlvx14Sz = sizeof( sWDSSetMIPParametersRequest_ReRegistrationOnlyWithTraffic ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx14Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x14; pHeader->mLength = tlvx14Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_ReRegistrationOnlyWithTraffic * pTLVx14; pTLVx14 = (sWDSSetMIPParametersRequest_ReRegistrationOnlyWithTraffic*)(pOut + offset); memset( pTLVx14, 0, tlvx14Sz ); // Set the value pTLVx14->mReRegistrationOnlyWithTraffic = (*pReRegTraffic == 0 ? 0 : 1); offset += tlvx14Sz; } // Add HA authenticator flag, if specified if (pHAAuthenticator != 0) { // Check size WORD tlvx15Sz = sizeof( sWDSSetMIPParametersRequest_MNHAAuthenticatorCalculator ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx15Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x15; pHeader->mLength = tlvx15Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_MNHAAuthenticatorCalculator * pTLVx15; pTLVx15 = (sWDSSetMIPParametersRequest_MNHAAuthenticatorCalculator*)(pOut + offset); memset( pTLVx15, 0, tlvx15Sz ); // Set the value pTLVx15->mMNHAAuthenticatorCalculator = (*pHAAuthenticator == 0 ? 0 : 1); offset += tlvx15Sz; } // Add HA RFC2002bis authentication flag, if specified if (pHA2002bis != 0) { // Check size WORD tlvx16Sz = sizeof( sWDSSetMIPParametersRequest_MNHARFC2002BISAuthentication ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx16Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x16; pHeader->mLength = tlvx16Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetMIPParametersRequest_MNHARFC2002BISAuthentication * pTLVx16; pTLVx16 = (sWDSSetMIPParametersRequest_MNHARFC2002BISAuthentication*)(pOut + offset); memset( pTLVx16, 0, tlvx16Sz ); // Set the value pTLVx16->mMNHARFC2002BISAuthentication = (*pHA2002bis == 0 ? 0 : 1); offset += tlvx16Sz; } // At least one of the optional parameters must have been set if (offset <= sizeof( sQMIRawContentHeader ) + tlvx01Sz) { return eGOBI_ERR_INVALID_ARG; } *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetMobileIPParameters DESCRIPTION: This function gets the mobile IP parameters PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pMode [ O ] - Current mobile IP setting pRetryLimit [ O ] - Retry attempt limit pRetryInterval [ O ] - Retry attempt interval pReRegPeriod [ O ] - Re-registration period pReRegTraffic [ O ] - Re-registration only with traffic? pHAAuthenticator [ O ] - MH-HA authenticator calculator? pHA2002bis [ O ] - MH-HA RFC 2002bis authentication? RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetMobileIPParameters( ULONG inLen, const BYTE * pIn, ULONG * pMode, BYTE * pRetryLimit, BYTE * pRetryInterval, BYTE * pReRegPeriod, BYTE * pReRegTraffic, BYTE * pHAAuthenticator, BYTE * pHA2002bis ) { // Validate arguments if (pIn == 0 || pMode == 0 || pRetryLimit == 0 || pRetryInterval == 0 || pReRegPeriod == 0 || pReRegTraffic == 0 || pHAAuthenticator == 0 || pHA2002bis == 0) { return eGOBI_ERR_INVALID_ARG; } *pMode = 0xffffffff; *pRetryLimit = 0xff; *pRetryInterval = 0xff; *pReRegPeriod = 0xff; *pReRegTraffic = 0xff; *pHAAuthenticator = 0xff; *pHA2002bis = 0xff; // Find the mode const sWDSGetMIPParametersResponse_MobileIPMode * pTLVx10; ULONG outLenx10; ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc == eGOBI_ERR_NONE) { if (outLenx10 < sizeof( sWDSGetMIPParametersResponse_MobileIPMode )) { return eGOBI_ERR_MALFORMED_RSP; } *pMode = pTLVx10->mMIPMode; } // Find the Retry limit const sWDSGetMIPParametersResponse_RetryAttemptLimit * pTLVx11; ULONG outLenx11; rc = GetTLV( inLen, pIn, 0x11, &outLenx11, (const BYTE **)&pTLVx11 ); if (rc == eGOBI_ERR_NONE) { if (outLenx11 < sizeof( sWDSGetMIPParametersResponse_RetryAttemptLimit )) { return eGOBI_ERR_MALFORMED_RSP; } *pRetryLimit = pTLVx11->mRetryAttemptLimit; } // Find the Retry Interval const sWDSGetMIPParametersResponse_RetryAttemptInterval * pTLVx12; ULONG outLenx12; rc = GetTLV( inLen, pIn, 0x12, &outLenx12, (const BYTE **)&pTLVx12 ); if (rc == eGOBI_ERR_NONE) { if (outLenx12 < sizeof( sWDSGetMIPParametersResponse_RetryAttemptInterval )) { return eGOBI_ERR_MALFORMED_RSP; } *pRetryInterval = pTLVx12->mRetryAttemptInterval; } // Find the Re-registration period const sWDSGetMIPParametersResponse_ReRegistrationPeriod * pTLVx13; ULONG outLenx13; rc = GetTLV( inLen, pIn, 0x13, &outLenx13, (const BYTE **)&pTLVx13 ); if (rc == eGOBI_ERR_NONE) { if (outLenx13 < sizeof( sWDSGetMIPParametersResponse_ReRegistrationPeriod )) { return eGOBI_ERR_MALFORMED_RSP; } *pReRegPeriod = pTLVx13->mReRegistrationPeriod; } // Find the Re-register on traffic flag const sWDSGetMIPParametersResponse_ReRegistrationOnlyWithTraffic * pTLVx14; ULONG outLenx14; rc = GetTLV( inLen, pIn, 0x14, &outLenx14, (const BYTE **)&pTLVx14 ); if (rc == eGOBI_ERR_NONE) { if (outLenx14 < sizeof( sWDSGetMIPParametersResponse_ReRegistrationOnlyWithTraffic )) { return eGOBI_ERR_MALFORMED_RSP; } *pReRegTraffic = pTLVx14->mReRegistrationOnlyWithTraffic; } // Find the HA authenticator const sWDSGetMIPParametersResponse_MNHAAuthenticatorCalculator * pTLVx15; ULONG outLenx15; rc = GetTLV( inLen, pIn, 0x15, &outLenx15, (const BYTE **)&pTLVx15 ); if (rc == eGOBI_ERR_NONE) { if (outLenx15 < sizeof( sWDSGetMIPParametersResponse_MNHAAuthenticatorCalculator )) { return eGOBI_ERR_MALFORMED_RSP; } *pHAAuthenticator = pTLVx15->mMNHAAuthenticatorCalculator; } // Find the HA RFC2002bis authentication flag const sWDSGetMIPParametersResponse_MNHARFC2002BISAuthentication * pTLVx16; ULONG outLenx16; rc = GetTLV( inLen, pIn, 0x16, &outLenx16, (const BYTE **)&pTLVx16 ); if (rc == eGOBI_ERR_NONE) { if (outLenx16 < sizeof( sWDSGetMIPParametersResponse_MNHARFC2002BISAuthentication )) { return eGOBI_ERR_MALFORMED_RSP; } *pHA2002bis = pTLVx16->mMNHARFC2002BISAuthentication; } return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetLastMobileIPError DESCRIPTION: This function gets the last mobile IP error PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pError [ O ] - Last mobile IP error RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetLastMobileIPError( ULONG inLen, const BYTE * pIn, ULONG * pError ) { // Validate arguments if (pIn == 0 || pError == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the TLV const sWDSGetLastMIPStatusResponse_Status * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc != eGOBI_ERR_NONE) { return rc; } // Is the TLV large enough? if (outLenx01 < sizeof( sWDSGetLastMIPStatusResponse_Status )) { return eGOBI_ERR_MALFORMED_RSP; } *pError = pTLVx01->mLastMIPStatus; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: PackSetDNSSettings DESCRIPTION: This function sets the DNS settings for the device PARAMETERS: pOutLen [I/O] - Upon input the maximum number of BYTEs pOut can contain, upon output the number of BYTEs copied to pOut pOut [ O ] - Output buffer pPrimaryDNS [ I ] - (Optional) Primary DNS IPv4 address pSecondaryDNS [ I ] - (Optional) Secondary DNS IPv4 address RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG PackSetDNSSettings( ULONG * pOutLen, BYTE * pOut, ULONG * pPrimaryDNS, ULONG * pSecondaryDNS ) { // Validate arguments // At least one must be specified if (pOut == 0 || (pPrimaryDNS == 0 && pSecondaryDNS == 0)) { return eGOBI_ERR_INVALID_ARG; } sQMIRawContentHeader * pHeader; ULONG offset = 0; // Add Primary DNS, if specified if (pPrimaryDNS != 0) { // Check size WORD tlvx10Sz = sizeof( sWDSSetDNSSettingRequest_PrimaryDNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx10Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x10; pHeader->mLength = tlvx10Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetDNSSettingRequest_PrimaryDNS * pTLVx10; pTLVx10 = (sWDSSetDNSSettingRequest_PrimaryDNS*)(pOut + offset); memset( pTLVx10, 0, tlvx10Sz ); ULONG ip0 = (*pPrimaryDNS & 0x000000FF); ULONG ip1 = (*pPrimaryDNS & 0x0000FF00) >> 8; ULONG ip2 = (*pPrimaryDNS & 0x00FF0000) >> 16; ULONG ip3 = (*pPrimaryDNS & 0xFF000000) >> 24; // Set the value pTLVx10->mIPV4Address[0] = (INT8)ip0; pTLVx10->mIPV4Address[1] = (INT8)ip1; pTLVx10->mIPV4Address[2] = (INT8)ip2; pTLVx10->mIPV4Address[3] = (INT8)ip3; offset += tlvx10Sz; } // Add Secondary DNS, if specified if (pSecondaryDNS != 0) { // Check size WORD tlvx11Sz = sizeof( sWDSSetDNSSettingRequest_SecondaryDNS ); if (*pOutLen < offset + sizeof( sQMIRawContentHeader ) + tlvx11Sz) { return eGOBI_ERR_BUFFER_SZ; } pHeader = (sQMIRawContentHeader*)(pOut + offset); pHeader->mTypeID = 0x11; pHeader->mLength = tlvx11Sz; offset += sizeof( sQMIRawContentHeader ); sWDSSetDNSSettingRequest_SecondaryDNS * pTLVx11; pTLVx11 = (sWDSSetDNSSettingRequest_SecondaryDNS*)(pOut + offset); memset( pTLVx11, 0, tlvx11Sz ); ULONG ip0 = (*pSecondaryDNS & 0x000000FF); ULONG ip1 = (*pSecondaryDNS & 0x0000FF00) >> 8; ULONG ip2 = (*pSecondaryDNS & 0x00FF0000) >> 16; ULONG ip3 = (*pSecondaryDNS & 0xFF000000) >> 24; // Set the value pTLVx11->mIPV4Address[0] = (INT8)ip0; pTLVx11->mIPV4Address[1] = (INT8)ip1; pTLVx11->mIPV4Address[2] = (INT8)ip2; pTLVx11->mIPV4Address[3] = (INT8)ip3; offset += tlvx11Sz; } *pOutLen = offset; return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetDNSSettings DESCRIPTION: This function gets the DNS settings for the device PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pPrimaryDNS [ O ] - Primary DNS IPv4 address pSecondaryDNS [ O ] - Secondary DNS IPv4 address RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetDNSSettings( ULONG inLen, const BYTE * pIn, ULONG * pPrimaryDNS, ULONG * pSecondaryDNS ) { // Validate arguments if (pIn == 0 || pPrimaryDNS == 0 || pSecondaryDNS == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the Primary DNS const sWDSGetDNSSettingResponse_PrimaryDNS * pTLVx10; ULONG outLenx10; ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 ); if (rc == eGOBI_ERR_NONE) { if (outLenx10 < sizeof( sWDSGetDNSSettingResponse_PrimaryDNS )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx10->mIPV4Address[0]; ULONG ip1 = pTLVx10->mIPV4Address[1] << 8; ULONG ip2 = pTLVx10->mIPV4Address[2] << 16; ULONG ip3 = pTLVx10->mIPV4Address[3] << 24; *pPrimaryDNS = (ip0 | ip1 | ip2 | ip3); } // Find the Secondary DNS const sWDSGetDNSSettingResponse_SecondaryDNS * pTLVx11; ULONG outLenx11; rc = GetTLV( inLen, pIn, 0x11, &outLenx11, (const BYTE **)&pTLVx11 ); if (rc == eGOBI_ERR_NONE) { if (outLenx11 < sizeof( sWDSGetDNSSettingResponse_SecondaryDNS )) { return eGOBI_ERR_MALFORMED_RSP; } ULONG ip0 = pTLVx11->mIPV4Address[0]; ULONG ip1 = pTLVx11->mIPV4Address[1] << 8; ULONG ip2 = pTLVx11->mIPV4Address[2] << 16; ULONG ip3 = pTLVx11->mIPV4Address[3] << 24; *pSecondaryDNS = (ip0 | ip1 | ip2 | ip3); } return eGOBI_ERR_NONE; } /*=========================================================================== METHOD: ParseGetDataBearerTechnology DESCRIPTION: This function retrieves the current data bearer technology (only valid when connected) PARAMETERS: inLen [ I ] - Length of input buffer pIn [ I ] - Input buffer pDataCaps [ O ] - The data bearer technology RETURN VALUE: ULONG - Return code ===========================================================================*/ ULONG ParseGetDataBearerTechnology( ULONG inLen, const BYTE * pIn, ULONG * pDataBearer ) { // Validate arguments if (pIn == 0 || pDataBearer == 0) { return eGOBI_ERR_INVALID_ARG; } // Find the TLV const sWDSGetDataBearerTechnologyResponse_Technology * pTLVx01; ULONG outLenx01; ULONG rc = GetTLV( inLen, pIn, 0x01, &outLenx01, (const BYTE **)&pTLVx01 ); if (rc != eGOBI_ERR_NONE) { return rc; } // Is the TLV large enough? if (outLenx01 < sizeof( sWDSGetDataBearerTechnologyResponse_Technology )) { return eGOBI_ERR_MALFORMED_RSP; } *pDataBearer = pTLVx01->mDataBearerTechnology; return eGOBI_ERR_NONE; }