msg.cpp

ril source code for Windows CE

    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpMsgServiceInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    // Add "AT"
    (void)strncpyz(szWalk, "AT", MAX_PATH - (szWalk - szCmd));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_SERVICE)
    {
        if (RIL_MSGSVCTYPE_PHASE2 == lpMsgServiceInfo->dwService)
        {
            nValue = 0;
        }
        else if (RIL_MSGSVCTYPE_PHASE2PLUS == lpMsgServiceInfo->dwService)
        {
            nValue = 1;
        }
        else
        {
            DEBUGCHK(FALSE);
        }

        // Add "+CSMS=<service>"
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CSMS=%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    if ((lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_READLOCATION) ||
        (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_WRITELOCATION) ||
        (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_STORELOCATION))
    {
        // At least one location is specified

        // Add ";", if needed
        if (szWalk != szCmd + 2)
        {  // NO_TYPO: 30
            (void)strncpyz(szWalk, ";", MAX_PATH - (szWalk - szCmd));
            szWalk++;
        }

        // Add "+CPMS="
        (void)strncpyz(szWalk, "+CPMS=", MAX_PATH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_READLOCATION)
        {
            nValue = lpMsgServiceInfo->dwReadLocation;
            DEBUGCHK(NUM_MSGLOCS > nValue);
            if ( RIL_MSGLOC_UNKNOWN == nValue || nValue >= NUM_MSGLOCS )
            {
                hr = E_INVALIDARG;
                goto Error;
            }

            // Add "<read_storage>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", g_rgszMsgLocations[nValue]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            rmsi.dwReadLocation = nValue;
            rmsi.dwParams |= RIL_PARAM_MSTI_READLOCATION;
        }

        // Add ","
        (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_WRITELOCATION)
        {
            nValue = lpMsgServiceInfo->dwWriteLocation;
            DEBUGCHK(NUM_MSGLOCS > nValue);
            if ( RIL_MSGLOC_UNKNOWN == nValue || nValue >= NUM_MSGLOCS )
            {
                hr = E_INVALIDARG;
                goto Error;
            }

            // Add "<write_storage>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", g_rgszMsgLocations[nValue]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            rmsi.dwWriteLocation = nValue;
            rmsi.dwParams |= RIL_PARAM_MSTI_WRITELOCATION;
        }

        // Add ","
        (void)strncpyz(szWalk, ",", MAX_PATH - (szWalk - szCmd));
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

        if (lpMsgServiceInfo->dwParams & RIL_PARAM_MSI_STORELOCATION)
        {
            nValue = lpMsgServiceInfo->dwStoreLocation;
            DEBUGCHK(NUM_MSGLOCS > nValue);
            if ( RIL_MSGLOC_UNKNOWN == nValue || nValue >= NUM_MSGLOCS )
            {
                hr = E_INVALIDARG;
                goto Error;
            }

            // Add "<store_storage>"
            (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "\"%s\"", g_rgszMsgLocations[nValue]);
            szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
            DEBUGCHK(NULL != szWalk);

            rmsi.dwStoreLocation = nValue;
            rmsi.dwParams |= RIL_PARAM_MSTI_STORELOCATION;
        }
    }

    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

    if (rmsi.dwParams)
    {
        pnd = new CNotificationData;
        if (pnd)
        {
            rmsi.cbSize = sizeof(RILMSGSTORAGEINFO);
            if (!pnd->InitFromRealBlob(RIL_NOTIFY_MSGSTORAGECHANGED, &rmsi, sizeof(RILMSGSTORAGEINFO)))
            {
                delete pnd;
                pnd = NULL;
            }
        }
    }
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETMSGSERVICEOPTIONS, NULL, pnd, hr))
    {
        hr = E_FAIL;
        goto Error;
    }
    pnd = NULL;

    Error:
    return hr;
}


//
//
//
static HRESULT ParseGetMsgConfigRsp(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetMsgConfigRsp);
    UINT nValue;
    char szAddress[MAX_PATH];
    //    char szLanguageRange[MAX_PATH];
    RILMSGCONFIG* prmc = NULL;
    HRESULT hr = S_OK;
    ENCODING_TYPE etEncoding = ENCODING_GSMDEFAULT_HEX;

    pBlob = NULL;
    cbBlob = 0;

    prmc = (RILMSGCONFIG*)AllocBlob(sizeof(RILMSGCONFIG));
    if (!prmc)
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }
    memset(prmc, 0x00, sizeof(RILMSGCONFIG));
    prmc->cbSize = sizeof(RILMSGCONFIG);

    // Parse "<prefix>+CSCA: <svcctr_addr>,<type_of_addr><postfix>"
    if (!ParseRspPrefix(szRsp, szRsp)                               ||
        !MatchStringBeginning(szRsp, "+CSCA: ", szRsp)              ||
        !ParseString(szRsp, szAddress, MAX_PATH, szRsp)             ||
        !MatchStringBeginning(szRsp, ",", szRsp)                    ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 0x100, nValue, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    etEncoding = g_rppPDDParams->etMessageEncodingType;

    // Convert data to address structure
    if (!StringToRILAddress(szAddress, (BYTE)nValue, prmc->raSvcCtrAddress, etEncoding))
    {
        hr = E_FAIL;
        goto Error;
    }
    prmc->dwParams |= RIL_PARAM_MC_SVCCTRADDRESS;

    pBlob = (void*)prmc;
    cbBlob = sizeof(RILMSGCONFIG);

    Error:
    if (FAILED(hr))
    {
        FreeBlob(prmc);
    }
    return hr;

}


//
//
//
HRESULT RILDrv_GetMsgConfig(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetMsgConfig);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+CSCA?\r", CMDOPT_NONE, APIID_GETMSGCONFIG, ParseGetMsgConfigRsp, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}


//
//
//
HRESULT RILDrv_SetMsgConfig(DWORD dwParam, const RILMSGCONFIG* lpMsgConfigInfo)
{
    FUNCTION_TRACE(RILDrv_SetMsgConfig);
    char szCmd[MAXLENGTH_MSGIDS + MAX_PATH * 3];
    LPSTR szWalk = szCmd;
    char szSvcCtrAddress[MAX_PATH];
    BYTE bTypeOfAddress;
    HRESULT hr = S_OK;
    ENCODING_TYPE etEncoding = ENCODING_GSMDEFAULT_HEX;
    
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpMsgConfigInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    (void)strncpyz(szWalk, "AT", MAX_PATH - (szWalk - szCmd));
    szWalk += 2;

    if (lpMsgConfigInfo->dwParams & RIL_PARAM_MC_SVCCTRADDRESS)
    {

        etEncoding = g_rppPDDParams->etMessageEncodingType;
        
        hr = RILAddressToString(lpMsgConfigInfo->raSvcCtrAddress, szSvcCtrAddress, MAX_PATH, bTypeOfAddress, etEncoding);
        if (FAILED(hr))
        {
            goto Error;
        }
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "+CSCA=\"%s\",%u", szSvcCtrAddress, bTypeOfAddress);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    (void)strncpyz(szWalk, ";+CSAS\r", MAX_PATH - (szWalk - szCmd));  // NO_TYPO: 30

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETMSGCONFIG, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

static RILCBMSGCONFIG * AllocCbMsgConfig(DWORD dwNumRanges)
{
    UINT Size = 0;
    if ( !safeIntUMul( dwNumRanges, sizeof(RILRANGE), &Size ) ||
         !safeIntUAdd( sizeof(RILCBMSGCONFIG), Size, &Size ) )
    {
        ASSERT( FALSE );
        return NULL;
    }

    RILCBMSGCONFIG* prmc = (RILCBMSGCONFIG*)AllocBlob(Size);
    if (NULL != prmc)
    {
        memset(prmc, 0x00, Size);
        prmc->cbSize = Size;
    }

    return prmc;
}

//
//
//
static HRESULT ParseBroadcastMsgIDs(const LPCSTR szBroadcastMsgIDs,
                                    RILCBMSGCONFIG ** pprCbMsgConfig)
{
    DEBUGCHK(NULL != szBroadcastMsgIDs);

    HRESULT hr = S_OK;
    DWORD dwNumRanges;
    LPCSTR szDummy;
    DWORD dwNumIDs = 0;

    if (*szBroadcastMsgIDs)
    {
        dwNumIDs++;

        for (LPCSTR szPtr = szBroadcastMsgIDs; '\0' != *szPtr; szPtr++)
        {
            if (',' == *szPtr)
                dwNumIDs++;
        }
    }

    *pprCbMsgConfig = AllocCbMsgConfig(dwNumIDs);
    if (NULL == *pprCbMsgConfig)
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    if (!ParseRangesFromString(szBroadcastMsgIDs,
                               (*pprCbMsgConfig)->rgrrBroadcastMsgIDs,
                               dwNumRanges,
                               dwNumIDs,
                               szDummy))
    {
        hr = E_FAIL;
        goto Error;
    }

    DEBUGCHK(dwNumRanges == dwNumIDs);

Error:
    return hr;
}

//
//
//
static HRESULT ParseGetCellBroadcastMsgConfigRsp(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetCellBroadcastMsgConfigRsp);
    UINT nValue;
    BOOL fAccept = FALSE;
    char szLanguageRange[MAX_PATH];
    char szBroadcastMsgIDs[MAXLENGTH_MSGIDS];
    RILCBMSGCONFIG* prmc = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

    // Parse "<prefix>+CSCB: <mode>"
    if (!ParseRspPrefix(szRsp, szRsp)                  ||
        !MatchStringBeginning(szRsp, "+CSCB: ", szRsp) ||
        !ParseUIntAndVerifyAbove(szRsp, TRUE, 2, nValue, szRsp)) {
        hr = E_FAIL;
        goto Error;
    }

    // Cache accept value for when we have a structure allocated
    fAccept = (nValue == 0);

    // Parse ",<msg_ids>,<msg_langs><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)                              ||
        !ParseString(szRsp, szBroadcastMsgIDs, MAXLENGTH_MSGIDS, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    // Parse broadcast message IDs
    // This also allocates the blob
    hr = ParseBroadcastMsgIDs(szBroadcastMsgIDs, &prmc);
    if (FAILED(hr))
    {
        goto Error;
    }

    prmc->fAccept = fAccept;
    prmc->dwParams |= (RIL_PARAM_CBMC_BROADCASTMSGIDS | RIL_PARAM_CBMC_ACCEPTIDS);

    if (MatchStringBeginning(szRsp, ",", szRsp))
    {
        if (!ParseString(szRsp, szLanguageRange, MAX_PATH, szRsp))
        {
            hr = E_FAIL;
            goto Error;
        }

        // Parse accepted languages
        if (!ParseBroadcastLangRange(szLanguageRange, prmc->dwBroadcastMsgLangs)) {
            hr = E_FAIL;
            goto Error;
        }

        prmc->dwParams |= RIL_PARAM_CBMC_BROADCASTMSGLANGS;
    }

    if (!ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    pBlob = (void*)prmc;
    cbBlob = prmc->cbSize;

    Error:
    if (FAILED(hr))
    {
        FreeBlob(prmc);
    }
    return hr;

}

//
//
//
HRESULT RILDrv_GetCellBroadcastMsgConfig(DWORD dwParam)
{
    FUNCTION_TRACE(RILDrv_GetCellBroadcastMsgConfig);
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!QueueCmd(pHandle, "AT+CSCB?\r", CMDOPT_NONE, APIID_GETCBMSGCONFIG,
                  ParseGetCellBroadcastMsgConfigRsp, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

//
//
//
HRESULT RILDrv_SetCellBroadcastMsgConfig(DWORD dwParam, const RILCBMSGCONFIG* lpMsgConfigInfo)
{
    FUNCTION_TRACE(RILDrv_SetCellBroadcastMsgConfig);
    char szCmd[MAXLENGTH_MSGIDS + MAX_PATH * 3];
    LPSTR szWalk = szCmd;
    char szCBMsgLangs[MAX_PATH];
    char szBroadcastMsgIDs[MAX_PATH];
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpMsgConfigInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

    if (!(lpMsgConfigInfo->dwParams & RIL_PARAM_CBMC_ACCEPTIDS))
    {
        hr = E_INVALIDARG;
        goto Error;
    }

    (void)_snprintfz(szCmd, MAX_PATH, "AT+CSCB=%d", (lpMsgConfigInfo->fAccept?0:1));
    szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
    DEBUGCHK(NULL != szWalk);

    if ((lpMsgConfigInfo->dwParams & RIL_PARAM_CBMC_BROADCASTMSGIDS))
    {
        MakeBroadcastMsgIDs(lpMsgConfigInfo->rgrrBroadcastMsgIDs,
                            (lpMsgConfigInfo->cbSize - sizeof(RILCBMSGCONFIG)) / sizeof(RILRANGE),
                            szBroadcastMsgIDs,
                            MAX_PATH);

        (void)_snprintfz(szWalk, MAX_PATH, ",\"%s\"", szBroadcastMsgIDs);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);

    }

    if (lpMsgConfigInfo->dwParams & RIL_PARAM_CBMC_BROADCASTMSGLANGS)
    {
        MakeBroadcastLangRange(lpMsgConfigInfo->dwBroadcastMsgLangs, szCBMsgLangs, MAX_PATH);

        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%s,\"%s\"", (lpMsgConfigInfo->dwParams & RIL_PARAM_CBMC_BROADCASTMSGIDS)?"":",", szCBMsgLangs);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), ";+CSAS\r");

    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETCBMSGCONFIG, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }