VOS_UINT32 TAF_SPM_TransUssdMsgToAsciiStr(
    TAF_SS_PROCESS_USS_REQ_STRU        *pstUssdMsg,
    VOS_UINT8                          *pucAsciiStr,
    VOS_UINT32                         *pulAsciiStrLength
)
{
    VOS_UINT8                          *pucUssdStr          = VOS_NULL_PTR;
    VOS_UINT8                          *pucUssdTransTbl     = VOS_NULL_PTR;
    VOS_UINT8                           aucUnpackUssdStr[TAF_SS_MAX_USSDSTRING_LEN];
    VOS_UINT32                          ulUssdStrLength;
    VOS_UINT32                          ulUnpackUssdStrLength;
    VOS_UINT32                          i;
    VOS_UINT32                          ulRet;
    MN_MSG_CBDCS_CODE_STRU              stDcsInfo;

    PS_MEM_SET(&stDcsInfo, 0, sizeof(stDcsInfo));

    ulRet = MN_MSG_DecodeCbsDcs(pstUssdMsg->DatacodingScheme,
                                pstUssdMsg->UssdStr.aucUssdStr,
                                pstUssdMsg->UssdStr.usCnt,
                                &stDcsInfo);
    if (MN_ERR_NO_ERROR != ulRet)
    {
        TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr:WARNING: Decode Failure");
        return VOS_FALSE;
    }

    /*
       非透传模式或非7BIT编码,TAF接收到的用户USSD字符串编码格式为ASCII码或UCS2码流,
       不需要转换,直接拷贝到输出参数
    */
    if ((TAF_SDC_USSD_TRAN_MODE != TAF_SDC_GetUssdTransMode())
     || (MN_MSG_MSG_CODING_7_BIT != stDcsInfo.enMsgCoding))
    {
        if (pstUssdMsg->UssdStr.usCnt > TAF_SS_MAX_USSDSTRING_LEN)
        {
            TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: USSD length overflow in none transparent mode.");
            return VOS_FALSE;
        }

        *pulAsciiStrLength  = pstUssdMsg->UssdStr.usCnt;

         PS_MEM_CPY(pucAsciiStr, pstUssdMsg->UssdStr.aucUssdStr, *pulAsciiStrLength);

        return VOS_TRUE;
    }

    /*
       这段代码完成从7BIT压缩编码的数字字符串到ASCII码流的转换
       透传模式并且DCS为7bit编码格式,用户输入每一个USSD数字,经过7Bit压缩后,
       每个字节的高4bit和低4bit在此处是分别由一个Byte表示的
       TAF接收到的用户USSD字符串就是2个字符表示一个数字,最大长度为320字符,
       USSD空口码流容量为160BYTE,160BYTE 传输7BIT编码的字符,可以传输182个字符,

       示例:
       用户输入*199#的情况,应用接收到ASCII码流2A 31 39 39 23,进行7BIT编码后为
       aa 58 2e 37 02,转换为数字字符串为61 61 35 38 32 65 33 37 30 32,通过AT命令
       AT+CUSD=1,"61613538326533373032",15 AT透传"61613538326533373032"到TAF,所以
       本函数输入: 61 61 35 38 32 65 33 37 30 32
       本函数输出: ASCII码流为2A 31 39 39 23,长度为5
       实现步骤:
       1) TAF_AsciiNum2HexStr: 61 61 35 38 32 65 33 37 30 32 => aa 58 2e 37 02
       2) MN_UnPack7Bit:          aa 58 2e 37 02                => 2A 31 39 39 23
       因为此处的ASCII码属于标准ASCII码,所以USSD的字符转换表对输出字符串无影响

       16进制表示的USSD码流字符串转换为16进制表示的USSD码流
       举例说明:
       16进制表示的7BIT字符表压缩编码的USSD码流字符串 0x61 0x61 0x35 0x38 0x32 0x65 0x33 0x37 0x30 0x32
       转换成
               16进制表示的7BIT字符表压缩编码的码流 0xaa 0x58 0x2e 0x37 0x02
       其中,0x61表示ASCII码的a 0x65表示ASCII码的e
    */
    if (pstUssdMsg->UssdStr.usCnt > TAF_SS_MAX_USSD_CHAR_HEX_FORMAT)
    {
        TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: USSD length overflow in transparent mode.");
        return VOS_FALSE;
    }

    pucUssdStr = (VOS_UINT8 *)PS_MEM_ALLOC(WUEPS_PID_TAF, TAF_SS_MAX_USSD_CHAR_HEX_FORMAT);
    if (VOS_NULL_PTR == pucUssdStr)
    {
        TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: Fail to alloc memory.");
        return VOS_FALSE;
    }

    PS_MEM_SET(pucUssdStr, 0, TAF_SS_MAX_USSD_CHAR_HEX_FORMAT);

    ulUssdStrLength = pstUssdMsg->UssdStr.usCnt;
    PS_MEM_CPY(pucUssdStr, pstUssdMsg->UssdStr.aucUssdStr, pstUssdMsg->UssdStr.usCnt);
    ulRet = TAF_STD_AsciiNum2HexString(pucUssdStr, (VOS_UINT16 *)&ulUssdStrLength);
    if (VOS_FALSE == ulRet)
    {
        TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr: Fail to TAF_AsciiNum2HexString.");
        PS_MEM_FREE(WUEPS_PID_TAF, pucUssdStr);
        return VOS_FALSE;
    }

    /*
    16进制表示的7BIT字符表压缩编码USSD码流转换成7BIT字符表非压缩编码USSD码流
    举例说明:
          16进制表示的7BIT字符表压缩编码USSD码流 0xaa 0x58 0x2e 0x37 0x02
    转换成
          7BIT字符表非压缩编码USSD码流           0x2A 0x31 0x39 0x39 0x23
    */
    ulUnpackUssdStrLength = TAF_SPM_GetUssdStringSeptetLength(ulUssdStrLength,
                                            *(pucUssdStr + ulUssdStrLength - 1));

    PS_MEM_SET(aucUnpackUssdStr, 0, sizeof(aucUnpackUssdStr));

    if (ulUssdStrLength > TAF_SS_MAX_USSDSTRING_LEN)
    {
        ulUssdStrLength = TAF_SS_MAX_USSDSTRING_LEN;
    }
    
    ulRet = TAF_STD_UnPack7Bit(pucUssdStr, ulUssdStrLength, 0, aucUnpackUssdStr);

    if (VOS_OK != ulRet)
    {
        TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_TransUssdMsgToAsciiStr:TAF_STD_UnPack7Bit Err.");
    }
    PS_MEM_FREE(WUEPS_PID_TAF, pucUssdStr);

    /*
    7BIT字符表非压缩编码USSD码流转换成ASCII码字符表编码的码流
    示例中不涉及7BIT字符表和ASCII码字符表存在差异的字符,所以无变化
    */
    pucUssdTransTbl = TAF_SDC_GetCurr7BitToAsciiTableAddr();
    for (i = 0; i < ulUnpackUssdStrLength; i++)
    {
        pucAsciiStr[i]  = pucUssdTransTbl[aucUnpackUssdStr[i]];
    }

    return VOS_TRUE;
}
Пример #2
0
VOS_UINT32  MN_MSG_DecodeCbmPage(
    const MN_MSG_CBRAW_TS_DATA_STRU     *pstCbRawInfo,
    MN_MSG_CBPAGE_STRU                  *pstCbmPageInfo
)
{
    VOS_UINT32                          ulRet;
    MN_MSG_CBGSMPAGE_STRU               *pstGsmPage;
    VOS_UINT32                          ulDataLen;

    /*判断输入参数的合法性*/
    if ((VOS_NULL_PTR == pstCbRawInfo)
     || (VOS_NULL_PTR == pstCbmPageInfo))
    {
        MN_ERR_LOG("MN_MSG_DecodeCbmPage: Parameter of the function is null.");
        return MN_ERR_NULLPTR;
    }

    pstGsmPage = (MN_MSG_CBGSMPAGE_STRU   *)pstCbRawInfo->aucData;

    /* 解析DCS */
    /* Modified by f62575 for V9R1 STK升级, 2013-6-26, begin */
    ulRet = MN_MSG_DecodeCbsDcs(pstGsmPage->ucDCS,
                                pstGsmPage->aucContent,
                                TAF_CBA_MAX_CBDATA_LEN,
                                &(pstCbmPageInfo->stDcs));
    /* Modified by f62575 for V9R1 STK升级, 2013-6-26, end */
    if (MN_ERR_NO_ERROR != ulRet)
    {
        MN_WARN_LOG1("MN_MSG_DecodeCbmPage:DCS Invalid:ulRet",(VOS_INT32)ulRet);
    }

    /* 解析SN */
    ulRet = MSG_CbDecodeSn(pstGsmPage, &(pstCbmPageInfo->stSn));
    if (MN_ERR_NO_ERROR != ulRet)
    {
        MN_WARN_LOG1("MN_MSG_DecodeCbmPage:SN Invalid:ulRet",(VOS_INT32)ulRet);
    }

    /* 解析MID */
    pstCbmPageInfo->usMid = pstGsmPage->ucMIdHigh;
    pstCbmPageInfo->usMid = (VOS_UINT16)(pstCbmPageInfo->usMid << 8) | pstGsmPage->ucMIdLow;

    /* page info */
    pstCbmPageInfo->ucPageIndex = pstGsmPage->Pagebit4;
    pstCbmPageInfo->ucPageNum = pstGsmPage->Pagesbit4;

    /* This parameter is coded as two 4-bit fields. The first field (bits 0-3) indicates the binary value of the total number of
    pages in the CBS message and the second field (bits 4-7) indicates binary the page number within that sequence. The
    coding starts at 0001, with 0000 reserved. If a mobile receives the code 0000 in either the first field or the second field
    then it shall treat the CBS message exactly the same as a CBS message with page parameter 0001 0001 (i.e. a single
    page message). */
    if ( ( 0 == pstCbmPageInfo->ucPageIndex )
      || ( 0 == pstCbmPageInfo->ucPageNum ))
    {
        pstCbmPageInfo->ucPageIndex = 1;
        pstCbmPageInfo->ucPageNum   = 1;
    }
    ulDataLen = pstCbRawInfo->ulLen - MSG_CBPAGE_HEADER_LEN;

    /* 如果是 7bit编码需要将其转化为8bit */
    if (MN_MSG_MSG_CODING_7_BIT == pstCbmPageInfo->stDcs.enMsgCoding )
    {

        pstCbmPageInfo->stContent.ulLen = (ulDataLen * 8)/7;

        if ( pstCbmPageInfo->stContent.ulLen > TAF_CBA_MAX_RAW_CBDATA_LEN )
        {
            pstCbmPageInfo->stContent.ulLen = TAF_CBA_MAX_RAW_CBDATA_LEN;
        }

        /* Modified by f62575 for V9R1 STK升级, 2013-6-26, begin */
        ulRet = TAF_STD_UnPack7Bit(pstGsmPage->aucContent,
                           pstCbmPageInfo->stContent.ulLen,
                           0,
                           pstCbmPageInfo->stContent.aucContent);
        if (VOS_OK != ulRet)
        {
            MN_WARN_LOG("MN_MSG_DecodeCbmPage:TAF_STD_UnPack7Bit fail");
        }
        /* Modified by f62575 for V9R1 STK升级, 2013-6-26, end */
    }
    else
    {
        pstCbmPageInfo->stContent.ulLen = ulDataLen;
        PS_MEM_CPY(pstCbmPageInfo->stContent.aucContent,
                   pstGsmPage->aucContent,
                   pstCbmPageInfo->stContent.ulLen);

    }
    return MN_ERR_NO_ERROR;
}
VOS_UINT32 TAF_SPM_BuildUssdStringInfo(
    TAF_SS_DATA_CODING_SCHEME           ucDatacodingScheme,
    TAF_SS_USSD_STRING_STRU            *pstSrcUssd,
    TAF_SS_USSD_STRING_STRU            *pstDstUssd
)
{
    VOS_UINT32                          ulRslt;
    MN_MSG_CBDCS_CODE_STRU              stDcsInfo;

    PS_MEM_SET(&stDcsInfo, 0, sizeof(stDcsInfo));

    /* USSD与CBS的DCS的协议相同,调用CBS的DCS解析函数解码,详细情况参考23038 */
    ulRslt = MN_MSG_DecodeCbsDcs(ucDatacodingScheme,
                                 pstSrcUssd->aucUssdStr,
                                 pstSrcUssd->usCnt,
                                 &stDcsInfo);
    if (MN_ERR_NO_ERROR != ulRslt)
    {
        TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo:WARNING: Decode Failure");
        return VOS_FALSE;
    }

    if (MN_MSG_MSG_CODING_7_BIT == stDcsInfo.enMsgCoding)
    {
        PS_MEM_CPY(pstDstUssd, pstSrcUssd, sizeof(TAF_SS_USSD_STRING_STRU));

        /* 非透传模式,编码方式为7bit时,上层是没有按7Bit压缩的,
           仍然是ASCII,此处需要保证DCS指示的编码方式与实际内容的编码方式一致 */
        if (TAF_SDC_USSD_NON_TRAN_MODE == TAF_SDC_GetUssdTransMode())
        {
            ulRslt = TAF_MmiEncodeUssdMessage(pstDstUssd);
            if (VOS_FALSE == ulRslt)
            {
                TAF_NORMAL_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: SSA_EncodeUssdMessage encode failure");
                return VOS_FALSE;
            }
        }
        /* 透传模式,编码方式为7bit时,上层是按7Bit压缩的,但用户输入每一个USSD数字,
           经过7Bit压缩后, 每个字节的高4bit和低4bit在此处是分别由一个Byte表示的,此处需要将两个byte还原为一个字节
           例如用户要输入*199#,7bit压缩后为aa 58 2e 37 02,拆分后为61 61 35 38 32 65 33 37 30 32
            */
        else
        {
            if (pstDstUssd->usCnt > TAF_SS_MAX_USSD_CHAR_HEX_FORMAT)
            {
                TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: String too Long failure");
                return VOS_FALSE;
            }

            ulRslt = TAF_STD_AsciiNum2HexString(pstDstUssd->aucUssdStr, &pstDstUssd->usCnt);

            if (VOS_FALSE == ulRslt)
            {
                TAF_NORMAL_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: TAF_AsciiNum2HexString encode failure");
                return VOS_FALSE;
            }
        }
    }
    else
    {
        if (pstSrcUssd->usCnt > TAF_SS_MAX_USS_CHAR)
        {
            TAF_WARNING_LOG(WUEPS_PID_TAF, "TAF_SPM_BuildUssdStringInfo: String too Long failure");
            return VOS_FALSE;
        }

        PS_MEM_CPY(pstDstUssd, pstSrcUssd, sizeof(TAF_SS_USSD_STRING_STRU));
    }

    return VOS_TRUE;
}