data.cpp

ril source code for Windows CE

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

    // Add "<neg>"
    if (lpDataCompInfo->dwParams & RIL_PARAM_DCI_NEGOTIATION)
    {
        if (!ValueFromFlag(lpDataCompInfo->dwNegotiation, g_DataCompNegotiation, NUM_DATACOMPNEGOTIATION, nValue))
        {
            hr = E_INVALIDARG;
            goto Error;
        }

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

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

    // Add "<P1>"
    if (lpDataCompInfo->dwParams & RIL_PARAM_DCI_MAXDICTENTRIES)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpDataCompInfo->dwMaxDictEntries);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

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

    // Add "<P2>"
    if (lpDataCompInfo->dwParams & RIL_PARAM_DCI_MAXSTRING)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", lpDataCompInfo->dwMaxStringLength);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETDATACOMPRESSION, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +ES: <orig_rqst>,<orig_fbk>,<ans_fbk>
HRESULT ParseGetErrorCorrection(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetErrorCorrection);
    UINT nValue;
    RILERRORCORRECTIONINFO* preci = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    // Parse "<prefix>+ES: <orig_rqst>"
    if (!ParseRspPrefix(szRsp, szRsp)                   ||
        !MatchStringBeginning(szRsp, "+ES: ", szRsp)    ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    FlagFromValue(nValue, g_ErrorCorrectionOrigRqst, NUM_ERRORCORRECTIONORIGRQST, preci->dwOriginalRequest);

    // Parse ",<orig_fbk>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)        ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    FlagFromValue(nValue, g_ErrorCorrectionOrigFbk, NUM_ERRORCORRECTIONORIGFBK, preci->dwOriginalFallback);

    // Parse ",<ans_fbk><postfix>"
    if (!MatchStringBeginning(szRsp, ",", szRsp)        ||
        !ParseUInt(szRsp, FALSE, nValue, szRsp)         ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    FlagFromValue(nValue, g_ErrorCorrectionAnsFbk, NUM_ERRORCORRECTIONANSFBK, preci->dwAnswererFallback);
    preci->dwParams |= RIL_PARAM_ECI_ALL;

    pBlob = (void*)preci;
    cbBlob = sizeof(RILERRORCORRECTIONINFO);

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

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

    if (!QueueCmd(pHandle, "AT+ES?\r", CMDOPT_NONE, APIID_GETERRORCORRECTION, ParseGetErrorCorrection, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

    Error:
    return hr;
}

// +ES=[<orig_rqst>[,<orig_fbk>[,<ans_fbk>]]]
HRESULT RILDrv_SetErrorCorrection (DWORD dwParam, const RILERRORCORRECTIONINFO* lpErrorCorrectionInfo)
{
    FUNCTION_TRACE(RILDrv_SetErrorCorrection);
    char szCmd[MAX_PATH];
    UINT nValue;
    LPSTR szWalk = szCmd;
    HRESULT hr = S_OK;
    CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
    if (!pHandle || !lpErrorCorrectionInfo)
    {
        hr = E_FAIL;
        goto Error;
    }

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

    if (!ValueFromFlag(lpErrorCorrectionInfo->dwOriginalRequest, g_ErrorCorrectionOrigRqst, NUM_ERRORCORRECTIONORIGRQST, nValue))
    {
        hr = E_INVALIDARG;
        goto Error;
    }

    // Add "<orig_rqst>"
    if (lpErrorCorrectionInfo->dwParams & RIL_PARAM_ECI_ORIGINALREQUEST)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

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

    if (!ValueFromFlag(lpErrorCorrectionInfo->dwOriginalFallback, g_ErrorCorrectionOrigFbk, NUM_ERRORCORRECTIONORIGFBK, nValue))
    {
        hr = E_INVALIDARG;
        goto Error;
    }

    // Add "<orig_fbk>"
    if (lpErrorCorrectionInfo->dwParams & RIL_PARAM_ECI_ORIGINALFALLBACK)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

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

    if (!ValueFromFlag(lpErrorCorrectionInfo->dwAnswererFallback, g_ErrorCorrectionAnsFbk, NUM_ERRORCORRECTIONANSFBK, nValue))
    {
        hr = E_INVALIDARG;
        goto Error;
    }

    // Add "<ans_fbk>"
    if (lpErrorCorrectionInfo->dwParams & RIL_PARAM_ECI_ANSWERERFALLBACK)
    {
        (void)_snprintfz(szWalk, MAX_PATH - (szWalk - szCmd), "%u", nValue);
        szWalk = strchr(szWalk, '\0');  // NO_TYPO: 27
        DEBUGCHK(NULL != szWalk);
    }

    // Add "<CR>"
    (void)strncpyz(szWalk, "\r", MAX_PATH - (szWalk - szCmd));
    if (!QueueCmd(pHandle, szCmd, CMDOPT_NONE, APIID_SETERRORCORRECTION, NULL, NULL, hr))
    {
        hr = E_FAIL;
        goto Error;
    }

Error:
    return hr;
}

//
//
//
HRESULT ParseGetDevCapsDataCompression(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsDataCompression);

    RILCAPSDATACOMPRESSION *prcdc = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    if (!ParseRspPrefix(szRsp, szRsp) ||
        !MatchStringBeginning(szRsp, "+DS: ", szRsp) ||
        !ParseRangeList(szRsp, g_DataCompDirection, NUM_DATACOMPDIRECTION, prcdc->dwDirection, szRsp) ||
        !MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseRangeList(szRsp, g_DataCompNegotiation, NUM_DATACOMPNEGOTIATION, prcdc->dwNegotiation, szRsp) ||
        !MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseRange(szRsp, prcdc->rrMaxDict, szRsp) ||
        !MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseRange(szRsp, prcdc->rrMaxString, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    prcdc->dwParams = RIL_PARAM_CDC_ALL;

    pBlob = (void*)prcdc;
    cbBlob = sizeof(RILCAPSDATACOMPRESSION);

Error:
    if (FAILED(hr))
    {
        FreeBlob(prcdc);
    }

    return hr;
}

//
//
//
HRESULT ParseGetDevCapsErrorCorrection(LPCSTR szRsp, void*& pBlob, UINT& cbBlob)
{
    FUNCTION_TRACE(ParseGetDevCapsErrorCorrection);

    RILCAPSERRORCORRECTION *prcec = NULL;
    HRESULT hr = S_OK;

    pBlob = NULL;
    cbBlob = 0;

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

    if (!ParseRspPrefix(szRsp, szRsp) ||
        !MatchStringBeginning(szRsp, "+ES: ", szRsp) ||
        !ParseRangeList(szRsp, g_ErrorCorrectionOrigRqst, NUM_ERRORCORRECTIONORIGRQST, prcec->dwOriginalRequest, szRsp) ||
        !MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseRangeList(szRsp, g_ErrorCorrectionOrigFbk, NUM_ERRORCORRECTIONORIGFBK, prcec->dwOriginalFallback, szRsp) ||
        !MatchStringBeginning(szRsp, ",", szRsp) ||
        !ParseRangeList(szRsp, g_ErrorCorrectionAnsFbk, NUM_ERRORCORRECTIONANSFBK, prcec->dwAnswererFallback, szRsp) ||
        !ParseRspPostfix(szRsp, szRsp))
    {
        hr = E_FAIL;
        goto Error;
    }

    prcec->dwParams = RIL_PARAM_CDC_ALL;

    pBlob = (void*)prcec;
    cbBlob = sizeof(RILCAPSERRORCORRECTION);

Error:
    if (FAILED(hr))
    {
        FreeBlob(prcec);
    }

    return hr;
}

HRESULT RILDrv_SetATLogging(DWORD dwParam, BOOL fEnable)
{
   FUNCTION_TRACE(RILDrv_SetATLogging);
   HRESULT hr = S_OK;
   CRilHandle* pRilDevice = NULL;
  
   CRilInstanceHandle* pHandle = ExtractHandle(dwParam);
   if (!pHandle)
   {
     hr = E_FAIL;
     goto Error;
   }
    
   pRilDevice = pHandle->GetDevice();
   if ( pRilDevice ) 
   {
     if ( fEnable )
       pRilDevice->SetAtLogOwner( pHandle );
     else
       pRilDevice->SetAtLogOwner(0);
   }

   // Build command
   if (!QueueCmd(pHandle,
                  NULL,
                  CMDOPT_NOOP,
                  APIID_REGISTERATCOMMANDLOGGING,
                  NULL,  // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
        hr=E_FAIL;

   Error:
    return hr;
}


// For Microsoft Test only. This does not need to be fully implemented.
// A return response of E_NOTIMPL is appropriate. 
HRESULT RILDrv_ATLogFile(DWORD dwParam, const TCHAR *pszFilename)
{
    FUNCTION_TRACE(RILDrv_ATLogFile);
    HRESULT hr = S_OK;

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

// If Watson support is not enabled return not implemented.
#ifndef RIL_WATSON_REPORT
    hr = E_NOTIMPL;
    goto Error;
    
#else
    // Move the read point in the at log buffer to the beginning
    // of the first command. (This removes partial log entries.)
    g_RilATCmdLogBuffer.AdvanceReadPastDelimiter((BYTE)'\n');
    
    // Create the log file.
    if ( !(g_RilATCmdLogBuffer.DumpToFile(pszFilename)) )
    {
         hr = E_FAIL;
         goto Error;        
    }
    
    // Build command
    if (!QueueCmd(pHandle,
                  NULL,
                  CMDOPT_NOOP,
                  APIID_ATCOMMANDLOGFILE,
                  NULL,     // Parse fn
                  NULL,     // Ptr to notification data
                  hr))
    {
        hr=E_FAIL;
    }
#endif // RIL_WATSON_REPORT

    
Error:
    return hr;
}

HRESULT RILDrv_GetSerialPortHandleFromContextID(DWORD dwContextID, __out_bcount( dwSize ) TCHAR *tszDataPortName, DWORD dwSize, DWORD *pdwSizeOut)
{
    HRESULT hr = E_FAIL;

    if ( tszDataPortName && pdwSizeOut )
    {
        // At the time of this implementation, we do not have any vendors that support multiple PPP-based APNs. In this case,
        // we will simply do what the proxy currently does. This allows for basic testing.
        const TCHAR DefaultDataVspName[] = _T("COM9:");
        *pdwSizeOut = 0;
        if ( dwSize > sizeof(DefaultDataVspName) )
        {
            // Get the COM port name
            if (!GetRegistrySZ( HKEY_LOCAL_MACHINE, TEXT("Software\\Microsoft\\RIL"), TEXT("DataPort"), tszDataPortName, (dwSize / sizeof(*tszDataPortName)) ))
            {
                _tcsncpyz( tszDataPortName, DefaultDataVspName, (sizeof(DefaultDataVspName) / sizeof(*DefaultDataVspName)) );
            }
            *pdwSizeOut = (_tcslen ( tszDataPortName ) + 1) * sizeof(*tszDataPortName);
            hr = S_OK;
        }
    }
    return hr;
}


HRESULT RILDrv_GetVTSerialPortHandle(TCHAR *tszVTPortName, DWORD dwSize, DWORD *pdwSizeOut)
{
    return E_NOTIMPL;
}