core: moved Gobi API sources and utils to their own subdirectories

1 files changed, 940 insertions, 0 deletions

diff --git a/gobi-api/GobiAPI_1.0.40/Shared/GobiQMICoreSMS.cpp b/gobi-api/GobiAPI_1.0.40/Shared/GobiQMICoreSMS.cpp
new file mode 100755
index 0000000..789280d
--- /dev/null
+++ b/gobi-api/GobiAPI_1.0.40/Shared/GobiQMICoreSMS.cpp
@@ -0,0 +1,940 @@
+/*===========================================================================
+FILE: 
+   GobiQMICoreSMS.cpp
+
+DESCRIPTION:
+   QUALCOMM Gobi QMI Based API Core (SMS Service)
+
+PUBLIC CLASSES AND FUNCTIONS:
+   cGobiQMICore
+
+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 "StdAfx.h"
+#include "GobiQMICore.h"
+
+#include "QMIBuffers.h"
+
+//---------------------------------------------------------------------------
+// Definitions
+//---------------------------------------------------------------------------
+
+/*=========================================================================*/
+// cGobiQMICore Methods
+/*=========================================================================*/
+
+/*===========================================================================
+METHOD:
+   DeleteSMS (Public Method)
+
+DESCRIPTION:
+   This function deletes one or more SMS messages from device memory
+
+PARAMETERS:
+   storageType    [ I ] - SMS message storage type
+   pMessageIndex  [ I ] - (Optional) message index
+   pMessageTag    [ I ] - (Optional) message tag
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::DeleteSMS( 
+   ULONG                      storageType, 
+   ULONG *                    pMessageIndex, 
+   ULONG *                    pMessageTag )
+{
+   WORD msgID = (WORD)eQMI_WMS_DELETE;
+   std::vector <sDB2PackingInput> piv;
+
+   std::ostringstream tmp;
+   tmp << (UINT)storageType;
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   if (pMessageIndex != 0)
+   {
+      std::ostringstream tmp2;
+      tmp2 << (UINT)*pMessageIndex;
+
+      sProtocolEntityKey pek1( eDB2_ET_QMI_WMS_REQ, msgID, 16 );
+      sDB2PackingInput pi1( pek1, (LPCSTR)tmp2.str().c_str() );
+      piv.push_back( pi1 );
+   }
+
+   if (pMessageTag != 0)
+   {
+      std::ostringstream tmp2;
+      tmp2 << (UINT)*pMessageTag;
+
+      sProtocolEntityKey pek1( eDB2_ET_QMI_WMS_REQ, msgID, 17 );
+      sDB2PackingInput pi1( pek1, (LPCSTR)tmp2.str().c_str() );
+      piv.push_back( pi1 );
+   }
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+
+   // Send the QMI request, check result, and return 
+   return SendAndCheckReturn( eQMI_SVC_WMS, pRequest, 10000 );
+}
+
+/*===========================================================================
+METHOD:
+   GetSMSList (Public Method)
+
+DESCRIPTION:
+   This function returns the list of SMS messages stored on the device
+
+PARAMETERS:
+   storageType       [ I ] - SMS message storage type
+   pRequestedTag     [ I ] - Message index
+   pMessageListSize  [I/O] - Upon input the maximum number of elements that the 
+                             message list array can contain.  Upon successful 
+                             output the actual number of elements in the message 
+                             list array
+   pMessageList      [ O ] - The message list array
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::GetSMSList( 
+   ULONG                      storageType, 
+   ULONG *                    pRequestedTag,
+   ULONG *                    pMessageListSize, 
+   BYTE *                     pMessageList )
+{
+   // Validate arguments
+   if (pMessageListSize == 0 || *pMessageListSize == 0 || pMessageList == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   ULONG maxMessageListSz = *pMessageListSize;
+
+   // Assume failure
+   *pMessageListSize = 0;
+
+   WORD msgID = (WORD)eQMI_WMS_GET_MSG_LIST;
+   std::vector <sDB2PackingInput> piv;
+
+   std::ostringstream tmp;
+   tmp << (UINT)storageType;
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   if (pRequestedTag != 0)
+   {
+      std::ostringstream tmp2;
+      tmp2 << (UINT)*pRequestedTag;
+
+      sProtocolEntityKey pek1( eDB2_ET_QMI_WMS_REQ, msgID, 16 );
+      sDB2PackingInput pi1( pek1, (LPCSTR)tmp2.str().c_str() );
+      piv.push_back( pi1 );
+   }
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+   if (pRequest == 0)
+   {
+      return eGOBI_ERR_MEMORY;
+   }
+   
+   // Send the QMI request
+   sProtocolBuffer rsp = Send( eQMI_SVC_WMS, pRequest, 5000 );
+   if (rsp.IsValid() == false)
+   {
+      return GetCorrectedLastError();
+   }
+
+   // Did we receive a valid QMI response?
+   sQMIServiceBuffer qmiRsp( rsp.GetSharedBuffer() );
+   if (qmiRsp.IsValid() == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   
+   // Check the mandatory QMI result TLV for success
+   ULONG rc = 0;
+   ULONG ec = 0;
+   bool bResult = qmiRsp.GetResult( rc, ec );
+   if (bResult == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   else if (rc != 0)
+   {
+      return GetCorrectedQMIError( ec );
+   }
+
+   // Prepare TLVs for parsing
+   std::vector <sDB2NavInput> tlvs = DB2ReduceQMIBuffer( qmiRsp );
+
+   // Parse the TLV we want (by DB key)
+   sProtocolEntityKey tlvKey( eDB2_ET_QMI_WMS_RSP, msgID, 1 );
+   cDataParser::tParsedFields pf = ParseTLV( db, rsp, tlvs, tlvKey );
+   if (pf.size() < 1) 
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   ULONG messageListSz = pf[0].mValue.mU32;
+   if (messageListSz == 0)
+   {
+      // No stored messages, but not necessarily a failure
+      return eGOBI_ERR_NONE;
+   }
+
+   if (pf.size() < (1 + (messageListSz * 2)) )
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   if (maxMessageListSz < messageListSz)
+   {
+      messageListSz = maxMessageListSz;
+   }
+
+   ULONG m = 0;
+   ULONG mf = 1;
+   ULONG * pData = (ULONG *)pMessageList;   
+   for (m = 0; m < messageListSz; m++)
+   {
+      *pData++ = pf[mf++].mValue.mU32;
+      *pData++ = pf[mf++].mValue.mU32;
+   }
+   
+   *pMessageListSize = messageListSz;
+   return eGOBI_ERR_NONE;
+}
+
+/*===========================================================================
+METHOD:
+   GetSMS (Public Method)
+
+DESCRIPTION:
+   This function returns an SMS message from device memory
+
+PARAMETERS:
+   storageType    [ I ] - SMS message storage type
+   messageIndex   [ I ] - Message index
+   pMessageTag    [ O ] - Message tag
+   pMessageFormat [ O ] - Message format
+   pMessageSize   [I/O] - Upon input the maximum number of bytes that can be 
+                          written to the message array.  Upon successful 
+                          output the actual number of bytes written to the 
+                          message array
+   pMessage       [ I ] - The message contents array
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::GetSMS( 
+   ULONG                      storageType, 
+   ULONG                      messageIndex, 
+   ULONG *                    pMessageTag,
+   ULONG *                    pMessageFormat,
+   ULONG *                    pMessageSize, 
+   BYTE *                     pMessage )
+{
+   // Validate arguments
+   if ( (pMessageTag == 0) 
+   ||   (pMessageFormat == 0)
+   ||   (pMessageSize == 0) 
+   ||   (*pMessageSize == 0) 
+   ||   (pMessage == 0) )
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   ULONG maxMessageSz = *pMessageSize;
+
+   // Assume failure
+   *pMessageSize = 0;
+
+   WORD msgID = (WORD)eQMI_WMS_RAW_READ;
+   std::vector <sDB2PackingInput> piv;
+
+   std::ostringstream tmp;
+   tmp << (UINT)storageType << " " << (UINT)messageIndex;
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+   if (pRequest == 0)
+   {
+      return eGOBI_ERR_MEMORY;
+   }
+   
+   // Send the QMI request
+   sProtocolBuffer rsp = Send( eQMI_SVC_WMS, pRequest, 5000 );
+   if (rsp.IsValid() == false)
+   {
+      return GetCorrectedLastError();
+   }
+
+   // Did we receive a valid QMI response?
+   sQMIServiceBuffer qmiRsp( rsp.GetSharedBuffer() );
+   if (qmiRsp.IsValid() == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   
+   // Check the mandatory QMI result TLV for success
+   ULONG rc = 0;
+   ULONG ec = 0;
+   bool bResult = qmiRsp.GetResult( rc, ec );
+   if (bResult == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   else if (rc != 0)
+   {
+      return GetCorrectedQMIError( ec );
+   }
+
+   // Prepare TLVs for parsing
+   std::vector <sDB2NavInput> tlvs = DB2ReduceQMIBuffer( qmiRsp );
+
+   // Parse the TLV we want (by DB key)
+   sProtocolEntityKey tlvKey( eDB2_ET_QMI_WMS_RSP, msgID, 1 );
+   cDataParser::tParsedFields pf = ParseTLV( db, rsp, tlvs, tlvKey );
+   if (pf.size() < 3) 
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   *pMessageTag = pf[0].mValue.mU32;
+   *pMessageFormat = pf[1].mValue.mU32;
+
+   ULONG messageSz = (ULONG)pf[2].mValue.mU16;
+   if (messageSz == 0)
+   {
+      // There has to be message data
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   if (pf.size() < 3 + messageSz)
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   if (maxMessageSz < messageSz)
+   {
+      // We have to be able to copy the whole message
+      return eGOBI_ERR_BUFFER_SZ;
+   }
+
+   // Copy message data
+   for (ULONG b = 0; b < messageSz; b++)
+   {
+      pMessage[b] = pf[3 + b].mValue.mU8;
+   }
+   
+   *pMessageSize = messageSz;
+   return eGOBI_ERR_NONE;
+}
+
+/*===========================================================================
+METHOD:
+   ModifySMSStatus (Public Method)
+
+DESCRIPTION:
+   This function modifies the status of an SMS message saved in storage on 
+   the device
+
+PARAMETERS:
+   storageType    [ I ] - SMS message storage type
+   messageIndex   [ I ] - Message index
+   messageTag     [ I ] - Message tag
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::ModifySMSStatus( 
+   ULONG                      storageType, 
+   ULONG                      messageIndex, 
+   ULONG                      messageTag )
+{
+   WORD msgID = (WORD)eQMI_WMS_MODIFY_TAG;
+   std::vector <sDB2PackingInput> piv;
+
+   std::ostringstream tmp;
+   tmp << (UINT)storageType << " " << (UINT)messageIndex << " " 
+       << (UINT)messageTag;
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+
+   // Send the QMI request, check result, and return 
+   return SendAndCheckReturn( eQMI_SVC_WMS, pRequest, 5000 );
+}
+
+/*===========================================================================
+METHOD:
+   SaveSMS (Public Method)
+
+DESCRIPTION:
+   This function saves an SMS message to device memory
+
+PARAMETERS:
+   storageType    [ I ] - SMS message storage type
+   messageFormat  [ I ] - Message format   
+   messageSize    [ I ] - The length of the message contents in bytes
+   pMessage       [ I ] - The message contents
+   pMessageIndex  [ O ] - The message index assigned by the device
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::SaveSMS(    
+   ULONG                      storageType, 
+   ULONG                      messageFormat, 
+   ULONG                      messageSize, 
+   BYTE *                     pMessage, 
+   ULONG *                    pMessageIndex )
+{
+   // Validate arguments
+   if (messageSize == 0 || pMessage == 0 || pMessageIndex == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   WORD msgID = (WORD)eQMI_WMS_RAW_WRITE;
+   std::vector <sDB2PackingInput> piv;
+
+   // "%u %u %u"
+   std::ostringstream tmp;
+   tmp << (UINT)storageType << " " << (UINT)messageFormat
+       << " " << (UINT)messageSize;
+
+   for (ULONG b = 0; b < messageSize; b++)
+   {
+      tmp << " " << (UINT)pMessage[b];
+   }
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+   if (pRequest == 0)
+   {
+      return eGOBI_ERR_MEMORY;
+   }
+   
+   // Send the QMI request
+   sProtocolBuffer rsp = Send( eQMI_SVC_WMS, pRequest, 10000 );
+   if (rsp.IsValid() == false)
+   {
+      return GetCorrectedLastError();
+   }
+
+   // Did we receive a valid QMI response?
+   sQMIServiceBuffer qmiRsp( rsp.GetSharedBuffer() );
+   if (qmiRsp.IsValid() == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   
+   // Check the mandatory QMI result TLV for success
+   ULONG rc = 0;
+   ULONG ec = 0;
+   bool bResult = qmiRsp.GetResult( rc, ec );
+   if (bResult == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   else if (rc != 0)
+   {
+      return GetCorrectedQMIError( ec );
+   }
+
+   // Prepare TLVs for parsing
+   std::vector <sDB2NavInput> tlvs = DB2ReduceQMIBuffer( qmiRsp );
+
+   // Parse the TLV we want (by DB key)
+   sProtocolEntityKey tlvKey( eDB2_ET_QMI_WMS_RSP, msgID, 1 );
+   cDataParser::tParsedFields pf = ParseTLV( db, rsp, tlvs, tlvKey );
+   if (pf.size() < 1) 
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   *pMessageIndex = pf[0].mValue.mU32;
+   return eGOBI_ERR_NONE;
+}
+
+/*===========================================================================
+METHOD:
+   SendSMS (Public Method)
+
+DESCRIPTION:
+   This function sends an SMS message for immediate over the air transmission
+
+PARAMETERS:
+   messageFormat        [ I ] - Message format   
+   messageSize          [ I ] - The length of the message contents in bytes
+   pMessage             [ I ] - The message contents
+   pMessageFailureCode  [ O ] - When the function fails due to an error sending
+                                the message this parameter may contain the 
+                                message failure cause code (see 3GPP2 N.S0005 
+                                Section 6.5.2.125).  If the cause code is not
+                                provided then the value will be 0xFFFFFFFF
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::SendSMS(    
+   ULONG                      messageFormat, 
+   ULONG                      messageSize, 
+   BYTE *                     pMessage, 
+   ULONG *                    pMessageFailureCode )
+{
+   // Validate arguments
+   if (messageSize == 0 || pMessage == 0 || pMessageFailureCode == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   // Assume we have no message failure cause code
+   *pMessageFailureCode = ULONG_MAX;
+
+   WORD msgID = (WORD)eQMI_WMS_RAW_SEND;
+   std::vector <sDB2PackingInput> piv;
+
+   std::ostringstream tmp;
+   tmp << (UINT)messageFormat << " " << (UINT)messageSize;
+
+   for (ULONG b = 0; b < messageSize; b++)
+   {
+      tmp << " " << (UINT)pMessage[b];
+   }
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+   if (pRequest == 0)
+   {
+      return eGOBI_ERR_MEMORY;
+   }
+   
+   // Send the QMI request
+   sProtocolBuffer rsp = Send( eQMI_SVC_WMS, pRequest, 300000 );
+   if (rsp.IsValid() == false)
+   {
+      return GetCorrectedLastError();
+   }
+
+   // Did we receive a valid QMI response?
+   sQMIServiceBuffer qmiRsp( rsp.GetSharedBuffer() );
+   if (qmiRsp.IsValid() == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   
+   // Check the mandatory QMI result TLV for success
+   ULONG rc = 0;
+   ULONG ec = 0;
+   bool bResult = qmiRsp.GetResult( rc, ec );
+   if (bResult == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   else if (rc != 0)
+   {
+      // Prepare TLVs for parsing
+      std::vector <sDB2NavInput> tlvs = DB2ReduceQMIBuffer( qmiRsp );
+
+      // Parse the optional TLV we want (by DB key)
+      sProtocolEntityKey tlvKey( eDB2_ET_QMI_WMS_RSP, msgID, 1 );
+      cDataParser::tParsedFields pf = ParseTLV( db, rsp, tlvs, tlvKey );
+      if (pf.size() >= 1) 
+      {
+         *pMessageFailureCode = (ULONG)pf[0].mValue.mU16;
+      }
+
+      return GetCorrectedQMIError( ec );
+   }
+
+   return eGOBI_ERR_NONE;
+}
+
+/*===========================================================================
+METHOD:
+   GetSMSCAddress (Public Method)
+
+DESCRIPTION:
+   Return the SMS center address
+
+PARAMETERS:
+   addressSize    [ I ] - The maximum number of characters (including NULL 
+                          terminator) that the SMS center address array 
+                          can contain
+   pSMSCAddress   [ 0 ] - The SMS center address represented as a NULL 
+                          terminated string
+   typeSize       [ I ] - The maximum number of characters (including NULL 
+                          terminator) that the SMS center address type array
+                          can contain
+   pSMSCType      [ 0 ] - The SMS center address type represented as a NULL 
+                          terminated string
+  
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::GetSMSCAddress( 
+   BYTE                       addressSize,
+   CHAR *                     pSMSCAddress,
+   BYTE                       typeSize,
+   CHAR *                     pSMSCType )
+{
+   // Validate arguments
+   if (addressSize == 0 || pSMSCAddress == 0 || typeSize == 0 || pSMSCType == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   pSMSCAddress[0] = 0;
+   pSMSCType[0] = 0;
+   
+   // Generate and send the QMI request
+   WORD msgID = (WORD)eQMI_WMS_GET_SMSC_ADDR;
+   sProtocolBuffer rsp = SendSimple( eQMI_SVC_WMS, msgID );
+   if (rsp.IsValid() == false)
+   {
+      return GetCorrectedLastError();
+   }
+
+   // Did we receive a valid QMI response?
+   sQMIServiceBuffer qmiRsp( rsp.GetSharedBuffer() );
+   if (qmiRsp.IsValid() == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   
+   // Check the mandatory QMI result TLV for success
+   ULONG rc = 0;
+   ULONG ec = 0;
+   bool bResult = qmiRsp.GetResult( rc, ec );
+   if (bResult == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   else if (rc != 0)
+   {
+      return GetCorrectedQMIError( ec );
+   }
+
+   // Prepare TLVs for parsing
+   std::vector <sDB2NavInput> tlvs = DB2ReduceQMIBuffer( qmiRsp );
+   const cCoreDatabase & db = GetDatabase();
+
+   // Parse the TLV we want (by DB key)
+   sProtocolEntityKey tlvKey( eDB2_ET_QMI_WMS_RSP, msgID, 1 );
+   cDataParser::tParsedFields pf = ParseTLV( db, rsp, tlvs, tlvKey );
+   if (pf.size() < 3) 
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   LONG strLen = pf[0].mValueString.size();
+   if (strLen > 0)
+   {
+      // Space to perform the copy?
+      if (typeSize < strLen + 1)
+      {
+         return eGOBI_ERR_BUFFER_SZ;
+      }
+
+      memcpy( (LPVOID)pSMSCType, (LPCSTR)pf[0].mValueString.c_str(), strLen );
+      pSMSCType[strLen] = 0;
+   }
+
+   strLen = pf[2].mValueString.size();
+   if (strLen > 0)
+   {
+      // Space to perform the copy?
+      if (addressSize < strLen + 1)
+      {
+         return eGOBI_ERR_BUFFER_SZ;
+      }
+
+      memcpy( (LPVOID)pSMSCAddress, (LPCSTR)pf[2].mValueString.c_str(), strLen );
+      pSMSCAddress[strLen] = 0;
+   }
+
+   return eGOBI_ERR_NONE;
+}
+
+/*===========================================================================
+METHOD:
+   SetSMSCAddress (Public Method)
+
+DESCRIPTION:
+   Set the SMS center address
+
+PARAMETERS:
+   pSMSCAddress   [ I ] - The SMS center address represented as a NULL 
+                          terminated string (maximum of 21 characters,
+                          including NULL)
+   pSMSCType      [ I ] - The SMS center address type represented as a NULL 
+                          terminated string (optional)
+
+RETURN VALUE:
+   eGobiError - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::SetSMSCAddress( 
+   CHAR *                     pSMSCAddress, 
+   CHAR *                     pSMSCType )
+{
+   // Validate arguments
+   if (pSMSCAddress == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   WORD msgID = (WORD)eQMI_WMS_SET_SMSC_ADDR;
+   std::vector <sDB2PackingInput> piv;
+
+   std::ostringstream addr;
+   if (pSMSCAddress[0] != 0)
+   {
+      addr << "\"" << pSMSCAddress << "\"";
+   }
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)addr.str().c_str() );
+   piv.push_back( pi );
+
+   if (pSMSCType != 0)
+   {
+      std::ostringstream addrType;
+      if (pSMSCType[0] != 0)
+      {
+         addrType << "\"" << pSMSCType << "\"";
+      }
+
+      pek = sProtocolEntityKey( eDB2_ET_QMI_WMS_REQ, msgID, 16 );
+      pi = sDB2PackingInput( pek, (LPCSTR)addrType.str().c_str() );
+      piv.push_back( pi );
+   }
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+
+   // Send the QMI request, check result, and return 
+   return SendAndCheckReturn( eQMI_SVC_WMS, pRequest, 5000 );
+}
+
+/*===========================================================================
+METHOD:
+   GetSMSRoutes (Public Method)
+
+DESCRIPTION:
+   Get the current incoming SMS routing information
+
+PARAMETERS:
+   pRouteSize  [I/O] - Upon input the maximum number of elements that the 
+                       SMS route array can contain.  Upon succes the actual 
+                       number of elements in the SMS route array
+   pRoutes     [ O ] - The SMS route array 
+  
+RETURN VALUE:
+   ULONG - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::GetSMSRoutes( 
+   BYTE *                     pRouteSize, 
+   BYTE *                     pRoutes )
+{
+   // Validate arguments
+   if (pRouteSize == 0 || *pRouteSize == 0 || pRoutes == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   // Assume failure
+   BYTE maxRoutes = *pRouteSize;
+   *pRouteSize = 0;
+   
+   // Generate and send the QMI request
+   WORD msgID = (WORD)eQMI_WMS_GET_ROUTES;
+   sProtocolBuffer rsp = SendSimple( eQMI_SVC_WMS, msgID, 5000 );
+   if (rsp.IsValid() == false)
+   {
+      return GetCorrectedLastError();
+   }
+
+   // Did we receive a valid QMI response?
+   sQMIServiceBuffer qmiRsp( rsp.GetSharedBuffer() );
+   if (qmiRsp.IsValid() == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   
+   // Check the mandatory QMI result TLV for success
+   ULONG rc = 0;
+   ULONG ec = 0;
+   bool bResult = qmiRsp.GetResult( rc, ec );
+   if (bResult == false)
+   {
+      return eGOBI_ERR_MALFORMED_RSP;
+   }
+   else if (rc != 0)
+   {
+      return GetCorrectedQMIError( ec );
+   }
+
+   // Prepare TLVs for parsing
+   std::vector <sDB2NavInput> tlvs = DB2ReduceQMIBuffer( qmiRsp );
+   const cCoreDatabase & db = GetDatabase();
+
+   // Parse the TLV we want (by DB key)
+   sProtocolEntityKey tlvKey( eDB2_ET_QMI_WMS_RSP, msgID, 1 );
+   cDataParser::tParsedFields pf = ParseTLV( db, rsp, tlvs, tlvKey );
+   if (pf.size() < 1) 
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   ULONG fi = 0;
+   ULONG routeCount = (ULONG)pf[fi++].mValue.mU16;
+   if ((ULONG)pf.size() < 1 + 4 * routeCount)
+   {
+      return eGOBI_ERR_INVALID_RSP;
+   }
+
+   if (routeCount > (ULONG)maxRoutes)
+   {
+      routeCount = (ULONG)maxRoutes;
+   }
+
+   ULONG * pRouteArray = (ULONG *)pRoutes;
+   for (ULONG r = 0; r < routeCount; r++)
+   {
+      // Message type
+      *pRouteArray++ = pf[fi++].mValue.mU32;
+
+      // Message class
+      *pRouteArray++ = pf[fi++].mValue.mU32;
+
+      // Storage type
+      *pRouteArray++ = pf[fi++].mValue.mU32;
+
+      // Receipt action
+      *pRouteArray++ = pf[fi++].mValue.mU32;
+   }
+
+   *pRouteSize = (BYTE)routeCount;
+   return eGOBI_ERR_NONE;
+}
+
+/*===========================================================================
+METHOD:
+   SetSMSRoutes (Public Method)
+
+DESCRIPTION:
+   Set the desired incoming SMS routing information
+
+PARAMETERS:
+   pRouteSize  [ I ] - The number of elements in the SMS route array
+   pRoutes     [ I ] - The SMS route array 
+  
+RETURN VALUE:
+   ULONG - Return code
+===========================================================================*/
+eGobiError cGobiQMICore::SetSMSRoutes( 
+   BYTE *                     pRouteSize, 
+   BYTE *                     pRoutes )
+{
+   // Validate arguments
+   if (pRouteSize == 0 || *pRouteSize == 0 || pRoutes == 0)
+   {
+      return eGOBI_ERR_INVALID_ARG;
+   }
+
+   // Format up the request
+   ULONG routeCount = (ULONG)*pRouteSize;
+
+   // %u
+   std::ostringstream tmp;
+   tmp << routeCount;
+
+   ULONG * pRouteArray = (ULONG *)pRoutes;
+   for (ULONG r = 0; r < routeCount; r++)
+   {
+      // Message type, class, storage type, receipt action
+      for (ULONG f = 0; f < 4; f++)
+      {
+         // tmp += " %u"
+         tmp << " " << *pRouteArray++;
+      }
+   }
+
+   WORD msgID = (WORD)eQMI_WMS_SET_ROUTES;
+   std::vector <sDB2PackingInput> piv;
+
+   sProtocolEntityKey pek( eDB2_ET_QMI_WMS_REQ, msgID, 1 );
+   sDB2PackingInput pi( pek, (LPCSTR)tmp.str().c_str() );
+   piv.push_back( pi );
+
+   // Pack up the QMI request
+   const cCoreDatabase & db = GetDatabase();
+   sSharedBuffer * pRequest = DB2PackQMIBuffer( db, piv );
+   if (pRequest == 0)
+   {
+      return eGOBI_ERR_MEMORY;
+   }
+   
+   // Send the QMI request, check result, and return 
+   return SendAndCheckReturn( eQMI_SVC_WMS, pRequest, 5000 );
+}