r64_decode_message.~cpp

wimax bs simulator对应的GUI程序

    return i_ret;
}

/*******************************************************************************
** Function Name: r64_decode_msg_header
** Input parameters description:
       a - p_udp_msg, pointer to the msg that contains the original data
       b - p_r64_msg, pointer to the msg that saves the encode result
** Output results description:
       a - ERROR, encode failure
       b - OK, encode success.
** function description:
      r64 decode msg header
*******************************************************************************/
int r64_decode_msg_header(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    R64_MESSAGE_HEAD_S * p_head;

    p_head = &p_r64_msg->msgHead;
    memset((BYTE *)p_head, 0, sizeof(R64_MESSAGE_HEAD_S));

    p_head->sourceIp = p_udp_msg->srcIp;
    p_head->destinationIp = p_udp_msg->destIp;
    p_head->sourceUdpPort = p_udp_msg->srcUdpPort;
    p_head->destinationUdpPort = p_udp_msg->destUdpPort;
	if ((p_head->destinationUdpPort == R6_BS_RECEIVE_UDP_PORT_FROM_GW) 
	    || (p_head->destinationUdpPort == R6_GW_RECEIVE_UDP_PORT_FROM_BS))
	{
        p_head->ifType = IF_TYPE_R6;
        if (p_udp_msg->dataLen < R64_R6_HEADER_LEN)
        {
            printf("r64_decode_msg_header, r6 data length %d < %ld (normal size)\n",
                p_udp_msg->dataLen, sizeof(R64_R6_HEADER_S));
            return ERROR;
        }
        r64_decode_msg_header_r6(p_udp_msg, p_head);

        if (p_head->length >= R64_R6_HEADER_LEN)
        {
            if (ERROR == r64_check_tlvs_len(p_udp_msg->data + R64_R6_HEADER_LEN,
                (WORD)(p_head->length - R64_R6_HEADER_LEN)))
            {
                printf("r64_decode_msg_header, length is not match\n");
                return ERROR;
            }

        }
        else
        {
            printf("r64_decode_msg_header, r6 header length %d < %ld (normal size)\n",
                p_udp_msg->dataLen, R64_R6_HEADER_LEN);
            return ERROR;
        }

    }
    else
    {
        p_head->ifType = IF_TYPE_R4;
        if (p_udp_msg->dataLen < R64_R4_HEADER_LEN)
        {
            printf("r64_decode_msg_header, r4 header length %d < %ld (normal size)\n",
                p_udp_msg->dataLen, R64_R4_HEADER_LEN);
            return ERROR;
        }

        r64_decode_msg_header_r4(p_udp_msg, p_head);

        if (p_head->length >= R64_R4_HEADER_LEN)
        {
            if (ERROR == r64_check_tlvs_len(p_udp_msg->data + R64_R4_HEADER_LEN,
                (WORD)(p_head->length - R64_R4_HEADER_LEN)))
            {
                printf("r64_decode_msg_header, length is not match\n");
                return ERROR;
            }
        }
        else
        {
            printf("r64_decode_msg_header, r6 header length %d < %ld (normal size)\n",
                p_udp_msg->dataLen, R64_R4_HEADER_LEN);
            return ERROR;
        }
    }

    return OK;
}

/*******************************************************************************
** Function Name: r64_decode_msg_header_r6
** Input parameters description:
       a - p_udp_msg, pointer to the msg that contains the original data
       b - p_r64_msg, pointer to the msg that saves the encode result
** Output results description:
       a - ERROR, encode failure
       b - OK, encode success.
** function description:
      r64 decode r6 msg header
*******************************************************************************/
int r64_decode_msg_header_r6(UDP_MSG_S * p_udp_msg, R64_MESSAGE_HEAD_S * p_head)
{
    R64_R6_HEADER_S * p_org_header;

    p_org_header = (R64_R6_HEADER_S *)p_udp_msg->data;

    p_head->version = p_org_header->b_ver;
    p_head->flags = p_org_header->b_flags;
    p_head->functionType = p_org_header->b_function_type;
    p_head->messageType = p_org_header->b_msg_type;
    p_head->length = ntohs(p_org_header->w_len);
    memcpy(p_head->msId.id, p_org_header->ab_msid, R64_MSID_LENGTH);

    p_head->reserved0[0] = p_org_header->ab_rsvd[0];
    p_head->reserved0[1] = p_org_header->ab_rsvd[1];
    p_head->reserved0[2] = p_org_header->ab_rsvd[2];
    p_head->reserved0[3] = p_org_header->ab_rsvd[3];

    p_head->transId = ntohs(p_org_header->w_transaction_id);
    p_head->reserved1 = p_org_header->b_rsvd;
    p_head->fragmentId = p_org_header->b_fragment_id;

    return OK;
}

/*******************************************************************************
** Function Name: r64_decode_msg_header_r4
** Input parameters description:
       a - p_udp_msg, pointer to the msg that contains the original data
       b - p_r64_msg, pointer to the msg that saves the encode result
** Output results description:
       a - ERROR, encode failure
       b - OK, encode success.
** function description:
      r64 decode r64 msg header
*******************************************************************************/
int r64_decode_msg_header_r4(UDP_MSG_S * p_udp_msg, R64_MESSAGE_HEAD_S * p_head)
{
    R64_R4_HEADER_S * p_org_header;

    p_org_header = (R64_R4_HEADER_S *)p_udp_msg->data;

    p_head->version = p_org_header->b_ver;
    p_head->flags = p_org_header->b_flags;
    p_head->functionType = p_org_header->b_function_type;
    p_head->messageType = p_org_header->b_msg_type;
    p_head->length = ntohs(p_org_header->w_len);
    memcpy(p_head->msId.id, p_org_header->ab_msid, R64_MSID_LENGTH);

    p_head->reserved0[0] = p_org_header->ab_rsvd[0];
    p_head->reserved0[1] = p_org_header->ab_rsvd[1];
    p_head->reserved0[2] = p_org_header->ab_rsvd[2];
    p_head->reserved0[3] = p_org_header->ab_rsvd[3];

    p_head->transId = ntohs(p_org_header->w_transaction_id);
    p_head->reserved1 = p_org_header->b_rsvd;
    p_head->fragmentId = p_org_header->b_fragment_id;

    p_head->destinationId = ntohl(p_org_header->dw_dst_entity_id);
    p_head->sourceId = ntohl(p_org_header->dw_src_entity_id);

    return OK;
}


/*******************************************************************************
** Function Name: r64_decode_ft_???
** Input parameters description:
       a - p_udp_msg, pointer to the msg that contains the original data
       b - p_r64_msg, pointer to the msg that saves the encode result
** Output results description:
       a - ERROR, encode failure
       b - OK, encode success.
** function description:
      r64 decode function type entry
*******************************************************************************/
int r64_decode_ft_qos(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    int i_ret = ERROR;
    switch (p_r64_msg->msgHead.messageType)
    {
    case R64_ID_RESOURCE_REGISTRATION_REQUEST:
        i_ret = r64_decode_ft_qos_msg_registration_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_RESOURCE_REGISTRATION_RESPONSE:
        i_ret = r64_decode_ft_qos_msg_registration_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_PD_REQUEST:
        i_ret = r64_decode_ft_qos_msg_pd_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_PD_RESPONSE:
        i_ret = r64_decode_ft_qos_msg_pd_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_PR_REQUEST:
        i_ret = r64_decode_ft_qos_msg_pr_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_PR_RESPONSE:
        i_ret = r64_decode_ft_qos_msg_pr_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_LU_REQUEST:
        i_ret = r64_decode_ft_qos_msg_lu_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_LU_RESPONSE:
        i_ret = r64_decode_ft_qos_msg_lu_response(p_udp_msg, p_r64_msg);
        break;
    default:
        R64_SAVE_DECODE_ERROR_LINE;
        printf("r64_decode_ft_qos, unknown msg type %d\n", p_r64_msg->msgHead.messageType);
        break;
    }
    return i_ret;
}

int r64_decode_ft_handoff(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    int i_ret = ERROR;
    switch (p_r64_msg->msgHead.messageType)
    {
    case R64_ID_HANDOFF_REQUEST:
        i_ret = r64_decode_ft_handoff_msg_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_HANDOFF_RESPONSE:
        i_ret = r64_decode_ft_handoff_msg_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_HANDOFF_CONFIRM:
        i_ret = r64_decode_ft_handoff_msg_confirm(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_HANDOFF_COMPLETE:
        i_ret = r64_decode_ft_handoff_msg_complete(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_HANDOFF_ACK:
        i_ret = r64_decode_ft_handoff_msg_ack(p_udp_msg, p_r64_msg);
        break;
    default:
        R64_SAVE_DECODE_ERROR_LINE;
        printf("r64_decode_ft_handoff, unknown msg type %d\n", p_r64_msg->msgHead.messageType);
        break;
    }
    return i_ret;
}

int r64_decode_ft_data_path(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    int i_ret = ERROR;
    switch (p_r64_msg->msgHead.messageType)
    {
    case R64_ID_DATA_PATH_PRE_REGISTRATION_REQUEST:
        i_ret = r64_decode_ft_data_path_msg_pre_registration(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_REGISTRATION_REQUEST:
        i_ret = r64_decode_ft_data_path_msg_registration_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_DE_REGISTRATION_REQUEST:
        i_ret = r64_decode_ft_data_path_msg_de_registration_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_MODIFICATION_REQUEST:
        i_ret = r64_decode_ft_data_path_msg_modification_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_PRE_REGISTRATION_RESPONSE:
        i_ret = r64_decode_ft_data_path_msg_pre_registration_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_REGISTRATION_RESPONSE:
        i_ret = r64_decode_ft_data_path_msg_registration_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_DE_REGISTRATION_RESPONSE:
        i_ret = r64_decode_ft_data_path_msg_de_registration_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_MODIFICATION_RESPONSE:
        i_ret = r64_decode_ft_data_path_msg_modification_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_REGISTRATION_ACK:
        i_ret = r64_decode_ft_data_path_msg_registration_ack(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_SETUP_REQUEST:
        i_ret = r64_decode_ft_data_path_msg_setup_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_SETUP_RESPONSE:
        i_ret = r64_decode_ft_data_path_msg_setup_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_MODIFY_ACK:
        i_ret = r64_decode_ft_data_path_msg_modify_ack(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_RELEASE_REQUEST:
        i_ret = r64_decode_ft_data_path_msg_release_request(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_RELEASE_RESPONSE:
        i_ret = r64_decode_ft_data_path_msg_release_response(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_RELEASE_ACK:
        i_ret = r64_decode_ft_data_path_msg_release_ack(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_DE_REGISTRATION_ACK:
        i_ret = r64_decode_ft_data_path_msg_de_registration_ack(p_udp_msg, p_r64_msg);
        break;
    case R64_ID_DATA_PATH_SETUP_ACK:
        i_ret = r64_decode_ft_data_path_msg_setup_ack(p_udp_msg, p_r64_msg);
        break;
    default:
        R64_SAVE_DECODE_ERROR_LINE;
        printf("r64_decode_ft_data_path, unknown msg type %d\n", p_r64_msg->msgHead.messageType);
        break;
    }
    return i_ret;
}

int r64_decode_ft_context(UDP_MSG_S * p_udp_msg, R64_MSG_S * p_r64_msg)
{
    int i_ret = ERROR;
    switch (p_r64_msg->msgHead.messageType)
    {
    case R64_ID_CONTEXT_REQUEST:
        i_ret = r64_decode_ft_context_msg_request(p_udp_msg, p_r64_msg);
        break;