r64_decode_message.~cpp

wimax bs simulator对应的GUI程序

                    else
                    {
                        printf("decode_msg %s, unknown targetServingInd %d in bs_info\n", p_name,
                            st_bs_info.targetServingInd.indicator);
                        return ERROR;
                    }
                }
            }
            else
            {
                printf("decode_msg %s, bs_info.present.targetServingIndPresent=0.\n", p_name);
                return ERROR;
            }
            break;

        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            i_ret = OK;
            break;
        }

        R64_DECODE_CHK_MSG_ERROR(p_name);
    }
    return OK;
}

int r64_decode_ft_handoff_msg_response(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_HO_RSP_S * p_msg;
    char * p_name = "R64_HO_RSP";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;
    BYTE * p_value;
    R64_IF_TYPE_E e_if_type;
    int i_ret = ERROR;

    R64_DECODE_MSG_PREPARE(p_r64_msg->u.hoRsp);

    p_msg->targetBsNum = 0;
    while (w_tlvs_len > 0)
    {
        R64_DECODE_MSG_SET_OFFSET_LEN;

        switch (w_type)
        {
        case R64_T_HO_TYPE:
            i_ret = r64_decode_tlv_ho_type(&p_msg->hoType, p_value, w_one_tlv_len);
            p_msg->present.hoTypePresent = 1;
            break;
        case R64_T_MS_INFO:
            i_ret = r64_decode_tlv_ms_info(&p_msg->msInfo, p_value, w_one_tlv_len);
            p_msg->present.msInfoPresent = 1;
            break;
        case R64_T_HO_OPERATION_MODE:
            i_ret = r64_decode_tlv_ho_operation_mode(&p_msg->operationMode, p_value, w_one_tlv_len);
            p_msg->present.operationModePresent = 1;
            break;
        case R64_T_RESOURCE_RETAIN_TYPE:
            i_ret = r64_decode_tlv_resource_retain_type(&p_msg->resourceRetainType, p_value, w_one_tlv_len);
            p_msg->present.resourceRetainTypePresent = 1;
            break;
        case R64_T_BS_INFO:
            i_ret = r64_decode_tlv_bs_info(&p_msg->targetBsInfo[p_msg->targetBsNum], p_value, w_one_tlv_len);
            p_msg->targetBsNum++;
            p_msg->present.targetBsInfoPresent = 1;
            break;
        case R64_T_PRE_REG_RESULT_CODE:
            i_ret = r64_decode_tlv_pre_reg_result_code(&p_msg->preRegResultCode, p_value, w_one_tlv_len);
            p_msg->present.preRegResultCodePresent = 1;
            break;
        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            i_ret = OK;
            break;
        }
        R64_DECODE_CHK_MSG_ERROR(p_name);
    }
    return OK;
}

int r64_decode_ft_handoff_msg_confirm(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_HO_CONFIRM_S * p_msg;
    char * p_name = "R64_HO_CONFIRM";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;
    BYTE * p_value;
    R64_IF_TYPE_E e_if_type;
    int i_ret = ERROR;

    R64_DECODE_MSG_PREPARE(p_r64_msg->u.hoConfirm);
    while (w_tlvs_len > 0)
    {
        R64_DECODE_MSG_SET_OFFSET_LEN;
        switch (w_type)
        {
        case R64_T_HO_INDICATION_TYPE:
            i_ret = r64_decode_tlv_ho_indication_type(&p_msg->hoIndType, p_value, w_one_tlv_len);
            p_msg->present.hoIndTypePresent = 1;
            break;
        case R64_T_MS_INFO:
            i_ret = r64_decode_tlv_ms_info(&p_msg->msInfo, p_value, w_one_tlv_len);
            p_msg->present.msInfoPresent = 1;
            break;
        case R64_T_BS_INFO:
            i_ret = r64_decode_tlv_bs_info(&p_msg->targetBsInfo, p_value, w_one_tlv_len);
            p_msg->present.targetBsInfoPresent = 1;
            break;
        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            break;
        }
        R64_DECODE_CHK_MSG_ERROR(p_name);
    }

    return OK;
}

int r64_decode_ft_handoff_msg_complete(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_HO_COMPLETE_S * p_msg;
    char * p_name = "R64_HO_COMPLETE";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;
    BYTE * p_value;
    R64_IF_TYPE_E e_if_type;
    int i_ret = ERROR;

    R64_DECODE_MSG_PREPARE(p_r64_msg->u.hoComplete);
    while (w_tlvs_len > 0)
    {
        R64_DECODE_MSG_SET_OFFSET_LEN;
        switch (w_type)
        {
        case R64_T_CAUSE_CODE:
            i_ret = r64_decode_tlv_cause_code(&p_msg->causeCode, p_value, w_one_tlv_len);
            p_msg->present.causeCodePresent = 1;
            break;
        case R64_T_MS_INFO:
            i_ret = r64_decode_tlv_ms_info(&p_msg->msInfo, p_value, w_one_tlv_len);
            p_msg->present.msInfoPresent = 1;
            break;
        case R64_T_BS_INFO:
            i_ret = r64_decode_tlv_bs_info(&p_msg->servingBsInfo, p_value, w_one_tlv_len);
            p_msg->present.servingBsInfoPresent = 1;
            break;
        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            i_ret = OK;
            break;
        }
        R64_DECODE_CHK_MSG_ERROR(p_name);
    }

    return OK;
}

int r64_decode_ft_handoff_msg_ack(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_HO_ACK_S * p_msg;
    char * p_name = "R64_HO_ACK";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;
    BYTE * p_value;
    R64_IF_TYPE_E e_if_type;
    int i_ret = ERROR;

    R64_DECODE_MSG_PREPARE(p_r64_msg->u.hoAck);
    while (w_tlvs_len > 0)
    {
        R64_DECODE_MSG_SET_OFFSET_LEN;
        switch (w_type)
        {
        case R64_T_MS_INFO:
            i_ret = r64_decode_tlv_ms_info(&p_msg->msInfo, p_value, w_one_tlv_len);
            p_msg->present.msInfoPresent = 1;
            break;
        case R64_T_BS_INFO:
            i_ret = r64_decode_tlv_bs_info(&p_msg->targetBsInfo, p_value, w_one_tlv_len);
            p_msg->present.targetBsInfoPresent = 1;
            break;
        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            i_ret = OK;
            break;
        }
        R64_DECODE_CHK_MSG_ERROR(p_name);
    }

    return OK;
}

int r64_decode_ft_data_path_msg_pre_registration(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    /* not used */
    return ERROR;
}

int r64_decode_ft_data_path_msg_registration_request(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_DATA_PATH_REGISTRATION_REQUEST_S * p_msg;
    char * p_name = "R64_DATA_PATH_REGISTRATION_REQUEST";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;
    BYTE * p_value;
    R64_IF_TYPE_E e_if_type;
    int i_ret = ERROR;

    R64_DECODE_MSG_PREPARE(p_r64_msg->u.dataPathRegReq);
    while (w_tlvs_len > 0)
    {
        R64_DECODE_MSG_SET_OFFSET_LEN;
        switch (w_type)
        {
        case R64_T_REGISTRATION_TYPE:
            i_ret = r64_decode_tlv_registration_type(&p_msg->regType, p_value, w_one_tlv_len);
            p_msg->present.regTypePresent = 1;
            break;
        case R64_T_MS_INFO:
            i_ret = r64_decode_tlv_ms_info(&p_msg->msInfo, p_value, w_one_tlv_len);
            p_msg->present.msInfoPresent = 1;
            break;
        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            i_ret = OK;
            break;
        }
        R64_DECODE_CHK_MSG_ERROR(p_name);
    }

    return OK;
}

int r64_decode_ft_data_path_msg_de_registration_request(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_DATA_PATH_DEREGISTER_REQUEST_S * p_msg;
    char * p_name = "R64_DATA_PATH_DEREGISTER_REQUEST";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;
    BYTE * p_value;
    R64_IF_TYPE_E e_if_type;
    int i_ret = ERROR;

    R64_DECODE_MSG_PREPARE(p_r64_msg->u.dataPathDeregReq);
    while (w_tlvs_len > 0)
    {
        R64_DECODE_MSG_SET_OFFSET_LEN;
        switch (w_type)
        {
        case R64_T_REGISTRATION_TYPE:
            i_ret = r64_decode_tlv_registration_type(&p_msg->deregType, p_value, w_one_tlv_len);
            p_msg->present.deregTypePresent = 1;
            break;
        case R64_T_MS_INFO:
            i_ret = r64_decode_tlv_ms_info(&p_msg->msInfo, p_value, w_one_tlv_len);
            p_msg->present.msInfoPresent = 1;
            break;
        case R64_T_BS_INFO:
            i_ret = r64_decode_tlv_bs_info(&p_msg->bsInfo, p_value, w_one_tlv_len);
            p_msg->present.bsInfoPresent = 1;
            break;
        default:
            R64_SAVE_DECODE_ERROR_LINE;
            printf("decode_msg %s, unknown type error %d.\n", p_name, w_type);
            i_ret = OK;
            break;
        }
        R64_DECODE_CHK_MSG_ERROR(p_name);
    }

    return OK;
}

int r64_decode_ft_data_path_msg_modification_request(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    /* not used */
    return ERROR;
}

int r64_decode_ft_data_path_msg_pre_registration_response(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    /* not used */
    return ERROR;
}

int r64_decode_ft_data_path_msg_registration_response(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_DATA_PATH_REGISTRATION_RESPONSE_S * p_msg;
    char * p_name = "R64_DATA_PATH_REGISTRATION_RESPONSE";
    BYTE * p_offset;
    WORD w_one_tlv_len = 0;
    WORD w_tlvs_len;
    WORD w_type;