r64_endec.h

wimax bs simulator对应的GUI程序

/******************************************************************************
**
**    Copyright (c) 2007, UTStarcom, Inc.
**            All Rights Reserved.
**
**    Subsystem : Wimax BS
**    File      : r64_endec.h
**    Created By: scott.wang
**    Created On: 1/5/2007
**
**    Purpose:
**        This file define R64 message structure.
**    History:
**    Programmer  Date       Rev     Description
**    Scott.wang   1/18/2007   0.0     Creating file
******************************************************************************/


#ifndef _R64_ENDEC_H_
#define _R64_ENDEC_H_

/* #define R64_ENDEC_DEBUG */

#define R64_R4_HEADER_LEN sizeof(R64_R4_HEADER_S)
#define R64_R6_HEADER_LEN sizeof(R64_R6_HEADER_S)
#define R64_TLV_TL_LEN    4

#define R64_T_SRC_ID      0xF001
#define R64_T_DST_ID      0xF002

#define R6_UDP_PORT       6021
#define R4_UDP_PORT       2231

#define R64_TLV_HEADER_LEN sizeof(R64_TLV_HEADER_S)
#define R64_PRINT_MAX_STR_LEN 512

typedef struct _R64_TLV_HEADER{
	WORD w_type;
	/* The length of the value portion of the TLV, the type and length field are not included.*/
	WORD w_len;
}R64_TLV_HEADER_S;

typedef struct _R64_R6_HEADER_{
	BYTE b_ver;
	BYTE b_flags;
	BYTE b_function_type;
	BYTE b_msg_type;
	/* The length of the message (including the header) in bytes. This field is 2 bytes long.*/
	WORD w_len;
	BYTE ab_msid[R64_MSID_LENGTH];
	BYTE ab_rsvd[4];
	WORD w_transaction_id;
	BYTE b_rsvd;
	BYTE b_fragment_id;
}R64_R6_HEADER_S;

typedef struct _R64_R4_HEADER_{
	BYTE b_ver;
	BYTE b_flags;
	BYTE b_function_type;
	BYTE b_msg_type;
	/* The length of the message (including the header) in bytes. This field is 2 bytes long.*/
	WORD w_len;
	BYTE ab_msid[R64_MSID_LENGTH];
	BYTE ab_rsvd[4];
	WORD w_transaction_id;
	BYTE b_rsvd;
	BYTE b_fragment_id;
	WORD w_src_id_type;
	WORD w_src_id_len;
	DWORD dw_src_entity_id;
	WORD w_dst_id_type;
	WORD w_dst_id_len;
	DWORD dw_dst_entity_id;
}R64_R4_HEADER_S;

#define R64_MAX_FUNCTION_TYPE 10
#define R64_MAX_MSG_TYPE      17

#define REAL_STR_DEF(S) #S
#define STR_DEF(S) REAL_STR_DEF(S)

#define PRINT_SIZE(a) printf("%40s size: %d\n", STR_DEF(a), (int)sizeof(a));

#ifdef R64_ENDEC_DEBUG
#define R64_MAX_ERROR_LINE 10000
typedef struct _R64_ENDEC_ERROR_LINE_{
	DWORD dw_index;
	DWORD adw_line[R64_MAX_ERROR_LINE];
}R64_ENDEC_ERROR_LINE_S;

extern R64_ENDEC_ERROR_LINE_S gst_encode_error_line;
extern R64_ENDEC_ERROR_LINE_S gst_decode_error_line;

#define R64_SAVE_ENCODE_ERROR_LINE \
{ \
	if (gst_encode_error_line.dw_index >= R64_MAX_ERROR_LINE) \
	{ \
		gst_encode_error_line.dw_index = 0;\
	} \
	gst_encode_error_line.adw_line[gst_encode_error_line.dw_index] = __LINE__;\
	gst_encode_error_line.dw_index++;\
}

#define R64_SAVE_DECODE_ERROR_LINE \
{ \
	if (gst_decode_error_line.dw_index >= R64_MAX_ERROR_LINE) \
	{ \
		gst_decode_error_line.dw_index = 0;\
	} \
	gst_decode_error_line.adw_line[gst_decode_error_line.dw_index] = __LINE__;\
	gst_decode_error_line.dw_index++;\
}

#else
#define R64_SAVE_ENCODE_ERROR_LINE ((void)0)
#define R64_SAVE_DECODE_ERROR_LINE ((void)0)
#endif

#define	R64_DEC_CHK_IE_LEN_EQ(a, b)	\
{\
	if ((a) != (b))\
	{\
		printf("decode error EQ, TLV-IE len is wrong[%d-%d]. file %s, line = [%d]!\n", (int)(a), (int)(b), __FILE__, __LINE__);\
		R64_SAVE_DECODE_ERROR_LINE; \
		return ERROR;\
	}\
}

#define R64_DEC_CHK_IE_LEN_LE(a, b) \
{\
	if ((a) > (b))\
	{\
		printf("decode error LE, TLV-IE len is wrong[%d-%d]. file %s, line = [%d]!\n", (int)(a), (int)(b), __FILE__, __LINE__);\
		R64_SAVE_DECODE_ERROR_LINE; \
		return ERROR;\
	}\
}

/* 
   a: function_name;
   b: p_tlv_structure
   c: present
   d: msg_name
   e: tlv_name
*/

#define	R64_ENCODE_TLV(a, b, c, d, e) \
{\
	if (a) \
	{\
		i_ret = (b)((c), p_offset, &w_one_tlv_value_len);\
		if (i_ret == ERROR)\
		{ \
			printf("encode msg %s, tlv %s error, line %d.\n", (d), (e), __LINE__);\
			R64_SAVE_ENCODE_ERROR_LINE; \
			return ERROR;\
		}\
		w_tlvs_len += w_one_tlv_value_len + R64_TLV_TL_LEN;\
		p_offset += w_one_tlv_value_len + R64_TLV_TL_LEN;\
	}\
}

#define R64_ENCODE_TLV_HEADER(type, length, addr) \
{ \
	WORD w_temp_value; \
	BYTE * p_addr; \
\
	p_addr = addr; \
	w_temp_value = type; \
	w_temp_value = htons(w_temp_value); \
	WORD_2_BYTEP(w_temp_value, p_addr); \
\
	p_addr += sizeof(WORD); \
	w_temp_value = length; \
	w_temp_value = htons(w_temp_value); \
	WORD_2_BYTEP(w_temp_value, p_addr); \
}

/*
	t: type;
	a: tlv name
*/
#define R64_ENCODE_TLVS_HEAD(t, a) \
{ \
	if (w_tlvs_len == 0) \
	{ \
		printf("encode tlv %s error, no ie exist, line %d.\n", a, __LINE__); \
		R64_SAVE_ENCODE_ERROR_LINE; \
		return ERROR; \
	} \
	R64_ENCODE_TLV_HEADER(t, w_tlvs_len, p_tlvs_value); \
}

#define R64_ENCODE_SET_OFFSET_LEN \
{\
	e_if_type = p_r64_msg->msgHead.ifType; \
	if (e_if_type == IF_TYPE_R4) \
	{ \
		p_offset = p_udp_msg->data + R64_R4_HEADER_LEN; \
		w_msg_head_len = R64_R4_HEADER_LEN; \
	} \
	else \
	{ \
		p_offset = p_udp_msg->data + R64_R6_HEADER_LEN; \
		w_msg_head_len = R64_R6_HEADER_LEN; \
	}\
}

/*
	t: type
	l: length
	v: value
*/
#define R64_ENCODE_BASIC_BYTE(t, l, v) \
{ \
	BYTE * p_value; \
	R64_ENCODE_TLV_HEADER(t, l, p_offset); \
    *pw_len = l; \
	p_value = p_offset + R64_TLV_TL_LEN; \
	*p_value = v; \
	return OK; \
}

#define R64_ENCODE_BASIC_WORD(t, l, v) \
{ \
	BYTE * p_value; \
	WORD   w_temp; \
	R64_ENCODE_TLV_HEADER(t, l, p_offset); \
	*pw_len = l; \
	p_value = p_offset + R64_TLV_TL_LEN; \
	w_temp = htons(v); \
	WORD_2_BYTEP(w_temp, p_value); \
	return OK; \
}

#define R64_ENCODE_BASIC_DWORD(t, l, v) \
{ \
	BYTE * p_value; \
	DWORD dw_temp; \
	R64_ENCODE_TLV_HEADER(t, l, p_offset); \
	*pw_len = l; \
	p_value = p_offset + R64_TLV_TL_LEN; \
	dw_temp = (v); \
	dw_temp = htonl(dw_temp); \
	DWORD_2_BYTEP(dw_temp, p_value); \
	return OK; \
}

#define R64_ENCODE_BASIC_BYTE_ARRAY(t, l, v) \
{ \
	BYTE * p_value; \
	R64_ENCODE_TLV_HEADER(t, l, p_offset); \
	*pw_len = l; \
	p_value = p_offset + R64_TLV_TL_LEN; \
	memcpy(p_value, v, l); \
	return OK; \
}

#define	R64_ENCODE_BASIC_WORD_ARRAY(t, l, v) \
{ \
	WORD i; \
	WORD w_len_tlv; \
	BYTE * p_value; \
	WORD w_temp; \
	w_len_tlv = l * sizeof(WORD); \
	R64_ENCODE_TLV_HEADER(t, w_len_tlv, p_offset); \
	*pw_len = w_len_tlv; \
	p_value = p_offset + R64_TLV_TL_LEN; \
	for (i=0; i<l; i++)\
	{\
		w_temp = htons((v)[i]); \
		WORD_2_BYTEP(w_temp, p_value); \
		p_value += sizeof(WORD); \
	} \
	return OK; \
}

#define	R64_ENCODE_BASIC_DWORD_ARRAY(t, l, v) \
{ \
	WORD i; \
	WORD w_len_tlv; \
	BYTE * p_value; \
	DWORD dw_temp; \
	w_len_tlv = l * sizeof(DWORD); \
	R64_ENCODE_TLV_HEADER(t, w_len_tlv, p_offset); \
	*pw_len = w_len_tlv; \
	p_value = p_offset + R64_TLV_TL_LEN; \
	for (i=0; i<l; i++)\
	{\
		dw_temp = htonl((v)[i]); \
		DWORD_2_BYTEP(dw_temp, p_value); \
		p_value += sizeof(DWORD); \
	} \
	return OK; \
}


/* decode macro */
/*
	p: pointer to the data buffer
	l: length
	v: value
	present
*/
#define R64_DECODE_MSG_PREPARE(a) \
{\
	e_if_type = p_r64_msg->msgHead.ifType; \
	p_msg = &a; \
	memset((char *)&p_msg->present, 0, sizeof(p_msg->present)); \
	if (e_if_type == IF_TYPE_R4) \
	{ \
		w_tlvs_len = p_udp_msg->dataLen - R64_R4_HEADER_LEN; \
		p_offset = p_udp_msg->data + R64_R4_HEADER_LEN; \
	} \
	else \
	{ \
		w_tlvs_len = p_udp_msg->dataLen - R64_R6_HEADER_LEN; \
		p_offset = p_udp_msg->data + R64_R6_HEADER_LEN; \
	}\
	if (0 == w_tlvs_len) \
	{ \
		return OK; \
	} \
}

#define R64_DECODE_MSG_SET_OFFSET_LEN \
{ \
	BYTEP_2_WORD(p_offset, w_type); \
	BYTEP_2_WORD(p_offset+sizeof(WORD), w_one_tlv_len); \
	p_value = p_offset + R64_TLV_HEADER_LEN; \
	w_one_tlv_len = htons(w_one_tlv_len); \
	w_type = htons(w_type); \
	w_tlvs_len = w_tlvs_len - (w_one_tlv_len + R64_TLV_HEADER_LEN); \
	p_offset += (w_one_tlv_len + R64_TLV_HEADER_LEN); \
}

#define R64_DECODE_CHK_MSG_ERROR(a) \
{ \
	if (i_ret == ERROR) \
	{ \
		R64_SAVE_DECODE_ERROR_LINE; \
		printf("Decode msg %s, line %d\n", a, __LINE__); \
		return ERROR; \
	} \
}


#define R64_DECODE_BASIC_BYTE(v, l) \
{ \
    R64_DEC_CHK_IE_LEN_EQ(w_len, l); \
    (v) = *p_offset; \
    return OK; \
}

#define R64_DECODE_BASIC_WORD(v, l) \
{ \
    R64_DEC_CHK_IE_LEN_EQ(w_len, l); \
	BYTEP_2_WORD(p_offset, (v)); \
    (v) = ntohs(v); \
    return OK; \
}

#define R64_DECODE_BASIC_DWORD(v, l) \
{ \
    R64_DEC_CHK_IE_LEN_EQ(w_len, l); \
	BYTEP_2_DWORD(p_offset, (v)); \
    (v) = ntohl(v); \
    return OK; \
}

#define R64_DECODE_BASIC_BYTE_ARRAY(v, l) \
{ \
    R64_DEC_CHK_IE_LEN_EQ(w_len, l); \
	memcpy(v, p_offset, l); \
    return OK; \
}

#define R64_DECODE_BASIC_BYTE_ARRAY_V(v, num, max_num) \
{ \
    R64_DEC_CHK_IE_LEN_LE(w_len, max_num); \
	memcpy(v, p_offset, w_len); \
	num = w_len; \
    return OK; \
}

#define	R64_DECODE_BASIC_WORD_ARRAY_V(v, num, max_num) \
{ \
	WORD i; \
	BYTE * p_value; \
	WORD w_num; \
	if (w_len % sizeof(WORD)) \
	{ \
		printf("R64_DECODE_BASIC_DWORD_ARRAY, %d is illegal.\n", w_len); \
		R64_SAVE_DECODE_ERROR_LINE; \
		return ERROR; \
	} \
    R64_DEC_CHK_IE_LEN_LE(w_len, max_num * sizeof(WORD)); \
	w_num = w_len/sizeof(WORD); \
	num = w_num; \
	p_value = p_offset;\
	for (i=0; i<w_num; i++)\
	{\
		BYTEP_2_WORD(p_value, (v)[i]); \
		(v)[i] = ntohs((v)[i]); \
		p_value += sizeof(WORD); \
	} \
    return OK; \
}

#define	R64_DECODE_BASIC_DWORD_ARRAY_V(v, num, max_num) \
{ \
	WORD i; \
	BYTE * p_value; \
	WORD w_num; \
	if (w_len % sizeof(DWORD)) \
	{ \
		printf("R64_DECODE_BASIC_DWORD_ARRAY, %d is illegal.\n", w_len); \
		R64_SAVE_DECODE_ERROR_LINE; \
		return ERROR; \
	} \
    R64_DEC_CHK_IE_LEN_LE(w_len, max_num * sizeof(DWORD)); \
	w_num = w_len / sizeof(DWORD); \
	num = w_num; \
	p_value = p_offset;\
	for (i=0; i<w_num; i++) \
	{\
		BYTEP_2_DWORD(p_value, (v)[i]); \
		(v)[i] = ntohl((v)[i]); \
		p_value += sizeof(DWORD); \
	} \
    return OK; \
}

#define R64_DECODE_TLV_PREPARE(a) \
{\
	w_tlvs_len = w_len; \
	p_tlv = a; \
	memset((char *)&p_tlv->present, 0, sizeof(p_tlv->present)); \
	if (0 == w_tlvs_len) \
	{ \
		return OK; \
	} \
	if (r64_check_tlvs_len(p_offset, w_len)) \
	{ \
		printf("decode tlv %s r64_check_tlvs_len error, line %d\n", p_name, __LINE__); \
		R64_SAVE_DECODE_ERROR_LINE; \
		return ERROR; \
	} \
}

#define R64_DECODE_TLV_SET_OFFSET_LEN R64_DECODE_MSG_SET_OFFSET_LEN

#define R64_DECODE_CHK_TLV_ERROR(a) \
{ \
	if (i_ret == ERROR) \
	{ \
		printf("Decode TLV %s, line %d\n", a, __LINE__); \
		R64_SAVE_DECODE_ERROR_LINE; \
		return ERROR; \
	} \
}

/* print macro */
#define	R64_PRINT_TLV(a, b, c, d, e) \
{\
	if (a) \
	{\
		b(c, d, e);\
	}\
}

#define R64_PRINT_TLVS_HEAD(t, a) \
{ \
}

#define R64_PRINT_BASIC_BYTE(p_pre3, value) \
{ \
	printf("%s.%s.%s = %d\n", p_prefix1, p_prefix2, p_pre3, value);\
	return;\
}

#define R64_PRINT_BASIC_WORD(p_pre3, value) \
{ \
	printf("%s.%s.%s = %d\n", p_prefix1, p_prefix2, p_pre3, value);\
	return;\
}

#define R64_PRINT_BASIC_DWORD(p_pre3, value) \
{ \
	printf("%s.%s.%s = %ld\n", p_prefix1, p_prefix2, p_pre3, value);\
	return;\
}

#define R64_PRINT_BASIC_BYTE_ARRAY(p_pre3, value, length) \
{\
	printf("%s.%s.%s, length %d, data: \n", p_prefix1, p_prefix2, p_pre3, length);\
	r64_dump(value, length); \
	return;\
}


#define	R64_PRINT_BASIC_WORD_ARRAY(p_pre3, value, length) \
{\
	int i; \
	printf("%s.%s.%s: \n", p_prefix1, p_prefix2, p_pre3);\
	for (i=0; i<length; i++) \
	{ \
	    printf("[%d] = %d\n", i, value[i]); \
	} \
	return;\
}

#define	R64_PRINT_BASIC_DWORD_ARRAY(p_pre3, value, length) \
{ \
	int i; \
	printf("%s.%s.%s: \n", p_prefix1, p_prefix2, p_pre3);\
	for (i=0; i<length; i++) \
	{ \
	    printf("[%d] = %ld\n", i, value[i]); \
	} \
	return;\
}

#endif