phone-side
/
libqmi-qmuxd
9
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
libqmi-qmuxd/gobi-api/GobiAPI_2013-07-31-1347/Gobi3000Translation/Gobi3000TranslationUIM.cpp

1170 lines
35 KiB
C++
Raw Blame History

/*===========================================================================
FILE:
Gobi3000TranslationUIM.cpp
DESCRIPTION:
QUALCOMM Translation for Gobi 3000 (DMS_UIM Service)
Copyright (c) 2013, The Linux Foundation. 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 The Linux Foundation 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:
ParseUIMUnblockControlKey
DESCRIPTION:
This function unblocks the specified facility control key
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pUnblockRetriesLeft [ O ] - The number of unblock retries left, after
which the control key will be permanently
blocked
(0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMUnblockControlKey(
ULONG inLen,
const BYTE * pIn,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0 || pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMUnblockControlKeyResponse_Status * pTLVx10;
ULONG outLenx10;
ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (outLenx10 < sizeof( sDMSUIMUnblockControlKeyResponse_Status ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pUnblockRetriesLeft = pTLVx10->mRemainingUnblockRetries;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMUnblockControlKey
DESCRIPTION:
This function unblocks the specified facility control key
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
id [ I ] - Facility ID
pValue [ I ] - Control key de-personalization string
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMUnblockControlKey(
ULONG * pOutLen,
BYTE * pOut,
ULONG id,
CHAR * pValue )
{
// Validate arguments
if (pOut == 0
|| pValue == 0
|| pValue[0] == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Add arguments
std::string val( pValue );
UINT8 valSz = (UINT8)val.size();
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMUnblockControlKeyRequest_Facility ) + valSz;
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
sDMSUIMUnblockControlKeyRequest_Facility * pTLVx01;
pTLVx01 = (sDMSUIMUnblockControlKeyRequest_Facility*)(pOut + offset);
memset( pTLVx01, 0, tlvx01Sz );
// Set the values
pTLVx01->mFacility = (eQMIDMSUIMFacility)id;
pTLVx01->mControlKeyLength = valSz;
offset += sizeof( sDMSUIMUnblockControlKeyRequest_Facility );
memcpy( (pOut + offset), (LPCSTR)val.c_str(), valSz );
offset += valSz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMSetControlKeyProtection
DESCRIPTION:
This function changes the specified facility control key
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pVerifyRetriesLeft [ O ] - Upon operational failure this will indicate
the number of retries left, after which the
control key will be blocked
(0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMSetControlKeyProtection(
ULONG inLen,
const BYTE * pIn,
ULONG * pVerifyRetriesLeft )
{
// Validate arguments
if (pIn == 0 || pVerifyRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMSetControlKeyProtectionResponse_Status * pTLVx10;
ULONG outLenx10;
ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (outLenx10 < sizeof( sDMSUIMSetControlKeyProtectionResponse_Status ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx10->mRemainingVerifyRetries;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMSetControlKeyProtection
DESCRIPTION:
This function changes the specified facility control key
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
id [ I ] - Facility ID
status [ I ] - Control key status
pValue [ I ] - Control key de-personalization string
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMSetControlKeyProtection(
ULONG * pOutLen,
BYTE * pOut,
ULONG id,
ULONG status,
CHAR * pValue )
{
// Validate arguments
if (pOut == 0
|| pValue == 0
|| pValue[0] == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Add arguments
std::string val( pValue );
UINT8 valSz = (UINT8)val.size();
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMSetControlKeyProtectionRequest_Facility ) + valSz;
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
sDMSUIMSetControlKeyProtectionRequest_Facility * pTLVx01;
pTLVx01 = (sDMSUIMSetControlKeyProtectionRequest_Facility*)(pOut + offset);
memset( pTLVx01, 0, tlvx01Sz );
// Set the values
pTLVx01->mFacility = (eQMIDMSUIMFacility)id;
pTLVx01->mFacilityState = (eQMIDMSUIMFacilityStates)status;
pTLVx01->mControlKeyLength = (UINT8)valSz;
offset += sizeof( sDMSUIMSetControlKeyProtectionRequest_Facility );
memcpy( (pOut + offset), val.c_str(), valSz );
offset += valSz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMGetControlKeyBlockingStatus
DESCRIPTION:
This function returns the status of the specified facility control key
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pStatus [ O ] - Control key status
pVerifyRetriesLeft [ O ] - The number of retries left, after which the
control key will be blocked
pUnblockRetriesLeft [ O ] - The number of unblock retries left, after
which the control key will be permanently
blocked
pbBlocking [ O ] - (Optional) Is the facility blocking?
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMGetControlKeyBlockingStatus(
ULONG inLen,
const BYTE * pIn,
ULONG * pStatus,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft,
ULONG * pbBlocking )
{
// Validate arguments
if (pIn == 0
|| pStatus == 0
|| pVerifyRetriesLeft == 0
|| pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the first arguments
const sDMSUIMGetControlKeyStatusResponse_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( sDMSUIMGetControlKeyStatusResponse_Status ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx01->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLVx01->mRemainingUnblockRetries;
*pStatus = pTLVx01->mFacilityState;
// Find the last (optional) argument
if (pbBlocking != 0)
{
const sDMSUIMGetControlKeyStatusResponse_Blocking * pTLVx10;
ULONG tlvLenx10;
rc = GetTLV( inLen, pIn, 0x10, &tlvLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (tlvLenx10 < sizeof( sDMSUIMGetControlKeyStatusResponse_Blocking ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pbBlocking = pTLVx10->mOperationBlocking;
}
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMGetControlKeyBlockingStatus
DESCRIPTION:
This function returns the status of the specified facility control key
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
id [ I ] - Facility ID
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMGetControlKeyBlockingStatus(
ULONG * pOutLen,
BYTE * pOut,
ULONG id )
{
// Validate arguments
if (pOut == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Add id
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMGetControlKeyStatusRequest_Facility );
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
sDMSUIMGetControlKeyStatusRequest_Facility * pTLVx01;
pTLVx01 = (sDMSUIMGetControlKeyStatusRequest_Facility*)(pOut + offset);
memset( pTLVx01, 0, tlvx01Sz );
// Set the values
pTLVx01->mFacility = (eQMIDMSUIMFacility)id;
offset += tlvx01Sz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMGetControlKeyStatus
DESCRIPTION:
This function returns the status of the specified facility control key
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pStatus [ O ] - Control key status
pVerifyRetriesLeft [ O ] - The number of retries left, after which the
control key will be blocked
pUnblockRetriesLeft [ O ] - The number of unblock retries left, after
which the control key will be permanently
blocked
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMGetControlKeyStatus(
ULONG inLen,
const BYTE * pIn,
ULONG * pStatus,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0
|| pStatus == 0
|| pVerifyRetriesLeft == 0
|| pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the arguments
const sDMSUIMGetControlKeyStatusResponse_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( sDMSUIMGetControlKeyStatusResponse_Status ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx01->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLVx01->mRemainingUnblockRetries;
*pStatus = pTLVx01->mFacilityState;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMGetControlKeyStatus
DESCRIPTION:
This function requests the status of the specified facility control key
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
id [ I ] - Facility ID
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMGetControlKeyStatus(
ULONG * pOutLen,
BYTE * pOut,
ULONG id )
{
// Request is the same as PackUIMGetControlKeyBlockingStatus
return PackUIMGetControlKeyBlockingStatus( pOutLen,
pOut,
id );
}
/*===========================================================================
METHOD:
ParseUIMGetICCID
DESCRIPTION:
This function returns the UIM ICCID
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
stringSize [ I ] - The maximum number of characters (including NULL
terminator) that the string array can contain
pString [ O ] - NULL terminated string
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMGetICCID(
ULONG inLen,
const BYTE * pIn,
BYTE stringSize,
CHAR * pString )
{
// Validate arguments
if (pIn == 0 || stringSize == 0 || pString == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMGetICCIDResponse_ICCID * 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( sDMSUIMGetICCIDResponse_ICCID ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
// The TLV only contains the string
// Space to perform the copy?
if (stringSize < outLenx01 + 1)
{
return eGOBI_ERR_BUFFER_SZ;
}
memcpy( pString, (const CHAR*)pTLVx01, outLenx01 );
pString[outLenx01] = 0;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMGetPINStatus
DESCRIPTION:
This function returns the status of the pin
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
id [ I ] - PIN ID (1/2)
pStatus [ O ] - PIN status (0xFFFFFFFF = unknown)
pVerifyRetriesLeft [ O ] - The number of retries left, after which the
PIN will be blocked (0xFFFFFFFF = unknown)
pUnblockRetriesLeft [ O ] - The number of unblock retries left, after
which the PIN will be permanently blocked,
i.e. UIM is unusable (0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMGetPINStatus(
ULONG inLen,
const BYTE * pIn,
ULONG id,
ULONG * pStatus,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0
|| id < 1
|| id > 2
|| pStatus == 0
|| pVerifyRetriesLeft == 0
|| pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
ULONG tlvLen;
// The typeID is either 0x11 or 0x12
if (id == 1)
{
const sDMSUIMGetPINStatusResponse_PIN1Status * pTLV11;
ULONG rc = GetTLV( inLen, pIn, 0x11, &tlvLen, (const BYTE **)&pTLV11 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (tlvLen < sizeof( sDMSUIMGetPINStatusResponse_PIN1Status ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLV11->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLV11->mRemainingUnblockRetries;
*pStatus = pTLV11->mPINStatus;
}
else if (id == 2)
{
const sDMSUIMGetPINStatusResponse_PIN2Status * pTLV12;
ULONG rc = GetTLV( inLen, pIn, 0x12, &tlvLen, (const BYTE **)&pTLV12 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (tlvLen < sizeof( sDMSUIMGetPINStatusResponse_PIN2Status ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLV12->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLV12->mRemainingUnblockRetries;
*pStatus = pTLV12->mPINStatus;
}
else
{
return eGOBI_ERR_INVALID_ARG;
}
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMChangePIN
DESCRIPTION:
This function changes the PIN value
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pVerifyRetriesLeft [ O ] - Upon operational failure this will indicate
the number of retries left, after which the
PIN will be blocked (0xFFFFFFFF = unknown)
pUnblockRetriesLeft [ O ] - Upon operational failure this will indicate
the number of unblock retries left, after
which the PIN will be permanently blocked,
i.e. UIM is unusable (0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMChangePIN(
ULONG inLen,
const BYTE * pIn,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0 || pVerifyRetriesLeft == 0 || pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMChangePINResponse_RetryInfo * pTLVx10;
ULONG outLenx10;
ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (outLenx10 < sizeof( sDMSUIMChangePINResponse_RetryInfo ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx10->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLVx10->mRemainingUnblockRetries;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMChangePIN
DESCRIPTION:
This function changes the PIN value
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
id [ I ] - PIN ID (1/2)
pOldValue [ I ] - Old PIN value of the PIN to change
pNewValue [ I ] - New PIN value of the PIN to change
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMChangePIN(
ULONG * pOutLen,
BYTE * pOut,
ULONG id,
CHAR * pOldValue,
CHAR * pNewValue )
{
// Validate arguments
if (pOut == 0
|| id < 1
|| id > 2
|| pOldValue == 0
|| pOldValue[0] == 0
|| pNewValue == 0
|| pNewValue[0] == 0 )
{
return eGOBI_ERR_INVALID_ARG;
}
// Add arguments
std::string oldVal( pOldValue );
ULONG oldValSz = (ULONG)oldVal.size();
std::string newVal( pNewValue );
ULONG newValSz = (ULONG)newVal.size();
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMChangePINRequest_Info )
+ (WORD)oldValSz + (WORD)newValSz;
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
// First part of the TLV
sDMSUIMChangePINRequest_Info1 * pTLVx01_1;
pTLVx01_1 = (sDMSUIMChangePINRequest_Info1*)(pOut + offset);
memset( pTLVx01_1, 0, tlvx01Sz );
pTLVx01_1->mPINID = (UINT8)id;
pTLVx01_1->mOldPINLength = (UINT8)oldValSz;
offset += sizeof( sDMSUIMChangePINRequest_Info1 );
// mOldPINValue string
memcpy( (pOut + offset), oldVal.c_str(), oldValSz );
offset += oldValSz;
// Second part of the TLV
sDMSUIMChangePINRequest_Info2 * pTLVx01_2;
pTLVx01_2 = (sDMSUIMChangePINRequest_Info2*)(pOut + offset);
pTLVx01_2->mNewPINLength = (UINT8)newValSz;
offset += sizeof( sDMSUIMChangePINRequest_Info2 );
// mNewPINValue string
memcpy( (pOut + offset), newVal.c_str(), newValSz );
offset += newValSz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMUnblockPIN
DESCRIPTION:
This function unblocks a blocked PIN
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pVerifyRetriesLeft [ O ] - Upon operational failure this will indicate
the number of retries left, after which the
PIN will be blocked (0xFFFFFFFF = unknown)
pUnblockRetriesLeft [ O ] - Upon operational failure this will indicate
the number of unblock retries left, after
which the PIN will be permanently blocked,
i.e. UIM is unusable (0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMUnblockPIN(
ULONG inLen,
const BYTE * pIn,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0 || pVerifyRetriesLeft == 0 || pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMUnblockPINResponse_RetryInfo * pTLVx10;
ULONG outLenx10;
ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (outLenx10 < sizeof( sDMSUIMUnblockPINResponse_RetryInfo ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx10->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLVx10->mRemainingUnblockRetries;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMUnblockPIN
DESCRIPTION:
This function unblocks a blocked PIN
PARAMETERS:
id [ I ] - PIN ID (1/2)
pPUKValue [ I ] - PUK value of the PIN to unblock
pNewValue [ I ] - New PIN value of the PIN to unblock
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMUnblockPIN(
ULONG * pOutLen,
BYTE * pOut,
ULONG id,
CHAR * pPUKValue,
CHAR * pNewValue )
{
// Validate arguments
if (pOut == 0
|| id < 1
|| id > 2
|| pPUKValue == 0
|| pPUKValue[0] == 0
|| pNewValue == 0
|| pNewValue[0] == 0 )
{
return eGOBI_ERR_INVALID_ARG;
}
// Add arguments
std::string oldVal( pPUKValue );
ULONG oldValSz = (ULONG)oldVal.size();
std::string newVal( pNewValue );
ULONG newValSz = (ULONG)newVal.size();
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMUnblockPINRequest_Info )
+ (WORD)oldValSz + (WORD)newValSz;
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
// First part of the TLV
sDMSUIMUnblockPINRequest_Info1 * pTLVx01_1;
pTLVx01_1 = (sDMSUIMUnblockPINRequest_Info1*)(pOut + offset);
memset( pTLVx01_1, 0, tlvx01Sz );
pTLVx01_1->mPINID = (UINT8)id;
pTLVx01_1->mPUKLength = (UINT8)oldValSz;
offset += sizeof( sDMSUIMUnblockPINRequest_Info1 );
// mPUKValue string
memcpy( (pOut + offset), oldVal.c_str(), oldValSz );
offset += oldValSz;
// Second part of the TLV
sDMSUIMUnblockPINRequest_Info2 * pTLVx01_2;
pTLVx01_2 = (sDMSUIMUnblockPINRequest_Info2*)(pOut + offset);
pTLVx01_2->mNewPINLength = (UINT8)newValSz;
offset += sizeof( sDMSUIMUnblockPINRequest_Info2 );
// mNewPINValue string
memcpy( (pOut + offset), newVal.c_str(), newValSz );
offset += newValSz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMVerifyPIN
DESCRIPTION:
This function verifies the PIN before accessing the UIM contents
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pVerifyRetriesLeft [ O ] - Upon operational failure this will indicate
the number of retries left, after which the
PIN will be blocked (0xFFFFFFFF = unknown)
pUnblockRetriesLeft [ O ] - Upon operational failure this will indicate
the number of unblock retries left, after
which the PIN will be permanently blocked,
i.e. UIM is unusable (0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMVerifyPIN(
ULONG inLen,
const BYTE * pIn,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0 || pVerifyRetriesLeft == 0 || pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMVerifyPINResponse_RetryInfo * pTLVx10;
ULONG outLenx10;
ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (outLenx10 < sizeof( sDMSUIMVerifyPINResponse_RetryInfo ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx10->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLVx10->mRemainingUnblockRetries;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMVerifyPIN
DESCRIPTION:
This function verifies the PIN before accessing the UIM contents
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
id [ I ] - PIN ID (1/2)
pValue [ I ] - PIN value of the PIN to verify
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMVerifyPIN(
ULONG * pOutLen,
BYTE * pOut,
ULONG id,
CHAR * pValue )
{
// Validate arguments
if (pOut == 0
|| id < 1
|| id > 2
|| pValue == 0
|| pValue[0] == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Add arguments
std::string val( pValue );
UINT8 valSz = (UINT8)val.size();
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMVerifyPINRequest_Info ) + valSz;
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
sDMSUIMVerifyPINRequest_Info * pTLVx01;
pTLVx01 = (sDMSUIMVerifyPINRequest_Info*)(pOut + offset);
memset( pTLVx01, 0, tlvx01Sz );
// Set the values
pTLVx01->mPINID = (UINT8)id;
pTLVx01->mPINLength = valSz;
offset += sizeof( sDMSUIMVerifyPINRequest_Info );
// Add mPINValue
memcpy( (pOut + offset), val.c_str(), valSz );
offset += valSz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
ParseUIMSetPINProtection
DESCRIPTION:
This function enables or disables protection of UIM contents by a
given PIN
PARAMETERS:
inLen [ I ] - Length of input buffer
pIn [ I ] - Input buffer
pVerifyRetriesLeft [ O ] - Upon operational failure this will indicate
the number of retries left, after which the
PIN will be blocked (0xFFFFFFFF = unknown)
pUnblockRetriesLeft [ O ] - Upon operational failure this will indicate
the number of unblock retries left, after
which the PIN will be permanently blocked,
i.e. UIM is unusable (0xFFFFFFFF = unknown)
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG ParseUIMSetPINProtection(
ULONG inLen,
const BYTE * pIn,
ULONG * pVerifyRetriesLeft,
ULONG * pUnblockRetriesLeft )
{
// Validate arguments
if (pIn == 0 || pVerifyRetriesLeft == 0 || pUnblockRetriesLeft == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Find the TLV
const sDMSUIMSetPINProtectionResponse_RetryInfo * pTLVx10;
ULONG outLenx10;
ULONG rc = GetTLV( inLen, pIn, 0x10, &outLenx10, (const BYTE **)&pTLVx10 );
if (rc != eGOBI_ERR_NONE)
{
return rc;
}
// Is the TLV large enough?
if (outLenx10 < sizeof( sDMSUIMSetPINProtectionResponse_RetryInfo ))
{
return eGOBI_ERR_MALFORMED_RSP;
}
*pVerifyRetriesLeft = pTLVx10->mRemainingVerifyRetries;
*pUnblockRetriesLeft = pTLVx10->mRemainingUnblockRetries;
return eGOBI_ERR_NONE;
}
/*===========================================================================
METHOD:
PackUIMSetPINProtection
DESCRIPTION:
This function enables or disables protection of UIM contents by a
given PIN
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
id [ I ] - PIN ID (1/2)
bEnable [ I ] - Enable/disable PIN protection (0 = disable)?
pValue [ I ] - PIN value of the PIN to be enabled/disabled
RETURN VALUE:
ULONG - Return code
===========================================================================*/
ULONG PackUIMSetPINProtection(
ULONG * pOutLen,
BYTE * pOut,
ULONG id,
ULONG bEnable,
CHAR * pValue )
{
// Validate arguments
if (pOut == 0
|| id < 1
|| id > 2
|| pValue == 0
|| pValue[0] == 0)
{
return eGOBI_ERR_INVALID_ARG;
}
// Add arguments
std::string val( pValue );
ULONG valSz = (ULONG)val.size();
// Check size
WORD tlvx01Sz = sizeof( sDMSUIMSetPINProtectionRequest_Info ) + (WORD)valSz;
if (*pOutLen < sizeof( sQMIRawContentHeader ) + tlvx01Sz)
{
return eGOBI_ERR_BUFFER_SZ;
}
sQMIRawContentHeader * pHeader = (sQMIRawContentHeader*)pOut;
pHeader->mTypeID = 0x01;
pHeader->mLength = tlvx01Sz;
ULONG offset = sizeof( sQMIRawContentHeader );
sDMSUIMSetPINProtectionRequest_Info * pTLVx01;
pTLVx01 = (sDMSUIMSetPINProtectionRequest_Info*)(pOut + offset);
memset( pTLVx01, 0, tlvx01Sz );
// Set the values
pTLVx01->mPINID = (UINT8)id;
pTLVx01->mPINEnabled = (bEnable == 0 ? 0 : 1);
pTLVx01->mPINLength = (UINT8)valSz;
offset += sizeof( sDMSUIMSetPINProtectionRequest_Info );
// Add mPINValue
memcpy( (pOut + offset), val.c_str(), valSz );
offset += valSz;
*pOutLen = offset;
return eGOBI_ERR_NONE;
}
Reference in New Issue View Git Blame Copy Permalink