psu->dwNumPlan = SIM_NUMPLAN_UNKNOWN;
    }

    // Only add the USSD string if it exists.
    if (m_dwUSSDLen)
    {
        // Shouldn't be here unless we've got something to send.
        ASSERT( NULL != m_pwszUSSD );
        ASSERT( m_dwUSSDLen > 0 );

        psu->dwParams |= SIM_PARAM_SIMUSSD_USSDOFFSET | SIM_PARAM_SIMUSSD_USSDSIZE;
        // Now add the USSD string of bytes (which was required)
        psu->dwUSSDSize = m_dwUSSDLen;
        psu->dwUSSDOffset = ROUNDTODWORD(sizeof(SIMUSSD));
        StringCbCopy( ((TCHAR *) ((LPBYTE) psu + psu->dwUSSDOffset)), m_dwUSSDLen, m_pwszUSSD );
    }

    // Set up the text string, if it's there
    if (m_dwAlphaIdLen)
    {
        psu->dwParams |= (SIM_PARAM_SIMUSSD_TEXTSIZE | SIM_PARAM_SIMUSSD_TEXTOFFSET);
        psu->dwTextSize = m_dwAlphaIdLen;
        psu->dwTextOffset = ROUNDTODWORD(sizeof(SIMUSSD)) + ROUNDTODWORD(m_dwUSSDLen);
        StringCbCopy( ((TCHAR *) ((LPBYTE) psu + psu->dwTextOffset)), m_dwAlphaIdLen, m_pwszAlphaId );
    }

    if (SIMTKIT_INVALID_VALUE != m_dwIconIdentifier)
    {
        psu->dwParams |= SIM_PARAM_SIMUSSD_ICONID;
        psu->dwIconIdentifier = m_dwIconIdentifier;
    }

    if (SIMTKIT_INVALID_VALUE != m_dwIconQualifier)
    {
        psu->dwParams |= SIM_PARAM_SIMUSSD_ICONQUALIFIER;
        psu->dwIconQualifier = m_dwIconQualifier;
    }

    *lpdwSize = dwSize;

Exit:
    *ppbResult = (LPBYTE) psu;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("RilDrv : SIMTKit: -CRilSimToolkitCommand::BuildSIMUSSD\r\n")));
    return hr;
}

/****************************************************************************

    FUNCTION:   BuildSIMSMS

    PURPOSE:    Builds the SIMSMS structure

    PARAMETERS: dwNotifyCode - Which command is this?
                bCmdQualifier - Specific info from the command details
                ppbResult - OUT parameter to hold allocated structure

    RETURNS:    HRESULT

****************************************************************************/

HRESULT CRilSimToolkitCommand::BuildSIMSMS(DWORD dwNotifyCode, BYTE bCmdQualifier, LPBYTE *ppbResult, DWORD *lpdwSize)
{
    HRESULT hr = S_OK;
    SIMSMS *pss = NULL;
    DWORD dwSize;
    unsigned int uiSize;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("RilDrv : SIMTKit: +CRilSimToolkitCommand::BuildSIMSMS\r\n")));

    dwNotifyCode;  // Avoid warning C4100: unreferenced formal parameter
    bCmdQualifier;    // Avoid warning C4100: unreferenced formal parameter

    // OK, let's put everything together here
    BOOL fSafeDword = FALSE;
    if ( TRUE == safeIntUAdd( ROUNDTODWORD(sizeof(SIMSMS)),ROUNDTODWORD(m_dwAlphaIdLen), &uiSize ))
    {
        if ( TRUE == safeIntUAdd( uiSize, ROUNDTODWORD(m_dwAddressLen), &uiSize ))
        {
            fSafeDword = safeIntUAdd( uiSize, ROUNDTODWORD(m_dwTPDULen), &uiSize );
        }
    }
    if ( FALSE == fSafeDword )
    {
        hr = E_ABORT;
        goto Exit;
    }
    else
    {
        dwSize = uiSize;
    }

    if ( dwSize == 0 )
    {
        hr = E_ABORT;
        goto Exit;
    }

    pss = (SIMSMS *) new BYTE[dwSize];
    if (!pss)
    {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

    memset(pss, 0, dwSize);
    pss->cbSize = dwSize;
    pss->dwParams = SIM_PARAM_SIMSMS_FLAGS;
    pss->dwFlags = 0;

    if (m_dwTPDULen)
    {
        pss->dwParams |= (SIM_PARAM_SIMSMS_TPDUOFFSET | SIM_PARAM_SIMSMS_TPDUSIZE);
        // Now, set the TPDU bytes
        pss->dwTPDUSize = m_dwTPDULen;
        pss->dwTPDUOffset = ROUNDTODWORD(sizeof(SIMSMS));
        memcpy(((LPBYTE *) ((LPBYTE) pss + pss->dwTPDUOffset)), m_lpbTPDU, m_dwTPDULen);
    }

    // Set up the text string, if it's there
    if (m_dwAlphaIdLen)
    {
        pss->dwParams |= (SIM_PARAM_SIMSMS_TEXTSIZE | SIM_PARAM_SIMSMS_TEXTOFFSET);
        pss->dwTextSize = m_dwAlphaIdLen;
        pss->dwTextOffset = ROUNDTODWORD(sizeof(SIMSMS)) + ROUNDTODWORD(m_dwTPDULen);
        StringCbCopy( ((TCHAR *) ((LPBYTE) pss + pss->dwTextOffset)), m_dwAlphaIdLen, m_pwszAlphaId );
    }

    // And finally the address, if it's there
    if (m_dwAddressLen)
    {
        // OK, the address needs to be there
        pss->dwParams |= (SIM_PARAM_SIMSMS_NUMPLAN | SIM_PARAM_SIMSMS_ADDRESSTYPE
                            | SIM_PARAM_SIMSMS_ADDRESSSIZE | SIM_PARAM_SIMSMS_ADDRESSOFFSET);
        pss->dwNumPlan = m_dwNumPlan;
        pss->dwAddressType = m_dwAddrType;
        pss->dwAddressSize = m_dwAddressLen;
        pss->dwAddressOffset = ROUNDTODWORD(sizeof(SIMSMS)) + ROUNDTODWORD(m_dwTPDULen) + ROUNDTODWORD(m_dwAlphaIdLen);
        StringCbCopy( ((TCHAR *) ((LPBYTE) pss + pss->dwAddressOffset)), m_dwAddressLen, m_pwszAddress );
    }

    if (SIMTKIT_INVALID_VALUE != m_dwIconIdentifier)
    {
        pss->dwParams |= SIM_PARAM_SIMSMS_ICONID;
        pss->dwIconIdentifier = m_dwIconIdentifier;
    }

    if (SIMTKIT_INVALID_VALUE != m_dwIconQualifier)
    {
        pss->dwParams |= SIM_PARAM_SIMSMS_ICONQUALIFIER;
        pss->dwIconQualifier = m_dwIconQualifier;
    }

    *lpdwSize = dwSize;

Exit:
    *ppbResult = (LPBYTE) pss;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("RilDrv : SIMTKit: +CRilSimToolkitCommand::BuildSIMSMS\r\n")));
    return hr;
}


/****************************************************************************

    FUNCTION:   BuildSIMEVENTLIST

    PURPOSE:    Builds the SIMEVENTLIST structure

    PARAMETERS: dwNotifyCode - Which command is this?
                bCmdQualifier - Specific info from the command details
                ppbResult - OUT parameter to hold allocated structure

    RETURNS:    HRESULT

****************************************************************************/

HRESULT CRilSimToolkitCommand::BuildSIMEVENTLIST(DWORD dwNotifyCode, BYTE bCmdQualifier, LPBYTE *ppbResult, DWORD *lpdwSize)
{
    SIMEVENTLIST *psel = NULL;
    HRESULT hr = S_OK;
    DWORD dwSize;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("RilDrv : SIMTKit: +CRilSimToolkitCommand::BuildSIMEVENTLIST\r\n")));

    dwNotifyCode;  // Avoid warning C4100: unreferenced formal parameter
    bCmdQualifier;    // Avoid warning C4100: unreferenced formal parameter

    // OK, let's see how much space we need now
    dwSize = ROUNDTODWORD(sizeof(SIMEVENTLIST)) + ROUNDTODWORD(m_dwEventListLen);

    if ( dwSize == 0 )
    {
        hr = E_ABORT;
        goto Exit;
    }

    psel = (SIMEVENTLIST *) new BYTE[dwSize];
    if (!psel)
    {
        DEBUGCHK(FALSE);
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

    memset(psel, 0, dwSize);
    psel->cbSize = dwSize;

    DEBUGCHK(0 < m_dwEventListLen);
    DEBUGCHK(NULL != m_lpbEventList);

    if (m_dwEventListLen && m_lpbEventList)
    {
        psel->dwParams = SIM_PARAM_SIMEVENTLIST_EVENTSSIZE | SIM_PARAM_SIMEVENTLIST_EVENTSOFFSET;
        psel->dwEventsSize = m_dwEventListLen;
        psel->dwEventsOffset= ROUNDTODWORD(sizeof(SIMEVENTLIST));
        memcpy(((LPBYTE *) ((LPBYTE) psel + psel->dwEventsOffset)), m_lpbEventList, m_dwEventListLen);
    }

    *lpdwSize = dwSize;

Exit:
    *ppbResult = (LPBYTE) psel;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("RilDrv : SIMTKit: -CRilSimToolkitCommand::BuildSIMEVENTLIST\r\n")));
    return hr;
}


/****************************************************************************

    FUNCTION:   BuildSIMLAUNCHBROWSER

    PURPOSE:    Builds the SIMLAUNCHBROWSER structure

    PARAMETERS: dwNotifyCode - Which command is this?
                bCmdQualifier - Specific info from the command details
                ppbResult - OUT parameter to hold allocated structure

    RETURNS:    HRESULT

****************************************************************************/
HRESULT CRilSimToolkitCommand::BuildSIMLAUNCHBROWSER(DWORD dwNotifyCode, BYTE bCmdQualifier, LPBYTE *ppbResult, DWORD *lpdwSize)
{
    SIMLAUNCHBROWSER *pslb = NULL;
    SIMFILEREFERENCE *psfr;
    HRESULT hr = S_OK;
    DWORD dwUsedSize;
    DWORD dwSize;
    DWORD i;
    DWORD cbFileSize;
    unsigned int uiSize;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("RilDrv : SIMTKit: +CRilSimToolkitCommand::BuildSIMLAUNCHBROWSER\r\n")));

    dwNotifyCode;  // Avoid warning C4100: unreferenced formal parameter

    // How much space do we need to allocate?
    BOOL fSafeDword = FALSE;
    if ( TRUE == safeIntUAdd( ROUNDTODWORD(sizeof(SIMLAUNCHBROWSER)),ROUNDTODWORD(m_dwAlphaIdLen), &uiSize ))
    {
        if ( TRUE == safeIntUAdd( uiSize, ROUNDTODWORD(m_dwURLLen), &uiSize ))
        {
            if ( TRUE == safeIntUAdd( uiSize, ROUNDTODWORD(m_dwBearerLen), &uiSize ))
            {
                if ( TRUE == safeIntUAdd( uiSize, ROUNDTODWORD(m_dwTextLen), &uiSize))
                {
                    for (i = 0, fSafeDword = TRUE; (i < m_numpsfr) && (TRUE == fSafeDword); i++)
                    {
                        fSafeDword = safeIntUAdd( uiSize, ROUNDTODWORD(m_rgpsfr[i]->cbSize), &uiSize);
                    }
                }
            }
        }
    }
    if ( FALSE == fSafeDword )
    {
        hr = E_ABORT;
        goto Exit;
    }
    else
    {
        dwSize = uiSize;
    }


    pslb = (SIMLAUNCHBROWSER *) new BYTE[dwSize];
    if (!pslb)
    {
        hr = E_OUTOFMEMORY;
        goto Exit;
    }

    // Populate this structure
    memset(pslb, 0, dwSize);
    pslb->cbSize = dwSize;
    dwUsedSize = ROUNDTODWORD(sizeof(SIMLAUNCHBROWSER));

    pslb->dwParams |= SIM_PARAM_SIMLAUNCHBROWSER_FLAGS;
    pslb->dwFlags = bCmdQualifier;

    if (m_dwBrowserId != -1)
    {
        pslb->dwParams |= SIM_PARAM_SIMLAUNCHBROWSER_BROWSERID;
        pslb->dwBrowserId = m_dwBrowserId;
    }

    if (m_dwURLLen)
    {
        pslb->dwParams |= (SIM_PARAM_SIMLAUNCHBROWSER_URLSIZE | SIM_PARAM_SIMLAUNCHBROWSER_URLOFFSET);
        pslb->dwURLSize = m_dwURLLen;
        pslb->dwURLOffset = dwUsedSize;
        StringCbCopy( ((TCHAR *) ((LPBYTE) pslb + pslb->dwURLOffset)), m_dwURLLen, m_pwszURL );
        dwUsedSize += ROUNDTODWORD(m_dwURLLen);
    }

    if (m_dwBearerLen)
    {
        pslb->dwParams |= (SIM_PARAM_SIMLAUNCHBROWSER_BEARERSIZE | SIM_PARAM_SIMLAUNCHBROWSER_BEAREROFFSET);
        pslb->dwBearerSize = m_dwBearerLen;
        pslb->dwBearerOffset = dwUsedSize;
        memcpy(((LPBYTE) pslb + pslb->dwBearerOffset), m_lpbBearer, m_dwBearerLen);
        dwUsedSize += ROUNDTODWORD(m_dwBearerLen);
    }

    if (m_dwTextLen)
    {
        pslb->dwParams |= (SIM_PARAM_SIMLAUNCHBROWSER_GATEWAYSIZE | SIM_PARAM_SIMLAUNCHBROWSER_GATEWAYOFFSET);
        pslb->dwGatewaySize = m_dwTextLen;
        pslb->dwGatewayOffset = dwUsedSize;
        StringCbCopy( ((TCHAR *) ((LPBYTE) pslb + pslb->dwGatewayOffset)), m_dwTextLen, m_pwszText );
        dwUsedSize += ROUNDTODWORD(m_dwTextLen);
    }

    if (m_dwAlphaIdLen)
    {
        pslb->dwParams |= (SIM_PARAM_SIMLAUNCHBROWSER_TEXTSIZE | SIM_PARAM_SIMLAUNCHBROWSER_TEXTOFFSET);
        pslb->dwTextSize = m_dwAlphaIdLen;
        pslb->dwTextOffset = dwUsedSize;
        StringCbCopy( ((TCHAR *) ((LPBYTE) pslb + pslb->dwTextOffset)), m_dwAlphaIdLen, m_pwszAlphaId );
        dwUsedSize += ROUNDTODWORD(m_dwAlphaIdLen);
    }

    // Now for the Provisioning file references
    if (m_numpsfr)
    {
        pslb->dwParams |= (SIM_PARAM_SIMLAUNCHBROWSER_PROVISIONFILECOUNT |
                           SIM_PARAM_SIMLAUNCHBROWSER_PROVISIONFILESIZE  |
                           SIM_PARAM_SIMLAUNCHBROWSER_PROVISIONFILEOFFSET);
        pslb->dwProvisionFileCount = m_numpsfr;
        pslb->dwProvisionFileOffset = dwUsedSize;
        pslb->dwProvisionFileSize = dwSize - pslb->dwProvisionFileOffset;

        psfr = (SIMFILEREFERENCE *) ((LPBYTE) pslb + pslb->dwProvisionFileOffset);
        for (i = 0; i < m_numpsfr; i++)
        {
            cbFileSize = m_rgpsfr[i]->cbSize;

            memcpy(psfr, m_rgpsfr[i], cbFileSize);
            psfr = (SIMFILEREFERENCE *) ((LPBYTE) psfr + cbFileSize);
        }
    }

    if (SIMTKIT_INVALID_VALUE != m_dwIconIdentifier)
    {
        pslb->dwParams |= SIM_PARAM_SIMLAUNCHBROWSER_ICONID;
        pslb->dwIconIdentifier = m_dwIconIdentifier;
    }

    if (SIMTKIT_INVALID_VALUE != m_dwIconQualifier)
    {
        pslb->dwParam