summaryrefslogtreecommitdiff
path: root/cesar/cp/msg
diff options
context:
space:
mode:
authorsave2008-04-07 14:17:42 +0000
committersave2008-04-07 14:17:42 +0000
commit3d58a62727346b7ac1a6cb36fed1a06ed72228dd (patch)
treed7788c3cf9f76426aef0286d0202e2097f0fa0eb /cesar/cp/msg
parent095dca4b0a8d4924093bab424f71f588fdd84613 (diff)
Moved the complete svn base into the cesar directory.
git-svn-id: svn+ssh://pessac/svn/cesar/trunk@1769 017c9cb6-072f-447c-8318-d5b54f68fe89
Diffstat (limited to 'cesar/cp/msg')
-rw-r--r--cesar/cp/msg/Module7
-rw-r--r--cesar/cp/msg/ecos.ecc.sh5
-rw-r--r--cesar/cp/msg/inc/msg_apcm.h16
-rw-r--r--cesar/cp/msg/inc/msg_cc.h73
-rw-r--r--cesar/cp/msg/inc/msg_cm.h88
-rw-r--r--cesar/cp/msg/inc/msg_cm_conn_dbg.h239
-rw-r--r--cesar/cp/msg/inc/msg_cm_convert.h24
-rw-r--r--cesar/cp/msg/inc/msg_const.h325
-rw-r--r--cesar/cp/msg/inc/msg_drv.h276
-rw-r--r--cesar/cp/msg/inc/msg_field.h410
-rw-r--r--cesar/cp/msg/msg.h105
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_info_cnf.c17
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_info_req.c17
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_cnf.c95
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_req.c85
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_new_cnf.c110
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_new_req.c91
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_ind.c92
-rw-r--r--cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_rsp.c76
-rw-r--r--cesar/cp/msg/src/field/msg_field_cid.c70
-rw-r--r--cesar/cp/msg/src/field/msg_field_cinfo.c93
-rw-r--r--cesar/cp/msg/src/field/msg_field_classifier.c563
-rw-r--r--cesar/cp/msg/src/field/msg_field_cspec.c114
-rw-r--r--cesar/cp/msg/src/field/msg_field_qmp.c1189
-rw-r--r--cesar/cp/msg/src/msg.c336
-rw-r--r--cesar/cp/msg/src/msg_apcm.c16
-rw-r--r--cesar/cp/msg/src/msg_cc.c141
-rw-r--r--cesar/cp/msg/src/msg_cm.c273
-rw-r--r--cesar/cp/msg/src/msg_cm_convert.c65
-rw-r--r--cesar/cp/msg/src/msg_drv.c497
-rw-r--r--cesar/cp/msg/test/ecos.ecc.sh5
-rw-r--r--cesar/cp/msg/test/inc/test_conn.h34
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn.c29
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c801
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn_mod_req.c755
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn_new_cnf.c816
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn_new_req.c879
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn_rel_ind.c800
-rw-r--r--cesar/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c90
-rw-r--r--cesar/cp/msg/test/src/test_msg_field.c2898
40 files changed, 12615 insertions, 0 deletions
diff --git a/cesar/cp/msg/Module b/cesar/cp/msg/Module
new file mode 100644
index 0000000000..39783871f8
--- /dev/null
+++ b/cesar/cp/msg/Module
@@ -0,0 +1,7 @@
+SOURCES := msg.c \
+ msg_cm.c \
+ msg_cm_convert.c \
+ msg_cc.c \
+ msg_apcm.c \
+ msg_drv.c \
+
diff --git a/cesar/cp/msg/ecos.ecc.sh b/cesar/cp/msg/ecos.ecc.sh
new file mode 100644
index 0000000000..8253d98c9a
--- /dev/null
+++ b/cesar/cp/msg/ecos.ecc.sh
@@ -0,0 +1,5 @@
+config=${1:-ecos-gen.ecc}
+ecosconfig --config=$config new linux default
+cat >> $config <<EOF
+EOF
+ecosconfig --config=$config check
diff --git a/cesar/cp/msg/inc/msg_apcm.h b/cesar/cp/msg/inc/msg_apcm.h
new file mode 100644
index 0000000000..13b38c1d42
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_apcm.h
@@ -0,0 +1,16 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_apcm.h
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+
+
diff --git a/cesar/cp/msg/inc/msg_cc.h b/cesar/cp/msg/inc/msg_cc.h
new file mode 100644
index 0000000000..0bfa9c1649
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_cc.h
@@ -0,0 +1,73 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/inc/msg_cc.h
+ * \brief MME messages of CC type
+ * \ingroup cp_msg
+ */
+
+#ifndef msg_cc__h__
+#define msg_cc__h__
+
+#include "cp/msg/msg.h"
+
+
+typedef struct cc_assoc_req_t // 11.2.28
+{
+ // TODO : set the real types
+ u8 req_type;
+ nid_t nid;
+ u8 cco_capability;
+ u8 proxy_networking_capability;
+} __attribute__ ((packed)) cc_assoc_req_t;
+
+typedef struct cc_assoc_cnf_t // 11.2.29
+{
+ u8 result;
+ nid_t nid;
+ u8 snid;
+ tei_t sta_tei;
+ u16 lease_time;
+} __attribute__ ((packed)) cc_assoc_cnf_t;
+
+typedef struct cc_set_tei_map_ind_sub_t // 11.2.35
+{
+ tei_t tei;
+ mac_address_t mac_address;
+ u8 status;
+} __attribute__ ((packed)) cc_set_tei_map_ind_sub_t;
+
+#define SET_TEI_MAP_SUB_NB_ELEM ((ETH_PACKET_MAX_SIZE - MSG_MME_HEADER_SIZE) / sizeof(cc_set_tei_map_ind_sub_t))
+
+typedef struct cc_set_tei_map_ind_t // 11.2.35
+{
+ u8 mode;
+ u8 num;
+ cc_set_tei_map_ind_sub_t sub[SET_TEI_MAP_SUB_NB_ELEM];
+} __attribute__ ((packed)) cc_set_tei_map_ind_t;
+
+
+void msg_cc_assoc_req_send(const mac_address_t oda);
+
+void msg_cc_assoc_cnf_send(const mac_address_t oda, const u8 result, const tei_t sta_tei, const u16 lease_time);
+
+/**
+ * \brief will send msg_cc_set_tei_map_ind
+ * \param oda : station to which the message is sent
+ * \param mode : see 11.2.35.1
+ * \param tei : if mode == 0x01 (resp 0x02), this is the tei of the added (resp deleted) sta
+ * if mode == 0x0, set tei to 0
+ * \param recall : when this message is fragmented, call this function once per fragment, but
+ * set recall to true only the first time.
+ * \return
+ */
+void msg_cc_set_tei_map_ind_send(const mac_address_t oda, const u8 mode, const tei_t tei, const bool recall);
+
+
+
+#endif
diff --git a/cesar/cp/msg/inc/msg_cm.h b/cesar/cp/msg/inc/msg_cm.h
new file mode 100644
index 0000000000..9307d91ee5
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_cm.h
@@ -0,0 +1,88 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/inc/msg_cm.h
+ * \brief MME messages of CM type
+ * \ingroup cp_msg
+ */
+#ifndef MSG_CM_H_
+#define MSG_CM_H_
+
+#include "cp/cp_types.h"
+#include "cp/interf/inc/interf_types.h"
+#include "cp/msg/msg.h"
+#include "cp/secu/secu.h"
+
+//#include "cp/msg/inc/msg_cm_conn.h"
+#include "cp/msg/inc/msg_cm_convert.h"
+
+
+typedef struct cm_unassociated_sta_t // 11.5.1
+{
+ // TODO : set the real types
+ nid_t nid;
+ u8 cco_capability;
+} __attribute__ ((packed)) cm_unassociated_sta_t;
+
+typedef struct cm_encrypted_payload_t // 11.5.2
+{
+ peks_t peks;
+ u8 avln_status;
+ u8 pid;
+ u16 prn;
+ u8 pmn;
+ u8 iv[16];
+ u16 len;
+ u8 rf[15];
+} __attribute__ ((packed)) cm_encrypted_payload_t;
+
+typedef struct cm_encrypted_payload_sub_t // 11.5.2
+{
+ u32 crc;
+ u8 pid;
+ u16 prn;
+ u8 pmn;
+ u8 padding[15];
+ u8 rf_len;
+} __attribute__ ((packed)) cm_encrypted_payload_sub_t;
+
+typedef struct cm_set_key_req_t
+{
+ u8 key_type;
+ u32 my_nonce;
+ u32 your_nonce;
+ u8 pid;
+ u16 prn;
+ u8 pmn;
+ u8 cco_capa;
+ //nid_t nid;
+ u8 nid[7];
+ u8 new_eks;
+ u8 new_key[16];
+} __attribute__ ((packed)) cm_set_key_req_t;
+
+void
+msg_cm_init(void);
+
+//void msg_cm_unassociated_sta_ind_send(interf_id_t interf_id, mac_adresse_t oda);
+void
+msg_cm_unassociated_sta_ind_send(const mac_address_t oda);
+
+void
+msg_cm_encrypted_payload_ind_send(
+ const msg_mme_t *encapsulated_msg,
+ const msg_param_t encapsulated_msg_param,
+ const tei_t tei,
+ const bool last_msg_of_p_run,
+ const cp_pid_t pid,
+ const u16 msg_size
+ );
+
+
+
+#endif /*MSG_CM_H_*/
diff --git a/cesar/cp/msg/inc/msg_cm_conn_dbg.h b/cesar/cp/msg/inc/msg_cm_conn_dbg.h
new file mode 100644
index 0000000000..e8e7730131
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_cm_conn_dbg.h
@@ -0,0 +1,239 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_dbg.h
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+
+
+
+
+#ifndef MSG_CM_CONN_DBG_H_
+#define MSG_CM_CONN_DBG_H_
+
+/*! \def cp_dbg_cinfo_valid(cinfo_valid)
+ * Assertion for CINFO.valid.
+ */
+#define cp_dbg_cinfo_valid(cinfo_valid) \
+ dbg_assert_print( ((cinfo_valid) == CINFO_NOT_VALID) || ((cinfo_valid) == CINFO_VALID), "Invalid CINFO.valid field - current value 0x%x", cinfo_valid)
+
+/*! \def cp_dbg_mac_service_type(mac_service_type)
+ * Assertion for CINFO.MAC_SERVICE_TYPE.
+ */
+#define cp_dbg_mac_service_type(mac_service_type) \
+ dbg_assert_print( ((mac_service_type) == MAC_CONTENTION_FREE) || ((mac_service_type) == MAC_CONTENTION) || (mac_service_type == MAC_CONTENTION_FREE_PREFERRED), "Invalid CINFO.mac_service_type field - current value 0x%x", mac_service_type)
+
+/*! \def cp_dbg_user_priority(user_priotity)
+ * Assertion for CINFO.USER_PRIORITY.
+ */
+#define cp_dbg_user_priority(user_priority) \
+ dbg_assert_print( ((user_priority) == USER_PRIORITY_CAP0) || ((user_priority) == USER_PRIORITY_CAP1) || (user_priority == USER_PRIORITY_CAP2) || (user_priority == USER_PRIORITY_CAP3), "Invalid CINFO.user_priority field - current valie 0x%x", user_priority )
+
+/*! \def cp_dbg_ats(ats)
+ * Assertion for CINFO.ats.
+ */
+#define cp_dbg_ats(ats)\
+ dbg_assert_print( ((ats) == ATS_FOR_HLE) || ((ats) == ATS_NOT_FOR_HLE), "Invalid CINFO.ats field - current value 0x%x", ats)
+
+/*! \def cp_dbg_smoothing(smoothing)
+ * Assertion for CINFO.smoothing.
+ */
+#define cp_dbg_smoothing(smoothing)\
+ dbg_assert_print( ((smoothing) == SMOOTHING_REQUESTED) || ((smoothing) == SMOOTHING_NOT_REQUESTED), "Invalid CINFO.smoothing field - current value 0x%x", smoothing)
+
+/*! \def cp_dbg_qmp_forward_or_reverse(ForR)
+ * Assertion for QMP.forward_or_reverse.
+ */
+#define cp_dbg_qmp_forward_or_reverse(ForR)\
+ dbg_assert_print( ((ForR) == QMP_FORWARD) || ((ForR) == QMP_REVERSE), "Invalid QMP.forward_or_reverse field - current value 0x%x", ForR)
+
+/*! \def cp_dbg_qmp_field_identifier(field_identifier)
+ * Assertion for QMP.fid.
+ */
+#define cp_dbg_qmp_field_identifier(field_identifier) \
+ dbg_assert_print( ((field_identifier) < 0x16) || (0X80 > (field_identifier)), "Invalid QMP.field_identifier field - current value 0x%x", field_identifier)
+
+/*! \def cp_dbg_cid(cid)
+ * Assertion for CID.
+ */
+#define cp_dbg_cid(cid) \
+ dbg_assert_print( (cid) != 0, "Invalid cid - current value 0x%x", cid)
+
+/*! \def cp_dbg_classifier_version(classifier_version)
+ * Assertion for classifier version.
+ */
+#define cp_dbg_classifier_version(classifier_version) \
+ dbg_assert_print((classifier_version) == 0, "Invalid classifier_version field - current value 0x%x", classifier_version)
+
+/*! \def cp_dbg_exception_policy(exception_policy)
+ * Assertion for exception policy.
+ */
+#define cp_dbg_exception_policy(exception_policy) \
+ dbg_assert_print( ((exception_policy) == 0x00) || ((exception_policy) == 0x01), "Invalid exception_policy field - current value 0x%x", exception_policy)
+
+/*! \def cp_dbg_bidirectional_burst(burst)
+ * Assertion for bidirectional burst.
+ */
+#define cp_dbg_bidirectional_burst(burst) \
+ dbg_assert_print( ( (burst) == 0x00 ) || ( (burst) == 0x01) || ( (burst) == 0x02), "Invalid bidirectional_burst field - current value 0x%x", burst)
+
+/*! \def cp_dbg_cdesc_ipversion(ipversion)
+ * Assertion for CDESC.ipversion
+ */
+#define cp_dbg_cdesc_ipversion(ipversion) \
+ dbg_assert_print( ( (ipversion) == 0x00) || ((ipversion) == 0x01), "Invalid CDESC.ipversion field - current version 0x%x", ipversion)
+
+/*! \def cp_dbg_lid(lid)
+ * Assertion for lid. See table 5-134 for more details
+ */
+#define cp_dbg_lid(lid) \
+ dbg_assert_print( ( (lid) !=0x01) || ( (lid) != 0x02) || ( (lid) != 0x03), "Invalid lid - current value 0x%x", lid)
+
+/*! \def cp_dbg_llid(lid)
+ * Assertion for llid.
+ */
+#define cp_dbg_llid(lid) cp_dbg_lid(lid)
+
+/*! \def cp_dbg_conn_new_result(result)
+ * Assertion for connection new result.
+ */
+#define cp_dbg_conn_new_result(result) \
+ dbg_assert_print( ( (result) == CONN_SUCCESS) || ( (result) == CONN_FAILURE_CLASSIFIER_RESSOURCE_NOT_AVAILABLE) || ( (result) == CONN_FAILURE_CLASSIFIER_RULE_NOT_SUPPORTED) || ( (result) == CONN_FAILURE_MAXIMUM_CONNECTION_REACHED) || ( (result) == CONN_FAILURE_OTHER), "Invalid conn_new_result - current value 0x%x", result )
+
+/*! \def cp_dbg_reason_code
+ * Assertion for reason code.
+ */
+#define cp_dbg_reason_code(reason_code) \
+ dbg_assert_print( ( (reason_code) == NORMAL_RELEASE) || ( (reason_code) == VIOLATED_CSPEC), "Invalid reason_code - current value 0x%x", reason_code)
+
+/*! \def cp_dbg_conn_mod_result(conn_mod_result)
+ * Assertion for conn_mod_result.
+ */
+#define cp_dbg_conn_mod_result(conn_mod_result) \
+ dbg_assert_print( ( (conn_mod_result) == CONN_MOD_FAILED) || ( (conn_mod_result) == CONN_MOD_SUCCESS), "Invalid conn_mod_result - current value 0x%x", conn_mod_result)
+
+/*! \def cp_dbg_conn_info_req_type(reqType)
+ * Assertion for req type.
+ */
+#define cp_dbg_conn_info_req_type(reqType) \
+ dbg_assert_print( ( (reqType) == CONN_INFO_ALL_ACTIVE_CONNECTION) || ( (reqType) == CONN_INFO_SPECIFIC_CID) || (reqType == CONN_INFO_GLOBAL_LINK), "Invalid request_type - current value 0x%x", reqType)
+
+/*! \def cp_dbg_tei(tei)
+ * Assertion for TEI (Terminal Equipment Identifier).
+ */
+#define cp_dbg_tei(tei) \
+ dbg_assert_print( tei, "Invalid TEI - current value 0x%x", tei)
+
+/*! \def cp_dbg_cinfo(cinfo)
+ * Assertion for cinfo structure.
+ */
+#define cp_dbg_cinfo(cinfo)\
+ cp_dbg_cinfo_valid( (cinfo).valid); \
+ cp_dbg_mac_service_type( (cinfo).mac_service_type); \
+ cp_dbg_user_priority( (cinfo).user_priority); \
+ cp_dbg_ats( (cinfo).ats); \
+ cp_dbg_smoothing( (cinfo).smoothing)
+
+/*! \def cp_dbg_qmp(qmp)
+ * Assertion for qmp structure.
+ */
+#define cp_dbg_qmp(qmp) \
+ cp_dbg_qmp_forward_or_reverse( (qmp).forward_or_reverse);\
+ cp_dbg_exception_policy( (qmp).cm.exception_policy); \
+ cp_dbg_bidirectional_burst( (qmp).cm.bidirectional_burst ); \
+ cp_dbg_cdesc_ipversion( (qmp).cm.cdesc.ip_version)
+
+/*! \def cp_dbg_cspec(cspec)
+ * Assertion for cspec structure.
+ */
+#define cp_dbg_cspec(cspec) \
+ cp_dbg_cinfo( (cspec).cinfo_forward); \
+ cp_dbg_cinfo( (cspec).cinfo_reverse); \
+ cp_dbg_qmp( (cspec).qmp_forward); \
+ cp_dbg_qmp( (cspec).qmp_reverse);\
+ dbg_assert_print( (cspec).qmp_forward.forward_or_reverse == QMP_FORWARD, "Invalid QMP_forward.forward_or_reverse value - expected QMP_FORWARD and current value : %i", (cspec).qmp_forward.forward_or_reverse );\
+ dbg_assert_print( (cspec).qmp_reverse.forward_or_reverse == QMP_REVERSE, "Invalid QMP_reverse.forward_or_reverse value - expected QMP_REVERSE and current value : %i", (cspec).qmp_forward.forward_or_reverse )
+
+
+/*! \def cp_dbg_classifier_rule(classifier_rule)
+ * Assertion for classifier rule
+ */
+#define cp_dbg_classifier_rule(classifier_rule)\
+ cp_dbg_classifier_version( (classifier_rule).classifier_version)
+
+/*! \def cp_dbg_conn_info(conn_info)
+ * Assertion for conn_info structure
+ */
+#define cp_dbg_conn_info( conn_info ) \
+ cp_dbg_cid( (conn_info).cid); \
+ cp_dbg_tei( (conn_info).stei); \
+ cp_dbg_tei( (conn_info).dtei); \
+ cp_dbg_lid( (conn_info).lid_t); \
+ cp_dbg_lid( (conn_info).lid_f); \
+ cp_dbg_cspec( (conn_info).cspec)
+
+/*! \def cp_dbg_msg_cm_conn_new_req(msg_cm_conn_new_req)
+ * Assertion for CM_CONN_NEW.REQ message.
+ */
+#define cp_dbg_msg_cm_conn_new_req(msg_cm_conn_new_req) \
+ cp_dbg_cid( (msg_cm_conn_new_req).cid); \
+ cp_dbg_cspec( (msg_cm_conn_new_req).cspec); \
+ cp_dbg_classifier_rule( (msg_cm_conn_new_req).classifier_rule)
+
+/*! \def cp_dbg_msg_cm_conn_new_cnf(msg_cm_conn_new_cnf)
+ * Assertion for CM_CONN_NEW.CNF message.
+ */
+#define cp_dbg_msg_cm_conn_new_cnf(msg_cm_conn_new_cnf) \
+ cp_dbg_cid( (msg_cm_conn_new_cnf).cid); \
+ cp_dbg_llid( (msg_cm_conn_new_cnf).llid_r); \
+ cp_dbg_conn_new_result( (msg_cm_conn_new_cnf).result); \
+ cp_dbg_cspec( (msg_cm_conn_new_cnf).cspec_proposed)
+
+/*! \def cp_dbg_msg_cm_conn_rel_ind(msg_cm_conn_rel_ind)
+ * Assertion for CM_CONN_REL.IND message
+ */
+#define cp_dbg_msg_cm_conn_rel_ind(msg_cm_conn_rel_ind) \
+ cp_dbg_cid( (msg_cm_conn_rel_ind).cid); \
+ cp_dbg_reason_code( (msg_cm_conn_rel_ind).reason_code);\
+ cp_dbg_cspec( (msg_cm_conn_rel_ind).violated_cspec)
+
+/*! \def cp_dbg_msg_cm_conn_rel_rsp(msg_cm_conn_rel_rsp)
+ * Assertion for CM_CONN_REL.RSP message.
+ */
+#define cp_dbg_msg_cm_conn_rel_rsp(msg_cm_conn_rel_rsp) \
+ cp_dbg_cid( (msg_cm_conn_rel_rsp).cid)
+
+/*! \def cp_dbg_msg_cm_conn_mod_req(msg_cm_conn_mod_req)
+ * Assertion for CM_CONN_MOD.REQ message.
+ */
+#define cp_dbg_msg_cm_conn_mod_req(msg_cm_conn_mod_req) \
+ cp_dbg_cid( (msg_cm_conn_mod_req).cid); \
+ cp_dbg_cspec( (msg_cm_conn_mod_req).modified_cspec)
+
+/*! \def cp_dbg_msg_cm_conn_mod_cnf(msg_cm_conn_mod_cnf)
+ * Assertion for CM_CONN_MOD.CNF message.
+ */
+#define cp_dbg_msg_cm_conn_mod_cnf(msg_cm_conn_mod_cnf)\
+ cp_dbg_cid( (msg_cm_conn_mod_cnf).cid); \
+ cp_dbg_conn_mod_result( (msg_cm_conn_mod_cnf).result); \
+ cp_dbg_cspec( (msg_cm_conn_mod_cnf).proposed_cspec)
+
+/*! \def cp_dbg_msg_cm_conn_info_req(msg_cm_conn_info_req)
+ * Assertion for CM_CONN_INFO.REQ message.
+ */
+#define cp_dbg_msg_cm_conn_info_req(msg_cm_conn_info_req) \
+ cp_dbg_conn_info_req_type( (msg_cm_conn_info_req).reqType); \
+ cp_dbg_cid( (msg_cm_conn_info_req).cid); \
+ cp_dbg_llid( (msg_cm_conn_info_req).glid)
+
+// TODO make cm_conn_info.cnf
+//#define cp_dbg_msg_cm_conn_info_cnf(msg_cm_conn_info) cp_dbg_conn()
+
+#endif /*MSG_CM_CONN_DBG_H_*/
diff --git a/cesar/cp/msg/inc/msg_cm_convert.h b/cesar/cp/msg/inc/msg_cm_convert.h
new file mode 100644
index 0000000000..3d90fbb68d
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_cm_convert.h
@@ -0,0 +1,24 @@
+#ifndef MSG_CM_CONVERT_H_
+#define MSG_CM_CONVERT_H_
+
+#include "cp/msg/inc/msg_cm.h"
+#include "lib/bitstream.h"
+
+
+void
+msg_mme_header_convert(
+ u8 *buffer,
+ msg_mme_t *msg,
+ bitstream_type_t read,
+ bitstream_t ctx
+ );
+
+void
+msg_cm_unassociated_sta_ind_convert(
+ u8 *buffer,
+ msg_mme_t *msg,
+ bitstream_type_t read
+ );
+
+
+#endif /*MSG_CM_CONVERT_H_*/
diff --git a/cesar/cp/msg/inc/msg_const.h b/cesar/cp/msg/inc/msg_const.h
new file mode 100644
index 0000000000..c393d63df8
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_const.h
@@ -0,0 +1,325 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/inc/msg_const.h
+ * \brief constants of msg module
+ * \ingroup cp_msg
+ */
+#ifndef MSG_CONST_H_
+#define MSG_CONST_H_
+
+#include "mac/sar/inc/sar_mf.h"
+#include "cp/cp_types.h"
+#include "cp/secu/inc/secu_types.h"
+
+/*
+ * Homeplug AV constantes
+ */
+#define MSG_VLAN_TAG 0 // TBD
+#define MSG_VLAN_TAG_IEEE_802_1Q 0x8100 // 11.1.3
+#define MSG_MTYPE 0x88E1 // 11.1
+#define MSG_MTYPE_IEEE_ETHERTYPE MSG_MTYPE
+#define MSG_MME_HEADER_SIZE 19
+#define MSG_MM_VERSION 0x01 // 11.1.5
+
+/* physical min & max length of MME header (refer to Table 11-178 in HP_AV spec) */
+#define MME_HEADER_MINSIZE 19 // physical min length of MME message header (MME header having no "VLAN Tag" field)
+#define MME_HEADER_MAXSIZE 23 // physical max length of MME message header (MME header having a "VLAN Tag" field)
+
+/*
+ * other constants
+ */
+
+// MMTYPE base-values for DRV-MME messages
+#define DRV_STA_SET_MAC_ADDR 0xA000
+#define DRV_STA_SET_CCO_PREF 0xA004
+#define DRV_STA_SET_WAS_CCO 0xA008
+#define DRV_STA_SET_NPW 0xA00C
+#define DRV_STA_SET_DPW 0xA010
+#define DRV_STA_SET_SL 0xA014
+#define DRV_STA_SET_M_STA_HFID 0xA018
+#define DRV_STA_SET_U_STA_HFID 0xA01C
+#define DRV_STA_SET_AVLN_HFID 0xA020
+#define DRV_STA_SET_TONEMASK 0xA024
+#define DRV_STA_START 0xA028
+#define DRV_STA_STOP 0xA02C
+
+// MMTYPE sub-values for MMEs (REQ, CNF, IND or RSP)
+#define REQ 0x00
+#define CNF 0x01
+#define IND 0x02
+#define RSP 0x03
+
+/*
+ * mm type constants
+ * take care of the following :
+ * according to Intellon technical reference manual of Homeplug AV firmware p9,
+ * the two LSB value of messages should be :
+ * 0b00 for REQ
+ * 0b01 for CNF
+ * 0b10 for IND
+ * 0b11 for RSP
+ * this is very unclear in the Homeplug AV specification v1.0.10
+ */
+typedef enum mm_type_t
+{
+ CC_CCO_APPOINT_REQ = 0x0000,
+ CC_CCO_APPOINT_CNF = 0x0001,
+ CC_BACKUP_APPOINT_REQ = 0x0004,
+ CC_BACKUP_APPOINT_CNF = 0x0005,
+ CC_LINK_INFO_REQ = 0x0008,
+ CC_LINK_INFO_CNF = 0x0009,
+ CC_LINK_INFO_IND = 0x000A,
+ CC_LINK_INFO_RSP = 0x000B,
+ CC_HANDOVER_REQ = 0x000C,
+ CC_HANDOVER_CNF = 0x000D,
+ CC_HANDOVER_INFO_IND = 0x0012,
+ CC_HANDOVER_INFO_RSP = 0x0013,
+ CC_DISCOVER_LIST_REQ = 0x0014,
+ CC_DISCOVER_LIST_CNF = 0x0015,
+ CC_DISCOVER_LIST_IND = 0x0016,
+ CC_LINK_NEW_REQ = 0x0018,
+ CC_LINK_NEW_CNF = 0x0019,
+ CC_LINK_MOD_REQ = 0x001C,
+ CC_LINK_MOD_CNF = 0x001D,
+ CC_LINK_SQZ_REQ = 0x0020,
+ CC_LINK_SQZ_CNF = 0x0021,
+ CC_LINK_REL_REQ = 0x0024,
+ CC_LINK_REL_IND = 0x0025,
+ CC_DETECT_REPORT_REQ = 0x0028,
+ CC_DETECT_REPORT_CNF = 0x0029,
+ CC_WHO_RU_REQ = 0x002C,
+ CC_WHO_RU_CNF = 0x002D,
+ CC_ASSOC_REQ = 0x0030,
+ CC_ASSOC_CNF = 0x0031,
+ CC_LEAVE_REQ = 0x0034,
+ CC_LEAVE_CNF = 0x0035,
+ CC_LEAVE_IND = 0x0036,
+ CC_LEAVE_RSP = 0x0037,
+ CC_SET_TEI_MAP_REQ = 0x0038,
+ CC_SET_TEI_MAP_IND = 0x0039,
+ CC_RELAY_REQ = 0x003C,
+ CC_RELAY_IND = 0x003D,
+ CC_BEACON_RELIABILITY_REQ = 0x0040,
+ CC_BEACON_RELIABILITY_CNF = 0x0041,
+ CC_ALLOC_MOVE_REQ = 0x0044,
+ CC_ALLOC_MOVE_CNF = 0x0045,
+ CC_ACCESS_NEW_REQ = 0x0048,
+ CC_ACCESS_NEW_CNF = 0x0049,
+ CC_ACCESS_NEW_IND = 0x004A,
+ CC_ACCESS_NEW_RSP = 0x004B,
+ CC_ACCESS_REL_REQ = 0x004C,
+ CC_ACCESS_REL_CNF = 0x004D,
+ CC_ACCESS_REL_IND = 0x004E,
+ CC_ACCESS_REL_RSP = 0x004F,
+ CC_DCPPC_IND = 0x0052,
+ CC_DCPPC_RSP = 0x0053,
+ CC_HP1_DET_REQ = 0x0054,
+ CC_HP1_DET_CNF = 0x0055,
+ CC_BLE_UPDATE_IND = 0x005A,
+
+ CP_PROXY_APPOINT_REQ = 0x2000,
+ CP_PROXY_APPOINT_CNF = 0x2001,
+ PH_PROXY_APPOINT_IND = 0x2006,
+ CP_PROXY_WAKE_REQ = 0x2008,
+
+ NN_INL_REQ = 0x4000,
+ NN_INL_CNF = 0x4001,
+ NN_NEW_REQ = 0x4004,
+ NN_NEW_CNF = 0x4005,
+ NN_NEW_IND = 0x4006,
+ NN_ADD_ALLOC_REQ = 0x4008,
+ NN_ADD_ALLOC_CNF = 0x4009,
+ NN_ADD_ALLOC_IND = 0x400A,
+ NN_REL_ALLOC_REQ = 0x400C,
+ NN_REL_ALLOC_CNF = 0x400D,
+ NN_REL_NET_IND = 0x4012,
+
+ CM_UNASSOCIATED_STA_IND = 0x6002,
+ CM_ENCRYPTED_PAYLOAD_IND = 0x6006,
+ CM_ENCRYPTED_PAYLOAD_RSP = 0x6007,
+ CM_SET_KEY_REQ = 0x6008,
+ CM_SET_KEY_CNF = 0x6009,
+ CM_GET_KEY_REQ = 0x600C,
+ CM_GET_KEY_CNF = 0x600D,
+ CM_SC_JOIN_REQ = 0x6010,
+ CM_SC_JOIN_CNF = 0x6011,
+ CM_CHAN_EST_IND = 0x6016,
+ CM_TM_UPDATE_IND = 0x601A,
+ CM_AMP_MAP_REQ = 0x601C,
+ CM_AMP_MAP_CNF = 0x601D,
+ CM_BRG_INFO_REQ = 0x6020,
+ CM_BRG_INFO_CNF = 0x6021,
+ CM_CONN_NEW_REQ = 0x6024,
+ CM_CONN_NEW_CNF = 0x6025,
+ CM_CONN_REL_IND = 0x602A,
+ CM_CONN_REL_RSP = 0x602B,
+ CM_CONN_MOD_REQ = 0x602C,
+ CM_CONN_MOD_CNF = 0x602D,
+ CM_CONN_INFO_REQ = 0x6030,
+ CM_CONN_INFO_CNF = 0x6031,
+ CM_STA_CAP_REQ = 0x6034,
+ CM_STA_CAP_CNF = 0x6035,
+ CM_NW_INFO_REQ = 0x6038,
+ CM_NW_INFO_CNF = 0x6039,
+ CM_GET_BEACON_REQ = 0x603C,
+ CM_GET_BEACON_CNF = 0x603D,
+ CM_HFID_REQ = 0x6040,
+ CM_HFID_CNF = 0x6041,
+ CM_MME_ERROR_IND = 0x6046,
+ CM_NW_STATS_REQ = 0x6048,
+ CM_NW_STATS_CNF = 0x6049,
+ CM_LINK_STATS_REQ = 0x604C,
+ CM_LINK_STATS_CNF = 0x604D,
+
+ DRV_STA_SET_MAC_ADDR_REQ = DRV_STA_SET_MAC_ADDR + REQ,
+ DRV_STA_SET_MAC_ADDR_CNF = DRV_STA_SET_MAC_ADDR + CNF,
+ DRV_STA_SET_CCO_PREF_REQ = DRV_STA_SET_CCO_PREF + REQ,
+ DRV_STA_SET_CCO_PREF_CNF = DRV_STA_SET_CCO_PREF + CNF,
+ DRV_STA_SET_WAS_CCO_REQ = DRV_STA_SET_WAS_CCO + REQ,
+ DRV_STA_SET_WAS_CCO_CNF = DRV_STA_SET_WAS_CCO + CNF,
+ DRV_STA_SET_WAS_CCO_IND = DRV_STA_SET_WAS_CCO + IND,
+ DRV_STA_SET_WAS_CCO_RSP = DRV_STA_SET_WAS_CCO + RSP,
+ DRV_STA_SET_NPW_REQ = DRV_STA_SET_NPW + REQ,
+ DRV_STA_SET_NPW_CNF = DRV_STA_SET_NPW + CNF,
+ DRV_STA_SET_DPW_REQ = DRV_STA_SET_DPW + REQ,
+ DRV_STA_SET_DPW_CNF = DRV_STA_SET_DPW + CNF,
+ DRV_STA_SET_SL_REQ = DRV_STA_SET_SL + REQ,
+ DRV_STA_SET_SL_CNF = DRV_STA_SET_SL + CNF,
+ DRV_STA_SET_M_STA_HFID_REQ = DRV_STA_SET_M_STA_HFID + REQ,
+ DRV_STA_SET_M_STA_HFID_CNF = DRV_STA_SET_M_STA_HFID + CNF,
+ DRV_STA_SET_U_STA_HFID_REQ = DRV_STA_SET_U_STA_HFID + REQ,
+ DRV_STA_SET_U_STA_HFID_CNF = DRV_STA_SET_U_STA_HFID + CNF,
+ DRV_STA_SET_AVLN_HFID_REQ = DRV_STA_SET_AVLN_HFID + REQ,
+ DRV_STA_SET_AVLN_HFID_CNF = DRV_STA_SET_AVLN_HFID + CNF,
+ DRV_STA_SET_TONEMASK_REQ = DRV_STA_SET_TONEMASK + REQ,
+ DRV_STA_SET_TONEMASK_CNF = DRV_STA_SET_TONEMASK + CNF,
+ DRV_STA_START_REQ = DRV_STA_START + REQ,
+ DRV_STA_START_CNF = DRV_STA_START + CNF,
+ DRV_STA_STOP_REQ = DRV_STA_STOP + REQ,
+ DRV_STA_STOP_CNF = DRV_STA_STOP + CNF,
+
+ TEST_MSG_NUM,
+ MSG_UNKNOW = 0xFFFF
+} __attribute__ ((packed)) mm_type_t;
+
+/*
+ * types of messages
+ */
+typedef struct msg_fmi_t // Table 11-178
+{
+ u8 nf_mi :4; // Number of fragments for message
+ u8 fn_mi :4; // fragment number
+ u8 fmsn; // fragmentation message sequence number
+} msg_fmi_t;
+
+typedef struct msg_mme_t // Table 11-178
+{
+ mac_address_t oda; // original destination adress
+ mac_address_t osa; // original source adress
+ u16 m_type; // const = 0x88E1
+ u8 mmv; // management message version
+ mm_type_t mm_type; // management message type
+ msg_fmi_t fmi;
+ u8 mm_entry[ETH_PACKET_MAX_SIZE - MSG_MME_HEADER_SIZE];
+} __attribute__ ((packed)) msg_mme_t;
+
+// the same, with vlan tag
+typedef struct msg_mme_b_t // Table 11-178
+{
+ mac_address_t oda; // original destination adress
+ mac_address_t osa; // original source adress
+ u32 v_lan_tag; // ieee 802.1 tag (optional)
+ u16 m_type; // const = 0x88E1
+ u8 mmv; // management message version
+ mm_type_t mm_type; // management message type
+ msg_fmi_t fmi;
+ u8 mm_entry[ETH_PACKET_MAX_SIZE - MSG_MME_HEADER_SIZE - 4];
+} __attribute__ ((packed)) msg_mme_b_t;
+
+/*
+ * MME header
+ *
+ * here, it is not the MME header format on phy but internal software format
+ * avoiding memory-alignment questions, thus more easy & suitable
+ * to manage MME header info
+ */
+struct mme_header_type {
+ bool vlan_tag_flag;
+ union {
+ u8 b[8];
+ unsigned long long u64;
+ } un_osa;
+ union {
+ u8 b[8];
+ unsigned long long u64;
+ } un_oda;
+ union {
+ u8 b[4];
+ unsigned long u32;
+ } un_vlan_tag;
+ union {
+ u8 b[4];
+ unsigned long u32;
+ } un_mtype;
+ union {
+ u8 b[4];
+ unsigned long u32;
+ } un_mmv;
+ union {
+ u8 b[4];
+ unsigned long u32;
+ } un_mmtype;
+ union {
+ u8 b[4];
+ unsigned long u32;
+ } un_fmi;
+};
+typedef struct mme_header_type mme_header_type;
+
+typedef struct msg_list_mme_t
+{
+ mm_type_t mm_type; // HP_AV Message type identifier
+ //void (*msg_func) (const msg_mme_t *msg); // Function processing the message
+ int msg_num; // FSM transition identifier (see FSM data & constants generated by VisualState from FSM model designed with VisualState)
+} msg_list_mme_t;
+
+typedef enum encryption_type_t
+{
+ NOT_ENCRYPTED,
+ HARDWARE_ENCRYPTED,
+ SOFTWARE_ENCRYPTED
+} encryption_type_t;
+
+
+typedef struct msg_param_t
+{
+ bool mnbf; // multi-network broadcast flag
+ encryption_type_t encryption;
+ peks_t peks; // if the message is soft encrypted, set the peks
+} msg_param_t;
+
+/**
+ * \brief Get DRV-MME .REQ message name
+ *
+ * \param cnf the REQ message type identifier
+ * \return the .REQ message name string constant
+ */
+char *
+get_str_drv_mme_req(int req);
+
+/**
+ * \brief Get DRV-MME .CNF message name
+ *
+ * \param cnf the CNF message type identifier
+ * \return the .CNF message name string constant
+ */
+char *
+get_str_drv_mme_cnf(int cnf);
+
+#endif /*MSG_CONST_H_*/
diff --git a/cesar/cp/msg/inc/msg_drv.h b/cesar/cp/msg/inc/msg_drv.h
new file mode 100644
index 0000000000..ae11683c00
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_drv.h
@@ -0,0 +1,276 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/inc/msg_drv.h
+ * \brief DRV-MME messages
+ * \ingroup cp_msg
+ */
+
+#ifndef msg_drv__h__
+#define msg_drv__h__
+
+/* MME message context */
+typedef struct {
+ void *user; // user context
+ mfs_rx_t *mfs; // the mfs from the one the MF comes if it comes from the PWL.
+ u8 *buffer; // buffer containing the MME message
+ uint length; // length of MME message
+ //cl_mme_recv_t *mme_recv; //
+ void *cl_mme_data; // data use by the CL
+} msg_ctx_t;
+
+/* enum constants for MME DRV ".CNF" message payload fields */
+typedef enum {
+ E_DRVMME_RESULT_FAILURE = 0,
+ E_DRVMME_RESULT_SUCCESS = 1
+} e_drv_mme_cnf_result;
+
+typedef enum {
+ E_DRVMME_ERRCODE_BAD_PARAMETER = 0,
+ E_DRVMME_ERRCODE_UNKNOWN_ID = 1,
+ E_DRVMME_ERRCODE_INVALID_VALUE = 2
+} e_drv_mme_cnf_errcode;
+
+/* constants for DRV-MME fields (DRV_STA_SET_TONEMASK.REQ) */
+#define TONEMASK_MAXCOUNT 1536
+#define TONEMASK_MAXSIZE (TONEMASK_MAXCOUNT / 8)
+
+/* MME DRV ".REQ" payloads */
+struct mme_drv_sta_set_mac_addr_payload_type {
+ u8 mac_addr[MAC_ADDR_SIZE];
+};
+typedef struct mme_drv_sta_set_mac_addr_payload_type mme_drv_sta_set_mac_addr_payload_type;
+
+struct mme_drv_sta_set_cco_pref_payload_type {
+ u8 cco_pref;
+};
+typedef struct mme_drv_sta_set_cco_pref_payload_type mme_drv_sta_set_cco_pref_payload_type;
+
+struct mme_drv_sta_set_was_cco_payload_type {
+ u8 was_cco;
+};
+typedef struct mme_drv_sta_set_was_cco_payload_type mme_drv_sta_set_was_cco_payload_type;
+
+struct mme_drv_sta_set_npw_payload_type {
+ char npw[MAX_PWD_SIZE];
+};
+typedef struct mme_drv_sta_set_npw_payload_type mme_drv_sta_set_npw_payload_type;
+
+struct mme_drv_sta_set_dpw_payload_type {
+ char dpw[MAX_PWD_SIZE];
+};
+typedef struct mme_drv_sta_set_dpw_payload_type mme_drv_sta_set_dpw_payload_type;
+
+struct mme_drv_sta_set_sl_payload_type {
+ u8 sl;
+};
+typedef struct mme_drv_sta_set_sl_payload_type mme_drv_sta_set_sl_payload_type;
+
+struct mme_drv_sta_set_m_sta_hfid_payload_type {
+ char m_sta_hfid[MAX_HFID_SIZE];
+};
+typedef struct mme_drv_sta_set_m_sta_hfid_payload_type mme_drv_sta_set_m_sta_hfid_payload_type;
+
+struct mme_drv_sta_set_u_sta_hfid_payload_type {
+ char u_sta_hfid[MAX_HFID_SIZE];
+};
+typedef struct mme_drv_sta_set_u_sta_hfid_payload_type mme_drv_sta_set_u_sta_hfid_payload_type;
+
+struct mme_drv_sta_set_avln_hfid_payload_type {
+ char u_sta_hfid[MAX_HFID_SIZE];
+};
+typedef struct mme_drv_sta_set_avln_hfid_payload_type mme_drv_sta_set_avln_hfid_payload_type;
+
+struct mme_drv_sta_set_tonemask_payload_type {
+ u8 sta_tonemask[TONEMASK_MAXSIZE];
+};
+typedef struct mme_drv_sta_set_tonemask_payload_type mme_drv_sta_set_tonemask_payload_type;
+
+
+/* MME DRV ".REQ" messages */
+struct mme_drv_sta_set_mac_addr_req_type {
+ mme_header_type header;
+ u8 mac_addr[MAC_ADDR_SIZE];
+};
+typedef struct mme_drv_sta_set_mac_addr_req_type mme_drv_sta_set_mac_addr_req_type;
+
+struct mme_drv_sta_set_cco_pref_req_type {
+ mme_header_type header;
+ u8 cco_pref;
+};
+typedef struct mme_drv_sta_set_cco_pref_req_type mme_drv_sta_set_cco_pref_req_type;
+
+struct mme_drv_sta_set_was_cco_req_type {
+ mme_header_type header;
+ u8 was_cco;
+};
+typedef struct mme_drv_sta_set_was_cco_req_type mme_drv_sta_set_was_cco_req_type;
+
+struct mme_drv_sta_set_npw_req_type {
+ mme_header_type header;
+ char npw[MAX_PWD_SIZE];
+};
+typedef struct mme_drv_sta_set_npw_req_type mme_drv_sta_set_npw_req_type;
+
+struct mme_drv_sta_set_dpw_req_type {
+ mme_header_type header;
+ char dpw[MAX_PWD_SIZE];
+};
+typedef struct mme_drv_sta_set_dpw_req_type mme_drv_sta_set_dpw_req_type;
+
+struct mme_drv_sta_set_sl_req_type {
+ mme_header_type header;
+ u8 sl;
+};
+typedef struct mme_drv_sta_set_sl_req_type mme_drv_sta_set_sl_req_type;
+
+struct mme_drv_sta_set_m_sta_hfid_req_type {
+ mme_header_type header;
+ char m_sta_hfid[MAX_HFID_SIZE];
+};
+typedef struct mme_drv_sta_set_m_sta_hfid_req_type mme_drv_sta_set_m_sta_hfid_req_type;
+
+struct mme_drv_sta_set_u_sta_hfid_req_type {
+ mme_header_type header;
+ char u_sta_hfid[MAX_HFID_SIZE];
+};
+typedef struct mme_drv_sta_set_u_sta_hfid_req_type mme_drv_sta_set_u_sta_hfid_req_type;
+
+struct mme_drv_sta_set_avln_hfid_req_type {
+ mme_header_type header;
+ char u_sta_hfid[MAX_HFID_SIZE];
+};
+typedef struct mme_drv_sta_set_avln_hfid_req_type mme_drv_sta_set_avln_hfid_req_type;
+
+struct mme_drv_sta_set_tonemask_req_type {
+ mme_header_type header;
+ u8 sta_tonemask[TONEMASK_MAXSIZE];
+};
+typedef struct mme_drv_sta_set_tonemask_req_type mme_drv_sta_set_tonemask_req_type;
+
+struct mme_drv_sta_start_mac_req_type {
+ mme_header_type header;
+ /* (no specific payload data) */
+};
+typedef struct mme_drv_sta_start_mac_req_type mme_drv_sta_start_mac_req_type;
+
+struct mme_drv_sta_stop_mac_req_type {
+ mme_header_type header;
+ /* (no specific payload data) */
+};
+typedef struct mme_drv_sta_stop_mac_req_type mme_drv_sta_stop_mac_req_type;
+
+
+/* MME DRV ".CNF" message */
+struct mme_drv_cnf_type {
+ mme_header_type header;
+ u8 result;
+ u8 errcode;
+};
+typedef struct mme_drv_cnf_type mme_drv_cnf_type;
+
+
+/**
+ * \brief Get DRV-MME .CNF message result string
+ *
+ * \param cnf_result the result code
+ * \return the result code string constant
+ */
+char *
+get_str_drv_mme_cnf_result(int cnf_result);
+
+/**
+ * \brief Get DRV-MME .CNF message error code string
+ *
+ * \param cnf_errcode the error code
+ * \return the error code string constant
+ */
+char *
+get_str_drv_mme_cnf_errcode(int cnf_errcode);
+
+/**
+ * \brief Get yes/no string.
+ *
+ * \param no_yes the index of yes/no string array
+ * \return the yes or no string constant
+ */
+char *
+get_str_yes_no(int no_yes);
+
+/**
+ * \brief Verify a password or HFID string validity.
+ *
+ * \param str the HFID string to be verified
+ * \param minlen the minimal length
+ * \param maxlen the maximal length
+ * \return true or false depending on validity ok or not
+ */
+bool
+check_password_or_hfid_is_valid(char *str, int minlen,int maxlen);
+
+/**
+ * \brief little endian to CPU host endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from little endian to CPU host endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+little_to_cpuhost_endian(u8 *addrval, int bytesizeval);
+
+/**
+ * \brief big endian to CPU host endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from big endian to CPU host endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+big_to_cpuhost_endian(u8 *addrval, int bytesizeval);
+
+/**
+ * \brief CPU host endian to little endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from CPU host endian to little endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+cpuhost_to_little_endian(u8 *addrval, int bytesizeval);
+
+/**
+ * \brief CPU host endian to big endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from CPU host endian to big endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+cpuhost_to_big_endian(u8 *addrval, int bytesizeval);
+
+u16
+big_to_cpuhost_endian_u16(u16 val);
+u32
+big_to_cpuhost_endian_u32(u32 val);
+u16
+cpuhost_to_big_endian_u16(u16 val);
+u32
+cpuhost_to_big_endian_u32(u32 val);
+
+void display_mme_header(mme_header_type *mme_header);
+
+/**
+ * \brief Build a "MME.CNF" confirmation message.
+ *
+ * \param recv_mme_header the buffer to contain the MME.CNF message being built
+ * \param send_mme the buffer containing the MME initially received for which we're building a CNF
+ * \param cnf_result the result code of the MME.CNF message to be built
+ * \param cnf_errcode the error code of the MME.CNF message to be built
+ * \param cnf_len the returned length of the MME.CNF message being built
+ *
+ */
+void
+cp_mme_build_cnf (mme_header_type *recv_mme_header, mme_drv_cnf_type *send_mme, e_drv_mme_cnf_result cnf_result, e_drv_mme_cnf_errcode cnf_errcode, uint *cnf_len, u8 *mme_tx_buffer, int *mme_buffer_first);
+
+#endif
diff --git a/cesar/cp/msg/inc/msg_field.h b/cesar/cp/msg/inc/msg_field.h
new file mode 100644
index 0000000000..d970de1b3c
--- /dev/null
+++ b/cesar/cp/msg/inc/msg_field.h
@@ -0,0 +1,410 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_field.h
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+
+#ifndef MSG_CM_CONN_FIELD_H_
+#define MSG_CM_CONN_FIELD_H_
+
+#include "cp/msg/inc/msg_const.h"
+
+/////////////////// ENUM ///////////////////////////
+
+// QMP Forward/Reverse definition (section 7.8.1 table 7-146)
+typedef enum
+{
+ QMP_FORWARD = 0x00, // forward (from source to receiver)
+ QMP_REVERSE = 0X01 // reverse (from receiver to source)
+} qmp_forward_or_reverse_t;
+
+// VALID CINFO definition (section 7.8.1 table 7-145)
+typedef enum
+{
+ CINFO_NOT_VALID = 0x00,
+ CINFO_VALID = 0x01
+} cinfo_valid_t;
+
+// MAC Service Type definition (section 7.8.1 table 7-145)
+typedef enum
+{
+ MAC_CONTENTION_FREE = 0x00, // Contention-free service
+ MAC_CONTENTION = 0x01, // Contention-based service
+ MAC_CONTENTION_FREE_PREFERRED = 0x02 // Contention-free service preferred
+} mac_service_type_t;
+
+// User Priority definition (section 7.8.1 table 7-145)
+typedef enum
+{
+ USER_PRIORITY_CAP0 = 0x00,
+ USER_PRIORITY_CAP1 = 0x01,
+ USER_PRIORITY_CAP2 = 0x02,
+ USER_PRIORITY_CAP3 = 0x03
+} user_priority_t;
+
+// Arrival Time Stamp definition (section 7.8.1 table 7-145)
+typedef enum
+{
+ ATS_NOT_FOR_HLE = 0x00,
+ ATS_FOR_HLE = 0x01
+} ats_t;
+
+/////////////////// DEFINTION ///////////////////////////
+
+typedef u32 len_t;
+
+// QMP Length definition (section 7.8.1 table 7-146)
+typedef u8 qmp_len_t;
+
+// CSPEC_LEN definition (section 7.8.1 table 7-144)
+typedef u16 cspec_len_t; // Length of CSPEC, including the 2 octets CSPEC_LEN field
+
+// CID definition (section 5.2.1.4.2)
+typedef u16 cid_t;
+
+// LID definition (section 5.2.1.4.2)
+typedef u8 lid_t;
+
+// LLID definition (section 5.2.1.4.2)
+typedef u8 llid_t;
+
+// LLID_F definition (section 5.2.1.4.2)
+typedef u8 llid_f_t;
+
+// LLID_R definition (section 5.2.1.4.2)
+typedef u8 llid_r_t;
+
+// TEI (Terminal Equipment Identifier) definition (section 7.3.2.1)
+//typedef u8 tei_t;
+
+// QMP Body
+#define MAX_SIZE_QMP_BODY 37
+typedef u8 qmp_body_t[MAX_SIZE_QMP_BODY];
+
+
+typedef struct
+{
+ bool available;
+ u32 value;
+}qmp_delay_bound_t;
+
+typedef struct
+{
+ bool delay_bound_available :1;
+ bool jitter_bound_available:1;
+ bool average_msdu_size_available:1;
+ bool maximum_msdu_size_available:1;
+ bool average_data_rate_available:1;
+ bool minimum_data_rate_available:1;
+ bool maximum_data_rate_available:1;
+ bool maximum_inter_txop_time_available:1;
+ bool minimum_inter_txop_time_available:1;
+ bool maximum_burst_size_available:1;
+ bool exception_policy_available:1;
+ bool inactivity_interval_available:1;
+ bool msdu_error_rate_available:1;
+ bool clst_available:1;
+ bool cdesc_available:1;
+ bool vendor_specific_available:1;
+ bool ats_tolerance_available:1;
+ bool smallest_tolerable_data_rate_available:1;
+ bool original_average_data_rate_available:1;
+ bool rx_window_size_available:1;
+ bool smoothing_buffer_size_available:1;
+ bool bidirectional_burst_available:1;
+ bool txops_per_beacon_period_available:1;
+ bool average_number_of_pbs_per_txop_available:1;
+ bool minimum_number_of_pbs_per_txop_available:1;
+ bool maximum_number_of_pbs_per_txop_available:1;
+ bool ppb_threshold_available:1;
+ bool surplus_bandwith_available:1;
+ bool cco_vendor_specific_available:1;
+ bool smallest_tolerable_average_number_of_pbs_per_txop_available:1;
+ bool original_average_number_of_pbs_per_txop_available:1;
+ bool cco_bidirectional_burst_available:1;
+}qmp_valid_field_t;
+
+
+typedef enum
+{
+ EXCEPTION_TERMINATE_CONNEXION = 0x00,
+ EXCEPTION_RECONFIGURE_CONNEXION = 0x01
+}qmp_exception_policy_t;
+
+typedef enum
+{
+ IP_VERSION_4 = 0x00,
+ IP_VERSION_6 = 0x01
+}ip_version_t;
+
+typedef struct
+{
+ ip_version_t ip_version:8;
+ union
+ {
+ u8 ipv4_source_address[4];
+ u8 ipv6_source_address[16];
+ };
+ u16 source_port;
+ union
+ {
+ u8 ipv4_destination_address[4];
+ u8 ipv6_destination_address[16];
+ };
+ u16 destination_port;
+ u8 protocol_type;
+}cdesc_t;
+/*
+// QMP (QoS and MAC Parameter) definition (section 7.8.1 table 7-146)
+typedef struct
+{
+ qmp_forward_or_reverse_t forward_or_reverse:8;
+ union
+ {
+ qmp_valid_field_t valid;
+ u32 valid_in_block;
+ };
+ struct
+ {
+ u32 delay_bound;
+ u32 jitter_bound;
+ u16 average_msdu_size;
+ u16 maximum_msdu_size;
+ u16 average_data_rate;
+ u16 minimum_data_rate;
+ u16 maximum_data_rate;
+ u16 maximum_inter_txop_time;
+ u16 minimum_inter_txop_time;
+ u16 maximum_burst_size;
+ qmp_exception_policy_t exception_policy;
+ u32 inactivity_interval;
+ u16 msdu_error_rate;
+ u8 clst;
+ cdesc_t cdesc;
+ u16 ats_tolerance;
+ u16 smallest_tolerable_data_rate;
+ u16 original_average_data_rate;
+ u16 rx_window_size;
+ u32 smoothing_buffer_size; //warning on 24 bits
+ u8 bidirectional_burst;
+ }cm;
+
+ struct
+ {
+ u8 txops_per_beacon_period;
+ u16 average_number_of_pbs_per_txop;
+ u16 minimum_number_of_pbs_per_txop;
+ u16 maximum_number_of_pbs_per_txop;
+ u16 ppb_threshold;
+ u16 surplus_bandwith;
+ u16 smallest_tolerable_average_number_of_pbs_per_txop;
+ u16 original_average_number_of_pbs_per_txop;
+ u8 cco_bidirectional_burst;
+ }cco;
+
+} qmp_t;
+
+
+
+
+// Smoothing definition (section 7.8.1 table 7-145)
+typedef enum
+{
+ SMOOTHING_NOT_REQUESTED = 0x00,
+ SMOOTHING_REQUESTED = 0x01
+}smoothing_t;
+
+
+// CINFO definition (section 7.8.1 table 7-145)
+typedef struct
+{
+ cinfo_valid_t valid:8;
+ mac_service_type_t mac_service_type:8;
+ user_priority_t user_priority:8; // Channel access priority of the Connection
+ ats_t ats:8;
+ smoothing_t smoothing:8;
+} cinfo_t;
+
+// CSPEC definition (section 7.8.1 table 7-144)
+typedef struct
+{
+ cspec_len_t len; // Length of CSPEC, including the 2 octets CSPEC_LEN field
+ cinfo_t cinfo_forward; // Forward Connection Information
+ cinfo_t cinfo_reverse; // Reverse Connection Information
+ qmp_t qmp_forward; // Forward QoS and MAC Parameters
+ qmp_t qmp_reverse; // Reverse QoS and MAC Parameters
+} cspec_t;
+
+// Conn Info definition (section 11.5.23 table 11-117)
+typedef struct
+{
+ cid_t cid; // Connection identifier of the Link
+ tei_t dtei; // TEI of the destination STA
+ tei_t stei; // TEI of the source STA
+ lid_t lid_f; // Link ID of the Forward Link
+ lid_t lid_r; // Link ID of the Reverse Link
+ cspec_t cspec; // Connection cspec
+} conn_info_t;
+
+*/
+///////////////////////////////////////////////////
+///////////// CLASSIFIER_RULE //////////////////
+///////////////////////////////////////////////////
+
+
+typedef u8 ethernet_destination_address_t[6];
+typedef u8 ethernet_source_address_t[6];
+typedef u8 vlan_user_priority_t;
+typedef u16 vlan_id_t;
+typedef u8 ipv4_type_of_service_t;
+typedef u8 ipv4_protocol_t;
+typedef u8 ipv4_source_address_t[4];
+typedef u8 ipv4_destination_address_t[4];
+typedef u8 ipv6_traffic_class_t;
+typedef u8 ipv6_flow_label_t[3];
+typedef u8 ipv6_source_address_t[16];
+typedef u8 ipv6_destination_address_t[16];
+typedef u16 tcp_source_port_t;
+typedef u16 tcp_destination_port_t;
+typedef u16 udp_source_port_t;
+typedef u16 udp_destination_port_t;
+
+typedef struct
+{
+ bool ethernet_destination_address_field_available :1;
+ bool ethernet_source_address_field_available : 1;
+ bool vlan_user_priority_field_available : 1;
+ bool vlan_id_field_available : 1;
+ bool ipv4_type_of_protocol_field_available :1;
+ bool ipv4_protocol_field_available : 1;
+ bool ipv4_source_address_field_available : 1;
+ bool ipv4_destination_address_field_available : 1;
+ bool ipv6_traffic_class_field_available : 1;
+ bool ipv6_flow_label_field_available : 1;
+ bool ipv6_source_address_field_available : 1;
+ bool ipv6_destination_address_field_available : 1;
+ bool tcp_source_port_field_available : 1;
+ bool tcp_destination_port_field_available : 1;
+ bool udp_source_port_field_available : 1;
+ bool udp_destination_port_field_available : 1;
+} classifier_rules_available_t;
+
+typedef struct
+{
+ union
+ {
+ classifier_rules_available_t classifier_rules_available;
+ u32 classifier_rules_available_block;
+ };
+ ethernet_destination_address_t ethernet_destination_address;
+ ethernet_source_address_t ethernet_source_address;
+ vlan_user_priority_t vlan_user_priority;
+ vlan_id_t vlan_id;
+ ipv4_type_of_service_t ipv4_type_of_service;
+ ipv4_protocol_t ipv4_protocol;
+ ipv4_source_address_t ipv4_source_address;
+ ipv4_destination_address_t ipv4_destination_address;
+ ipv6_traffic_class_t ipv6_traffic_class;
+ ipv6_flow_label_t ipv6_flow_label;
+ ipv6_source_address_t ipv6_source_address;
+ ipv6_destination_address_t ipv6_destination_address;
+ tcp_source_port_t tcp_source_port;
+ tcp_destination_port_t tcp_destination_port;
+ udp_source_port_t udp_source_port;
+ udp_destination_port_t udp_destination_port;
+} classifier_rules_data_t;
+
+// Classifier Rule Set Version definition (section 6.3 table 6-138)
+typedef enum
+{
+ CLASSIFIER_CURRENT_VERSION = 0x00 // Current Version
+ // 0X01 to 0x0FF reserved for future use
+} classifier_version_t;
+
+// Classifier Rule definition (section 6.3 table 6-138)
+typedef struct
+{
+ classifier_version_t classifier_version:8;
+ u8 nbr_rules;
+ classifier_rules_data_t data;
+} classifier_rules_t;
+
+typedef u8 id_t;
+
+// Reason Code definition (section 11.5.18) needed by cm_conn_rel_ind
+typedef enum
+{
+ NORMAL_RELEASE = 0x00,
+ VIOLATED_CSPEC = 0x01
+} reason_code_t;
+
+// New Connection Result definition (section 11.5.17 table 11-280)
+typedef enum
+{
+ CONN_SUCCESS = 0x00,
+ CONN_FAILURE_CLASSIFIER_RULE_NOT_SUPPORTED = 0x01,
+ CONN_FAILURE_CLASSIFIER_RESSOURCE_NOT_AVAILABLE = 0x02,
+ CONN_FAILURE_MAXIMUM_CONNECTION_REACHED = 0x03,
+ CONN_FAILURE_OTHER = 0X04
+} conn_new_result_t;
+
+// Mod Connection Result definition (section 11.5.21 table 11-284)
+typedef enum
+{
+ CONN_MOD_SUCCESS = 0x00,
+ CONN_MOD_FAILED = 0X01
+} conn_mod_result_t;
+
+// Add Connection Result definition (section 12.2.2.2)
+typedef enum
+{
+ CONN_ADD_SUCCESS = 0x00,
+ CONN_ADD_FAILED = 0x01
+} conn_add_result_t;
+
+// Info Connection - Request Type (section 11.5.22 table 11-285)
+typedef enum
+{
+ CONN_INFO_ALL_ACTIVE_CONNECTIONS = 0x00,
+ CONN_INFO_SPECIFIC_CID = 0x01,
+ CONN_INFO_GLOBAL_LINK = 0x02
+} conn_info_req_type_t;
+
+
+
+
+///////////////////////////////////////////////////////////////////////////
+//////////////////// FUNCTION DECLARATION /////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+/*
+void msg_field_cinfo_init (cinfo_t*);
+void msg_field_qmp_init (qmp_t*);
+void msg_field_cid_init (cid_t*);
+void msg_field_classifier_init(classifier_rules_t*);
+void msg_field_cspec_init (cspec_t*);
+
+
+len_t msg_field_cid_get_from_stream (u8* stream, cid_t* cid);
+len_t msg_field_cinfo_get_from_stream (u8* stream, cinfo_t* cinfo);
+len_t msg_field_qmp_get_from_stream (u8* stream,u8* stream_end, qmp_t* qmp, qmp_forward_or_reverse_t qmp_type);
+len_t msg_field_classifier_get_from_stream (u8* stream, classifier_rules_t* claissifier_rules);
+len_t msg_field_cspec_get_from_stream (u8* stream, cspec_t* cspec);
+
+len_t msg_field_cid_set_on_stream (u8* stream, cid_t* cid);
+len_t msg_field_classifier_set_on_stream (u8* stream, classifier_rules_t* classifier_rules);
+len_t msg_field_qmp_set_on_stream (u8* stream, qmp_t* qmp);
+len_t msg_field_cinfo_set_on_stream (u8* stream, cinfo_t* cinfo);
+len_t msg_field_cspec_set_on_stream (u8* stream, cspec_t* cspec);
+
+*/
+
+#endif /*MSG_CM_CONN_FIELD_H_*/
diff --git a/cesar/cp/msg/msg.h b/cesar/cp/msg/msg.h
new file mode 100644
index 0000000000..448ab2f92e
--- /dev/null
+++ b/cesar/cp/msg/msg.h
@@ -0,0 +1,105 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/msg.h
+ * \brief MME message processing
+ * \ingroup cp_msg
+ */
+
+#ifndef msg__h__
+#define msg__h__
+
+#include "cp/interf/inc/interf_types.h"
+#include "cp/msg/inc/msg_const.h"
+#include "cp/msg/inc/msg_cc.h"
+#include "cp/msg/inc/msg_cm.h"
+#include "cp/msg/inc/msg_drv.h"
+#include "cp/cp_types.h"
+#include "cp/interf/interf.h"
+
+/*
+ * Global variables
+ */
+extern const msg_list_mme_t msg_list[];
+
+
+void
+msg_test_rcv(const msg_mme_t *msg);
+
+/**
+ * \brief init the msg module
+ */
+void msg_init(void);
+
+/**
+ * \brief return the fmsn (Fragmentation Message Sequence Number) to be used
+ * \param new : set to true if this is a new sequence
+ * \return the fmsn
+ */
+u8
+msg_get_fmsn(const bool new);
+
+
+/**
+ * \brief Give the message number in our local reference.
+ * \param Msg : pointer to the message
+ * \return the message number or UNKNOW_MSG
+ */
+u16
+msg_get_number (msg_mme_t *msg);
+
+/**
+ * \brief this function is called in STA or CCO thread when a message is
+ * present in the corresponding fifo.
+// * \param msg : pointer to the message
+ * \param msg_ctx : pointer to the message context
+ * \return
+ */
+//void
+//msg_dispatch (msg_mme_t *msg);
+void
+msg_dispatch (msg_ctx_t *msg_ctx);
+
+/**
+ * \brief set the const values of mme (ie mtype)
+ * \param Msg : pointer to the message
+ * \return
+ */
+void
+msg_set_mme_const_values (msg_mme_t *msg);
+
+/**
+ * \brief check the const values of mme (ie mtype)
+ * \param Msg : pointer to the message
+ * \return true if ok
+ */
+bool
+msg_check_wrong_mme_const_values (const msg_mme_t *msg);
+
+
+/**
+ * \brief common process to all message when sending a message
+ * \param oda : destination mac address
+ * \param msg_param : the message parameters (will be set to default values)
+ * \return pointer to the message
+ */
+msg_mme_t *
+msg_sending_common_part(msg_mme_t *msg, const mac_address_t oda, msg_param_t *msg_param);
+
+/**
+ * \brief add field common to all mme messages (OSA)
+ * and send it through the interface
+ * \param msg : pointer to the message
+ * \param msg_size : size of the message (including header)
+ * \return
+ */
+void
+msg_send(msg_mme_t *msg, u16 msg_size, msg_param_t msg_param);
+
+#endif
+
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_info_cnf.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_info_cnf.c
new file mode 100644
index 0000000000..1ccb86bc67
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_info_cnf.c
@@ -0,0 +1,17 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_rel_ind.c
+ * \brief This file provides management functions for message CM_CONN_INFO.CNF.
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_info_req.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_info_req.c
new file mode 100644
index 0000000000..be01371940
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_info_req.c
@@ -0,0 +1,17 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_rel_ind.c
+ * \brief This file provides management functions for message CM_CONN_INFO.REQ.
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_cnf.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_cnf.c
new file mode 100644
index 0000000000..267006eb47
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_cnf.c
@@ -0,0 +1,95 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_mod_cnf.c
+ * \brief This file provides management functions for message CM_CONN_MOD.CNF.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+#include "cp/msg/inc/msg_field.h"
+
+
+
+/**
+ * Initialize the message CM_CONN_MOD_CNF
+ * \param msg Message to be initialized.
+ *
+ */
+void
+msg_cm_conn_mod_cnf_init(msg_cm_conn_mod_cnf_t* data)
+{
+ dbg_assert_ptr(data);
+
+ msg_field_cid_init(&(data->cid));
+ data->result = 0;
+ msg_field_cspec_init(&(data->proposed_cspec));
+
+ cp_dbg_msg_cm_conn_mod_cnf(*data);
+
+}
+
+
+
+/**
+ * Decode a CM_CONN_MOD_CNF message from a MME message.
+ * \param msg MME Message.
+ * \param data Structure where the data is saved.
+ *
+ */
+void
+msg_cm_conn_mod_cnf_set_on_mme_msg(msg_mme_t* msg, msg_cm_conn_mod_cnf_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ cp_dbg_msg_cm_conn_mod_cnf(*data);
+ dbg_assert_ptr(msg);
+
+ len = msg_field_cid_set_on_stream( local_stream, &(data->cid));
+ local_stream += len;
+
+ *local_stream = data->result;
+ local_stream++;
+
+ if(data->result == CONN_MOD_FAILED)
+ msg_field_cspec_set_on_stream( local_stream, &(data->proposed_cspec));
+
+}
+
+
+/**
+ * Encode a CM_CONN_MOD_CNF message on a MME msg.
+ * \param msg MME message where the data is saved.
+ * \param data Data source.
+ *
+ */
+void
+msg_cm_conn_mod_cnf_get_from_mme_msg(msg_mme_t* msg, msg_cm_conn_mod_cnf_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+
+ dbg_assert_ptr(msg);
+ dbg_assert_ptr(data);
+
+ len = msg_field_cid_get_from_stream( local_stream, &(data->cid));
+ local_stream += len;
+
+ data->result = *local_stream;
+ local_stream ++;
+
+ if(data->result == CONN_MOD_FAILED)
+ msg_field_cspec_get_from_stream( local_stream, &(data->proposed_cspec));
+
+ cp_dbg_msg_cm_conn_mod_cnf(*data);
+}
+
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_req.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_req.c
new file mode 100644
index 0000000000..b422464692
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_mod_req.c
@@ -0,0 +1,85 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_mod_req.c
+ * \brief This file provides management functions for message CM_CONN_MOD.REQ.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+#include "cp/msg/inc/msg_field.h"
+
+
+
+/**
+ * Initialize the message CM_CONN_MOD_REQ
+ * \param msg Message to be initialized.
+ *
+ */
+void
+msg_cm_conn_mod_req_init(msg_cm_conn_mod_req_t* data)
+{
+ dbg_assert_ptr(data);
+
+ msg_field_cid_init(&(data->cid));
+ msg_field_cspec_init(&(data->modified_cspec));
+
+ cp_dbg_msg_cm_conn_mod_req(*data);
+
+}
+
+
+
+/**
+ * Decode a CM_CONN_MOD_REQ message from a MME message.
+ * \param msg MME Message.
+ * \param data Structure where the data is saved.
+ *
+ */
+void
+msg_cm_conn_mod_req_set_on_mme_msg(msg_mme_t* msg, msg_cm_conn_mod_req_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ cp_dbg_msg_cm_conn_mod_req(*data);
+ dbg_assert_ptr(msg);
+
+ len = msg_field_cid_set_on_stream( local_stream, &(data->cid));
+ local_stream += len;
+
+ msg_field_cspec_set_on_stream( local_stream, &(data->modified_cspec));
+
+}
+
+
+/**
+ * Encode a CM_CONN_MOD_REQ message on a MME msg.
+ * \param msg MME message where the data is saved.
+ * \param data Data source.
+ *
+ */
+void
+msg_cm_conn_mod_req_get_from_mme_msg(msg_mme_t* msg, msg_cm_conn_mod_req_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(msg);
+ dbg_assert_ptr(data);
+
+ len = msg_field_cid_get_from_stream( local_stream, &(data->cid));
+ local_stream += len;
+
+ msg_field_cspec_get_from_stream( local_stream, &(data->modified_cspec));
+
+ cp_dbg_msg_cm_conn_mod_req(*data);
+}
+
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_new_cnf.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_new_cnf.c
new file mode 100644
index 0000000000..da2cc7b4a8
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_new_cnf.c
@@ -0,0 +1,110 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_new_cnf.c
+ * \brief This file provides management functions for message CM_CONN_NEW.CNF.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+#include "cp/msg/inc/msg_field.h"
+
+
+/**
+ * Initialize the message MSG_CM_CONN_NEW_CNF.
+ * \param msg Message to be initialized.
+ *
+ */
+void
+msg_cm_conn_new_cnf_init(msg_cm_conn_new_cnf_t* msg)
+{
+ dbg_assert_ptr(msg);
+
+ msg_field_cid_init(&(msg->cid));
+ msg->llid_r = 0;
+ msg->result = 0;
+ msg_field_cspec_init( &(msg->cspec_proposed));
+}
+
+
+
+/**
+ * Decode a CM_CONN_NEW_CNF message from a MME message.
+ * \param msg MME Message.
+ * \param data Structure where the data is saved.
+ *
+ */
+void
+msg_cm_conn_new_cnf_get_from_mme_msg(msg_mme_t* msg, msg_cm_conn_new_cnf_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ dbg_assert_ptr(msg);
+
+ // get CID
+ len = msg_field_cid_get_from_stream(local_stream, &(data->cid));
+ local_stream += len;
+
+ // get LLID-R
+ data->llid_r = *local_stream;
+ local_stream ++;
+
+ // get Result
+ data->result = *local_stream;
+ local_stream ++;
+
+ if(data->result == CONN_FAILURE_OTHER)
+ {
+ // get CSPEC
+ msg_field_cspec_get_from_stream(local_stream, &(data->cspec_proposed));
+ }
+
+ cp_dbg_msg_cm_conn_new_cnf(*data);
+
+}
+
+
+/**
+ * Encode a CM_CONN_NEW_CNF message on a MME msg.
+ * \param msg MME message where the data is saved.
+ * \param data Data source.
+ *
+ */
+void
+msg_cm_conn_new_cnf_set_on_mme_msg(msg_mme_t* msg, msg_cm_conn_new_cnf_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ cp_dbg_msg_cm_conn_new_cnf(*data);
+ dbg_assert_ptr(msg);
+
+
+ // set CID
+ len = msg_field_cid_set_on_stream(local_stream, &(data->cid));
+ local_stream += len;
+
+ // set LLID-R
+ *local_stream = data->llid_r ;
+ local_stream ++;
+
+ // set Result
+ *local_stream = data->result;
+ local_stream ++;
+
+ if (data->result == CONN_FAILURE_OTHER)
+ {
+ // set CSPEC
+ msg_field_cspec_set_on_stream(local_stream, &(data->cspec_proposed));
+ }
+
+}
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_new_req.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_new_req.c
new file mode 100644
index 0000000000..abe38597ae
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_new_req.c
@@ -0,0 +1,91 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_new_req.c
+ * \brief This file provides management functions for message CM_CONN_NEW.REQ.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+
+/**
+ * Initialize the message CM_CONN_NEW_REQ
+ * \param msg Message to be initialized.
+ *
+ */
+void
+msg_cm_conn_new_req_init(msg_cm_conn_new_req_t* data)
+{
+ dbg_assert_ptr(data);
+
+ msg_field_cid_init( &(data->cid));
+ msg_field_classifier_init( &(data->classifier_rule));
+ msg_field_cspec_init( &(data->cspec));
+
+}
+
+/**
+ * Decode a CM_CONN_NEW_REQ message from a MME message.
+ * \param msg MME Message.
+ * \param data Structure where the data is saved.
+ *
+ */
+void
+msg_cm_conn_new_req_get_from_mme_msg(msg_mme_t* msg, msg_cm_conn_new_req_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+
+ dbg_assert_ptr(msg);
+
+ // get CID
+ len = msg_field_cid_get_from_stream(local_stream, &(data->cid));
+ local_stream += len;
+
+ // get CSPEC
+ len = msg_field_cspec_get_from_stream(local_stream, &(data->cspec));
+ local_stream += len;
+
+ // get classifier rules
+ msg_field_classifier_get_from_stream(local_stream, &(data->classifier_rule));
+
+ cp_dbg_msg_cm_conn_new_req( *data );
+}
+
+/**
+ * Encode a CM_CONN_NEW_REQ message on a MME msg.
+ * \param msg MME message where the data is saved.
+ * \param data Data source.
+ *
+ */
+void
+msg_cm_conn_new_req_set_on_mme_msg(msg_mme_t* msg, msg_cm_conn_new_req_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ cp_dbg_msg_cm_conn_new_req( *data );
+ dbg_assert_ptr(msg);
+
+ // set CID
+ len = msg_field_cid_set_on_stream(local_stream, &(data->cid));
+ local_stream += len;
+
+ // set CSPEC
+ len = msg_field_cspec_set_on_stream(local_stream, &(data->cspec));
+ local_stream += len;
+
+ // set classifier rule
+ msg_field_classifier_set_on_stream( local_stream, &(data->classifier_rule));
+
+}
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_ind.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_ind.c
new file mode 100644
index 0000000000..f06409c028
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_ind.c
@@ -0,0 +1,92 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_rel_ind.c
+ * \brief This file provides management functions for message CM_CONN_NEW.REQ.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+
+/**
+ * Initialize the message CM_CONN_REL_IND
+ * \param msg Message to be initialized.
+ *
+ */
+void
+msg_cm_conn_rel_ind_init(msg_cm_conn_rel_ind_t* data)
+{
+ dbg_assert_ptr(data);
+
+ msg_field_cid_init(&(data->cid));
+ data->reason_code = 0;
+ msg_field_cspec_init( &(data->violated_cspec));
+}
+
+/**
+ * Decode a CM_CONN_REL_IND message from a MME message.
+ * \param msg MME Message.
+ * \param data Structure where the data is saved.
+ *
+ */
+void
+msg_cm_conn_rel_ind_get_from_mme_msg(msg_mme_t* msg, msg_cm_conn_rel_ind_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ dbg_assert_ptr(msg);
+
+ // get CID
+ len = msg_field_cid_get_from_stream(local_stream, &(data->cid));
+ local_stream += len;
+
+ // get Reason Code
+ data->reason_code = *local_stream;
+ local_stream ++;
+
+ // get violated CSPEC
+ msg_field_cspec_get_from_stream(local_stream, &(data->violated_cspec));
+
+ cp_dbg_msg_cm_conn_rel_ind(*data);
+}
+
+
+/**
+ * Encode a CM_CONN_REL_IND message on a MME msg.
+ * \param msg MME message where the data is saved.
+ * \param data Data source.
+ *
+ */
+void
+msg_cm_conn_rel_ind_set_on_mme_msg(msg_mme_t* msg, msg_cm_conn_rel_ind_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+ len_t len;
+
+ dbg_assert_ptr(data);
+ cp_dbg_msg_cm_conn_rel_ind(*data);
+ dbg_assert_ptr(msg);
+
+ // set CID
+ len = msg_field_cid_set_on_stream(local_stream, &(data->cid));
+ local_stream += len;
+
+ // set Reason Code
+ *local_stream = data->reason_code;
+ local_stream ++;
+
+ // set violated CSPEC
+ msg_field_cspec_set_on_stream(local_stream, &(data->violated_cspec));
+
+}
+
+
diff --git a/cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_rsp.c b/cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_rsp.c
new file mode 100644
index 0000000000..e25f5017e8
--- /dev/null
+++ b/cesar/cp/msg/src/cm/conn/msg_cm_conn_rel_rsp.c
@@ -0,0 +1,76 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_cm_conn_new_rsp.c
+ * \brief This file provides management functions for message CM_CONN_NEW.RSP.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+#include "cp/msg/inc/msg_field.h"
+
+
+
+/**
+ * Initialize the message CM_CONN_REL_RSP
+ * \param msg Message to be initialized.
+ *
+ */
+void
+msg_cm_conn_rel_rsp_init(msg_cm_conn_rel_rsp_t* data)
+{
+ dbg_assert_ptr(data);
+
+ msg_field_cid_init(&(data->cid));
+
+ cp_dbg_msg_cm_conn_rel_rsp(*data);
+
+}
+
+
+
+/**
+ * Decode a CM_CONN_REL_RSP message from a MME message.
+ * \param msg MME Message.
+ * \param data Structure where the data is saved.
+ *
+ */
+void
+msg_cm_conn_rel_rsp_set_on_mme_msg(msg_mme_t* msg, msg_cm_conn_rel_rsp_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+
+ dbg_assert_ptr(data);
+ cp_dbg_msg_cm_conn_rel_rsp(*data);
+ dbg_assert_ptr(msg);
+
+ msg_field_cid_set_on_stream( local_stream, &(data->cid));
+
+}
+
+
+/**
+ * Encode a CM_CONN_REL_RSP message on a MME msg.
+ * \param msg MME message where the data is saved.
+ * \param data Data source.
+ *
+ */
+void
+msg_cm_conn_rel_rsp_get_from_mme_msg(msg_mme_t* msg, msg_cm_conn_rel_rsp_t* data)
+{
+ u8* local_stream = (u8*)msg->mm_entry;
+
+ dbg_assert_ptr(msg);
+ dbg_assert_ptr(data);
+
+ msg_field_cid_get_from_stream( local_stream, &(data->cid));
+
+ cp_dbg_msg_cm_conn_rel_rsp(*data);
+}
+
diff --git a/cesar/cp/msg/src/field/msg_field_cid.c b/cesar/cp/msg/src/field/msg_field_cid.c
new file mode 100644
index 0000000000..b893e1314c
--- /dev/null
+++ b/cesar/cp/msg/src/field/msg_field_cid.c
@@ -0,0 +1,70 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file conn_msg_cid.c
+ * \brief This file provides management functions for CID (Connection Identifier) field.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "lib/swap.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+
+/**
+ * Initialize a CID (Connection Identifier) structure.
+ * \param cid Pointer of the data to be initialized
+ *
+ */
+void
+msg_field_cid_init(cid_t* cid)
+{
+ *cid = 1;
+}
+
+
+
+/**
+ * Read the CID (Connection Identifier) from the stream and put the CID value
+ * on the cid pointer. The function returns the CID length.
+ *
+ * \param stream Data source contening the cid value.
+ * \param cid Pointer of the data to be modified.
+ * \return length of the CID field.
+ *
+ */
+len_t
+msg_field_cid_get_from_stream (u8* stream, cid_t * cid)
+{
+
+ dbg_assert_ptr (stream);
+ dbg_assert_ptr (cid);
+
+
+ *cid = ntohs(*(u16*)stream);
+
+ dbg_assert (*cid != 0);
+
+ return 2;
+}
+
+
+/**
+* Write the CID value on the stream. The function returns the data length written.
+*
+* param stream Data destination of the CID value.
+* param cid Pointer of the data to be written.
+* return Length of the data.
+*
+*/
+len_t
+msg_field_cid_set_on_stream(u8 * stream, cid_t* cid)
+{
+ *(u16*)stream = htons(*cid);
+ return 2;
+}
diff --git a/cesar/cp/msg/src/field/msg_field_cinfo.c b/cesar/cp/msg/src/field/msg_field_cinfo.c
new file mode 100644
index 0000000000..4407feb04a
--- /dev/null
+++ b/cesar/cp/msg/src/field/msg_field_cinfo.c
@@ -0,0 +1,93 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file conn_msg_cinfo.c
+ * \brief This file provides management functions for CINFO (Connection Information) field.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+
+/**
+ * Initialize a CINFO structure.
+ * \param cinfo
+ *
+ */
+void
+msg_field_cinfo_init (cinfo_t* cinfo)
+{
+
+ bzero(cinfo, 5);
+
+}
+
+
+/**
+ * Read a CINFO structure on a stream. The function returns the length of the structure.
+ * \param stream Data source contening the CINFO structure.
+ * \param cinfo Pointer of the data destination.
+ * \return Length of the CINFO structure.
+ *
+ */
+len_t
+msg_field_cinfo_get_from_stream(u8 * stream, cinfo_t* cinfo)
+{
+
+ u8 * local_stream = stream;
+ len_t len;
+
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(cinfo);
+
+ cinfo->valid = *local_stream; local_stream++;
+
+ if (cinfo->valid == CINFO_VALID)
+ {
+ bcopy( local_stream, (u8*)(cinfo)+1, 4);
+ len = 5;
+ }
+ else // cinfo->valid == CINFO_NOT_VALID
+ {
+ len = 1;
+ }
+
+ cp_dbg_cinfo(*cinfo);
+
+ return len;
+}
+
+
+
+/**
+ * Write a CINFO structure on a stream. The function returns the length of the structure.
+ * \param stream Destination of the CINFO data.
+ * \param cinfo Source.
+ * \return Length of the data written.
+ *
+ */
+len_t
+msg_field_cinfo_set_on_stream(u8 * stream, cinfo_t* cinfo)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(cinfo);
+ cp_dbg_cinfo(*cinfo);
+
+ if (cinfo->valid == CINFO_VALID)
+ {
+ bcopy((u8*)cinfo, stream, 5);
+ return 5;
+ }
+ else // cinfo->valid == CINFO_NOT_VALID
+ {
+ bcopy( (u8*)cinfo, stream, 1);
+ return 1;
+ }
+
+}
diff --git a/cesar/cp/msg/src/field/msg_field_classifier.c b/cesar/cp/msg/src/field/msg_field_classifier.c
new file mode 100644
index 0000000000..90ccc065da
--- /dev/null
+++ b/cesar/cp/msg/src/field/msg_field_classifier.c
@@ -0,0 +1,563 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_field_classifier.c
+ * \brief This file provides management functions for classifier_rules field.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "lib/swap.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+// Private functions declaration
+len_t msg_field_classifier_copy_rule_ethernet_destination_address_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_rule_ethernet_source_address_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_rule_vlan_user_priority_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_rule_vlan_id_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_type_of_service_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_protocol_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_source_address_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_destination_address_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_traffic_class_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_flow_label_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_source_address_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_destination_address_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_tcp_source_port_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_tcp_destination_port_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_udp_source_port_on_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_udp_destination_port_on_stream(u8* stream, classifier_rules_data_t* data);
+
+
+len_t msg_field_classifier_copy_rule_ethernet_destination_address_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_rule_ethernet_source_address_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_rule_vlan_user_priority_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_rule_vlan_id_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_type_of_service_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_protocol_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_source_address_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv4_destination_address_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_traffic_class_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_flow_label_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_source_address_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_ipv6_destination_address_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_tcp_source_port_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_tcp_destination_port_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_udp_source_port_from_stream(u8* stream, classifier_rules_data_t* data);
+len_t msg_field_classifier_copy_udp_destination_port_from_stream(u8* stream, classifier_rules_data_t* data);
+
+
+
+
+
+//////////////////////////////////////////////////////////////
+// Private Type
+
+#define NBR_CLASSIFIER_FIELD 16
+#define FILTER_FIRST_BIT 0x01
+
+typedef len_t ( *copy_classifier_t)(u8* stream, classifier_rules_data_t* data);
+
+copy_classifier_t copy_classifier_from_stream_tb[] =
+{
+ msg_field_classifier_copy_rule_ethernet_destination_address_from_stream,
+ msg_field_classifier_copy_rule_ethernet_source_address_from_stream,
+ msg_field_classifier_copy_rule_vlan_user_priority_from_stream,
+ msg_field_classifier_copy_rule_vlan_id_from_stream,
+ msg_field_classifier_copy_ipv4_type_of_service_from_stream,
+ msg_field_classifier_copy_ipv4_protocol_from_stream,
+ msg_field_classifier_copy_ipv4_source_address_from_stream,
+ msg_field_classifier_copy_ipv4_destination_address_from_stream,
+ msg_field_classifier_copy_ipv6_traffic_class_from_stream,
+ msg_field_classifier_copy_ipv6_flow_label_from_stream,
+ msg_field_classifier_copy_ipv6_source_address_from_stream,
+ msg_field_classifier_copy_ipv6_destination_address_from_stream,
+ msg_field_classifier_copy_tcp_source_port_from_stream,
+ msg_field_classifier_copy_tcp_destination_port_from_stream,
+ msg_field_classifier_copy_udp_source_port_from_stream,
+ msg_field_classifier_copy_udp_destination_port_from_stream
+};
+
+copy_classifier_t copy_classifier_on_stream_tb[] =
+{
+ msg_field_classifier_copy_rule_ethernet_destination_address_on_stream,
+ msg_field_classifier_copy_rule_ethernet_source_address_on_stream,
+ msg_field_classifier_copy_rule_vlan_user_priority_on_stream,
+ msg_field_classifier_copy_rule_vlan_id_on_stream,
+ msg_field_classifier_copy_ipv4_type_of_service_on_stream,
+ msg_field_classifier_copy_ipv4_protocol_on_stream,
+ msg_field_classifier_copy_ipv4_source_address_on_stream,
+ msg_field_classifier_copy_ipv4_destination_address_on_stream,
+ msg_field_classifier_copy_ipv6_traffic_class_on_stream,
+ msg_field_classifier_copy_ipv6_flow_label_on_stream,
+ msg_field_classifier_copy_ipv6_source_address_on_stream,
+ msg_field_classifier_copy_ipv6_destination_address_on_stream,
+ msg_field_classifier_copy_tcp_source_port_on_stream,
+ msg_field_classifier_copy_tcp_destination_port_on_stream,
+ msg_field_classifier_copy_udp_source_port_on_stream,
+ msg_field_classifier_copy_udp_destination_port_on_stream
+};
+typedef struct
+{
+ u32 len;
+ u32 ptr_shift;
+} info_rule_t;
+
+/////////////////////////////////////////////////////////////////////
+//////////////////// Classifier TOOLBOX ////////////////////////////
+/////////////////////////////////////////////////////////////////////
+
+
+
+len_t
+msg_field_classifier_copy_rule_ethernet_destination_address_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ethernet_destination_address_t* address = &(data->ethernet_destination_address);
+
+ bcopy((void *)address, stream, 6);
+
+ return 6;
+}
+
+len_t
+msg_field_classifier_copy_rule_ethernet_destination_address_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ethernet_destination_address_t* address = &(data->ethernet_destination_address);
+
+ bcopy(stream, (void *)address, 6);
+
+ return 6;
+}
+
+
+
+len_t
+msg_field_classifier_copy_rule_ethernet_source_address_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ethernet_source_address_t* address = &(data->ethernet_source_address);
+
+ bcopy((void *)address, stream, 6);
+
+ return 6;
+}
+
+len_t
+msg_field_classifier_copy_rule_ethernet_source_address_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ethernet_source_address_t* address = &(data->ethernet_source_address);
+
+ bcopy(stream, (void *)address, 6);
+
+ return 6;
+}
+
+
+
+
+len_t
+msg_field_classifier_copy_rule_vlan_user_priority_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *stream = data->vlan_user_priority;
+
+ return 1;
+}
+
+len_t
+msg_field_classifier_copy_rule_vlan_user_priority_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->vlan_user_priority = *stream;
+
+ return 1;
+}
+
+
+
+
+len_t
+msg_field_classifier_copy_rule_vlan_id_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *(u16*)stream = htons(data->vlan_id);
+
+ return 2;
+}
+
+len_t
+msg_field_classifier_copy_rule_vlan_id_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->vlan_id = ntohs(*(u16*)stream);
+
+ return 2;
+}
+
+
+
+len_t
+msg_field_classifier_copy_ipv4_type_of_service_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *stream = data->ipv4_type_of_service;
+
+ return 1;
+}
+
+len_t
+msg_field_classifier_copy_ipv4_type_of_service_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->ipv4_type_of_service = *stream;
+
+ return 1;
+}
+
+
+
+len_t
+msg_field_classifier_copy_ipv4_protocol_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *stream = data->ipv4_protocol;
+
+ return 1;
+}
+
+len_t
+msg_field_classifier_copy_ipv4_protocol_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->ipv4_protocol = *stream;
+
+ return 1;
+}
+
+
+
+len_t
+msg_field_classifier_copy_ipv4_source_address_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv4_source_address_t* address = &(data->ipv4_source_address);
+
+ bcopy( (void *)address, (void *)stream, 4);
+
+ return 4;
+}
+
+len_t
+msg_field_classifier_copy_ipv4_source_address_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv4_source_address_t* dest = &(data->ipv4_source_address);
+
+ bcopy( stream, (void *)dest, 4);
+
+ return 4;
+}
+
+
+
+len_t
+msg_field_classifier_copy_ipv4_destination_address_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv4_destination_address_t* address = &(data->ipv4_destination_address);
+
+ bcopy( (void*)address, stream, 4);
+
+ return 4;
+}
+
+len_t
+msg_field_classifier_copy_ipv4_destination_address_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv4_destination_address_t* dest = &(data->ipv4_destination_address);
+
+ bcopy( stream, (void*)dest, 4);
+
+ return 4;
+}
+
+
+
+
+len_t
+msg_field_classifier_copy_ipv6_traffic_class_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *stream = data->ipv6_traffic_class;
+
+ return 1;
+}
+
+len_t
+msg_field_classifier_copy_ipv6_traffic_class_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->ipv6_traffic_class = *stream;
+
+ return 1;
+}
+
+
+
+len_t
+msg_field_classifier_copy_ipv6_flow_label_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv6_flow_label_t* flow = &(data->ipv6_flow_label);
+
+ bcopy( (void*)flow, stream, 3);
+
+ return 3;
+}
+
+len_t
+msg_field_classifier_copy_ipv6_flow_label_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv6_flow_label_t* flow = &(data->ipv6_flow_label);
+
+ bcopy( stream, (void*)flow, 3);
+
+ return 3;
+}
+
+
+
+len_t
+msg_field_classifier_copy_ipv6_source_address_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv6_source_address_t* address = &(data->ipv6_source_address);
+
+ bcopy( (void*)address, stream, 16);
+
+ return 16;
+}
+
+len_t
+msg_field_classifier_copy_ipv6_source_address_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv6_source_address_t* address = &(data->ipv6_source_address);
+
+ bcopy( stream, (void*)address, 16);
+
+ return 16;
+}
+
+
+
+
+len_t
+msg_field_classifier_copy_ipv6_destination_address_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv6_destination_address_t* address = &(data->ipv6_destination_address);
+
+ bcopy( (void*)address, stream, 16);
+
+ return 16;
+}
+
+len_t
+msg_field_classifier_copy_ipv6_destination_address_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ ipv6_destination_address_t* address = &(data->ipv6_destination_address);
+
+ bcopy( stream, (void*)address, 16);
+
+ return 16;
+}
+
+
+
+len_t
+msg_field_classifier_copy_tcp_source_port_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *(u16*)stream = htons(data->tcp_source_port);
+
+ return 2;
+}
+
+len_t
+msg_field_classifier_copy_tcp_source_port_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->tcp_source_port = ntohs(*(u16*)stream );
+
+ return 2;
+}
+
+
+
+len_t
+msg_field_classifier_copy_tcp_destination_port_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *(u16*)stream = htons(data->tcp_destination_port);
+
+ return 2;
+}
+
+len_t
+msg_field_classifier_copy_tcp_destination_port_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->tcp_destination_port = ntohs(*(u16*)stream);
+
+ return 2;
+}
+
+
+
+len_t
+msg_field_classifier_copy_udp_source_port_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *(u16*)stream = htons(data->udp_source_port);
+
+ return 2;
+}
+
+len_t
+msg_field_classifier_copy_udp_source_port_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->udp_source_port = ntohs(*(u16*)stream);
+
+ return 2;
+}
+
+
+
+len_t
+msg_field_classifier_copy_udp_destination_port_on_stream(u8* stream, classifier_rules_data_t* data)
+{
+ *(u16*)stream = htons(data->udp_destination_port);
+
+ return 2;
+}
+
+len_t
+msg_field_classifier_copy_udp_destination_port_from_stream(u8* stream, classifier_rules_data_t* data)
+{
+ data->udp_destination_port = ntohs(*(u16*)stream);
+
+ return 2;
+}
+
+////////////////////////////////////////////////////////////////////
+////////////////// Main Classifier Function ////////////////////////
+////////////////////////////////////////////////////////////////////
+
+
+/**
+ * Init a Classifier_rules structures
+ * \param classifier_rules pointer of the data to be initialized
+ *
+ */
+void
+msg_field_classifier_init(classifier_rules_t* classifier_rules)
+{
+ bzero(classifier_rules, sizeof(classifier_rules_t));
+
+}
+
+
+
+/**
+ * Get Classifier from stream
+ * \param stream the source stream
+ * \param classifier_rules destination of the data
+ * \return len the function return the length of the classifier_rules frame on the stream,
+ * this value does not correspond with the reality when the frame contains vendor field
+ *
+ */
+len_t
+msg_field_classifier_get_from_stream (u8* stream, classifier_rules_t* classifier_rules)
+{
+ int nbr_classifier_rules;
+ int rule_index = 0;
+ u8* local_stream;
+ len_t len = 0;
+
+ dbg_assert_ptr (stream);
+ dbg_assert_ptr (classifier_rules);
+
+ // Init
+ classifier_rules->classifier_version = *stream; stream++;
+ nbr_classifier_rules = *stream;stream++;
+
+ local_stream = stream;
+
+ while (rule_index < nbr_classifier_rules)
+ {
+ // get the Classifier Rule Identifier
+ u8 classifier_rule_id = *local_stream;
+ len++;local_stream++;
+
+ dbg_assert_print( (classifier_rule_id < 0x10) || (classifier_rule_id > 0xDF), "Classifier Rule Identifier not valid - received fid: 0x%x", classifier_rule_id);
+
+ classifier_rules->data.classifier_rules_available_block |= (0x01 << classifier_rule_id);
+
+ if (classifier_rule_id > 0xDF)
+ {
+ // Vendor defined Classifier Rule
+ nbr_classifier_rules = rule_index;
+ break;
+ }
+ else
+ {
+ // Homeplug AV Classifier Rule
+ len += copy_classifier_from_stream_tb[classifier_rule_id](local_stream, &(classifier_rules->data));
+ }
+
+
+ local_stream = stream + len;
+ rule_index ++;
+ }
+
+ classifier_rules->nbr_rules = nbr_classifier_rules;
+
+ cp_dbg_classifier_rule(*classifier_rules);
+
+ return len + 2;
+}
+
+
+
+
+/**
+ * set Classifier Rules on stream
+ * \param stream Destination.
+ * \param classifier_rules Source.
+ * \return Length of the data.
+ */
+len_t
+msg_field_classifier_set_on_stream(u8* stream, classifier_rules_t* classifier_rules)
+{
+ u8 index_rules;
+ u8* local_stream;
+ u32 available_rules = classifier_rules->data.classifier_rules_available_block;
+ len_t len = 0;
+
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(classifier_rules);
+ cp_dbg_classifier_rule(*classifier_rules);
+
+ bcopy( classifier_rules, stream, 2);//Copy of Classifier version and nbr of rules
+
+ stream += 2;
+
+ local_stream = stream;
+ // copy of the rules
+ for(index_rules = 0; index_rules < NBR_CLASSIFIER_FIELD; index_rules++)
+ {
+ u32 shift = available_rules >> index_rules;
+ u32 filtered = shift & FILTER_FIRST_BIT;
+
+ if ( filtered == 0X1)
+ {
+
+ *local_stream = index_rules;
+
+ local_stream++;
+ len ++;
+
+ len += copy_classifier_on_stream_tb[index_rules](local_stream, &(classifier_rules->data));
+ local_stream = stream + len;
+ }
+ }
+
+ return len+2;
+
+}
+
+
+
diff --git a/cesar/cp/msg/src/field/msg_field_cspec.c b/cesar/cp/msg/src/field/msg_field_cspec.c
new file mode 100644
index 0000000000..e148597300
--- /dev/null
+++ b/cesar/cp/msg/src/field/msg_field_cspec.c
@@ -0,0 +1,114 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_field_cspec.c
+ * \brief This file provides management functions for CSPEC (Connection Specification) field.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "lib/swap.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+
+/**
+ * Initialize the CSPEC (Connection Specification) structure.
+ * \param cspec Pointer of the data to be initialized.
+ *
+ */
+void
+msg_field_cspec_init(cspec_t* cspec)
+{
+ cspec->len = 0;
+ msg_field_cinfo_init( &(cspec->cinfo_forward) );
+ msg_field_cinfo_init( &(cspec->cinfo_reverse) );
+ msg_field_qmp_init( &(cspec->qmp_forward) );
+ cspec->qmp_forward.forward_or_reverse = QMP_FORWARD;
+ msg_field_qmp_init( &(cspec->qmp_reverse) );
+ cspec->qmp_reverse.forward_or_reverse = QMP_REVERSE;
+}
+
+
+/**
+ * Get CSPEC field from a stream.
+ * \param stream Source Stream.
+ * \param cspec Destination.
+ * \return Length of the CSPEC data.
+ *
+ */
+len_t
+msg_field_cspec_get_from_stream(u8* stream, cspec_t* cspec)
+{
+ u8* local_stream = stream;
+ u8* stream_end;
+
+ dbg_assert_ptr( stream );
+ dbg_assert_ptr( cspec );
+
+ cspec->len = ntohs (*(u16*)local_stream); local_stream += 2;
+ stream_end = stream + cspec->len;
+
+ local_stream += msg_field_cinfo_get_from_stream(local_stream, &(cspec->cinfo_forward) );
+ local_stream += msg_field_cinfo_get_from_stream(local_stream, &(cspec->cinfo_reverse) );
+
+ if(cspec->cinfo_forward.valid == CINFO_VALID)
+ local_stream += msg_field_qmp_get_from_stream(local_stream, stream_end, &(cspec->qmp_forward), QMP_FORWARD);
+
+ if(cspec->cinfo_reverse.valid == CINFO_VALID)
+ msg_field_qmp_get_from_stream(local_stream, stream_end, &(cspec->qmp_reverse), QMP_REVERSE);
+
+ cp_dbg_cspec(*cspec);
+
+ return cspec->len;
+
+}
+
+
+
+
+/**
+ * Set CSPEC on stream.
+ * \param stream Data destination.
+ * \param cspec Data source.
+ * \return Length of the data copied.
+ *
+ */
+len_t
+msg_field_cspec_set_on_stream(u8 * stream, cspec_t* cspec)
+{
+ u8 * local_stream = stream;
+
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(cspec);
+ cp_dbg_cspec(*cspec);
+
+ //cspec_len
+ local_stream += 2;
+
+ // copy cinfo_forward
+ local_stream += msg_field_cinfo_set_on_stream( local_stream, &(cspec->cinfo_forward));
+
+ // copy cinfo_reverse
+ local_stream += msg_field_cinfo_set_on_stream( local_stream, &(cspec->cinfo_reverse));
+
+ // copy qmp_forward
+ if (cspec->cinfo_forward.valid == CINFO_VALID)
+ {
+ local_stream += msg_field_qmp_set_on_stream( local_stream, &(cspec->qmp_forward));
+ }
+
+ // copy qmp_reverse
+ if (cspec->cinfo_reverse.valid == CINFO_VALID)
+ {
+ local_stream += msg_field_qmp_set_on_stream( local_stream, &(cspec->qmp_reverse));
+ }
+
+ // copy cspec_len
+ *(u16*)stream = htons(local_stream-stream);
+ return local_stream - stream;
+}
diff --git a/cesar/cp/msg/src/field/msg_field_qmp.c b/cesar/cp/msg/src/field/msg_field_qmp.c
new file mode 100644
index 0000000000..b0351e38a3
--- /dev/null
+++ b/cesar/cp/msg/src/field/msg_field_qmp.c
@@ -0,0 +1,1189 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_field_qmp.c
+ * \brief This file provides management functions for QMP (QoS and Mac Parameters) field.
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "lib/swap.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+
+
+
+// Private definition
+typedef struct
+{
+ qmp_forward_or_reverse_t forward_or_reverse:8;
+ u8 qmp_len;
+ u8 fid;
+ u8 data[];
+} data_qmp_t;
+
+typedef void (*qmp_copy_from_stream_t)(u8*, qmp_t*);
+typedef len_t (*qmp_copy_from_qmp_t )(qmp_t*, u8*);
+
+void msg_field_qmp_copy_delay_bound_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_jitter_bound_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_average_msdu_size_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_maximum_msdu_size_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_average_data_rate_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_minimum_data_rate_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_maximum_data_rate_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_maximum_inter_txop_time_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_minimum_inter_txop_time_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_maximum_burst_size_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_exception_policy_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_inactivity_interval_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_msdu_error_rate_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_clst_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_cdesc_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_ats_tolerance_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_smallest_tolerable_data_rate_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_original_average_data_rate_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_rx_window_size_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_smoothing_buffer_size_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_bidirectional_burst_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_txops_per_beacon_period_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_average_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_minimum_number_of_pbs_per_txop_from_stream_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_maximum_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_ppb_threshold_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_surplus_bandwith_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_smallest_tolerable_average_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_original_average_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_cco_bidirectional_burst_from_stream(u8 * stream, qmp_t* qmp);
+void msg_field_qmp_copy_unknown_from_stream(u8 * stream, qmp_t* qmp);
+
+len_t msg_field_qmp_copy_delay_bound_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_jitter_bound_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_average_msdu_size_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_maximum_msdu_size_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_average_data_rate_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_minimum_data_rate_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_maximum_data_rate_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_maximum_inter_txop_time_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_minimum_inter_txop_time_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_maximum_burst_size_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_exception_policy_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_inactivity_interval_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_msdu_error_rate_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_clst_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_cdesc_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_ats_tolerance_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_smallest_tolerable_data_rate_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_original_average_data_rate_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_rx_window_size_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_smoothing_buffer_size_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_bidirectional_burst_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_txops_per_beacon_period_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_average_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_minimum_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_maximum_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_ppb_threshold_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_surplus_bandwith_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_smallest_tolerable_average_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_original_average_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_cco_bidirectional_burst_from_qmp(qmp_t* qmp, u8* stream);
+len_t msg_field_qmp_copy_unknown_from_qmp(qmp_t* qmp, u8* stream);
+
+
+
+
+qmp_copy_from_stream_t qmp_copy_from_stream[32] =
+{
+ msg_field_qmp_copy_delay_bound_from_stream,
+ msg_field_qmp_copy_jitter_bound_from_stream,
+ msg_field_qmp_copy_average_msdu_size_from_stream,
+ msg_field_qmp_copy_maximum_msdu_size_from_stream,
+ msg_field_qmp_copy_average_data_rate_from_stream,
+ msg_field_qmp_copy_minimum_data_rate_from_stream,
+ msg_field_qmp_copy_maximum_data_rate_from_stream,
+ msg_field_qmp_copy_maximum_inter_txop_time_from_stream,
+ msg_field_qmp_copy_minimum_inter_txop_time_from_stream,
+ msg_field_qmp_copy_maximum_burst_size_from_stream,
+ msg_field_qmp_copy_exception_policy_from_stream,
+ msg_field_qmp_copy_inactivity_interval_from_stream,
+ msg_field_qmp_copy_msdu_error_rate_from_stream,
+ msg_field_qmp_copy_clst_from_stream,
+ msg_field_qmp_copy_cdesc_from_stream,
+ msg_field_qmp_copy_unknown_from_stream,
+ msg_field_qmp_copy_ats_tolerance_from_stream,
+ msg_field_qmp_copy_smallest_tolerable_data_rate_from_stream,
+ msg_field_qmp_copy_original_average_data_rate_from_stream,
+ msg_field_qmp_copy_rx_window_size_from_stream,
+ msg_field_qmp_copy_smoothing_buffer_size_from_stream,
+ msg_field_qmp_copy_bidirectional_burst_from_stream,
+ msg_field_qmp_copy_txops_per_beacon_period_from_stream,
+ msg_field_qmp_copy_average_number_of_pbs_per_txop_from_stream,
+ msg_field_qmp_copy_minimum_number_of_pbs_per_txop_from_stream_from_stream,
+ msg_field_qmp_copy_maximum_number_of_pbs_per_txop_from_stream,
+ msg_field_qmp_copy_ppb_threshold_from_stream,
+ msg_field_qmp_copy_surplus_bandwith_from_stream,
+ msg_field_qmp_copy_unknown_from_stream,
+ msg_field_qmp_copy_smallest_tolerable_average_number_of_pbs_per_txop_from_stream,
+ msg_field_qmp_copy_original_average_number_of_pbs_per_txop_from_stream,
+ msg_field_qmp_copy_cco_bidirectional_burst_from_stream
+
+};
+
+
+qmp_copy_from_qmp_t qmp_copy_from_qmp[32]=
+{
+ msg_field_qmp_copy_delay_bound_from_qmp,
+ msg_field_qmp_copy_jitter_bound_from_qmp,
+ msg_field_qmp_copy_average_msdu_size_from_qmp,
+ msg_field_qmp_copy_maximum_msdu_size_from_qmp,
+ msg_field_qmp_copy_average_data_rate_from_qmp,
+ msg_field_qmp_copy_minimum_data_rate_from_qmp,
+ msg_field_qmp_copy_maximum_data_rate_from_qmp,
+ msg_field_qmp_copy_maximum_inter_txop_time_from_qmp,
+ msg_field_qmp_copy_minimum_inter_txop_time_from_qmp,
+ msg_field_qmp_copy_maximum_burst_size_from_qmp,
+ msg_field_qmp_copy_exception_policy_from_qmp,
+ msg_field_qmp_copy_inactivity_interval_from_qmp,
+ msg_field_qmp_copy_msdu_error_rate_from_qmp,
+ msg_field_qmp_copy_clst_from_qmp,
+ msg_field_qmp_copy_cdesc_from_qmp,
+ msg_field_qmp_copy_unknown_from_qmp, // vendor specific
+ msg_field_qmp_copy_ats_tolerance_from_qmp,
+ msg_field_qmp_copy_smallest_tolerable_data_rate_from_qmp,
+ msg_field_qmp_copy_original_average_data_rate_from_qmp,
+ msg_field_qmp_copy_rx_window_size_from_qmp,
+ msg_field_qmp_copy_smoothing_buffer_size_from_qmp,
+ msg_field_qmp_copy_bidirectional_burst_from_qmp,
+ msg_field_qmp_copy_txops_per_beacon_period_from_qmp,
+ msg_field_qmp_copy_average_number_of_pbs_per_txop_from_qmp,
+ msg_field_qmp_copy_minimum_number_of_pbs_per_txop_from_qmp,
+ msg_field_qmp_copy_maximum_number_of_pbs_per_txop_from_qmp,
+ msg_field_qmp_copy_ppb_threshold_from_qmp,
+ msg_field_qmp_copy_surplus_bandwith_from_qmp,
+ msg_field_qmp_copy_unknown_from_qmp,
+ msg_field_qmp_copy_smallest_tolerable_average_number_of_pbs_per_txop_from_qmp,
+ msg_field_qmp_copy_original_average_number_of_pbs_per_txop_from_qmp,
+ msg_field_qmp_copy_cco_bidirectional_burst_from_qmp
+
+
+};
+////////////////////////////////////////////////////////////////////
+//////////////////////////// QMP TOOLBOX////////////////////////////
+////////////////////////////////////////////////////////////////////
+
+
+void
+msg_field_qmp_copy_delay_bound_from_stream(u8* stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.delay_bound_available = true;
+
+ qmp->cm.delay_bound = ntohl( *(u32*)stream);
+
+}
+
+len_t
+msg_field_qmp_copy_delay_bound_from_qmp(qmp_t* qmp, u8* stream)
+{
+
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.delay_bound_available, "PRE : no delay_bound_present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x04; stream++; // body length
+ *stream = 0x00; stream++; // FID : delay bound
+ *(u32*)stream = htonl(qmp->cm.delay_bound);
+
+ return 7;
+
+}
+
+
+
+void
+msg_field_qmp_copy_jitter_bound_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert(stream);
+ dbg_assert(qmp);
+
+ qmp->valid.jitter_bound_available = true;
+
+ qmp->cm.jitter_bound = ntohl( *(u32*)stream);
+}
+
+len_t
+msg_field_qmp_copy_jitter_bound_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.jitter_bound_available, "PRE : no jitter_bound_present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x04; stream++; // body length
+ *stream = 0x01; stream++; // FID : delay bound
+ *(u32*)stream = htonl(qmp->cm.jitter_bound);
+
+ return 7;
+}
+
+
+
+void
+msg_field_qmp_copy_average_msdu_size_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.average_msdu_size_available = true;
+
+ qmp->cm.average_msdu_size = ntohs( *(u16*)stream);
+
+}
+
+len_t
+msg_field_qmp_copy_average_msdu_size_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.average_msdu_size_available, "PRE : no average_msdu_size_present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x02; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.average_msdu_size);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_maximum_msdu_size_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.maximum_msdu_size_available = true;
+
+ qmp->cm.maximum_msdu_size = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_maximum_msdu_size_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.maximum_msdu_size_available, "PRE : no maximum_msdu_size_present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x03; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.maximum_msdu_size);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_average_data_rate_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.average_data_rate_available = true;
+
+ qmp->cm.average_data_rate = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_average_data_rate_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.average_data_rate_available, "PRE : no average_data_rate_present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x04; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.average_data_rate);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_minimum_data_rate_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.minimum_data_rate_available = true;
+
+ qmp->cm.minimum_data_rate = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_minimum_data_rate_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.minimum_data_rate_available, "PRE : no minimum_data_rate_present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x05; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.minimum_data_rate);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_maximum_data_rate_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.maximum_data_rate_available = true;
+
+ qmp->cm.maximum_data_rate = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_maximum_data_rate_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.maximum_data_rate_available, "PRE : no maximum_data_rate present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x06; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.maximum_data_rate);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_maximum_inter_txop_time_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.maximum_inter_txop_time_available = true;
+
+ qmp->cm.maximum_inter_txop_time = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_maximum_inter_txop_time_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.maximum_inter_txop_time_available, "PRE : no maximum_inter_txop_time present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x07; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.maximum_inter_txop_time);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_minimum_inter_txop_time_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.minimum_inter_txop_time_available = true;
+
+ qmp->cm.minimum_inter_txop_time = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_minimum_inter_txop_time_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.minimum_inter_txop_time_available, "PRE : no minimum_inter_txop_time present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x08; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.minimum_inter_txop_time);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_maximum_burst_size_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.maximum_burst_size_available = true;
+
+ qmp->cm.maximum_burst_size = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_maximum_burst_size_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.maximum_burst_size_available, "PRE : no maximum_burst_size present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x09; stream++; // FID : maximum burst size
+ *(u16*)stream = htons(qmp->cm.maximum_burst_size);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_exception_policy_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.exception_policy_available = true;
+
+ qmp->cm.exception_policy = *stream;
+}
+
+len_t
+msg_field_qmp_copy_exception_policy_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.exception_policy_available, "PRE : no exception_policy present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x01; stream++; // body length
+ *stream = 0x0A; stream++; // FID : delay bound
+ *stream = qmp->cm.exception_policy;
+
+ return 4;
+}
+
+
+
+void
+msg_field_qmp_copy_inactivity_interval_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.inactivity_interval_available = true;
+
+ qmp->cm.inactivity_interval = ntohl( *(u32*)stream);
+}
+
+len_t
+msg_field_qmp_copy_inactivity_interval_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.inactivity_interval_available, "PRE : no inactivity_interval on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x04; stream++; // body length
+ *stream = 0x0B; stream++; // FID : delay bound
+ *(u32*)stream = htonl(qmp->cm.inactivity_interval);
+
+ return 7;
+}
+
+
+
+void
+msg_field_qmp_copy_msdu_error_rate_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.msdu_error_rate_available = true;
+
+ qmp->cm.msdu_error_rate = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_msdu_error_rate_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.msdu_error_rate_available, "PRE : no msdu_error_rate present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x0C; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.msdu_error_rate);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_clst_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.clst_available = true;
+
+ qmp->cm.clst = *stream;
+}
+
+len_t
+msg_field_qmp_copy_clst_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.clst_available, "PRE : no clst present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x01; stream++; // body length
+ *stream = 0x0D; stream++; // FID : delay bound
+ *stream = qmp->cm.clst;
+
+ return 4;
+}
+
+
+
+void
+msg_field_qmp_copy_cdesc_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.cdesc_available = true;
+
+ qmp->cm.cdesc.ip_version = *stream;
+ stream ++;
+
+ if( qmp->cm.cdesc.ip_version == IP_VERSION_4)
+ {
+ bcopy(stream, &qmp->cm.cdesc.ipv4_source_address , 4); stream += 4; // copy source ip address
+ qmp->cm.cdesc.source_port = ntohs( *(u16*)stream);stream += 2;
+
+ bcopy(stream, &qmp->cm.cdesc.ipv4_destination_address , 4); stream += 4; // copy destination ip address
+ qmp->cm.cdesc.destination_port = ntohs( *(u16*)stream); stream += 2;
+
+ }
+ else if ( qmp->cm.cdesc.ip_version == IP_VERSION_6)
+ {
+ bcopy(stream, &qmp->cm.cdesc.ipv6_source_address, 36);
+ qmp->cm.cdesc.destination_port = ntohs(qmp->cm.cdesc.destination_port);
+ qmp->cm.cdesc.source_port = ntohs(qmp->cm.cdesc.source_port);
+ }
+ else
+ {
+ dbg_assert_print(true, "!!! ERROR : ip version invalid");
+ }
+ qmp->cm.cdesc.protocol_type = *stream;
+
+}
+
+len_t
+msg_field_qmp_copy_cdesc_from_qmp(qmp_t* qmp, u8* stream)
+{
+ len_t len = 0;
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.cdesc_available, "PRE : no cdesc present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+
+ if(qmp->cm.cdesc.ip_version == IP_VERSION_4)
+ {
+ *stream = 0x0E; stream++; // body length
+ *stream = 0x0E; stream++; // FID : delay bound
+ *stream = qmp->cm.cdesc.ip_version; stream++;
+
+ bcopy(qmp->cm.cdesc.ipv4_source_address,stream, sizeof( qmp->cm.cdesc.ipv4_source_address ) );
+ stream += sizeof( qmp->cm.cdesc.ipv4_source_address );
+
+ *(u16*)stream = htons(qmp->cm.cdesc.source_port);
+ stream += 2;
+
+ bcopy(qmp->cm.cdesc.ipv4_destination_address,stream, sizeof( qmp->cm.cdesc.ipv4_destination_address ) );
+ stream += sizeof( qmp->cm.cdesc.ipv4_destination_address);
+
+ *(u16*)stream = htons(qmp->cm.cdesc.destination_port);
+ stream += 2;
+
+ len = 17;
+ }
+ else if(qmp->cm.cdesc.ip_version == IP_VERSION_6)
+ {
+ *stream = 0x26; stream++; // body length
+ *stream = 0x0E; stream++; // FID : delay bound
+ *stream = qmp->cm.cdesc.ip_version; stream++;
+
+ bcopy(qmp->cm.cdesc.ipv4_source_address,stream, 16 ); stream += 16;
+ *(u16*)stream = htons(qmp->cm.cdesc.source_port); stream += 2;
+ bcopy(qmp->cm.cdesc.ipv4_destination_address,stream, 16 ); stream += 16;
+ *(u16*)stream = htons(qmp->cm.cdesc.destination_port); stream += 2;
+
+ len = 41;
+ }
+ else
+ dbg_assert_print(true,"Invalid ip version");
+
+ *stream = qmp->cm.cdesc.protocol_type;
+
+
+ return len;
+}
+
+
+
+void
+msg_field_qmp_copy_ats_tolerance_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.ats_tolerance_available = true;
+
+ qmp->cm.ats_tolerance = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_ats_tolerance_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.ats_tolerance_available, "PRE : no ats_tolerance present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x10; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.ats_tolerance);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_smallest_tolerable_data_rate_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.smallest_tolerable_data_rate_available = true;
+
+ qmp->cm.smallest_tolerable_data_rate = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_smallest_tolerable_data_rate_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.smallest_tolerable_data_rate_available, "PRE : no smallest_tolerable_data_rate present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x11; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.smallest_tolerable_data_rate);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_original_average_data_rate_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.original_average_data_rate_available = true;
+
+ qmp->cm.original_average_data_rate = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_original_average_data_rate_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.original_average_data_rate_available, "PRE : no original_average_data_rate present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x12; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.original_average_data_rate);
+
+ return 5;
+}
+
+
+
+
+void
+msg_field_qmp_copy_rx_window_size_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.rx_window_size_available = true;
+
+ qmp->cm.rx_window_size = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_rx_window_size_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.rx_window_size_available, "PRE : no rx_window_size present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x13; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cm.rx_window_size);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_smoothing_buffer_size_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.smoothing_buffer_size_available = true;
+
+ bcopy(stream, &qmp->cm.smoothing_buffer_size, 3);
+
+#if DEFS_BIG_ENDIAN
+
+#else
+#define var (qmp->cm.smoothing_buffer_size)
+ var = (var & 0x0000FF) << 16 | (var & 0x00FF00) | (var & 0xFF0000) >> 16;
+#endif
+}
+
+len_t
+msg_field_qmp_copy_smoothing_buffer_size_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.smoothing_buffer_size_available, "PRE : no smoothing_buffer_sizepresent on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x03; stream++; // body length
+ *stream = 0x14; stream++; // FID : delay bound
+
+
+#if DEFS_BIG_ENDIAN
+
+#else
+#define var (qmp->cm.smoothing_buffer_size)
+ *(u32*)stream = (var & 0x0000FF) << 16 | (var & 0x00FF00) | (var & 0xFF0000) >> 16;
+#endif
+
+
+ return 6;
+}
+
+
+
+void
+msg_field_qmp_copy_bidirectional_burst_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert(stream);
+ dbg_assert(qmp);
+
+ qmp->valid.bidirectional_burst_available = true;
+
+ qmp->cm.bidirectional_burst = *stream;
+}
+
+len_t
+msg_field_qmp_copy_bidirectional_burst_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.bidirectional_burst_available, "PRE : no bidirectional_burst present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x01; stream++; // body length
+ *stream = 0x15; stream++; // FID : delay bound
+ *stream = qmp->cm.bidirectional_burst;
+
+ return 4;
+}
+
+
+
+void
+msg_field_qmp_copy_txops_per_beacon_period_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+ qmp->valid.txops_per_beacon_period_available = true;
+
+ qmp->cco.txops_per_beacon_period = *stream;
+}
+
+len_t
+msg_field_qmp_copy_txops_per_beacon_period_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.txops_per_beacon_period_available, "PRE : no txops_per_beacon_period present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x01; stream++; // body length
+ *stream = 0x80; stream++; // FID : delay bound
+ *stream = qmp->cco.txops_per_beacon_period;
+
+ return 4;
+}
+
+
+
+void
+msg_field_qmp_copy_average_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert(stream);
+ dbg_assert(qmp);
+
+ qmp->valid.average_number_of_pbs_per_txop_available = true;
+
+ qmp->cco.average_number_of_pbs_per_txop = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_average_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.average_number_of_pbs_per_txop_available, "PRE : no average_number_of_pbs_per_txop present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x81; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.average_number_of_pbs_per_txop);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_minimum_number_of_pbs_per_txop_from_stream_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.minimum_number_of_pbs_per_txop_available = true;
+
+ qmp->cco.minimum_number_of_pbs_per_txop = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_minimum_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.minimum_number_of_pbs_per_txop_available, "PRE : no minimum_number_of_pbs_per_txop present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x82; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.minimum_number_of_pbs_per_txop);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_maximum_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.maximum_number_of_pbs_per_txop_available = true;
+
+ qmp->cco.maximum_number_of_pbs_per_txop = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_maximum_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.maximum_number_of_pbs_per_txop_available, "PRE : no maximum_number_of_pbs_per_txop present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x83; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.maximum_number_of_pbs_per_txop);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_ppb_threshold_from_stream(u8 * stream, qmp_t* qmp)
+{
+ qmp->valid.ppb_threshold_available = true;
+
+ qmp->cco.ppb_threshold = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_ppb_threshold_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.ppb_threshold_available, "PRE : no ppb_threshold present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x84; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.ppb_threshold);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_surplus_bandwith_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.surplus_bandwith_available = true;
+
+ qmp->cco.surplus_bandwith = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_surplus_bandwith_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.ppb_threshold_available, "PRE : no ppb_threshold present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x85; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.ppb_threshold);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_smallest_tolerable_average_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+
+ qmp->cco.smallest_tolerable_average_number_of_pbs_per_txop = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_smallest_tolerable_average_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.smallest_tolerable_average_number_of_pbs_per_txop_available, "PRE : no smallest_tolerable_average_number_of_pbs_per_txop present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x87; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.smallest_tolerable_average_number_of_pbs_per_txop);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_original_average_number_of_pbs_per_txop_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.original_average_number_of_pbs_per_txop_available = true;
+
+ qmp->cco.original_average_number_of_pbs_per_txop = ntohs( *(u16*)stream);
+}
+
+len_t
+msg_field_qmp_copy_original_average_number_of_pbs_per_txop_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.original_average_number_of_pbs_per_txop_available, "PRE : no original_average_number_of_pbs_per_txop present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x02; stream++; // body length
+ *stream = 0x88; stream++; // FID : delay bound
+ *(u16*)stream = htons(qmp->cco.original_average_number_of_pbs_per_txop);
+
+ return 5;
+}
+
+
+
+void
+msg_field_qmp_copy_cco_bidirectional_burst_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+
+ qmp->valid.cco_bidirectional_burst_available = true;
+
+ qmp->cco.cco_bidirectional_burst = *stream;
+}
+
+len_t
+msg_field_qmp_copy_cco_bidirectional_burst_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_ptr(qmp);
+ dbg_assert_ptr(stream);
+ dbg_assert_print(qmp->valid.cco_bidirectional_burst_available, "PRE : no cco_bidirectional_burst present on qmp frame");
+
+ *stream = qmp->forward_or_reverse; stream ++;
+ *stream = 0x01; stream++; // body length
+ *stream = 0x89; stream++; // FID : delay bound
+ *stream = qmp->cco.cco_bidirectional_burst;
+
+ return 4;
+}
+
+
+
+void
+msg_field_qmp_copy_unknown_from_stream(u8 * stream, qmp_t* qmp)
+{
+ dbg_assert_print(true, "Error unknown fid on QMP");
+}
+
+
+len_t
+msg_field_qmp_copy_unknown_from_qmp(qmp_t* qmp, u8* stream)
+{
+ dbg_assert_print(true, "Erreur copy unknown");
+ return 0;
+}
+
+
+
+u8
+qmp_get_index_from_fid(u8 fid)
+{
+ dbg_assert_print(fid < 0x16 || fid >= 0x80, "PRE : fid value not valid");
+
+ if( fid < 0x16)
+ { // cm fid
+ return fid;
+ }
+ else
+ { // cco fid
+ dbg_assert_print( (fid < 0x8A) && ( fid > 0x7F), "POST: invalid fid range = %x", fid);
+ return fid-0x6A;
+ }
+
+}
+////////////////////////////////////////////////////////////////////
+//////////////////////// Main QMP Function /////////////////////////
+////////////////////////////////////////////////////////////////////
+
+
+
+/**
+ * Initialize the QMP structure.
+ *
+ * \param qmp Data to be initialized.
+ *
+ */
+void
+msg_field_qmp_init(qmp_t* qmp)
+{
+ bzero(qmp, sizeof(qmp_t));
+}
+
+
+
+/**
+ * Get a QMP field from a stream.
+ *
+ * \param stream Stream of data contening the qmp field.
+ * \param qmp Data destination.
+ * \param qmp_type Type of QMP frame to read (QMP_FORWARD or QMP_REVERSE defined on CSPEC).
+ * return Length of the data;
+ *
+ */
+len_t
+msg_field_qmp_get_from_stream (u8* stream, u8* stream_end, qmp_t * qmp, qmp_forward_or_reverse_t qmp_type)
+{
+ data_qmp_t* packet;
+ len_t len;
+
+ dbg_assert_ptr (stream);
+ dbg_assert (*stream == qmp_type); // is really a forward qmp stream
+ dbg_assert_ptr (qmp);
+
+ qmp->forward_or_reverse = qmp_type;
+
+ packet = (data_qmp_t*)(stream);
+
+ while ( (packet->forward_or_reverse == qmp_type) && ( (u8*)packet < stream_end))
+ {
+ u8 index;
+
+ dbg_assert_ptr(packet);
+
+ index = qmp_get_index_from_fid(packet->fid);
+
+ qmp_copy_from_stream[index]((u8*)(packet->data), qmp);
+
+ len = packet->qmp_len;
+ packet = (data_qmp_t *)((u8*)(packet)+(len) + 3);
+ }
+
+ cp_dbg_qmp(*qmp);
+ return (len_t)((u8*)packet-stream);
+}
+
+
+
+/**
+ * Set QMP field on stream.
+ *
+ * \param stream Data destination.
+ * \param qmp Data source.
+ * \return Length of the data.
+ */
+len_t
+msg_field_qmp_set_on_stream(u8 * stream, qmp_t* qmp)
+{
+ len_t len = 0;
+ int qmp_field_i;
+ u8 * local_stream = stream;
+
+ dbg_assert_ptr(stream);
+ dbg_assert_ptr(qmp);
+ cp_dbg_qmp(*qmp);
+
+ for(qmp_field_i = 0; qmp_field_i < 32; qmp_field_i++ )
+ {
+ if ( ( (0x01<< qmp_field_i) & qmp->valid_in_block ) != 0)
+ {
+ len += qmp_copy_from_qmp[qmp_field_i](qmp, local_stream);
+
+ local_stream = stream + len;
+ }
+
+ }
+
+ return len;
+}
+
+
diff --git a/cesar/cp/msg/src/msg.c b/cesar/cp/msg/src/msg.c
new file mode 100644
index 0000000000..b5eb37cdca
--- /dev/null
+++ b/cesar/cp/msg/src/msg.c
@@ -0,0 +1,336 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/msg.c
+ * \brief MME message processing
+ * \ingroup cp_msg
+ */
+
+#include "common/std.h"
+
+#include "cp/beacon/inc/bentry.h"
+#include "cp/beacon/inc/beacons_ctx.h"
+#include "cp/beacon/forward.h"
+#include "cp/beacon/inc/beacons_work.h"
+
+#include "cp/msg/msg.h"
+
+/*
+ * this array describe messages, their prefered destination and the function
+ * which process it.
+ * the array must be ordered on the first field of each line.
+ */
+const msg_list_mme_t msg_list_m[] =
+ {
+ { CC_CCO_APPOINT_REQ, 0 },
+ { CC_CCO_APPOINT_CNF, 0 },
+ { CC_BACKUP_APPOINT_REQ, 0 },
+ { CC_BACKUP_APPOINT_CNF, 0 },
+ { CC_LINK_INFO_REQ, 0 },
+ { CC_LINK_INFO_CNF, 0 },
+ { CC_LINK_INFO_IND, 0 },
+ { CC_LINK_INFO_RSP, 0 },
+ { CC_HANDOVER_REQ, 0 },
+ { CC_HANDOVER_CNF, 0 },
+ { CC_HANDOVER_INFO_IND, 0 },
+ { CC_HANDOVER_INFO_RSP, 0 },
+ // TBC ...
+ {CC_ASSOC_REQ, RECEIVE_CC_ASSOC_REQ},
+ {CC_ASSOC_CNF, RECEIVE_CC_ASSOC_CNF},
+ {CC_SET_TEI_MAP_REQ, RECEIVE_CC_SET_TEI_MAP_REQ},
+ {CC_SET_TEI_MAP_IND, RECEIVE_CC_SET_TEI_MAP_IND},
+
+ { CM_UNASSOCIATED_STA_IND, RECEIVE_USTA_MME},
+ // TBC ...
+
+ {DRV_STA_SET_MAC_ADDR_REQ, RECEIVE_DRV_SET_MAC_ADDRESS},
+ {DRV_STA_SET_CCO_PREF_REQ, RECEIVE_DRV_SET_CCO_PREFERENCE_REQ},
+ {DRV_STA_SET_WAS_CCO_REQ, RECEIVE_DRV_SET_WAS_CCO},
+ {DRV_STA_SET_NPW_REQ, RECEIVE_DRV_SET_NPW_REQ},
+ {DRV_STA_SET_DPW_REQ, RECEIVE_DRV_SET_DPW_REQ},
+ {DRV_STA_SET_SL_REQ, RECEIVE_DRV_SET_SL},
+ {DRV_STA_SET_M_STA_HFID_REQ, RECEIVE_DRV_SET_M_STA_HFID},
+ {DRV_STA_SET_U_STA_HFID_REQ, RECEIVE_DRV_SET_U_STA_HFID},
+ {DRV_STA_SET_AVLN_HFID_REQ, RECEIVE_DRV_SET_AVLN_HFID},
+ {DRV_STA_SET_TONEMASK_REQ, RECEIVE_DRV_SET_TONEMASK},
+ {DRV_STA_START_REQ, RECEIVE_DRV_MAC_START_REQ},
+ {DRV_STA_STOP_REQ, RECEIVE_DRV_MAC_STOP_IND}
+ /*
+ {DRV_STA_SET_NID_REQ, RECEIVE_DRV_SET_NID},
+ {DRV_STA_SET_SNID_REQ, RECEIVE_DRV_SET_SNID},
+ */
+ };
+
+const char *cst_str_drv_mme_req[] = {
+ "DRV_STA_SET_MAC_ADDR.REQ",
+ "DRV_STA_SET_CCO_PREF.REQ",
+ "DRV_STA_SET_WAS_CCO.REQ",
+ "DRV_STA_SET_NPW.REQ",
+ "DRV_STA_SET_DPW.REQ",
+ "DRV_STA_SET_SL.REQ",
+ "DRV_STA_SET_M_STA_HFID.REQ",
+ "DRV_STA_SET_U_STA_HFID.REQ",
+ "DRV_STA_SET_AVLN_HFID.REQ",
+ "DRV_STA_SET_TONEMASK.REQ",
+ "DRV_STA_START.REQ",
+ "DRV_STA_STOP.REQ"
+};
+
+const char *cst_str_drv_mme_cnf[] = {
+ "DRV_STA_SET_MAC_ADDR.CNF",
+ "DRV_STA_SET_CCO_PREF.CNF",
+ "DRV_STA_SET_WAS_CCO.CNF",
+ "DRV_STA_SET_NPW.CNF",
+ "DRV_STA_SET_DPW.CNF",
+ "DRV_STA_SET_SL.CNF",
+ "DRV_STA_SET_M_STA_HFID.CNF",
+ "DRV_STA_SET_U_STA_HFID.CNF",
+ "DRV_STA_SET_AVLN_HFID.CNF",
+ "DRV_STA_SET_TONEMASK.CNF",
+ "DRV_STA_START.CNF",
+ "DRV_STA_STOP.CNF"
+};
+
+// this is the fmsn that will be used in fragmented mme
+static u8 fmsn_m;
+
+void msg_init(void)
+{
+#if DEBUG == 0
+ uint i;
+ for(i=1 ; i<COUNT(msg_list_m) ; i++)
+ dbg_assert(msg_list_m[i].mm_type > msg_list_m[i-1].mm_type);
+#endif
+ fmsn_m = 0;
+ msg_cm_init();
+}
+
+u8
+msg_get_fmsn(const bool new)
+{
+ printf ("%u %s()...\n",cyg_hal_sys_getpid(),__FUNCTION__);
+ // TODO the question is : is it possible to have 2 thread accessing this
+ // function at the same time ?
+ if(new) fmsn_m++;
+ return fmsn_m;
+}
+
+u16
+msg_get_number (msg_mme_t *msg)
+{
+ msg_mme_b_t * msg_b;
+ u16 mme_num;
+ u16 ret = MSG_UNKNOW;
+
+ printf ("%u %s() : DEBUT...\n",cyg_hal_sys_getpid(),__FUNCTION__);
+ dbg_assert ( !msg_check_wrong_mme_const_values (msg));
+ msg_b = (msg_mme_b_t *)msg;
+ printf ("%u %s() : VERIF... msg->m_type = 0x%04x ; msg_b->m_type = 0x%04x\n",cyg_hal_sys_getpid(),__FUNCTION__,big_to_cpuhost_endian_u16(msg->m_type),big_to_cpuhost_endian_u16(msg_b->m_type));
+ //TODO this is maybe not very efficient, to check with more messages ...
+ if (big_to_cpuhost_endian_u16(msg->m_type) == MSG_MTYPE_IEEE_ETHERTYPE)
+ {
+ printf ("%u %s() : DICHOTOMY sur msg->mm_type 0x%04x...\n",cyg_hal_sys_getpid(),__FUNCTION__,msg->mm_type);
+ DICHOTOMY_SEARCH(0, COUNT(msg_list_m), mme_num, msg->mm_type <= msg_list_m[mme_num].mm_type);
+ printf("%u requested msg : 0x%04x, index found : %i\n",cyg_hal_sys_getpid(), msg->mm_type, mme_num);
+ if(msg->mm_type != msg_list_m[mme_num].mm_type)
+ {
+ printf ("%u %s() : FIN. ; MSG_UNKNOW !\n",cyg_hal_sys_getpid(),__FUNCTION__);
+ ret = MSG_UNKNOW;
+ }
+ else
+ {
+ printf ("%u %s() : FIN. ; mme_num = %i (0x%04x)\n",cyg_hal_sys_getpid(),__FUNCTION__,mme_num,mme_num);
+ ret = mme_num;
+ }
+ }
+ else if ((big_to_cpuhost_endian_u16(msg_b->m_type) == MSG_MTYPE_IEEE_ETHERTYPE))
+ {
+ printf ("%u %s() : DICHOTOMY sur msg_b->mm_type 0x%04x...\n",cyg_hal_sys_getpid(),__FUNCTION__,msg_b->mm_type);
+ DICHOTOMY_SEARCH(0, COUNT(msg_list_m), mme_num, msg_b->mm_type <= msg_list_m[mme_num].mm_type);
+ printf ("%u requested msg : 0x%04x, index found : %i\n",cyg_hal_sys_getpid(), msg_b->mm_type, mme_num);
+ if(msg_b->mm_type != msg_list_m[mme_num].mm_type)
+ {
+ printf ("%u %s() : FIN. ; MSG_UNKNOW !\n",cyg_hal_sys_getpid(),__FUNCTION__);
+ ret = MSG_UNKNOW;
+ }
+ else
+ {
+ printf ("%u %s() : FIN. ; mme_num = %i (0x%04x)\n",cyg_hal_sys_getpid(),__FUNCTION__,mme_num,mme_num);
+ ret = mme_num;
+ }
+ }
+ else
+ {
+ printf ("%u %s() : FIN. ; ERREUR (mme_num = %i (0x%04x) !!!\n",cyg_hal_sys_getpid(),__FUNCTION__,mme_num,mme_num);
+ }
+ return ret;
+}
+
+//void
+//msg_dispatch (msg_mme_t *msg)
+void
+msg_dispatch (msg_ctx_t *msg_ctx)
+{
+ msg_mme_t *msg;
+ msg_mme_b_t *msg_b;
+ u16 mme_num;
+
+ printf ("%u %s() : DEBUT...\n",cyg_hal_sys_getpid(),__FUNCTION__);
+
+ dbg_assert(msg_ctx);
+ dbg_assert(msg_ctx->buffer);
+ msg = (msg_mme_t *)msg_ctx->buffer;
+ msg_b = (msg_mme_b_t *)msg;
+
+ dbg_assert ( !msg_check_wrong_mme_const_values (msg));
+ mme_num = msg_get_number (msg);
+ printf ("%u %s() : suite... ; mme_num = %i (0x%04x)\n",cyg_hal_sys_getpid(),__FUNCTION__,mme_num,mme_num);
+ if (mme_num != MSG_UNKNOW)
+ {
+ dbg_assert(msg_list_m[mme_num].msg_num);
+ cp_station_add_event(msg_list_m[mme_num].msg_num, (void *) msg_ctx);
+ }
+ // release the message's buffer(s)
+// interf_release_buf(msg);
+ printf ("%u %s() : FIN.\n",cyg_hal_sys_getpid(),__FUNCTION__);
+}
+
+void
+msg_set_mme_const_values (msg_mme_t *msg)
+{
+ dbg_assert (msg);
+
+ msg->m_type = cpuhost_to_big_endian_u16(MSG_MTYPE); // 11.1.4
+ msg->mmv = MSG_MM_VERSION;
+ #if CHECK_BUFFER_OVERFLOW
+ interf_buffer_t *buffer = NULL;
+ buffer = PARENT_OF(interf_buffer_t, msg, msg);
+ buffer->signature = BUFFER_SIGNATURE;
+ #endif
+}
+
+bool
+msg_check_wrong_mme_const_values (const msg_mme_t *msg)
+{int i; u8 *p = (u8*)msg;
+ msg_mme_b_t *msg_b;
+
+ printf ("%u %s()...\n",cyg_hal_sys_getpid(),__FUNCTION__);
+ for (i=0;i<1;i++)printf("msg = 0x%08lx ",(unsigned long)msg);printf("\n");
+ dbg_assert (msg);
+
+ msg_b = (msg_mme_b_t *)msg;
+
+ #if CHECK_BUFFER_OVERFLOW
+ interf_buffer_t *buffer = NULL;
+ buffer = PARENT_OF(interf_buffer_t, msg, msg);
+ dbg_assert(buffer->signature == BUFFER_SIGNATURE);
+ #endif
+
+ for (i= 0;i<16;i++)printf("%02x.",p[i]);printf("\n");
+ for (i=16;i<32;i++)printf("%02x.",p[i]);printf("\n");
+ for (i=32;i<48;i++)printf("%02x.",p[i]);printf("\n");
+ for (i=48;i<64;i++)printf("%02x.",p[i]);printf("\n");
+ printf("%u %s() : msg->m_type = 0x%04x\n",cyg_hal_sys_getpid(),__FUNCTION__,big_to_cpuhost_endian_u16(msg->m_type));
+ printf("%u %s() : msg_b->m_type = 0x%04x\n",cyg_hal_sys_getpid(),__FUNCTION__,big_to_cpuhost_endian_u16(msg_b->m_type));
+ if (big_to_cpuhost_endian_u16(msg->m_type) == MSG_MTYPE)
+ for (i=0;i<1;i++)printf("msg->m_type = 0x%04x ; msg->mm_type = 0x%04x",big_to_cpuhost_endian_u16(msg->m_type),msg->mm_type);
+ else if (big_to_cpuhost_endian_u16(msg_b->m_type) == MSG_MTYPE)
+ for (i=0;i<1;i++)printf("msg->m_type = 0x%04x ; msg->mm_type = 0x%04x",big_to_cpuhost_endian_u16(msg_b->m_type),msg_b->mm_type);
+ else
+ for (i=0;i<1;i++)printf("msg->m_type = 0x???? ; msg->mm_type = 0x????");
+ printf("\n");
+
+ return ((big_to_cpuhost_endian_u16(msg->m_type) != MSG_MTYPE) && (big_to_cpuhost_endian_u16(msg_b->m_type) != MSG_MTYPE));
+}
+
+msg_mme_t *
+msg_sending_common_part(msg_mme_t *msg, const mac_address_t oda, msg_param_t *msg_param)
+{
+ dbg_assert(msg);
+ dbg_assert(msg_param);
+
+ // ask for a buffer
+ //msg = interf_give_buf ();
+ //dbg_assert ( !msg_check_wrong_mme_const_values (msg));
+ // set the header values of msg
+ memcpy(msg->oda, oda, sizeof(mac_address_t));
+ //memcpy(msg->osa, station_get_mac_address(), sizeof(mac_address_t));
+ cp_station_get_mac_address(NULL,&msg->osa); //TODO : pass CP ctx as first argument instead of NULL pointer...
+ // vlan is optional and not used
+ msg->m_type = cpuhost_to_big_endian_u16(MSG_MTYPE); // 11.1.4
+ msg->mmv = MSG_MM_VERSION;
+ // set fragmentation default values
+ msg->fmi.nf_mi = 0;
+ msg->fmi.fn_mi = 0;
+ msg->fmi.fmsn = 0;
+ // set the default message parameters
+ memset(msg_param, 0, sizeof(msg_param_t));
+ msg_param->encryption = HARDWARE_ENCRYPTED;
+ msg_param->peks = NOT_ENCRYPTED;
+ return msg;
+}
+
+void
+msg_send(msg_mme_t *msg, u16 msg_size, msg_param_t msg_param)
+{
+ tei_t tei;
+
+ dbg_assert ( !msg_check_wrong_mme_const_values (msg));
+ dbg_assert(msg_size <= ETH_PACKET_MAX_SIZE);
+
+ // find the tei of the ODA
+ tei = cp_station_find_tei_from_mac(msg->oda);
+ // check if the message is software encrypted
+ if(msg_param.encryption == SOFTWARE_ENCRYPTED)
+ {
+
+ }
+ else
+ {
+ // and then, send the message
+ interf_send (msg, msg_size, msg_param, tei);
+ }
+}
+
+/**
+ * \brief Get DRV-MME .REQ message name
+ *
+ * \param cnf the REQ message type identifier
+ * \return the .REQ message name string constant
+ */
+char *
+get_str_drv_mme_req(int req)
+{
+ return (char*)cst_str_drv_mme_req[req];
+}
+
+/**
+ * \brief Get DRV-MME .CNF message name
+ *
+ * \param cnf the CNF message type identifier
+ * \return the .CNF message name string constant
+ */
+char *
+get_str_drv_mme_cnf(int cnf)
+{
+ return (char*)cst_str_drv_mme_cnf[cnf];
+}
+
+#if 0
+/**
+ * \brief Get a message type name string
+ *
+ * \param mmtype the message type identifier
+ * \return the message type name string constant
+ */
+char *
+get_str_mmtype(u16 mmtype)
+{
+ return (char*)cst_str_drv_mme_cnf[cnf];
+}
+#endif
diff --git a/cesar/cp/msg/src/msg_apcm.c b/cesar/cp/msg/src/msg_apcm.c
new file mode 100644
index 0000000000..9aee40a5c3
--- /dev/null
+++ b/cesar/cp/msg/src/msg_apcm.c
@@ -0,0 +1,16 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file msg_apcm.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+
+
diff --git a/cesar/cp/msg/src/msg_cc.c b/cesar/cp/msg/src/msg_cc.c
new file mode 100644
index 0000000000..cdee5d9a46
--- /dev/null
+++ b/cesar/cp/msg/src/msg_cc.c
@@ -0,0 +1,141 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/msg_cc.c
+ * \brief
+ * \ingroup cp_msg
+ */
+
+#include "common/std.h"
+
+#include "cp/beacon/inc/bentry.h"
+#include "cp/beacon/inc/beacons_ctx.h"
+#include "cp/beacon/forward.h"
+#include "cp/beacon/inc/beacons_work.h"
+
+#include "cp/msg/inc/msg_cc.h"
+
+
+
+void msg_cc_assoc_req_send(const mac_address_t oda)
+{
+/* msg_mme_t *msg;
+ cc_assoc_req_t *cc_assoc_req;
+ msg_param_t msg_param;
+
+ msg = msg_sending_common_part(oda, &msg_param);
+ msg->mm_type = CC_ASSOC_REQ;
+ // set the message values ( 11.2.28 )
+ cc_assoc_req = (cc_assoc_req_t *) & msg->mm_entry;
+ cc_assoc_req->cco_capability = station_get_cco_capa();
+ cc_assoc_req->nid = station_get_nid();
+ cc_assoc_req->proxy_networking_capability = 0;
+ cc_assoc_req->req_type = 0;
+ // set the message parameters
+ msg_param.encryption = NOT_ENCRYPTED;
+ // and then, send the message
+ msg_send(msg, sizeof(cc_assoc_req_t) + MSG_MME_HEADER_SIZE, msg_param);
+ */
+}
+
+void msg_cc_assoc_cnf_send(const mac_address_t oda, const u8 result, const tei_t sta_tei, const u16 lease_time)
+{
+/* msg_mme_t *msg;
+ cc_assoc_cnf_t *cc_assoc_cnf;
+ msg_param_t msg_param;
+
+ msg = msg_sending_common_part(oda, &msg_param);
+ msg->mm_type = CC_ASSOC_CNF;
+ // set the message values ( 11.2.29 )
+ cc_assoc_cnf = (cc_assoc_cnf_t *) & msg->mm_entry;
+ cc_assoc_cnf->result = result;
+ cc_assoc_cnf->nid = station_get_nid();
+ cc_assoc_cnf->snid = station_get_snid();
+ cc_assoc_cnf->sta_tei = sta_tei;
+ cc_assoc_cnf->lease_time = lease_time;
+ // set the message parameters
+ msg_param.encryption = NOT_ENCRYPTED;
+ // and then, send the message
+ msg_send(msg, sizeof(cc_assoc_cnf_t) + MSG_MME_HEADER_SIZE, msg_param);
+*/
+}
+
+void
+msg_cc_set_tei_map_ind_send(const mac_address_t oda, const u8 mode, const tei_t tei, const bool recall)
+{/*
+ // 11.2.35
+ msg_mme_t *msg;
+ cc_set_tei_map_ind_t *cc_set_tei_map_ind;
+ msg_param_t msg_param;
+ u8 number_sta;
+ int i;
+ static tei_t m_tei;
+ tei_t next_tei;
+ station_t sta;
+
+ // TODO remove printf
+ //printf("msg_cc_set_tei_map_ind_send oda : %c%c%c%c%c%c, mode : %i\n", oda[0], oda[1], oda[2], oda[3], oda[4], oda[5], mode);
+ msg = msg_sending_common_part(oda, &msg_param);
+ msg->mm_type = CC_SET_TEI_MAP_IND;
+ // set the message values ( 11.2.35 )
+ cc_set_tei_map_ind = (cc_set_tei_map_ind_t *) & msg->mm_entry;
+ cc_set_tei_map_ind->mode = mode;
+ if(mode == 0)
+ {
+ msg_param.encryption = NOT_ENCRYPTED;
+ number_sta = station_get_number_of_assoc();
+ if( ! recall)
+ {
+ // first time that the function is called
+ if(number_sta < SET_TEI_MAP_SUB_NB_ELEM)
+ {
+ cc_set_tei_map_ind->num = number_sta;
+ }
+ else
+ {
+ msg->fmi.nf_mi = 1;
+ msg->fmi.fn_mi = 0;
+ msg->fmi.fmsn = msg_get_fmsn(true);
+ cc_set_tei_map_ind->num = SET_TEI_MAP_SUB_NB_ELEM;
+ }
+ }
+ else
+ {
+ cc_set_tei_map_ind->num = number_sta - SET_TEI_MAP_SUB_NB_ELEM;
+ msg->fmi.nf_mi = 1;
+ msg->fmi.fn_mi = 1;
+ msg->fmi.fmsn = msg_get_fmsn(false);
+ }
+ }
+ else // mode != 0
+ {
+ msg_param.encryption = HARDWARE_ENCRYPTED;
+ number_sta = 1;
+ cc_set_tei_map_ind->num = 1;
+ }
+ if( ! recall) m_tei = tei;
+ for(i=0 ; i<number_sta ; i++)
+ {
+ if( ( ! tei) && ( ! i ) && ( ! recall) )
+ next_tei = station_get_associate_info(&sta, true , 0);
+ else
+ next_tei = station_get_associate_info(&sta, false , m_tei);
+ memcpy(cc_set_tei_map_ind->sub[i].mac_address, sta.mac_address, sizeof(mac_address_t));
+ if(sta.station_status == STATION_ASSOCIATED)
+ cc_set_tei_map_ind->sub[i].status = 0x0;
+ else cc_set_tei_map_ind->sub[i].status = 0x1;
+ cc_set_tei_map_ind->sub[i].tei = m_tei;
+ m_tei = next_tei;
+ }
+ // set the message parameters
+ //msg_param.mnbf = 0;
+ // and then, send the message
+ msg_send(msg, MSG_MME_HEADER_SIZE + 2 + number_sta * sizeof(cc_set_tei_map_ind_sub_t), msg_param);
+*/
+}
+
diff --git a/cesar/cp/msg/src/msg_cm.c b/cesar/cp/msg/src/msg_cm.c
new file mode 100644
index 0000000000..3795fe2828
--- /dev/null
+++ b/cesar/cp/msg/src/msg_cm.c
@@ -0,0 +1,273 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/msg_cm.c
+ * \brief
+ * \ingroup cp_msg
+ */
+
+#include "common/std.h"
+
+#include "cp/beacon/inc/bentry.h"
+#include "cp/beacon/inc/beacons_ctx.h"
+#include "cp/beacon/forward.h"
+#include "cp/beacon/inc/beacons_work.h"
+
+#include "cp/msg/inc/msg_cm.h"
+#include "lib/crc.h"
+
+
+static crc_t crc_m;
+static u32 *crc_table[256];
+
+void
+msg_cm_init(void)
+{
+ // init the CRC context (CRC used in cm_encrypted_payload)
+ crc_m.width = 32;
+ crc_m.generator = 0x4C11DB7; //4.2.1
+ crc_m.init = 0xFFFFFFFF;
+ crc_m.refin = true;
+ crc_m.refout = true;
+ crc_m.xorout = 0xFFFFFFFF;
+ crc_m.table.t32 = (u32 *) crc_table;
+ crc_m.reg_init = 0;
+ crc_init(&crc_m);
+}
+
+void
+msg_cm_unassociated_sta_ind_send(const mac_address_t oda)
+{
+ // 11.5.1
+ msg_mme_t *msg_p, *msg_to_send;
+ cm_unassociated_sta_t *unassociated_sta_p;
+ msg_param_t msg_param;
+ u8 buffer[1518];
+
+ msg_p = msg_sending_common_part((msg_mme_t *)buffer, oda, &msg_param);
+ msg_p->mm_type = CM_UNASSOCIATED_STA_IND;
+ // set the message values
+ unassociated_sta_p = (cm_unassociated_sta_t *) & msg_p->mm_entry;
+ unassociated_sta_p->nid = cp_station_get_nid(NULL); //TODO : pass CP ctx as first argument instead of NULL pointer...
+ unassociated_sta_p->cco_capability = cp_station_get_cco_capa();
+ // set the mnbf flag
+ msg_param.mnbf = 1;
+ msg_param.encryption = NOT_ENCRYPTED;
+ // and finaly, send the message
+ printf(" send cm_unassociated_sta\n");
+ msg_to_send = interf_give_buf ();
+ dbg_assert ( !msg_check_wrong_mme_const_values (msg_to_send));
+ //msg_cm_unassociated_sta_ind_convert((u8 *)msg_to_send, msg_p, BITSTREAM_WRITE);
+ msg_send(msg_p, sizeof(cm_unassociated_sta_t) + MSG_MME_HEADER_SIZE, msg_param);
+}
+
+// set the following flag to 1 if you want to
+// test the message as on page 681
+#define TEST_681 0
+
+void
+msg_cm_encrypted_payload_ind_send(
+ const msg_mme_t *encapsulated_msg_p,
+ const msg_param_t encapsulated_msg_param,
+ const tei_t tei,
+ const bool last_msg_of_p_run,
+ const cp_pid_t pid,
+ const u16 msg_size
+ )
+{
+ // 11.5.2
+ msg_mme_t *msg_p;
+ cm_encrypted_payload_t *cm_encrypted_payload_p;
+ cm_encrypted_payload_sub_t *cm_encrypted_payload_sub_p;
+ msg_param_t msg_param;
+ cp_station_status_t station_status;
+ protocol_run_t pr_run;
+ u8 rf, i, pad_size;
+ aes_key_t *aes_key_p;
+ aes_context ctx;
+ u16 total_msg_size = msg_size + sizeof(cm_encrypted_payload_t) - COUNT(cm_encrypted_payload_p->rf) + 9;
+ u8 buffer[1518], data_to_encrypt[1518];
+ int *int_p;
+ u8 iv[16];
+
+ dbg_assert ( !msg_check_wrong_mme_const_values (encapsulated_msg_p));
+ dbg_assert(tei != 0 && tei != 0xFF);
+ dbg_assert(pid <= HLE_PRO);
+ dbg_assert(msg_size < (sizeof(msg_mme_t) - sizeof(cm_encrypted_payload_t) - sizeof(cm_encrypted_payload_sub_t)));
+
+
+ msg_p = msg_sending_common_part((msg_mme_t *)buffer, encapsulated_msg_p->oda, &msg_param);
+ msg_p->mm_type = CM_ENCRYPTED_PAYLOAD_IND;
+ // set the message values
+ cm_encrypted_payload_p = (cm_encrypted_payload_t *) & msg_p->mm_entry;
+ // set the message values...
+ cm_encrypted_payload_p->peks = encapsulated_msg_param.peks;
+ // set the avln status of the station
+ station_status = cp_station_get_status();
+ #if TEST_681
+ station_status = 5;
+ #endif
+ if(station_status == STATION_UNASSOCIATED)
+ {
+ cm_encrypted_payload_p->avln_status = cp_station_get_cco_capa();
+ }
+ else
+ {
+ if(cp_station_get_is_cco())
+ {
+ cm_encrypted_payload_p->avln_status = 0x08;
+ }
+ else
+ {
+ // the station is assosciated
+ cm_encrypted_payload_p->avln_status = 0x04;
+ if(cp_station_get_pcco_capa()) cm_encrypted_payload_p->avln_status = 0x05;
+ }
+ }
+ // set the protocol run parameters
+ if(secu_gen_protocol_run_param(tei, last_msg_of_p_run, &pr_run) == PRN_NotInitialised)
+ {
+ secu_start_new_protocol_run(tei, pid, &pr_run);
+ secu_gen_protocol_run_param(tei, last_msg_of_p_run, &pr_run);
+ #if TEST_681
+ pr_run.pmn = 3;
+ pr_run.prn = 0x372D;
+ #endif
+ }
+ cm_encrypted_payload_p->pid = pr_run.pid;
+ cm_encrypted_payload_p->prn = pr_run.prn;
+ cm_encrypted_payload_p->pmn = pr_run.pmn;
+ cm_encrypted_payload_p->len = msg_size;
+ if(pid == HLE_PRO) // case PID == 0x4
+ {
+ // calculate the UUID field as specified in rfc4122 chap 4.4
+ int_p = (int *)cm_encrypted_payload_p->iv;
+ for(i=0 ; i<4 ; i++)
+ {
+ *int_p = rand_in(0, 0);
+ int_p++;
+ }
+ cm_encrypted_payload_p->iv[8] &= 0xBF;
+ cm_encrypted_payload_p->iv[8] |= 0x80;
+ cm_encrypted_payload_p->iv[6] = 0x4;
+ cm_encrypted_payload_p->iv[7] = 0x0;
+ // case PID == 0x4 implies no random filer
+ rf = 0;
+ memcpy(cm_encrypted_payload_p->rf, encapsulated_msg_p, msg_size);
+ }
+ else
+ {
+ // set the IV field (16 random bytes)
+ int_p = (int *) iv;
+ for(i=0 ; i<4 ; i++)
+ {
+ *int_p = rand_in(0, 0);
+ int_p++;
+ }
+ #if TEST_681
+ memcpy(iv, "\xFE\xDC\xBA\x98\x76\x54\x32\x10\xFE\xDC\xBA\x98\x76\x54\x32\x10", 16);
+ #endif
+ memcpy(cm_encrypted_payload_p->iv, iv, 16);
+ // calculate the rf filler size
+ rf = rand_in(0, COUNT(cm_encrypted_payload_p->rf));
+ // fill the rf field with random data
+ for(i=0 ; i<rf ; i++)
+ data_to_encrypt[i] = (u8) rand_in(0, 0xFF);
+ #if TEST_681
+ rf = 5;
+ data_to_encrypt[0] = 0x24;
+ data_to_encrypt[1] = 0x68;
+ data_to_encrypt[2] = 0xac;
+ data_to_encrypt[3] = 0xe0;
+ data_to_encrypt[4] = 0x35;
+ #endif
+ memcpy(&data_to_encrypt[rf], encapsulated_msg_p, msg_size);
+ cm_encrypted_payload_sub_p = (cm_encrypted_payload_sub_t *) &data_to_encrypt[i+msg_size];
+ // calculate CRC of the encapsulated mme
+ cm_encrypted_payload_sub_p->crc = crc_compute_block(&crc_m, (u8 *)encapsulated_msg_p, msg_size);
+ cm_encrypted_payload_sub_p->pid = pid;
+ cm_encrypted_payload_sub_p->prn = pr_run.prn;
+ cm_encrypted_payload_sub_p->pmn = pr_run.pmn;
+ pad_size = 16 - (msg_size + rf + 9) % 16;
+ for(i=0 ; i < pad_size ; i++)
+ cm_encrypted_payload_sub_p->padding[i] = (u8) rand_in(0, 0xFF);
+ #if TEST_681
+ cm_encrypted_payload_sub_p->padding[0] = 0xac ;
+ cm_encrypted_payload_sub_p->padding[1] = 0xbc ;
+ cm_encrypted_payload_sub_p->padding[2] = 0xd2 ;
+ cm_encrypted_payload_sub_p->padding[3] = 0x11 ;
+ cm_encrypted_payload_sub_p->padding[4] = 0x4d ;
+ cm_encrypted_payload_sub_p->padding[5] = 0xae ;
+ cm_encrypted_payload_sub_p->padding[6] = 0x15 ;
+ cm_encrypted_payload_sub_p->padding[7] = 0x77 ;
+ cm_encrypted_payload_sub_p->padding[8] = 0xc6 ;
+ #endif
+ cm_encrypted_payload_sub_p->padding[i] = rf;
+ aes_key_p = secu_get_ek_from_peks(encapsulated_msg_param.peks, tei);
+ aes_set_key(&ctx, (u8 *) aes_key_p, sizeof(aes_key_t)*8);
+ aes_cbc_encrypt (&ctx, iv, data_to_encrypt, cm_encrypted_payload_p->rf+rf, rf+msg_size+pad_size+9);
+ total_msg_size += rf + pad_size;
+ }
+ // set the mnbf flag
+ msg_param.encryption = NOT_ENCRYPTED;
+ // and finaly, send the message
+ msg_send(msg_p, total_msg_size, msg_param);
+
+}
+
+
+/*
+void
+msg_cm_conn_new_req_send(msg_cm_conn_new_req_t msg)
+{
+ // msg_mme_t *msg;
+ // cm_conn_new_req_t
+}
+
+void
+msg_cm_conn_new_cnf_send()
+{
+
+}
+
+void
+msg_cm_conn_rel_ind_send()
+{
+
+}
+
+void
+msg_cm_conn_rel_rsp_send()
+{
+
+}
+
+void
+msg_cm_conn_mod_req_send()
+{
+
+}
+
+void
+msg_cm_conn_mod_cnf_send()
+{
+
+}
+
+void
+msg_cm_conn_info_req_send()
+{
+
+}
+
+void
+msg_cm_conn_info_cnf_send()
+{
+
+}
+*/
diff --git a/cesar/cp/msg/src/msg_cm_convert.c b/cesar/cp/msg/src/msg_cm_convert.c
new file mode 100644
index 0000000000..b009db35f5
--- /dev/null
+++ b/cesar/cp/msg/src/msg_cm_convert.c
@@ -0,0 +1,65 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/msg_cm.c
+ * \brief
+ * \ingroup cp_msg
+ */
+
+#include "common/std.h"
+
+#include "cp/beacon/inc/bentry.h"
+#include "cp/beacon/inc/beacons_ctx.h"
+#include "cp/beacon/forward.h"
+#include "cp/beacon/inc/beacons_work.h"
+
+#include "cp/msg/inc/msg_cm_convert.h"
+
+void
+msg_mme_header_convert(u8 *buffer, msg_mme_t *msg, bitstream_type_t b_type, bitstream_t ctx)
+{/*
+ dbg_assert(buffer);
+ dbg_assert(msg);
+ u8 tmp;
+
+ bitstream_access(&ctx, &msg->oda, 48);
+ bitstream_access(&ctx, &msg->osa, 48);
+ //bitstream_access(&ctx, &msg->v_lan_tag, 32);
+ bitstream_access(&ctx, &msg->m_type, 16);
+ bitstream_access(&ctx, &msg->mmv, 8);
+ bitstream_access(&ctx, &msg->mm_type, 16);
+ tmp = msg->fmi.nf_mi;
+ bitstream_access(&ctx, &tmp, 4);
+ if(b_type == BITSTREAM_READ) msg->fmi.nf_mi = tmp;
+ tmp = msg->fmi.fn_mi;
+ bitstream_access(&ctx, &tmp, 4);
+ if(b_type == BITSTREAM_READ) msg->fmi.fn_mi = tmp;
+ bitstream_access(&ctx, &msg->fmi.fmsn, 8);
+*/
+}
+
+void
+msg_cm_unassociated_sta_ind_convert(u8 *buffer, msg_mme_t *msg, bitstream_type_t read)
+{// 11.5.1
+
+ bitstream_t ctx;
+ cm_unassociated_sta_t *entry_p;
+
+ dbg_assert(buffer);
+ dbg_assert(msg);
+
+ bitstream_init(&ctx, buffer, 1518, read);
+
+ msg_mme_header_convert(buffer, msg, read, ctx);
+ entry_p = ( cm_unassociated_sta_t *) msg->mm_entry;
+ bitstream_access(&ctx, &entry_p->nid, 2); // this is just to read the 2 non significant bits
+ bitstream_access(&ctx, &entry_p->nid, 54);
+ bitstream_access(&ctx, &entry_p->cco_capability, 1);
+
+ bitstream_finalise(&ctx); // don't forget it to write the last word
+}
diff --git a/cesar/cp/msg/src/msg_drv.c b/cesar/cp/msg/src/msg_drv.c
new file mode 100644
index 0000000000..60533040a5
--- /dev/null
+++ b/cesar/cp/msg/src/msg_drv.c
@@ -0,0 +1,497 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2008 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}} */
+/**
+ * \file cp/msg/src/msg_drv.c
+ * \brief « brief description »
+ * \ingroup « module »
+ *
+ * « long description »
+ */
+#include <stdio.h>
+#include <string.h>
+#include "common/std.h"
+#include "lib/bitstream.h"
+#include "cp/secu/inc/secu_types.h"
+#include "cp/msg/inc/msg_const.h"
+#include "cp/msg/inc/msg_drv.h"
+
+const char *cst_str_drv_mme_cnf_result[] = {
+ "FAILURE",
+ "SUCCESS"
+};
+
+const char *cst_str_drv_mme_cnf_errcode[] = {
+ "BAD PARAMETER",
+ "UNKNOWN ID",
+ "INVALID VALUE"
+};
+
+const char *cst_str_yes_no[] = {
+ "no",
+ "yes"
+};
+
+
+/**
+ * \brief Get DRV-MME .CNF message result string
+ *
+ * \param cnf_result the result code
+ * \return the result code string constant
+ */
+char *
+get_str_drv_mme_cnf_result(int cnf_result)
+{
+ return (char*)cst_str_drv_mme_cnf_result[cnf_result];
+}
+
+/**
+ * \brief Get DRV-MME .CNF message error code string
+ *
+ * \param cnf_errcode the error code
+ * \return the error code string constant
+ */
+char *
+get_str_drv_mme_cnf_errcode(int cnf_errcode)
+{
+ return (char*)cst_str_drv_mme_cnf_errcode[cnf_errcode];
+}
+
+/**
+ * \brief Get yes/no string.
+ *
+ * \param no_yes the index of yes/no string array
+ * \return the yes or no string constant
+ */
+char *
+get_str_yes_no(int no_yes)
+{
+ return (char*)cst_str_yes_no[no_yes];
+}
+
+/**
+ * \brief Verify a password or HFID string validity.
+ *
+ * \param str the HFID string to be verified
+ * \param minlen the minimal length
+ * \param maxlen the maximal length
+ * \return true or false depending on validity ok or not
+ */
+bool
+check_password_or_hfid_is_valid(char *str, int minlen,int maxlen)
+{
+ int i;
+
+ if (((int)strlen(str) < minlen) || ((int)strlen(str) > maxlen)) return false;
+
+ for (i = 0; i < (int)strlen(str); i++)
+ {
+ if (((u8)str[i] < MIN_PWD_ASCII_CHAR) || ((u8)str[i] > MAX_PWD_ASCII_CHAR))
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+/**
+ * \brief little endian to CPU host endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from little endian to CPU host endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+little_to_cpuhost_endian(u8 *addrval, int bytesizeval)
+{
+ u8 c;
+ int i;
+ union {
+ u32 u32;
+ u8 b[4];
+ } cpuarch;
+
+ cpuarch.u32 = 1;
+ if (cpuarch.b[0] != 1)
+ {
+ //printf("BIG-ENDIAN CPU...\n");
+ for (i = 0; i < (bytesizeval / 2); i++)
+ {
+ c = addrval[i];
+ addrval[i] = addrval[bytesizeval-1-i];
+ //printf("[%d] <- 0x%02X ; [%d] <- 0x%02X\n",i,addrval[bytesizeval-1-i],bytesizeval-1-i,c);
+ addrval[bytesizeval-1-i] = c;
+ }
+ }
+}
+
+/**
+ * \brief big endian to CPU host endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from big endian to CPU host endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+big_to_cpuhost_endian(u8 *addrval, int bytesizeval)
+{
+ u8 c;
+ int i;
+ union {
+ u32 u32;
+ u8 b[4];
+ } cpuarch;
+
+ cpuarch.u32 = 1;
+ if (cpuarch.b[0] == 1)
+ {
+ //printf("LITTLE-ENDIAN CPU...\n");
+ for (i = 0; i < (bytesizeval / 2); i++)
+ {
+ c = addrval[i];
+ addrval[i] = addrval[bytesizeval-1-i];
+ //printf("[%d] <- 0x%02X ; [%d] <- 0x%02X\n",i,addrval[bytesizeval-1-i],bytesizeval-1-i,c);
+ addrval[bytesizeval-1-i] = c;
+ }
+ }
+}
+
+/**
+ * \brief CPU host endian to little endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from CPU host endian to little endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+cpuhost_to_little_endian(u8 *addrval, int bytesizeval)
+{
+ u8 c;
+ int i;
+ union {
+ u32 u32;
+ u8 b[4];
+ } cpuarch;
+
+ cpuarch.u32 = 1;
+ if (cpuarch.b[0] != 1)
+ {
+ //printf("BIG-ENDIAN CPU...\n");
+ for (i = 0; i < (bytesizeval / 2); i++)
+ {
+ c = addrval[i];
+ addrval[i] = addrval[bytesizeval-1-i];
+ //printf("[%d] <- 0x%02X ; [%d] <- 0x%02X\n",i,addrval[bytesizeval-1-i],bytesizeval-1-i,c);
+ addrval[bytesizeval-1-i] = c;
+ }
+ }
+}
+
+/**
+ * \brief CPU host endian to big endian conversion.
+ *
+ * \param addrval pointer to the value to be (re)formatted from CPU host endian to big endian
+ * \param bytesizeval the size in bytes of the value
+ */
+void
+cpuhost_to_big_endian(u8 *addrval, int bytesizeval)
+{
+ u8 c;
+ int i;
+ union {
+ u32 u32;
+ u8 b[4];
+ } cpuarch;
+
+ cpuarch.u32 = 1;
+ if (cpuarch.b[0] == 1)
+ {
+ //printf("LITTLE-ENDIAN CPU...\n");
+ for (i = 0; i < (bytesizeval / 2); i++)
+ {
+ c = addrval[i];
+ addrval[i] = addrval[bytesizeval-1-i];
+ //printf("[%d] <- 0x%02X ; [%d] <- 0x%02X\n",i,addrval[bytesizeval-1-i],bytesizeval-1-i,c);
+ addrval[bytesizeval-1-i] = c;
+ }
+ }
+}
+
+u16
+big_to_cpuhost_endian_u16(u16 val)
+{
+ u16 ret = val;
+ big_to_cpuhost_endian((u8 *)&ret, sizeof(ret));
+ return ret;
+}
+
+u32
+big_to_cpuhost_endian_u32(u32 val)
+{
+ u32 ret = val;
+ big_to_cpuhost_endian((u8 *)&ret, sizeof(ret));
+ return ret;
+}
+
+u16
+cpuhost_to_big_endian_u16(u16 val)
+{
+ u16 ret = val;
+ cpuhost_to_big_endian((u8 *)&ret, sizeof(ret));
+ return ret;
+}
+
+u32
+cpuhost_to_big_endian_u32(u32 val)
+{
+ u32 ret = val;
+ cpuhost_to_big_endian((u8 *)&ret, sizeof(ret));
+ return ret;
+}
+
+void display_mme_header(mme_header_type *mme_header)
+{
+ printf ("%u /*\t0x%08x : osa ........ 0x%012llX => @MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_osa,
+ mme_header->un_osa.u64,
+ (u8)((mme_header->un_osa.u64 & 0xFF0000000000ULL) >> 40),
+ (u8)((mme_header->un_osa.u64 & 0x00FF00000000ULL) >> 32),
+ (u8)((mme_header->un_osa.u64 & 0x0000FF000000ULL) >> 24),
+ (u8)((mme_header->un_osa.u64 & 0x000000FF0000ULL) >> 16),
+ (u8)((mme_header->un_osa.u64 & 0x00000000FF00ULL) >> 8),
+ (u8) (mme_header->un_osa.u64 & 0x0000000000FFULL)
+ );
+ printf ("%u /*\t0x%08x : oda ........ 0x%012llX => @MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_oda,
+ mme_header->un_oda.u64,
+ (u8)((mme_header->un_oda.u64 & 0xFF0000000000ULL) >> 40),
+ (u8)((mme_header->un_oda.u64 & 0x00FF00000000ULL) >> 32),
+ (u8)((mme_header->un_oda.u64 & 0x0000FF000000ULL) >> 24),
+ (u8)((mme_header->un_oda.u64 & 0x000000FF0000ULL) >> 16),
+ (u8)((mme_header->un_oda.u64 & 0x00000000FF00ULL) >> 8),
+ (u8) (mme_header->un_oda.u64 & 0x0000000000FFULL)
+ );
+ if (mme_header->vlan_tag_flag == true)
+ {
+ printf
+ ("%u /*\t0x%08x : vlan_tag ... 0x%04X 0x%04X",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_vlan_tag,
+ (u16)(mme_header->un_vlan_tag.u32 >> 16),
+ (u16)(mme_header->un_vlan_tag.u32 & 0x0000FFFF));
+ if ((u16)(mme_header->un_vlan_tag.u32 >> 16) == MSG_VLAN_TAG_IEEE_802_1Q)
+ printf(" => IEEE 802.1Q VLAN Tag\n");
+ else
+ printf(" => UNKNOWN/UNEXPECTED !?\n");
+ }
+ printf ("%u /*\t0x%08x : mtype ...... 0x%04lX",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_mtype,
+ mme_header->un_mtype.u32);
+ if (mme_header->un_mtype.u32 == MSG_MTYPE_IEEE_ETHERTYPE)
+ printf(" => IEEE ETHERTYPE\n");
+ else
+ printf(" => UNKNOWN/UNEXPECTED !?\n");
+ printf ("%u /*\t0x%08x : mmv ........ 0x%02lX (%lu) => HomePlug AV 1.%lu specification\n",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_mmv,
+ mme_header->un_mmv.u32,mme_header->un_mmv.u32,
+ mme_header->un_mmv.u32);
+ printf ("%u /*\t0x%08x : mmtype ..... 0x%04lX",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_mmtype,
+ mme_header->un_mmtype.u32);
+
+ switch(mme_header->un_mmtype.u32)
+ {
+ case DRV_STA_SET_MAC_ADDR_REQ :
+ case DRV_STA_SET_CCO_PREF_REQ :
+ case DRV_STA_SET_WAS_CCO_REQ :
+ case DRV_STA_SET_NPW_REQ :
+ case DRV_STA_SET_DPW_REQ :
+ case DRV_STA_SET_SL_REQ :
+ case DRV_STA_SET_M_STA_HFID_REQ :
+ case DRV_STA_SET_U_STA_HFID_REQ :
+ case DRV_STA_SET_AVLN_HFID_REQ :
+ case DRV_STA_SET_TONEMASK_REQ :
+ case DRV_STA_START_REQ :
+ case DRV_STA_STOP_REQ :
+ printf(" => %s\n",get_str_drv_mme_req((mme_header->un_mmtype.u32-DRV_STA_SET_MAC_ADDR_REQ)/4));
+ break;
+ case DRV_STA_SET_MAC_ADDR_CNF :
+ case DRV_STA_SET_CCO_PREF_CNF :
+ case DRV_STA_SET_WAS_CCO_CNF :
+ case DRV_STA_SET_NPW_CNF :
+ case DRV_STA_SET_DPW_CNF :
+ case DRV_STA_SET_SL_CNF :
+ case DRV_STA_SET_M_STA_HFID_CNF :
+ case DRV_STA_SET_U_STA_HFID_CNF :
+ case DRV_STA_SET_AVLN_HFID_CNF :
+ case DRV_STA_SET_TONEMASK_CNF :
+ case DRV_STA_START_CNF :
+ case DRV_STA_STOP_CNF :
+ printf(" => %s\n",get_str_drv_mme_cnf((mme_header->un_mmtype.u32-DRV_STA_SET_MAC_ADDR_CNF)/4));
+ break;
+ default :
+ printf("\n");
+ break;
+ }
+ printf ("%u /*\t0x%08x : fmi ........ 0x%04lX => MMENTRY fragment %lu/%lu, FNSM = 0x%02lX (%lu)\n",
+ cyg_hal_sys_getpid(),
+ (unsigned int)&mme_header->un_fmi,
+ mme_header->un_fmi.u32,
+ ((mme_header->un_fmi.u32 & 0xF000) >> 12)+1,
+ ((mme_header->un_fmi.u32 & 0xF00) >> 8)+1,
+ mme_header->un_fmi.u32 & 0xFF,
+ mme_header->un_fmi.u32 & 0xFF);
+}
+
+/**
+ * \brief Build a "MME.CNF" confirmation message.
+ *
+ * \param recv_mme_header the buffer to contain the MME.CNF message being built
+ * \param send_mme the buffer containing the MME initially received for which we're building a CNF
+ * \param cnf_result the result code of the MME.CNF message to be built
+ * \param cnf_errcode the error code of the MME.CNF message to be built
+ * \param cnf_len the returned length of the MME.CNF message being built
+ *
+ */
+void
+cp_mme_build_cnf (mme_header_type *recv_mme_header, mme_drv_cnf_type *send_mme, e_drv_mme_cnf_result cnf_result, e_drv_mme_cnf_errcode cnf_errcode, uint *cnf_len, u8 *mme_tx_buffer, int *mme_buffer_first)
+{
+ bitstream_t bstr_ctx;
+ uint pld_maxlen;
+ uint i, j;
+
+ printf ("%u %s() : mme_tx_buffer = 0x%08lx\n",cyg_hal_sys_getpid(),__FUNCTION__,(unsigned long)mme_tx_buffer);
+
+ /* Prepare CNF message to be sent back to OSA */
+ send_mme->header = *recv_mme_header;
+ send_mme->header.un_osa.u64 = recv_mme_header->un_oda.u64;
+ send_mme->header.un_oda.u64 = recv_mme_header->un_osa.u64;
+ send_mme->header.un_mmtype.u32 |= CNF;
+
+ /* TODO : don't reset the VLAN tag field, keep the one of the incoming message header... */
+ send_mme->header.un_vlan_tag.u32 = 0x00000000;
+
+ /* TODO : fill & format the FMI field... */
+ send_mme->header.un_fmi.u32 = 0x00000000;
+
+ printf ("%u /* MME HEADER :\n",cyg_hal_sys_getpid());
+ display_mme_header(&send_mme->header);
+ printf ("%u /***************************************************/\n",cyg_hal_sys_getpid());
+
+ switch(send_mme->header.un_mmtype.u32)
+ {
+ case DRV_STA_SET_MAC_ADDR_CNF :
+ case DRV_STA_SET_CCO_PREF_CNF :
+ case DRV_STA_SET_WAS_CCO_CNF :
+ case DRV_STA_SET_NPW_CNF :
+ case DRV_STA_SET_DPW_CNF :
+ case DRV_STA_SET_SL_CNF :
+ case DRV_STA_SET_M_STA_HFID_CNF :
+ case DRV_STA_SET_U_STA_HFID_CNF :
+ case DRV_STA_SET_AVLN_HFID_CNF :
+ case DRV_STA_SET_TONEMASK_CNF :
+ case DRV_STA_START_CNF :
+ case DRV_STA_STOP_CNF :
+ pld_maxlen = 2;
+ break;
+ default :
+ pld_maxlen = 0; /* TO DO : what length ? */
+ break;
+ }
+
+ printf ("%u /* MME PAYLOAD :\n",cyg_hal_sys_getpid());
+ switch(send_mme->header.un_mmtype.u32)
+ {
+ case DRV_STA_SET_MAC_ADDR_CNF :
+ case DRV_STA_SET_CCO_PREF_CNF :
+ case DRV_STA_SET_WAS_CCO_CNF :
+ case DRV_STA_SET_NPW_CNF :
+ case DRV_STA_SET_DPW_CNF :
+ case DRV_STA_SET_SL_CNF :
+ case DRV_STA_SET_M_STA_HFID_CNF :
+ case DRV_STA_SET_U_STA_HFID_CNF :
+ case DRV_STA_SET_AVLN_HFID_CNF :
+ case DRV_STA_SET_TONEMASK_CNF :
+ case DRV_STA_START_CNF :
+ case DRV_STA_STOP_CNF :
+ send_mme->result = cnf_result;
+ send_mme->errcode = cnf_errcode;
+ printf ("%u /*\t0x%08x : result ..... 0x%02X (%u) => %s\n",cyg_hal_sys_getpid(),(unsigned int)&send_mme->result,
+ send_mme->result,send_mme->result,get_str_drv_mme_cnf_result(send_mme->result));
+ printf ("%u /*\t0x%08x : errcode .... 0x%02X (%u)",cyg_hal_sys_getpid(),(unsigned int)&send_mme->errcode,
+ send_mme->errcode,send_mme->errcode);
+ if (send_mme->result != E_DRVMME_RESULT_SUCCESS)
+ printf (" => %s\n",get_str_drv_mme_cnf_errcode(send_mme->errcode));
+ else
+ printf ("\n");
+ break;
+ default :
+ printf("\n");
+ break;
+ }
+ printf ("%u /***************************************************/\n",cyg_hal_sys_getpid());
+
+ /* re-convert needed fields to big-endian... */
+ cpuhost_to_big_endian(&send_mme->header.un_osa.b[0],MAC_ADDR_SIZE);
+ cpuhost_to_big_endian(&send_mme->header.un_oda.b[0],MAC_ADDR_SIZE);
+ cpuhost_to_big_endian(&send_mme->header.un_vlan_tag.b[0],4);
+ cpuhost_to_big_endian(&send_mme->header.un_mtype.b[0],2);
+
+ /*
+ * take into account right mme header len depending on VLAN Tag field
+ * was present in incoming message or not (reply message header conforms
+ * to incoming message header)
+ */
+ if (!send_mme->header.vlan_tag_flag)
+ {
+ *cnf_len = (uint)MAX(60,MME_HEADER_MINSIZE+(int)pld_maxlen);
+ }
+ else
+ {
+ *cnf_len = (uint)MAX(60,MME_HEADER_MAXSIZE+(int)pld_maxlen);
+ }
+ memset(mme_tx_buffer,0x00,*cnf_len);
+
+#if 1
+ bitstream_init(&bstr_ctx,mme_tx_buffer,*cnf_len,BITSTREAM_WRITE);
+ bitstream_access(&bstr_ctx,&send_mme->header.un_osa.u64,48);
+ bitstream_access(&bstr_ctx,&send_mme->header.un_oda.u64,48);
+ if (send_mme->header.vlan_tag_flag) bitstream_access(&bstr_ctx,&send_mme->header.un_vlan_tag.u32,32);
+ bitstream_access(&bstr_ctx,&send_mme->header.un_mtype.u32,16);
+ bitstream_access(&bstr_ctx,&send_mme->header.un_mmv.u32,8);
+ bitstream_access(&bstr_ctx,&send_mme->header.un_mmtype.u32,16);
+ bitstream_access(&bstr_ctx,&send_mme->header.un_fmi.u32,16);
+ bitstream_access(&bstr_ctx,&send_mme->result,8);
+ bitstream_access(&bstr_ctx,&send_mme->errcode,8);
+ bitstream_finalise(&bstr_ctx);
+#endif
+
+ printf ("%u /***************************************************/\n",cyg_hal_sys_getpid());
+ printf ("%u /* STA : %d CP : SENDING AN MME (len = %u bytes)...\n",
+ cyg_hal_sys_getpid(),
+ 0/*cp_sta_global.mac_config->tei*/,
+ *cnf_len);
+#if 1
+ j = 0;
+ printf("%u /* ",cyg_hal_sys_getpid());
+ for (i = 0; i < (uint)(*cnf_len / 16); i++)
+ {
+ for (j = 0; j < 16; j++) printf ("%02x.",mme_tx_buffer[(i*16)+j]);
+ printf("\n");
+ printf("%u /* ",cyg_hal_sys_getpid());
+ }
+ for (i = 0; i < (*cnf_len % 16); i++)
+ {
+ printf ("%02x.",mme_tx_buffer[(j*16)+i]);
+ }
+ printf("\n");
+#endif
+ printf ("%u /***************************************************/\n",cyg_hal_sys_getpid());
+}
diff --git a/cesar/cp/msg/test/ecos.ecc.sh b/cesar/cp/msg/test/ecos.ecc.sh
new file mode 100644
index 0000000000..8253d98c9a
--- /dev/null
+++ b/cesar/cp/msg/test/ecos.ecc.sh
@@ -0,0 +1,5 @@
+config=${1:-ecos-gen.ecc}
+ecosconfig --config=$config new linux default
+cat >> $config <<EOF
+EOF
+ecosconfig --config=$config check
diff --git a/cesar/cp/msg/test/inc/test_conn.h b/cesar/cp/msg/test/inc/test_conn.h
new file mode 100644
index 0000000000..d7fe99fac9
--- /dev/null
+++ b/cesar/cp/msg/test/inc/test_conn.h
@@ -0,0 +1,34 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_conn.h
+ * \brief File Description
+ * \ingroup cp/conn
+ *
+ */
+
+
+
+#ifndef TEST_H_
+#define TEST_H_
+
+#include <stdio.h>
+#include "lib/test.h"
+
+#include <cyg/kernel/kapi.h>
+#include <cyg/hal/hal_arch.h>
+
+
+// Function declaration
+void test_msg_field(test_t t);
+void test_msg_cm_conn_new_req(test_t t);
+void test_msg_cm_conn_new_cnf(test_t t);
+void test_msg_cm_conn_rel_ind(test_t t);
+void test_msg_cm_conn_rel_rsp(test_t t);
+void test_msg_cm_conn_mod_cnf(test_t t);
+void test_msg_cm_conn_mod_req(test_t t);
+#endif /*TEST_H_*/
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn.c b/cesar/cp/msg/test/src/test_msg_cm_conn.c
new file mode 100644
index 0000000000..3d5b9e3a78
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn.c
@@ -0,0 +1,29 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+
+
+
+
+
+void test_msg_cm_conn(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin (t, "TEST MESSAGE CM_CONN");
+
+ //TODO to complete
+
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c b/cesar/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c
new file mode 100644
index 0000000000..60c0fcfad1
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn_mod_cnf.c
@@ -0,0 +1,801 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_mod_cnf.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
+
+msg_mme_t msg_cm_conn_mod_cnf_1 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_MOD_CNF,
+ {0,0,0},
+ {
+ 0x53, // CID
+ 0x25, // CID
+ 0x00 // result (=success)
+ }
+};
+
+msg_mme_t msg_cm_conn_mod_cnf_2 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_MOD_CNF,
+ {0,0,0},
+ {
+ 0x53, // CID
+ 0x25, // CID
+ 0x01, // result (=failure)
+ 0x01, // CSPEC Length :338 bytes
+ 0x54, // CSPEC Length :
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priori ty
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY copy
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01 // QMP BODY
+ }
+};
+
+
+void
+test_msg_cm_conn_mod_cnf_get_from_mme_msg(test_t t)
+{
+ msg_cm_conn_mod_cnf_t msg;
+
+ test_case_begin(t, "TEST cm_conn_mod_cnf_get_from_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+ msg_cm_conn_mod_cnf_init(&msg);
+
+ msg_cm_conn_mod_cnf_get_from_mme_msg( &msg_cm_conn_mod_cnf_1, &msg);
+
+ test_fail_unless(msg.cid == 0x5325);
+ test_fail_unless(msg.result == CONN_MOD_SUCCESS);
+
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+
+ msg_cm_conn_mod_cnf_init(&msg);
+
+ msg_cm_conn_mod_cnf_get_from_mme_msg( &msg_cm_conn_mod_cnf_2, &msg);
+
+ test_fail_unless( msg.cid == 0x5325 );
+ test_fail_unless( msg.result == CONN_MOD_FAILED );
+
+
+
+
+ // CINFO FORWARD
+ test_fail_unless( msg.proposed_cspec.cinfo_forward.valid == CINFO_VALID);
+ test_fail_unless( msg.proposed_cspec.cinfo_forward.mac_service_type == MAC_CONTENTION);
+ test_fail_unless( msg.proposed_cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless( msg.proposed_cspec.cinfo_forward.ats == ATS_FOR_HLE);
+ test_fail_unless( msg.proposed_cspec.cinfo_forward.smoothing == SMOOTHING_REQUESTED);
+
+ // CINFO REVERSE
+ test_fail_unless( msg.proposed_cspec.cinfo_reverse.valid == CINFO_VALID );
+ test_fail_unless( msg.proposed_cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION );
+ test_fail_unless( msg.proposed_cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0 );
+ test_fail_unless( msg.proposed_cspec.cinfo_reverse.ats == ATS_FOR_HLE );
+ test_fail_unless( msg.proposed_cspec.cinfo_reverse.smoothing == SMOOTHING_REQUESTED );
+
+ // QMP FORWARD
+ test_fail_unless( msg.proposed_cspec.qmp_forward.forward_or_reverse == QMP_FORWARD);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+
+
+ // QMP REVERSE
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.delay_bound_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.jitter_bound_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.exception_policy_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.clst_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.cdesc_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.rx_window_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.proposed_cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+ test_fail_unless( msg.proposed_cspec.len == 0x0154 );
+
+ }test_end;
+
+}
+
+
+void
+test_msg_cm_conn_mod_cnf_set_on_mme_msg(test_t t)
+{
+ msg_cm_conn_mod_cnf_t msg;
+ msg_mme_t test_msg;
+ int i;
+
+ test_case_begin(t, "TEST cm_conn_mod_cnf_set_on_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+ msg_cm_conn_mod_cnf_init(&msg);
+
+ msg.cid = 0x5325;
+ msg.result = CONN_MOD_SUCCESS;
+
+ msg_cm_conn_mod_cnf_set_on_mme_msg(&test_msg, &msg);
+
+ for(i=0; i< 2;i++)
+ {
+ test_fail_unless( test_msg.mm_entry[i] == msg_cm_conn_mod_cnf_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_msg.mm_entry[i],msg_cm_conn_mod_cnf_1.mm_entry[i]);
+ }
+
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+ msg.cid = 0x5325;
+ msg.result = CONN_MOD_FAILED;
+
+ msg.proposed_cspec.cinfo_forward.valid = CINFO_VALID;
+ msg.proposed_cspec.cinfo_forward.mac_service_type = MAC_CONTENTION;
+ msg.proposed_cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0;
+ msg.proposed_cspec.cinfo_forward.ats = ATS_FOR_HLE;
+ msg.proposed_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED;
+ msg.proposed_cspec.cinfo_reverse.valid = CINFO_VALID ;
+ msg.proposed_cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION ;
+ msg.proposed_cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0 ;
+ msg.proposed_cspec.cinfo_reverse.ats = ATS_FOR_HLE ;
+ msg.proposed_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED ;
+ msg.proposed_cspec.qmp_forward.forward_or_reverse = QMP_FORWARD;
+ msg.proposed_cspec.qmp_forward.valid.delay_bound_available = true;
+ msg.proposed_cspec.qmp_forward.valid.jitter_bound_available = true;
+ msg.proposed_cspec.qmp_forward.valid.average_msdu_size_available = true;
+ msg.proposed_cspec.qmp_forward.valid.maximum_msdu_size_available = true;
+ msg.proposed_cspec.qmp_forward.valid.average_data_rate_available = true;
+ msg.proposed_cspec.qmp_forward.valid.minimum_data_rate_available = true;
+ msg.proposed_cspec.qmp_forward.valid.maximum_data_rate_available = true;
+ msg.proposed_cspec.qmp_forward.valid.minimum_inter_txop_time_available = true;
+ msg.proposed_cspec.qmp_forward.valid.maximum_inter_txop_time_available = true;
+ msg.proposed_cspec.qmp_forward.valid.maximum_burst_size_available = true;
+ msg.proposed_cspec.qmp_forward.valid.exception_policy_available = true;
+ msg.proposed_cspec.qmp_forward.valid.inactivity_interval_available = true;
+ msg.proposed_cspec.qmp_forward.valid.msdu_error_rate_available = true;
+ msg.proposed_cspec.qmp_forward.valid.clst_available = true;
+ msg.proposed_cspec.qmp_forward.valid.cdesc_available = true;
+ msg.proposed_cspec.qmp_forward.valid.ats_tolerance_available = true;
+ msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true;
+ msg.proposed_cspec.qmp_forward.valid.original_average_data_rate_available = true;
+ msg.proposed_cspec.qmp_forward.valid.rx_window_size_available = true;
+ msg.proposed_cspec.qmp_forward.valid.smoothing_buffer_size_available = true;
+ msg.proposed_cspec.qmp_forward.valid.bidirectional_burst_available = true;
+ msg.proposed_cspec.qmp_forward.valid.txops_per_beacon_period_available = true;
+ msg.proposed_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_forward.valid.ppb_threshold_available = true;
+ msg.proposed_cspec.qmp_forward.valid.surplus_bandwith_available = true;
+ msg.proposed_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_forward.valid.cco_bidirectional_burst_available = true;
+ msg.proposed_cspec.qmp_forward.cm.delay_bound = 0x01010101;
+ msg.proposed_cspec.qmp_forward.cm.jitter_bound = 0x10101010;
+ msg.proposed_cspec.qmp_forward.cm.average_msdu_size = 0XF0F0;
+ msg.proposed_cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0;
+ msg.proposed_cspec.qmp_forward.cm.average_data_rate = 0x0F0F;
+ msg.proposed_cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F;
+ msg.proposed_cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F;
+ msg.proposed_cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.proposed_cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.proposed_cspec.qmp_forward.cm.maximum_burst_size = 0x00FF;
+ msg.proposed_cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.proposed_cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF;
+ msg.proposed_cspec.qmp_forward.cm.msdu_error_rate = 0x00FF;
+ msg.proposed_cspec.qmp_forward.cm.clst = 0x00;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ip_version = 0x00;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1;
+ msg.proposed_cspec.qmp_forward.cm.cdesc.protocol_type = 0x00;
+ msg.proposed_cspec.qmp_forward.cm.ats_tolerance = 0x00FF;
+ msg.proposed_cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.proposed_cspec.qmp_forward.cm.original_average_data_rate = 0x000F;
+ msg.proposed_cspec.qmp_forward.cm.rx_window_size = 0x100F;
+ msg.proposed_cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10;
+ msg.proposed_cspec.qmp_forward.cm.bidirectional_burst = 0x01;
+ msg.proposed_cspec.qmp_forward.cco.txops_per_beacon_period = 0x15;
+ msg.proposed_cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.proposed_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.proposed_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.proposed_cspec.qmp_forward.cco.ppb_threshold = 0x0FF0;
+ msg.proposed_cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0;
+ msg.proposed_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.proposed_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.proposed_cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01;
+ msg.proposed_cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE;
+ msg.proposed_cspec.qmp_reverse.valid.delay_bound_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.jitter_bound_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.average_msdu_size_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.maximum_msdu_size_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.average_data_rate_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.minimum_data_rate_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.maximum_data_rate_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.maximum_burst_size_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.exception_policy_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.inactivity_interval_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.msdu_error_rate_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.clst_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.cdesc_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.ats_tolerance_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.original_average_data_rate_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.rx_window_size_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.smoothing_buffer_size_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.bidirectional_burst_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.txops_per_beacon_period_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.ppb_threshold_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.surplus_bandwith_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.proposed_cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true;
+ msg.proposed_cspec.qmp_reverse.cm.delay_bound = 0x01010101;
+ msg.proposed_cspec.qmp_reverse.cm.jitter_bound = 0x10101010;
+ msg.proposed_cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0;
+ msg.proposed_cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0;
+ msg.proposed_cspec.qmp_reverse.cm.average_data_rate = 0x0F0F;
+ msg.proposed_cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F;
+ msg.proposed_cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F;
+ msg.proposed_cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.proposed_cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.proposed_cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF;
+ msg.proposed_cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.proposed_cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF;
+ msg.proposed_cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF;
+ msg.proposed_cspec.qmp_reverse.cm.clst = 0x00;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ip_version = 0x00;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1;
+ msg.proposed_cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00;
+ msg.proposed_cspec.qmp_reverse.cm.ats_tolerance = 0x00FF;
+ msg.proposed_cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.proposed_cspec.qmp_reverse.cm.original_average_data_rate = 0x000F;
+ msg.proposed_cspec.qmp_reverse.cm.rx_window_size = 0x100F;
+ msg.proposed_cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10;
+ msg.proposed_cspec.qmp_reverse.cm.bidirectional_burst = 0x01;
+ msg.proposed_cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15;
+ msg.proposed_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.proposed_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.proposed_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.proposed_cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0;
+ msg.proposed_cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0;
+ msg.proposed_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.proposed_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.proposed_cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01;
+ msg.proposed_cspec.len = 0x0154 ;
+
+ msg_cm_conn_mod_cnf_set_on_mme_msg(&test_msg, &msg);
+
+ for(i=0; i< 341;i++)
+ {
+ test_fail_unless( test_msg.mm_entry[i] == msg_cm_conn_mod_cnf_2.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_msg.mm_entry[i],msg_cm_conn_mod_cnf_2.mm_entry[i]);
+ }
+
+ }test_end;
+
+}
+
+
+void
+test_msg_cm_conn_mod_cnf(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin(t, "TEST MESSAGE CM_CONN_MOD_CNF");
+
+ test_msg_cm_conn_mod_cnf_get_from_mme_msg(t);
+ test_msg_cm_conn_mod_cnf_set_on_mme_msg(t);
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn_mod_req.c b/cesar/cp/msg/test/src/test_msg_cm_conn_mod_req.c
new file mode 100644
index 0000000000..2152156aed
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn_mod_req.c
@@ -0,0 +1,755 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_mod_req.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
+
+msg_mme_t msg_cm_conn_mod_req_1 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_MOD_REQ,
+ {0,0,0},
+ {
+ 0x53, // CID
+ 0x25, // CID
+ 0x01, // CSPEC Length :338 bytes
+ 0x54, // CSPEC Length :
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priori ty
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY copy
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01 // QMP BODY
+ }
+};
+
+
+void
+test_msg_cm_conn_mod_req_get_from_mme_msg(test_t t)
+{
+ msg_cm_conn_mod_req_t msg;
+
+ test_case_begin(t, "TEST cm_conn_mod_req_get_from_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+
+ msg_cm_conn_mod_req_init(&msg);
+
+ msg_cm_conn_mod_req_get_from_mme_msg( &msg_cm_conn_mod_req_1, &msg);
+
+ test_fail_unless( msg.cid == 0x5325 );
+
+ // CINFO FORWARD
+ test_fail_unless( msg.modified_cspec.cinfo_forward.valid == CINFO_VALID);
+ test_fail_unless( msg.modified_cspec.cinfo_forward.mac_service_type == MAC_CONTENTION);
+ test_fail_unless( msg.modified_cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless( msg.modified_cspec.cinfo_forward.ats == ATS_FOR_HLE);
+ test_fail_unless( msg.modified_cspec.cinfo_forward.smoothing == SMOOTHING_REQUESTED);
+
+ // CINFO REVERSE
+ test_fail_unless( msg.modified_cspec.cinfo_reverse.valid == CINFO_VALID );
+ test_fail_unless( msg.modified_cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION );
+ test_fail_unless( msg.modified_cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0 );
+ test_fail_unless( msg.modified_cspec.cinfo_reverse.ats == ATS_FOR_HLE );
+ test_fail_unless( msg.modified_cspec.cinfo_reverse.smoothing == SMOOTHING_REQUESTED );
+
+ // QMP FORWARD
+ test_fail_unless( msg.modified_cspec.qmp_forward.forward_or_reverse == QMP_FORWARD);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+
+
+ // QMP REVERSE
+ test_fail_unless( msg.modified_cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.delay_bound_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.jitter_bound_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.exception_policy_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.clst_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.cdesc_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.rx_window_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.modified_cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+ test_fail_unless( msg.modified_cspec.len == 0x0154 );
+
+ }test_end;
+
+}
+
+
+void
+test_msg_cm_conn_mod_req_set_on_mme_msg(test_t t)
+{
+ msg_cm_conn_mod_req_t msg;
+ msg_mme_t test_msg;
+ int i;
+
+ test_case_begin(t, "TEST cm_conn_mod_req_set_on_mme_msg");
+
+
+ test_begin(t, "test case 1")
+ {
+
+ msg_cm_conn_mod_req_init(&msg);
+
+ msg.cid = 0x5325;
+
+ msg.modified_cspec.cinfo_forward.valid = CINFO_VALID;
+ msg.modified_cspec.cinfo_forward.mac_service_type = MAC_CONTENTION;
+ msg.modified_cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0;
+ msg.modified_cspec.cinfo_forward.ats = ATS_FOR_HLE;
+ msg.modified_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED;
+ msg.modified_cspec.cinfo_reverse.valid = CINFO_VALID ;
+ msg.modified_cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION ;
+ msg.modified_cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0 ;
+ msg.modified_cspec.cinfo_reverse.ats = ATS_FOR_HLE ;
+ msg.modified_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED ;
+ msg.modified_cspec.qmp_forward.forward_or_reverse = QMP_FORWARD;
+ msg.modified_cspec.qmp_forward.valid.delay_bound_available = true;
+ msg.modified_cspec.qmp_forward.valid.jitter_bound_available = true;
+ msg.modified_cspec.qmp_forward.valid.average_msdu_size_available = true;
+ msg.modified_cspec.qmp_forward.valid.maximum_msdu_size_available = true;
+ msg.modified_cspec.qmp_forward.valid.average_data_rate_available = true;
+ msg.modified_cspec.qmp_forward.valid.minimum_data_rate_available = true;
+ msg.modified_cspec.qmp_forward.valid.maximum_data_rate_available = true;
+ msg.modified_cspec.qmp_forward.valid.minimum_inter_txop_time_available = true;
+ msg.modified_cspec.qmp_forward.valid.maximum_inter_txop_time_available = true;
+ msg.modified_cspec.qmp_forward.valid.maximum_burst_size_available = true;
+ msg.modified_cspec.qmp_forward.valid.exception_policy_available = true;
+ msg.modified_cspec.qmp_forward.valid.inactivity_interval_available = true;
+ msg.modified_cspec.qmp_forward.valid.msdu_error_rate_available = true;
+ msg.modified_cspec.qmp_forward.valid.clst_available = true;
+ msg.modified_cspec.qmp_forward.valid.cdesc_available = true;
+ msg.modified_cspec.qmp_forward.valid.ats_tolerance_available = true;
+ msg.modified_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true;
+ msg.modified_cspec.qmp_forward.valid.original_average_data_rate_available = true;
+ msg.modified_cspec.qmp_forward.valid.rx_window_size_available = true;
+ msg.modified_cspec.qmp_forward.valid.smoothing_buffer_size_available = true;
+ msg.modified_cspec.qmp_forward.valid.bidirectional_burst_available = true;
+ msg.modified_cspec.qmp_forward.valid.txops_per_beacon_period_available = true;
+ msg.modified_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_forward.valid.ppb_threshold_available = true;
+ msg.modified_cspec.qmp_forward.valid.surplus_bandwith_available = true;
+ msg.modified_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_forward.valid.cco_bidirectional_burst_available = true;
+ msg.modified_cspec.qmp_forward.cm.delay_bound = 0x01010101;
+ msg.modified_cspec.qmp_forward.cm.jitter_bound = 0x10101010;
+ msg.modified_cspec.qmp_forward.cm.average_msdu_size = 0XF0F0;
+ msg.modified_cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0;
+ msg.modified_cspec.qmp_forward.cm.average_data_rate = 0x0F0F;
+ msg.modified_cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F;
+ msg.modified_cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F;
+ msg.modified_cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.modified_cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.modified_cspec.qmp_forward.cm.maximum_burst_size = 0x00FF;
+ msg.modified_cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.modified_cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF;
+ msg.modified_cspec.qmp_forward.cm.msdu_error_rate = 0x00FF;
+ msg.modified_cspec.qmp_forward.cm.clst = 0x00;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ip_version = 0x00;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.modified_cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1;
+ msg.modified_cspec.qmp_forward.cm.cdesc.protocol_type = 0x00;
+ msg.modified_cspec.qmp_forward.cm.ats_tolerance = 0x00FF;
+ msg.modified_cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.modified_cspec.qmp_forward.cm.original_average_data_rate = 0x000F;
+ msg.modified_cspec.qmp_forward.cm.rx_window_size = 0x100F;
+ msg.modified_cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10;
+ msg.modified_cspec.qmp_forward.cm.bidirectional_burst = 0x01;
+ msg.modified_cspec.qmp_forward.cco.txops_per_beacon_period = 0x15;
+ msg.modified_cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.modified_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.modified_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.modified_cspec.qmp_forward.cco.ppb_threshold = 0x0FF0;
+ msg.modified_cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0;
+ msg.modified_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.modified_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.modified_cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01;
+ msg.modified_cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE;
+ msg.modified_cspec.qmp_reverse.valid.delay_bound_available = true;
+ msg.modified_cspec.qmp_reverse.valid.jitter_bound_available = true;
+ msg.modified_cspec.qmp_reverse.valid.average_msdu_size_available = true;
+ msg.modified_cspec.qmp_reverse.valid.maximum_msdu_size_available = true;
+ msg.modified_cspec.qmp_reverse.valid.average_data_rate_available = true;
+ msg.modified_cspec.qmp_reverse.valid.minimum_data_rate_available = true;
+ msg.modified_cspec.qmp_reverse.valid.maximum_data_rate_available = true;
+ msg.modified_cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true;
+ msg.modified_cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true;
+ msg.modified_cspec.qmp_reverse.valid.maximum_burst_size_available = true;
+ msg.modified_cspec.qmp_reverse.valid.exception_policy_available = true;
+ msg.modified_cspec.qmp_reverse.valid.inactivity_interval_available = true;
+ msg.modified_cspec.qmp_reverse.valid.msdu_error_rate_available = true;
+ msg.modified_cspec.qmp_reverse.valid.clst_available = true;
+ msg.modified_cspec.qmp_reverse.valid.cdesc_available = true;
+ msg.modified_cspec.qmp_reverse.valid.ats_tolerance_available = true;
+ msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true;
+ msg.modified_cspec.qmp_reverse.valid.original_average_data_rate_available = true;
+ msg.modified_cspec.qmp_reverse.valid.rx_window_size_available = true;
+ msg.modified_cspec.qmp_reverse.valid.smoothing_buffer_size_available = true;
+ msg.modified_cspec.qmp_reverse.valid.bidirectional_burst_available = true;
+ msg.modified_cspec.qmp_reverse.valid.txops_per_beacon_period_available = true;
+ msg.modified_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_reverse.valid.ppb_threshold_available = true;
+ msg.modified_cspec.qmp_reverse.valid.surplus_bandwith_available = true;
+ msg.modified_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.modified_cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true;
+ msg.modified_cspec.qmp_reverse.cm.delay_bound = 0x01010101;
+ msg.modified_cspec.qmp_reverse.cm.jitter_bound = 0x10101010;
+ msg.modified_cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0;
+ msg.modified_cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0;
+ msg.modified_cspec.qmp_reverse.cm.average_data_rate = 0x0F0F;
+ msg.modified_cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F;
+ msg.modified_cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F;
+ msg.modified_cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.modified_cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.modified_cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF;
+ msg.modified_cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.modified_cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF;
+ msg.modified_cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF;
+ msg.modified_cspec.qmp_reverse.cm.clst = 0x00;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ip_version = 0x00;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1;
+ msg.modified_cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00;
+ msg.modified_cspec.qmp_reverse.cm.ats_tolerance = 0x00FF;
+ msg.modified_cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.modified_cspec.qmp_reverse.cm.original_average_data_rate = 0x000F;
+ msg.modified_cspec.qmp_reverse.cm.rx_window_size = 0x100F;
+ msg.modified_cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10;
+ msg.modified_cspec.qmp_reverse.cm.bidirectional_burst = 0x01;
+ msg.modified_cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15;
+ msg.modified_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.modified_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.modified_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.modified_cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0;
+ msg.modified_cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0;
+ msg.modified_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.modified_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.modified_cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01;
+ msg.modified_cspec.len = 0x0154 ;
+
+ msg_cm_conn_mod_req_set_on_mme_msg(&test_msg, &msg);
+
+ for(i=0; i< 340;i++)
+ {
+ test_fail_unless( test_msg.mm_entry[i] == msg_cm_conn_mod_req_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_msg.mm_entry[i],msg_cm_conn_mod_req_1.mm_entry[i]);
+ }
+
+ }test_end;
+
+}
+
+
+void
+test_msg_cm_conn_mod_req(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin(t, "TEST MESSAGE CM_CONN_MOD_REQ");
+ test_msg_cm_conn_mod_req_get_from_mme_msg(t);
+ test_msg_cm_conn_mod_req_set_on_mme_msg(t);
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn_new_cnf.c b/cesar/cp/msg/test/src/test_msg_cm_conn_new_cnf.c
new file mode 100644
index 0000000000..d823069b42
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn_new_cnf.c
@@ -0,0 +1,816 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_new_cnf.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
+
+msg_mme_t msg_cm_conn_new_cnf_1 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_NEW_CNF,
+ {0,0,0},
+ {
+ 0x53, // CID (=0x5325)
+ 0x25, // CID
+ 0x25, // LLID-R (=0x25)
+ 0x04, // Result
+ 0x01, // CSPEC Length :338 bytes
+ 0x54, // CSPEC Length :
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priori ty
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // 0x0FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY copy
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ }
+};
+
+
+
+msg_mme_t msg_cm_conn_new_cnf_2 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_NEW_CNF,
+ {0,0,0},
+ {
+ 0x53, // CID (=0x5325)
+ 0x25, // CID
+ 0x25, // LLID-R (=0x25)
+ 0x00 // Result (=success)
+ }
+};
+
+void
+test_msg_cm_conn_new_cnf_set_on_mme_msg(test_t t)
+{
+ msg_cm_conn_new_cnf_t msg;
+
+ test_case_begin(t, "TEST msg_cm_conn_new_cnf_set_on_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+
+ msg_cm_conn_new_cnf_init(&msg);
+
+
+
+ msg.cid = 0x5325;
+ msg.llid_r = 0x25;
+ msg.result = CONN_FAILURE_OTHER;
+ msg.cspec_proposed.cinfo_forward.valid = CINFO_VALID;
+ msg.cspec_proposed.cinfo_forward.mac_service_type = MAC_CONTENTION;
+ msg.cspec_proposed.cinfo_forward.user_priority = USER_PRIORITY_CAP0;
+ msg.cspec_proposed.cinfo_forward.ats = ATS_FOR_HLE;
+ msg.cspec_proposed.cinfo_forward.smoothing = SMOOTHING_REQUESTED;
+
+ msg.cspec_proposed.cinfo_reverse.valid = CINFO_VALID;
+ msg.cspec_proposed.cinfo_reverse.mac_service_type = MAC_CONTENTION;
+ msg.cspec_proposed.cinfo_reverse.user_priority = USER_PRIORITY_CAP0;
+ msg.cspec_proposed.cinfo_reverse.ats = ATS_FOR_HLE;
+ msg.cspec_proposed.cinfo_reverse.smoothing = SMOOTHING_REQUESTED;
+
+ msg.cspec_proposed.qmp_forward.valid.delay_bound_available = true;
+ msg.cspec_proposed.qmp_forward.valid.jitter_bound_available = true;
+ msg.cspec_proposed.qmp_forward.valid.average_msdu_size_available = true;
+ msg.cspec_proposed.qmp_forward.valid.maximum_msdu_size_available = true;
+ msg.cspec_proposed.qmp_forward.valid.average_data_rate_available = true;
+ msg.cspec_proposed.qmp_forward.valid.minimum_data_rate_available = true;
+ msg.cspec_proposed.qmp_forward.valid.maximum_data_rate_available = true;
+ msg.cspec_proposed.qmp_forward.valid.minimum_inter_txop_time_available = true;
+ msg.cspec_proposed.qmp_forward.valid.maximum_inter_txop_time_available = true;
+ msg.cspec_proposed.qmp_forward.valid.maximum_burst_size_available = true;
+ msg.cspec_proposed.qmp_forward.valid.exception_policy_available = true;
+ msg.cspec_proposed.qmp_forward.valid.inactivity_interval_available = true;
+ msg.cspec_proposed.qmp_forward.valid.msdu_error_rate_available = true;
+ msg.cspec_proposed.qmp_forward.valid.clst_available = true;
+ msg.cspec_proposed.qmp_forward.valid.cdesc_available = true;
+ msg.cspec_proposed.qmp_forward.valid.ats_tolerance_available = true;
+ msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_data_rate_available = true;
+ msg.cspec_proposed.qmp_forward.valid.original_average_data_rate_available = true;
+ msg.cspec_proposed.qmp_forward.valid.rx_window_size_available = true;
+ msg.cspec_proposed.qmp_forward.valid.smoothing_buffer_size_available = true;
+ msg.cspec_proposed.qmp_forward.valid.bidirectional_burst_available = true;
+ msg.cspec_proposed.qmp_forward.valid.txops_per_beacon_period_available = true;
+ msg.cspec_proposed.qmp_forward.valid.average_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_forward.valid.ppb_threshold_available = true;
+ msg.cspec_proposed.qmp_forward.valid.surplus_bandwith_available = true;
+ msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_forward.valid.cco_bidirectional_burst_available = true;
+ msg.cspec_proposed.qmp_forward.cm.delay_bound = 0x01010101;
+ msg.cspec_proposed.qmp_forward.cm.jitter_bound = 0x10101010;
+ msg.cspec_proposed.qmp_forward.cm.average_msdu_size = 0XF0F0;
+ msg.cspec_proposed.qmp_forward.cm.maximum_msdu_size = 0XF0F0;
+ msg.cspec_proposed.qmp_forward.cm.average_data_rate = 0x0F0F;
+ msg.cspec_proposed.qmp_forward.cm.minimum_data_rate = 0x0F0F;
+ msg.cspec_proposed.qmp_forward.cm.maximum_data_rate = 0x0F0F;
+ msg.cspec_proposed.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.cspec_proposed.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.cspec_proposed.qmp_forward.cm.maximum_burst_size = 0x00FF;
+ msg.cspec_proposed.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.cspec_proposed.qmp_forward.cm.inactivity_interval = 0X00FF00FF;
+ msg.cspec_proposed.qmp_forward.cm.msdu_error_rate = 0x00FF;
+ msg.cspec_proposed.qmp_forward.cm.clst = 0x00;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ip_version = 0x00;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.source_port = 0x0FF1;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.destination_port = 0xFFF1;
+ msg.cspec_proposed.qmp_forward.cm.cdesc.protocol_type = 0x00;
+ msg.cspec_proposed.qmp_forward.cm.ats_tolerance = 0x00FF;
+ msg.cspec_proposed.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.cspec_proposed.qmp_forward.cm.original_average_data_rate = 0x000F;
+ msg.cspec_proposed.qmp_forward.cm.rx_window_size = 0x100F;
+ msg.cspec_proposed.qmp_forward.cm.smoothing_buffer_size = 0x100F10;
+ msg.cspec_proposed.qmp_forward.cm.bidirectional_burst = 0x01;
+ msg.cspec_proposed.qmp_forward.cco.txops_per_beacon_period = 0x15;
+ msg.cspec_proposed.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.cspec_proposed.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec_proposed.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec_proposed.qmp_forward.cco.ppb_threshold = 0x0FF0;
+ msg.cspec_proposed.qmp_forward.cco.surplus_bandwith = 0x0FF0;
+ msg.cspec_proposed.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec_proposed.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec_proposed.qmp_forward.cco.cco_bidirectional_burst = 0x01;
+
+ msg.cspec_proposed.qmp_reverse.valid.delay_bound_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.jitter_bound_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.average_msdu_size_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.maximum_msdu_size_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.average_data_rate_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.minimum_data_rate_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.maximum_data_rate_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.minimum_inter_txop_time_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.maximum_inter_txop_time_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.maximum_burst_size_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.exception_policy_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.inactivity_interval_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.msdu_error_rate_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.clst_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.cdesc_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.ats_tolerance_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.smallest_tolerable_data_rate_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.original_average_data_rate_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.rx_window_size_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.smoothing_buffer_size_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.bidirectional_burst_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.txops_per_beacon_period_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.ppb_threshold_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.surplus_bandwith_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.cspec_proposed.qmp_reverse.valid.cco_bidirectional_burst_available = true;
+ msg.cspec_proposed.qmp_reverse.cm.delay_bound = 0x01010101;
+ msg.cspec_proposed.qmp_reverse.cm.jitter_bound = 0x10101010;
+ msg.cspec_proposed.qmp_reverse.cm.average_msdu_size = 0XF0F0;
+ msg.cspec_proposed.qmp_reverse.cm.maximum_msdu_size = 0XF0F0;
+ msg.cspec_proposed.qmp_reverse.cm.average_data_rate = 0x0F0F;
+ msg.cspec_proposed.qmp_reverse.cm.minimum_data_rate = 0x0F0F;
+ msg.cspec_proposed.qmp_reverse.cm.maximum_data_rate = 0x0F0F;
+ msg.cspec_proposed.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.cspec_proposed.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.cspec_proposed.qmp_reverse.cm.maximum_burst_size = 0x00FF;
+ msg.cspec_proposed.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.cspec_proposed.qmp_reverse.cm.inactivity_interval = 0X00FF00FF;
+ msg.cspec_proposed.qmp_reverse.cm.msdu_error_rate = 0x00FF;
+ msg.cspec_proposed.qmp_reverse.cm.clst = 0x00;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ip_version = 0x00;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.source_port = 0x0FF1;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.destination_port = 0xFFF1;
+ msg.cspec_proposed.qmp_reverse.cm.cdesc.protocol_type = 0x00;
+ msg.cspec_proposed.qmp_reverse.cm.ats_tolerance = 0x00FF;
+ msg.cspec_proposed.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.cspec_proposed.qmp_reverse.cm.original_average_data_rate = 0x000F;
+ msg.cspec_proposed.qmp_reverse.cm.rx_window_size = 0x100F;
+ msg.cspec_proposed.qmp_reverse.cm.smoothing_buffer_size = 0x100F10;
+ msg.cspec_proposed.qmp_reverse.cm.bidirectional_burst = 0x01;
+ msg.cspec_proposed.qmp_reverse.cco.txops_per_beacon_period = 0x15;
+ msg.cspec_proposed.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.cspec_proposed.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec_proposed.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec_proposed.qmp_reverse.cco.ppb_threshold = 0x0FF0;
+ msg.cspec_proposed.qmp_reverse.cco.surplus_bandwith = 0x0FF0;
+ msg.cspec_proposed.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec_proposed.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec_proposed.qmp_reverse.cco.cco_bidirectional_burst = 0x01;
+
+
+ {
+
+ msg_mme_t test_mme;
+
+ msg_cm_conn_new_cnf_set_on_mme_msg(&test_mme, &msg);
+
+
+ int i;
+
+ for(i=0; i < 378; i++)
+ {
+ test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_new_cnf_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_new_cnf_1.mm_entry[i]);
+ }
+ }
+
+
+ }test_end;
+
+
+ test_begin(t, "test case 2")
+ {
+
+ msg_cm_conn_new_cnf_init(&msg);
+ msg.cid = 0x5325;
+ msg.llid_r = 0x25;
+ msg.result = CONN_SUCCESS;
+
+ {
+ msg_mme_t test_mme;
+ int i;
+
+ msg_cm_conn_new_cnf_set_on_mme_msg(&test_mme, &msg);
+
+ for(i=0; i < 3; i++)
+ {
+ test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_new_cnf_2.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_new_cnf_2.mm_entry[i]);
+ }
+ }
+
+
+
+
+ }test_end;
+
+
+}
+
+
+void
+test_msg_cm_conn_new_cnf_get_from_mme_msg(test_t t)
+{
+ msg_cm_conn_new_cnf_t msg;
+
+ test_case_begin(t, "TEST msg_cm_conn_new_cnf_get_from_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+ msg_cm_conn_new_cnf_init(&msg);
+
+ msg_cm_conn_new_cnf_get_from_mme_msg(&msg_cm_conn_new_cnf_1, &msg);
+
+ test_fail_unless( msg.cid == 0x5325 );
+ test_fail_unless( msg.llid_r == 0x25 );
+ test_fail_unless( msg.result == CONN_FAILURE_OTHER );
+ test_fail_unless(msg.cspec_proposed.cinfo_forward.valid == CINFO_VALID );
+ test_fail_unless(msg.cspec_proposed.cinfo_forward.mac_service_type == MAC_CONTENTION);
+ test_fail_unless(msg.cspec_proposed.cinfo_forward.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless(msg.cspec_proposed.cinfo_forward.ats == ATS_FOR_HLE);
+ test_fail_unless(msg.cspec_proposed.cinfo_forward.smoothing = SMOOTHING_REQUESTED);
+
+ test_fail_unless(msg.cspec_proposed.cinfo_reverse.valid == CINFO_VALID );
+ test_fail_unless(msg.cspec_proposed.cinfo_reverse.mac_service_type == MAC_CONTENTION);
+ test_fail_unless(msg.cspec_proposed.cinfo_reverse.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless(msg.cspec_proposed.cinfo_reverse.ats == ATS_FOR_HLE);
+ test_fail_unless(msg.cspec_proposed.cinfo_reverse.smoothing = SMOOTHING_REQUESTED);
+
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec_proposed.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+
+ msg_cm_conn_new_cnf_init(&msg);
+
+ msg_cm_conn_new_cnf_get_from_mme_msg(&msg_cm_conn_new_cnf_2, &msg);
+
+
+ test_fail_unless( msg.cid == 0x5325 );
+ test_fail_unless( msg.llid_r == 0x25 );
+ test_fail_unless( msg.result == CONN_SUCCESS );
+
+
+ }test_end;
+}
+
+
+void
+test_msg_cm_conn_new_cnf(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin(t, "TEST MESSAGE CM_CONN_NEW_CNF");
+
+ test_msg_cm_conn_new_cnf_get_from_mme_msg(t);
+ test_msg_cm_conn_new_cnf_set_on_mme_msg(t);
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn_new_req.c b/cesar/cp/msg/test/src/test_msg_cm_conn_new_req.c
new file mode 100644
index 0000000000..489a777cb0
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn_new_req.c
@@ -0,0 +1,879 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_new_req.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
+
+msg_mme_t msg_cm_conn_new_req =
+{
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // oda
+ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // osa
+ 0, // ieee tag
+ 0x88E1, // m_type
+ 0, // mmv
+ CM_CONN_NEW_REQ, // mm_types
+ { 0, 0, 0}, //fmi
+ {
+ 0x53, // CID
+ 0x53, //CID
+ 0x01, // CSPEC Length :338 bytes
+ 0x54, // CSPEC Length :
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priori ty
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY copy
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ 0x00, // Classifier Version Classifier_rule
+ 0x08, // Number of classifier rule
+ 0x00, // Classifier Rule identifier //Ethernet Destination Address
+ 0x01, // Classifier Rule data
+ 0x02, // Classifier Rule data
+ 0x03, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x05, // Classifier Rule data
+ 0x06, // Classifier Rule data
+ 0x01, // Classifier Rule identifier //Ethernet Source Address
+ 0x06, // Classifier Rule data
+ 0x05, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x03, // Classifier Rule data
+ 0x02, // Classifier Rule data
+ 0x01, // Classifier Rule data
+ 0X04, // Classifier Rule identifier //IPV4 type of service
+ 0x08, // Classifier Rule data
+ 0x05, // Classifier Rule identifier //IPV4 Proto
+ 0x02, // Classifier Rule data
+ 0x06, // Classifier Rule identifier //IPV4 source addr
+ 0x04, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x07, // Classifier Rule identifier //IPV4 destination addr
+ 0x34, // Classifier Rule data
+ 0x34, // Classifier Rule data
+ 0x34, // Classifier Rule data
+ 0x34, // Classifier Rule data
+ 0x0C, // Classifier Rule identifier //TCP Source port
+ 0x54, // Classifier Rule data
+ 0X32,
+ 0x0D, // Classifier Rule identifier //TCP Destination Port
+ 0x34, // Classifier Rule data
+ 0x54, // Classifier Rule data
+
+}};
+
+
+
+void
+test_msg_cm_conn_new_req_get_from_mme_msg(test_t t)
+{
+ msg_cm_conn_new_req_t msg;
+
+ test_case_begin(t, "TEST msg_cm_conn_new_req_get_from_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+
+ msg_cm_conn_new_req_init(&msg);
+
+ msg_cm_conn_new_req_get_from_mme_msg(&(msg_cm_conn_new_req), &msg);
+
+ test_fail_unless(msg.cid == 0x5353);
+
+ test_fail_unless(msg.cspec.cinfo_forward.valid == CINFO_VALID );
+ test_fail_unless(msg.cspec.cinfo_forward.mac_service_type == MAC_CONTENTION);
+ test_fail_unless(msg.cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless(msg.cspec.cinfo_forward.ats == ATS_FOR_HLE);
+ test_fail_unless(msg.cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED);
+
+ test_fail_unless(msg.cspec.cinfo_reverse.valid == CINFO_VALID );
+ test_fail_unless(msg.cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION);
+ test_fail_unless(msg.cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless(msg.cspec.cinfo_reverse.ats == ATS_FOR_HLE);
+ test_fail_unless(msg.cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED);
+
+ test_fail_unless( msg.cspec.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.cspec.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.cspec.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.cspec.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.cspec.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.cspec.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.cspec.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.cspec.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+
+ test_fail_unless( msg.cspec.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.cspec.qmp_forward.valid.cco_bidirectional_burst_available == true);
+
+ test_fail_unless( msg.cspec.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.cspec.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+ test_fail_unless( msg.classifier_rule.classifier_version == CLASSIFIER_CURRENT_VERSION);
+ test_fail_unless( msg.classifier_rule.nbr_rules == 8 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ethernet_destination_address_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ethernet_source_address_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.vlan_user_priority_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.vlan_id_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_type_of_protocol_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_protocol_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_source_address_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv4_destination_address_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_traffic_class_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_flow_label_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_source_address_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.ipv6_destination_address_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.tcp_source_port_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.tcp_destination_port_field_available == 1 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.udp_source_port_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.classifier_rules_available.udp_destination_port_field_available == 0 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[0] == 0x01 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[1] == 0x02 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[2] == 0x03 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[3] == 0x04 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[4] == 0x05 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_destination_address[5] == 0x06 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_source_address[0] == 0x06 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_source_address[1] == 0x05 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_source_address[2] == 0x04 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_source_address[3] == 0x03 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_source_address[4] == 0x02 );
+ test_fail_unless( msg.classifier_rule.data.ethernet_source_address[5] == 0x01 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_type_of_service == 0x08 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_protocol == 0x02);
+ test_fail_unless( msg.classifier_rule.data.ipv4_source_address[0] == 0x04 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_source_address[1] == 0x04 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_source_address[2] == 0x04 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_source_address[3] == 0x04 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[0] == 0x34 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[1] == 0x34 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[2] == 0x34 );
+ test_fail_unless( msg.classifier_rule.data.ipv4_destination_address[3] == 0x34 );
+ test_fail_unless( msg.classifier_rule.data.tcp_destination_port == 0x3454 );
+ test_fail_unless( msg.classifier_rule.data.tcp_source_port == 0x5432 );
+
+ }test_end;
+
+}
+
+
+void
+test_msg_cm_conn_new_req_set_on_mme_msg(test_t t)
+{
+ msg_cm_conn_new_req_t msg;
+ msg_mme_t test_mme;
+
+ test_case_begin(t, "TEST set_msg_cm_conn_new_req");
+
+ test_begin(t, "test case 1")
+ {
+
+ msg_cm_conn_new_req_init(&msg);
+
+ msg.cid = 0x5353;
+
+
+ msg.cspec.cinfo_forward.valid = CINFO_VALID;
+ msg.cspec.cinfo_forward.mac_service_type = MAC_CONTENTION;
+ msg.cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0;
+ msg.cspec.cinfo_forward.ats = ATS_FOR_HLE;
+ msg.cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED;
+
+ msg.cspec.cinfo_reverse.valid = CINFO_VALID ;
+ msg.cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION;
+ msg.cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0;
+ msg.cspec.cinfo_reverse.ats = ATS_FOR_HLE;
+ msg.cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED;
+
+ msg.cspec.qmp_forward.forward_or_reverse = QMP_FORWARD;
+ msg.cspec.qmp_forward.valid.delay_bound_available = true;
+ msg.cspec.qmp_forward.valid.jitter_bound_available = true;
+ msg.cspec.qmp_forward.valid.average_msdu_size_available = true;
+ msg.cspec.qmp_forward.valid.maximum_msdu_size_available = true;
+ msg.cspec.qmp_forward.valid.average_data_rate_available = true;
+ msg.cspec.qmp_forward.valid.minimum_data_rate_available = true;
+ msg.cspec.qmp_forward.valid.maximum_data_rate_available = true;
+ msg.cspec.qmp_forward.valid.minimum_inter_txop_time_available = true;
+ msg.cspec.qmp_forward.valid.maximum_inter_txop_time_available = true;
+ msg.cspec.qmp_forward.valid.maximum_burst_size_available = true;
+ msg.cspec.qmp_forward.valid.exception_policy_available = true;
+ msg.cspec.qmp_forward.valid.inactivity_interval_available = true;
+ msg.cspec.qmp_forward.valid.msdu_error_rate_available = true;
+ msg.cspec.qmp_forward.valid.clst_available = true;
+ msg.cspec.qmp_forward.valid.cdesc_available = true;
+ msg.cspec.qmp_forward.valid.ats_tolerance_available = true;
+ msg.cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true;
+ msg.cspec.qmp_forward.valid.original_average_data_rate_available = true;
+ msg.cspec.qmp_forward.valid.rx_window_size_available = true;
+ msg.cspec.qmp_forward.valid.smoothing_buffer_size_available = true;
+ msg.cspec.qmp_forward.valid.bidirectional_burst_available = true;
+ msg.cspec.qmp_forward.valid.txops_per_beacon_period_available = true;
+ msg.cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_forward.valid.ppb_threshold_available = true;
+ msg.cspec.qmp_forward.valid.surplus_bandwith_available = true;
+ msg.cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_forward.valid.cco_bidirectional_burst_available = true;
+ msg.cspec.qmp_forward.cm.delay_bound = 0x01010101;
+ msg.cspec.qmp_forward.cm.jitter_bound = 0x10101010;
+ msg.cspec.qmp_forward.cm.average_msdu_size = 0XF0F0;
+ msg.cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0;
+ msg.cspec.qmp_forward.cm.average_data_rate = 0x0F0F;
+ msg.cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F;
+ msg.cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F;
+ msg.cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.cspec.qmp_forward.cm.maximum_burst_size = 0x00FF;
+ msg.cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF;
+ msg.cspec.qmp_forward.cm.msdu_error_rate = 0x00FF;
+ msg.cspec.qmp_forward.cm.clst = 0x00;
+ msg.cspec.qmp_forward.cm.cdesc.ip_version = 0x00;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1;
+ msg.cspec.qmp_forward.cm.cdesc.protocol_type = 0x00;
+ msg.cspec.qmp_forward.cm.ats_tolerance = 0x00FF;
+ msg.cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.cspec.qmp_forward.cm.original_average_data_rate = 0x000F;
+ msg.cspec.qmp_forward.cm.rx_window_size = 0x100F;
+ msg.cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10;
+ msg.cspec.qmp_forward.cm.bidirectional_burst = 0x01;
+ msg.cspec.qmp_forward.cco.txops_per_beacon_period = 0x15;
+ msg.cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec.qmp_forward.cco.ppb_threshold = 0x0FF0;
+ msg.cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0;
+ msg.cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01;
+
+ msg.cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE;
+ msg.cspec.qmp_reverse.valid.delay_bound_available = true;
+ msg.cspec.qmp_reverse.valid.jitter_bound_available = true;
+ msg.cspec.qmp_reverse.valid.average_msdu_size_available = true;
+ msg.cspec.qmp_reverse.valid.maximum_msdu_size_available = true;
+ msg.cspec.qmp_reverse.valid.average_data_rate_available = true;
+ msg.cspec.qmp_reverse.valid.minimum_data_rate_available = true;
+ msg.cspec.qmp_reverse.valid.maximum_data_rate_available = true;
+ msg.cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true;
+ msg.cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true;
+ msg.cspec.qmp_reverse.valid.maximum_burst_size_available = true;
+ msg.cspec.qmp_reverse.valid.exception_policy_available = true;
+ msg.cspec.qmp_reverse.valid.inactivity_interval_available = true;
+ msg.cspec.qmp_reverse.valid.msdu_error_rate_available = true;
+ msg.cspec.qmp_reverse.valid.clst_available = true;
+ msg.cspec.qmp_reverse.valid.cdesc_available = true;
+ msg.cspec.qmp_reverse.valid.ats_tolerance_available = true;
+ msg.cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true;
+ msg.cspec.qmp_reverse.valid.original_average_data_rate_available = true;
+ msg.cspec.qmp_reverse.valid.rx_window_size_available = true;
+ msg.cspec.qmp_reverse.valid.smoothing_buffer_size_available = true;
+ msg.cspec.qmp_reverse.valid.bidirectional_burst_available = true;
+ msg.cspec.qmp_reverse.valid.txops_per_beacon_period_available = true;
+ msg.cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_reverse.valid.ppb_threshold_available = true;
+ msg.cspec.qmp_reverse.valid.surplus_bandwith_available = true;
+ msg.cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true;
+
+ msg.cspec.qmp_reverse.cm.delay_bound = 0x01010101;
+ msg.cspec.qmp_reverse.cm.jitter_bound = 0x10101010;
+ msg.cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0;
+ msg.cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0;
+ msg.cspec.qmp_reverse.cm.average_data_rate = 0x0F0F;
+ msg.cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F;
+ msg.cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F;
+ msg.cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF;
+ msg.cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF;
+ msg.cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF;
+ msg.cspec.qmp_reverse.cm.clst = 0x00;
+ msg.cspec.qmp_reverse.cm.cdesc.ip_version = 0x00;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1;
+ msg.cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00;
+ msg.cspec.qmp_reverse.cm.ats_tolerance = 0x00FF;
+ msg.cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.cspec.qmp_reverse.cm.original_average_data_rate = 0x000F;
+ msg.cspec.qmp_reverse.cm.rx_window_size = 0x100F;
+ msg.cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10;
+ msg.cspec.qmp_reverse.cm.bidirectional_burst = 0x01;
+ msg.cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15;
+ msg.cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0;
+ msg.cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0;
+ msg.cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01;
+
+ msg.classifier_rule.classifier_version = CLASSIFIER_CURRENT_VERSION;
+ msg.classifier_rule.nbr_rules = 8 ;
+ msg.classifier_rule.data.classifier_rules_available.ethernet_destination_address_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.ethernet_source_address_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.vlan_user_priority_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.vlan_id_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv4_type_of_protocol_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv4_protocol_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv4_source_address_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv4_destination_address_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv6_traffic_class_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv6_flow_label_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv6_source_address_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.ipv6_destination_address_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.tcp_source_port_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.tcp_destination_port_field_available = 1 ;
+ msg.classifier_rule.data.classifier_rules_available.udp_source_port_field_available = 0 ;
+ msg.classifier_rule.data.classifier_rules_available.udp_destination_port_field_available = 0 ;
+ msg.classifier_rule.data.ethernet_destination_address[0] = 0x01 ;
+ msg.classifier_rule.data.ethernet_destination_address[1] = 0x02 ;
+ msg.classifier_rule.data.ethernet_destination_address[2] = 0x03 ;
+ msg.classifier_rule.data.ethernet_destination_address[3] = 0x04 ;
+ msg.classifier_rule.data.ethernet_destination_address[4] = 0x05 ;
+ msg.classifier_rule.data.ethernet_destination_address[5] = 0x06 ;
+ msg.classifier_rule.data.ethernet_source_address[0] = 0x06 ;
+ msg.classifier_rule.data.ethernet_source_address[1] = 0x05 ;
+ msg.classifier_rule.data.ethernet_source_address[2] = 0x04 ;
+ msg.classifier_rule.data.ethernet_source_address[3] = 0x03 ;
+ msg.classifier_rule.data.ethernet_source_address[4] = 0x02 ;
+ msg.classifier_rule.data.ethernet_source_address[5] = 0x01 ;
+ msg.classifier_rule.data.ipv4_type_of_service = 0x08 ;
+ msg.classifier_rule.data.ipv4_protocol = 0x02;
+ msg.classifier_rule.data.ipv4_source_address[0] = 0x04 ;
+ msg.classifier_rule.data.ipv4_source_address[1] = 0x04 ;
+ msg.classifier_rule.data.ipv4_source_address[2] = 0x04 ;
+ msg.classifier_rule.data.ipv4_source_address[3] = 0x04 ;
+ msg.classifier_rule.data.ipv4_destination_address[0] = 0x34 ;
+ msg.classifier_rule.data.ipv4_destination_address[1] = 0x34 ;
+ msg.classifier_rule.data.ipv4_destination_address[2] = 0x34 ;
+ msg.classifier_rule.data.ipv4_destination_address[3] = 0x34 ;
+ msg.classifier_rule.data.tcp_destination_port = 0x3454 ;
+ msg.classifier_rule.data.tcp_source_port = 0x5432 ;
+
+
+ msg_cm_conn_new_req_set_on_mme_msg(&test_mme, &msg);
+
+ {
+ // test block
+ int i;
+
+ for(i=0; i < 378; i++)
+ {
+ test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_new_req.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_new_req.mm_entry[i]);
+ }
+ }
+ }
+ test_end;
+}
+
+
+
+void
+test_msg_cm_conn_new_req(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin(t, "TEST MESSAGE CM_CONN_NEW_REQ");
+
+ test_msg_cm_conn_new_req_get_from_mme_msg(t);
+ test_msg_cm_conn_new_req_set_on_mme_msg(t);
+
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn_rel_ind.c b/cesar/cp/msg/test/src/test_msg_cm_conn_rel_ind.c
new file mode 100644
index 0000000000..2e4abb8e4b
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn_rel_ind.c
@@ -0,0 +1,800 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_rel_ind.c
+ * \brief This file provides management functions for message CM_CONN_REL.IND.
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
+
+msg_mme_t msg_cm_conn_rel_ind_1 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_NEW_CNF,
+ {0,0,0},
+ {
+ 0x53, // CID (=0x5325)
+ 0x25, // CID
+ 0x01, // reason code (=violated cspec)
+ 0x01, // CSPEC Length :338 bytes
+ 0x54, // CSPEC Length :
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priori ty
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // 0x0FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY copy
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ }
+};
+
+msg_mme_t msg_cm_conn_rel_ind_2 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_NEW_CNF,
+ {0,0,0},
+ {
+ 0x53, // CID (=0x5325)
+ 0x25, // CID
+ 0x00 // reason code (= normal release)
+ }
+};
+
+
+void
+test_msg_cm_conn_rel_ind_set_on_mme_msg(test_t t)
+{
+ msg_cm_conn_rel_ind_t msg;
+
+ test_case_begin(t, "TEST msg_cm_conn_rel_ind_set_on_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+
+ msg_cm_conn_rel_ind_init(&msg);
+
+
+
+ msg.cid = 0x5325;
+ msg.reason_code = VIOLATED_CSPEC;
+ msg.violated_cspec.cinfo_forward.valid = CINFO_VALID;
+ msg.violated_cspec.cinfo_forward.mac_service_type = MAC_CONTENTION;
+ msg.violated_cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0;
+ msg.violated_cspec.cinfo_forward.ats = ATS_FOR_HLE;
+ msg.violated_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED;
+
+ msg.violated_cspec.cinfo_reverse.valid = CINFO_VALID;
+ msg.violated_cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION;
+ msg.violated_cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0;
+ msg.violated_cspec.cinfo_reverse.ats = ATS_FOR_HLE;
+ msg.violated_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED;
+
+ msg.violated_cspec.qmp_forward.valid.delay_bound_available = true;
+ msg.violated_cspec.qmp_forward.valid.jitter_bound_available = true;
+ msg.violated_cspec.qmp_forward.valid.average_msdu_size_available = true;
+ msg.violated_cspec.qmp_forward.valid.maximum_msdu_size_available = true;
+ msg.violated_cspec.qmp_forward.valid.average_data_rate_available = true;
+ msg.violated_cspec.qmp_forward.valid.minimum_data_rate_available = true;
+ msg.violated_cspec.qmp_forward.valid.maximum_data_rate_available = true;
+ msg.violated_cspec.qmp_forward.valid.minimum_inter_txop_time_available = true;
+ msg.violated_cspec.qmp_forward.valid.maximum_inter_txop_time_available = true;
+ msg.violated_cspec.qmp_forward.valid.maximum_burst_size_available = true;
+ msg.violated_cspec.qmp_forward.valid.exception_policy_available = true;
+ msg.violated_cspec.qmp_forward.valid.inactivity_interval_available = true;
+ msg.violated_cspec.qmp_forward.valid.msdu_error_rate_available = true;
+ msg.violated_cspec.qmp_forward.valid.clst_available = true;
+ msg.violated_cspec.qmp_forward.valid.cdesc_available = true;
+ msg.violated_cspec.qmp_forward.valid.ats_tolerance_available = true;
+ msg.violated_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available = true;
+ msg.violated_cspec.qmp_forward.valid.original_average_data_rate_available = true;
+ msg.violated_cspec.qmp_forward.valid.rx_window_size_available = true;
+ msg.violated_cspec.qmp_forward.valid.smoothing_buffer_size_available = true;
+ msg.violated_cspec.qmp_forward.valid.bidirectional_burst_available = true;
+ msg.violated_cspec.qmp_forward.valid.txops_per_beacon_period_available = true;
+ msg.violated_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_forward.valid.ppb_threshold_available = true;
+ msg.violated_cspec.qmp_forward.valid.surplus_bandwith_available = true;
+ msg.violated_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_forward.valid.cco_bidirectional_burst_available = true;
+ msg.violated_cspec.qmp_forward.cm.delay_bound = 0x01010101;
+ msg.violated_cspec.qmp_forward.cm.jitter_bound = 0x10101010;
+ msg.violated_cspec.qmp_forward.cm.average_msdu_size = 0XF0F0;
+ msg.violated_cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0;
+ msg.violated_cspec.qmp_forward.cm.average_data_rate = 0x0F0F;
+ msg.violated_cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F;
+ msg.violated_cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F;
+ msg.violated_cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.violated_cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.violated_cspec.qmp_forward.cm.maximum_burst_size = 0x00FF;
+ msg.violated_cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.violated_cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF;
+ msg.violated_cspec.qmp_forward.cm.msdu_error_rate = 0x00FF;
+ msg.violated_cspec.qmp_forward.cm.clst = 0x00;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ip_version = 0x00;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.violated_cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1;
+ msg.violated_cspec.qmp_forward.cm.cdesc.protocol_type = 0x00;
+ msg.violated_cspec.qmp_forward.cm.ats_tolerance = 0x00FF;
+ msg.violated_cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.violated_cspec.qmp_forward.cm.original_average_data_rate = 0x000F;
+ msg.violated_cspec.qmp_forward.cm.rx_window_size = 0x100F;
+ msg.violated_cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10;
+ msg.violated_cspec.qmp_forward.cm.bidirectional_burst = 0x01;
+ msg.violated_cspec.qmp_forward.cco.txops_per_beacon_period = 0x15;
+ msg.violated_cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.violated_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.violated_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.violated_cspec.qmp_forward.cco.ppb_threshold = 0x0FF0;
+ msg.violated_cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0;
+ msg.violated_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.violated_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.violated_cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01;
+
+ msg.violated_cspec.qmp_reverse.valid.delay_bound_available = true;
+ msg.violated_cspec.qmp_reverse.valid.jitter_bound_available = true;
+ msg.violated_cspec.qmp_reverse.valid.average_msdu_size_available = true;
+ msg.violated_cspec.qmp_reverse.valid.maximum_msdu_size_available = true;
+ msg.violated_cspec.qmp_reverse.valid.average_data_rate_available = true;
+ msg.violated_cspec.qmp_reverse.valid.minimum_data_rate_available = true;
+ msg.violated_cspec.qmp_reverse.valid.maximum_data_rate_available = true;
+ msg.violated_cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true;
+ msg.violated_cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true;
+ msg.violated_cspec.qmp_reverse.valid.maximum_burst_size_available = true;
+ msg.violated_cspec.qmp_reverse.valid.exception_policy_available = true;
+ msg.violated_cspec.qmp_reverse.valid.inactivity_interval_available = true;
+ msg.violated_cspec.qmp_reverse.valid.msdu_error_rate_available = true;
+ msg.violated_cspec.qmp_reverse.valid.clst_available = true;
+ msg.violated_cspec.qmp_reverse.valid.cdesc_available = true;
+ msg.violated_cspec.qmp_reverse.valid.ats_tolerance_available = true;
+ msg.violated_cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true;
+ msg.violated_cspec.qmp_reverse.valid.original_average_data_rate_available = true;
+ msg.violated_cspec.qmp_reverse.valid.rx_window_size_available = true;
+ msg.violated_cspec.qmp_reverse.valid.smoothing_buffer_size_available = true;
+ msg.violated_cspec.qmp_reverse.valid.bidirectional_burst_available = true;
+ msg.violated_cspec.qmp_reverse.valid.txops_per_beacon_period_available = true;
+ msg.violated_cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_reverse.valid.ppb_threshold_available = true;
+ msg.violated_cspec.qmp_reverse.valid.surplus_bandwith_available = true;
+ msg.violated_cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true;
+ msg.violated_cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true;
+ msg.violated_cspec.qmp_reverse.cm.delay_bound = 0x01010101;
+ msg.violated_cspec.qmp_reverse.cm.jitter_bound = 0x10101010;
+ msg.violated_cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0;
+ msg.violated_cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0;
+ msg.violated_cspec.qmp_reverse.cm.average_data_rate = 0x0F0F;
+ msg.violated_cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F;
+ msg.violated_cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F;
+ msg.violated_cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF;
+ msg.violated_cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF;
+ msg.violated_cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF;
+ msg.violated_cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ msg.violated_cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF;
+ msg.violated_cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF;
+ msg.violated_cspec.qmp_reverse.cm.clst = 0x00;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ip_version = 0x00;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1;
+ msg.violated_cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00;
+ msg.violated_cspec.qmp_reverse.cm.ats_tolerance = 0x00FF;
+ msg.violated_cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF;
+ msg.violated_cspec.qmp_reverse.cm.original_average_data_rate = 0x000F;
+ msg.violated_cspec.qmp_reverse.cm.rx_window_size = 0x100F;
+ msg.violated_cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10;
+ msg.violated_cspec.qmp_reverse.cm.bidirectional_burst = 0x01;
+ msg.violated_cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15;
+ msg.violated_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F;
+ msg.violated_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ msg.violated_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ msg.violated_cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0;
+ msg.violated_cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0;
+ msg.violated_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.violated_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ msg.violated_cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01;
+
+
+ {
+
+ msg_mme_t test_mme;
+
+ msg_cm_conn_rel_ind_set_on_mme_msg(&test_mme, &msg);
+
+
+ int i;
+
+ for(i=0; i < 342; i++)
+ {
+ test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_rel_ind_1.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_rel_ind_1.mm_entry[i]);
+ }
+ }
+
+
+ }test_end;
+
+
+ test_begin(t,"test case 2");
+ {
+
+ msg.cid = 0x5325;
+ msg.reason_code = NORMAL_RELEASE;
+
+
+ {
+ msg_mme_t test_mme;
+
+ msg_cm_conn_rel_ind_set_on_mme_msg(&test_mme, &msg);
+
+ int i;
+
+ for(i=0; i<2 ;i++)
+ {
+ test_fail_unless(test_mme.mm_entry[i] == msg_cm_conn_rel_ind_2.mm_entry[i], "Error on test_mme in item %i test = 0x%x msg = 0x%x\n",i,test_mme.mm_entry[i],msg_cm_conn_rel_ind_2.mm_entry[i]);
+ }
+ }
+
+ }test_end;
+}
+
+
+void
+test_msg_cm_conn_rel_ind_get_from_mme_msg(test_t t)
+{
+ msg_cm_conn_rel_ind_t msg;
+
+ test_case_begin(t, "TEST msg_cm_conn_rel_ind_get_from_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+ msg_cm_conn_rel_ind_init(&msg);
+
+ msg_cm_conn_rel_ind_get_from_mme_msg(&msg_cm_conn_rel_ind_1, &msg);
+
+ test_fail_unless( msg.cid == 0x5325 );
+ test_fail_unless( msg.reason_code == VIOLATED_CSPEC );
+ test_fail_unless(msg.violated_cspec.cinfo_forward.valid == CINFO_VALID );
+ test_fail_unless(msg.violated_cspec.cinfo_forward.mac_service_type == MAC_CONTENTION);
+ test_fail_unless(msg.violated_cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless(msg.violated_cspec.cinfo_forward.ats == ATS_FOR_HLE);
+ test_fail_unless(msg.violated_cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED);
+
+ test_fail_unless(msg.violated_cspec.cinfo_reverse.valid == CINFO_VALID );
+ test_fail_unless(msg.violated_cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION);
+ test_fail_unless(msg.violated_cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless(msg.violated_cspec.cinfo_reverse.ats == ATS_FOR_HLE);
+ test_fail_unless(msg.violated_cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED);
+
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_burst_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.delay_bound_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.jitter_bound_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_msdu_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_msdu_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.average_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.exception_policy_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.inactivity_interval_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.msdu_error_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.clst_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.cdesc_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.ats_tolerance_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_data_rate_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.rx_window_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.bidirectional_burst_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.ppb_threshold_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.surplus_bandwith_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_forward.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( msg.violated_cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+ msg_cm_conn_rel_ind_init(&msg);
+
+ msg_cm_conn_rel_ind_get_from_mme_msg(&msg_cm_conn_rel_ind_2, &msg);
+
+ test_fail_unless( msg.cid == 0x5325 );
+ test_fail_unless( msg.reason_code == NORMAL_RELEASE );
+ }test_end;
+}
+
+
+void
+test_msg_cm_conn_rel_ind(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin(t, "TEST MESSAGE CM_CONN_REL_IND");
+
+ test_msg_cm_conn_rel_ind_get_from_mme_msg(t);
+ test_msg_cm_conn_rel_ind_set_on_mme_msg(t);
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c b/cesar/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c
new file mode 100644
index 0000000000..024fcefebc
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_cm_conn_rel_rsp.c
@@ -0,0 +1,90 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_msg_cm_conn_rel_rsp.c
+ * \brief File Description
+ * \ingroup cp/msg
+ *
+ */
+
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm.h"
+
+
+msg_mme_t msg_cm_conn_rel_rsp_1 =
+{
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // ODA
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // OSA
+ 0, // vlan tag
+ 0x88E1,
+ 0, // mmv
+ CM_CONN_REL_RSP,
+ {0,0,0},
+ {
+ 0x53,
+ 0x25
+ }
+};
+
+
+
+void
+test_msg_cm_conn_rel_rsp_get_from_mme_msg(test_t t)
+{
+ msg_cm_conn_rel_rsp_t msg;
+
+ test_case_begin(t, "TEST msg_cm_conn_rel_rsp_get_from_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+ msg_cm_conn_rel_rsp_init(&msg);
+
+ msg_cm_conn_rel_rsp_get_from_mme_msg(&msg_cm_conn_rel_rsp_1, &msg);
+
+ test_fail_unless(msg.cid == 0x5325);
+
+ }test_end;
+}
+
+
+
+void
+test_msg_cm_conn_rel_rsp_set_on_mme_msg(test_t t)
+{
+ msg_cm_conn_rel_rsp_t msg;
+ msg_mme_t result;
+
+ test_case_begin(t, "TEST msg_cm_conn_rel_rsp_set_on_mme_msg");
+
+ test_begin(t, "test case 1")
+ {
+ msg_cm_conn_rel_rsp_init(&msg);
+
+ msg.cid = 0x5325;
+
+ msg_cm_conn_rel_rsp_set_on_mme_msg(&result, &msg);
+
+ test_fail_unless( result.mm_entry[0] == 0x53);
+ test_fail_unless( result.mm_entry[1] == 0x25);
+
+ }test_end;
+}
+
+
+
+void
+test_msg_cm_conn_rel_rsp(test_t t)
+{
+ dbg_assert(t);
+
+ test_suite_begin(t, "TEST MESSAGE CM_CONN_REL_RSP");
+
+ test_msg_cm_conn_rel_rsp_get_from_mme_msg(t);
+ test_msg_cm_conn_rel_rsp_set_on_mme_msg(t);
+
+}
diff --git a/cesar/cp/msg/test/src/test_msg_field.c b/cesar/cp/msg/test/src/test_msg_field.c
new file mode 100644
index 0000000000..2663c13209
--- /dev/null
+++ b/cesar/cp/msg/test/src/test_msg_field.c
@@ -0,0 +1,2898 @@
+/* Cesar project {{{
+ *
+ * Copyright (C) 2007 Spidcom
+ *
+ * <<<Licence>>>
+ *
+ * }}}
+ * \file test_conn_msg_field.c
+ * \brief File Description
+ * \ingroup cp/conn
+ *
+ */
+
+#include "common/std.h"
+#include "cp/msg/inc/msg_cm_conn.h"
+#include "cp/msg/inc/msg_field.h"
+
+u8 test_stream_forward_1[255] =
+{
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Biderectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE
+};
+
+
+u8 test_stream_reverse_1[255] =
+{
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Biderectional Burst
+ 0x01 // QMP BODY
+};
+
+
+msg_mme_t test_msg_1 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS OSA
+ { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 }, // MAC_ADDRESS ODA
+ 0x00000000, // VLAN_TAG
+ 0x88E1, // M_TYPE
+ 0x00, // MMV
+ CM_CONN_NEW_REQ, // Management Message Type
+ { 1, 1, 1 }, // fmi
+ { 0x53, // CID
+ 0x53, //CID
+ 0x01, // CSPEC Length :338 bytes
+ 0x52, // CSPEC Length :
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Biderectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Biderectional Burst
+ 0x01, // QMP BODY
+ 0x00, // Classifier Version Classifier_rule
+ 0x08, // Number of classifier rule
+ 0x01, // Classifier Rule identifier //Ethernet Source Address
+ 0x06, // Classifier Rule data
+ 0x05, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x03, // Classifier Rule data
+ 0x02, // Classifier Rule data
+ 0x01, // Classifier Rule data
+ 0x00, // Classifier Rule identifier //Ethernet Destination Address
+ 0x01, // Classifier Rule data
+ 0x02, // Classifier Rule data
+ 0x03, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x05, // Classifier Rule data
+ 0x06, // Classifier Rule data
+ 0X04, // Classifier Rule identifier //IPV4 type of service
+ 0x08, // Classifier Rule data
+ 0x05, // Classifier Rule identifier //IPV4 Proto
+ 0x02, // Classifier Rule data
+ 0x06, // Classifier Rule identifier //IPV4 source addr
+ 0x04, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x04, // Classifier Rule data
+ 0x07, // Classifier Rule identifier //IPV4 destination addr
+ 0x34, // Classifier Rule data
+ 0x34, // Classifier Rule data
+ 0x34, // Classifier Rule data
+ 0x34, // Classifier Rule data
+ 0x0D, // Classifier Rule identifier //TCP Destination Port
+ 0x34, // Classifier Rule data
+ 0x54, // Classifier Rule data
+ 0x0C, // Classifier Rule identifier //TCP Source port
+ 0x54, // Classifier Rule data
+ 0X32
+
+}
+};
+
+msg_mme_t test_msg_2 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS OSA
+ { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 }, // MAC_ADDRESS ODA
+ 0x00000000, // VLAN_TAG
+ 0x88E1, // M_TYPE
+ 0x00, // MMV
+ CM_CONN_NEW_REQ, // Management Message Type
+ { 1, 1, 1 }, // fmi
+ { 0x53, // CID
+ 0x53, // CID
+ 0x00, // CSPEC Length
+ 0xAA, // CSPEC Length
+ CINFO_VALID, // CINFO Valid? CINFO Forward
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ CINFO_NOT_VALID, // CINFO Valid? CINFO Reverse
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_FORWARD,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_FORWARD,
+ 0x01, // QMP body length
+ 0x89, // FID: Biderectional Burst
+ 0x01, // QMP BODY
+ 0x00, // Classifier Version
+ 0x0A, // Number of Classifier Rule
+ 0x00, // Classifier Rule Identifier // Ethernet Destination Addr
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x01, // Classifier Rule Identifier // Ethernet Source Addr
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x02, // Classifier Rule Identifier // VLAN User Priority
+ 0x34, // Classifier Rule Data
+ 0x03, // Classifier Rule Identifier // VLAN ID
+ 0x45, // Classifier Rule Data
+ 0x54, // Classifier Rule Data
+ 0x08, // Classifier Rule Identifier // IPV6 traffic Class
+ 0x45, // Classifier Rule Data
+ 0x09, // Classifier Rule Identifier // IPV6 Flow Label
+ 0x05, // Classifier Rule Data
+ 0x15, // Classifier Rule Data
+ 0x25, // Classifier Rule Data
+ 0x0A, // Classifier Rule Identifier // IPV6 Source Address
+ 0x05, // Classifier Rule Data 1
+ 0x15, // Classifier Rule Data 2
+ 0x25, // Classifier Rule Data 3
+ 0x05, // Classifier Rule Data 4
+ 0x15, // Classifier Rule Data 5
+ 0x25, // Classifier Rule Data 6
+ 0x05, // Classifier Rule Data 7
+ 0x15, // Classifier Rule Data 8
+ 0x25, // Classifier Rule Data 9
+ 0x05, // Classifier Rule Data 10
+ 0x15, // Classifier Rule Data 11
+ 0x25, // Classifier Rule Data 12
+ 0x05, // Classifier Rule Data 13
+ 0x15, // Classifier Rule Data 14
+ 0x25, // Classifier Rule Data 15
+ 0x05, // Classifier Rule Data 16
+ 0x0B, // Classifier Rule Identifier // IPV6 Source Address
+ 0x15, // Classifier Rule Data 1
+ 0x25, // Classifier Rule Data 2
+ 0x35, // Classifier Rule Data 3
+ 0x15, // Classifier Rule Data 4
+ 0x25, // Classifier Rule Data 5
+ 0x35, // Classifier Rule Data 6
+ 0x15, // Classifier Rule Data 7
+ 0x25, // Classifier Rule Data 8
+ 0x35, // Classifier Rule Data 9
+ 0x15, // Classifier Rule Data 10
+ 0x25, // Classifier Rule Data 11
+ 0x35, // Classifier Rule Data 12
+ 0x15, // Classifier Rule Data 13
+ 0x25, // Classifier Rule Data 14
+ 0x35, // Classifier Rule Data 15
+ 0x15, // Classifier Rule Data 16
+ 0x0E, // Classifier Rule Identifier // UDP Source Port
+ 0x34, // Classifier Rule Data
+ 0x83, // Classifier Rule Data
+ 0x0F, // Classifier Rule Identifier // UDP Destination Port
+ 0x83, // Classifier Rule Data
+ 0x43 // Classifier Rule Data
+
+
+ } };
+
+msg_mme_t test_msg_3 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS OSA
+ { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 }, // MAC_ADDRESS ODA
+ 0x00000000, // VLAN_TAG
+ 0x88E1, // M_TYPE
+ 0x00, // MMV
+ CM_CONN_NEW_REQ, // Management Message Type
+ { 1, 1, 1 }, // fmi
+ { 0x53, // CID
+ 0x53, // CID
+ 0x00, // CSPEC Length
+ 0xAF, // CSPEC Length
+ CINFO_NOT_VALID, // CINFO Valid? CINFO Forward
+ CINFO_VALID, // CINFO Valid? CINFO Reverse
+ MAC_CONTENTION, // Mac Service Type
+ USER_PRIORITY_CAP0, // User Priority
+ ATS_FOR_HLE, // Arrival Time Stamp
+ SMOOTHING_REQUESTED, // Smoothing
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x00, // FID: Delay bound
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x01, // FID: Jitter bound
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x02, // FID: Average MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x03, // FID: Maximum MSDU Size
+ 0xF0, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x04, // FID: Average Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x05, // FID: Minimum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x06, // FID: Maximum Data Rate
+ 0x0F, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x07, // FID: Maximum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x08, // FID: Minimum Inter-TXOP time
+ 0xFF, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x09, // FID: Maximum Burst Size
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0A, // FID: Exception Policy
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x04, // QMP body length
+ 0x0B, // FID: inactivity_interval
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x0C, // FID: MSDU Error Rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x0D, // FID: CLST
+ 0x00, // QMP BODY
+ QMP_REVERSE,
+ 0x0E, // QMP body length
+ 0x0E, // FID: CDESC
+ 0x00, // IP Version 4
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x01, // Source IP
+ 0x0F, // source port
+ 0xF1, // source port
+ 0x01, // Dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0x01, // dest IP
+ 0xFF, // dest port
+ 0xF1, // dest port
+ 0x00, // ip proto type
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x10, // FID: ATS Tolerance
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x11, // FID: Smallest tolerable Average data rate
+ 0x00, // QMP BODY
+ 0xFF, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x12, // FID: Original Average data rate
+ 0x00, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x13, // FID: rx_window_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x03, // QMP body length
+ 0x14, // FID: smoothing_buffer_size
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ 0x10, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x15, // FID: Bidirectional Burst
+ 0x01, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x80, // FID: TXOPs per Beacon Period
+ 0x15, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x81, // FID: Average Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x82, // FID: Minimum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x83, // FID: Maximum Number of PBs per TXOP
+ 0x10, // QMP BODY
+ 0x0F, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x84, // FID: PPB_Threshold
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x85, // FID: Surplus Bandwidth
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x87, // FID: Smallest Tolerable Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x02, // QMP body length
+ 0x88, // FID: Original Average Number of PBs per TXOP
+ 0x0F, // QMP BODY
+ 0xF0, // QMP BODY
+ QMP_REVERSE,
+ 0x01, // QMP body length
+ 0x89, // FID: Biderectional Burst
+ 0x01, // QMP BODY
+ 0x00, // Classifier Version
+ 0x0A, // Number of Classifier Rule
+ 0x00, // Classifier Rule Identifier // Ethernet Destination Addr
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x22, // Classifier Rule Data
+ 0x01, // Classifier Rule Identifier // Ethernet Source Addr
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x33, // Classifier Rule Data
+ 0x02, // Classifier Rule Identifier // VLAN User Priority
+ 0x34, // Classifier Rule Data
+ 0x03, // Classifier Rule Identifier // VLAN ID
+ 0x45, // Classifier Rule Data
+ 0x54, // Classifier Rule Data
+ 0x08, // Classifier Rule Identifier // IPV6 traffic Class
+ 0x45, // Classifier Rule Data
+ 0x09, // Classifier Rule Identifier // IPV6 Flow Label
+ 0x05, // Classifier Rule Data
+ 0x15, // Classifier Rule Data
+ 0x25, // Classifier Rule Data
+ 0x0A, // Classifier Rule Identifier // IPV6 Source Address
+ 0x05, // Classifier Rule Data 1
+ 0x15, // Classifier Rule Data 2
+ 0x25, // Classifier Rule Data 3
+ 0x05, // Classifier Rule Data 4
+ 0x15, // Classifier Rule Data 5
+ 0x25, // Classifier Rule Data 6
+ 0x05, // Classifier Rule Data 7
+ 0x15, // Classifier Rule Data 8
+ 0x25, // Classifier Rule Data 9
+ 0x05, // Classifier Rule Data 10
+ 0x15, // Classifier Rule Data 11
+ 0x25, // Classifier Rule Data 12
+ 0x05, // Classifier Rule Data 13
+ 0x15, // Classifier Rule Data 14
+ 0x25, // Classifier Rule Data 15
+ 0x05, // Classifier Rule Data 16
+ 0x0B, // Classifier Rule Identifier // IPV6 Source Address
+ 0x15, // Classifier Rule Data 1
+ 0x25, // Classifier Rule Data 2
+ 0x35, // Classifier Rule Data 3
+ 0x15, // Classifier Rule Data 4
+ 0x25, // Classifier Rule Data 5
+ 0x35, // Classifier Rule Data 6
+ 0x15, // Classifier Rule Data 7
+ 0x25, // Classifier Rule Data 8
+ 0x35, // Classifier Rule Data 9
+ 0x15, // Classifier Rule Data 10
+ 0x25, // Classifier Rule Data 11
+ 0x35, // Classifier Rule Data 12
+ 0x15, // Classifier Rule Data 13
+ 0x25, // Classifier Rule Data 14
+ 0x35, // Classifier Rule Data 15
+ 0x15, // Classifier Rule Data 16
+ 0x0E, // Classifier Rule Identifier // UDP Source Port
+ 0x34, // Classifier Rule Data
+ 0x83, // Classifier Rule Data
+ 0x0F, // Classifier Rule Identifier // UDP Destination Port
+ 0x83, // Classifier Rule Data
+ 0x43 // Classifier Rule Data
+}
+};
+
+msg_mme_t test_msg_4 = { { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 }, // MAC_ADDRESS OSA
+ { 0x02, 0x02, 0x02, 0x02, 0x02, 0x02 }, // MAC_ADDRESS ODA
+ 0x00000000, // VLAN_TAG
+ 0x88E1, // M_TYPE
+ 0x00, // MMV
+ CM_CONN_NEW_REQ, // Management Message Type
+ { 1, 1, 1 }, // fmi
+ { 0x53, // CID
+ 0x53, // CID
+ 0x00, // CSPEC Length
+ 0x09, // CSPEC Length
+ CINFO_NOT_VALID, // CINFO Valid? CINFO Forward
+ CINFO_NOT_VALID, // CINFO Valid? CINFO Reverse
+ QMP_FORWARD, // QMP Forward QMP
+ 0x04, // QMP body length
+ 0X00, // FID Delay Bound
+ 0x00, // QMP body
+ 0X00, // QMP body
+ 0x00, // QMP body
+ 0x00, // Version Number of the Classifier Rule
+ 0x01 // Number of classifier Rule
+
+ } };
+/*
+void conn_test_is_valid_cm_conn_new_req (test_t t)
+{
+ // Intialization
+ msg_mme_t msg_test;
+
+ test_case_begin (t, "TEST is_valid_cm_conn_new_req");
+
+ test_begin(t, "valid frame")
+ {
+ msg_test.mm_type = CM_CONN_NEW_REQ;
+ msg_test.oda[2] = 4;
+ msg_test.osa[4] = 35;
+
+ test_fail_unless( is_valid_cm_conn_new_req(&msg_test) == true );
+
+ }
+ test_end;
+
+ test_begin(t, "invalid oda")
+ {
+
+ bzero(msg_test.oda,6);
+
+ test_fail_unless( is_valid_cm_conn_new_req(&msg_test) == false );
+
+ }
+ test_end;
+
+ msg_test.oda[3] = 23;
+ bzero (msg_test.osa, 6);
+
+ test_begin(t, "invalid osa")
+ {
+ test_fail_unless( is_valid_cm_conn_new_req(&msg_test) == false);
+
+ }
+ test_end;
+
+ msg_test.osa[4] = 34;
+ dbg_assert_ptr (t);
+ msg_test.mm_type = CM_CONN_INFO_REQ;
+
+ test_begin(t, "m_type invalid")
+ {
+ test_fail_unless( is_valid_cm_conn_new_req(&msg_test) == false);
+
+ }
+ test_end;
+
+}
+*/
+
+
+void
+conn_test_set_cinfo_on_stream(test_t t )
+{
+ cinfo_t local_cinfo;
+ u8 stream[10];
+ len_t len;
+
+ test_case_begin(t, "TEST set_cinfo_on_stream");
+
+ test_begin(t, "test case 1 : cinfo valid")
+ {
+ msg_field_cinfo_init(&local_cinfo);
+
+ local_cinfo.valid = CINFO_NOT_VALID;
+
+ len = msg_field_cinfo_set_on_stream(stream, &local_cinfo);
+
+ test_fail_unless( len == 1);
+ test_fail_unless( stream[0] == CINFO_NOT_VALID);
+
+ }test_end;
+
+ test_begin(t, "test case 2 : cinfo not valid")
+ {
+ msg_field_cinfo_init(&local_cinfo);
+
+ local_cinfo.valid = CINFO_VALID;
+ local_cinfo.mac_service_type = MAC_CONTENTION;
+ local_cinfo.user_priority = USER_PRIORITY_CAP0;
+ local_cinfo.ats = ATS_FOR_HLE;
+ local_cinfo.smoothing = SMOOTHING_REQUESTED;
+
+ len = msg_field_cinfo_set_on_stream(stream, &local_cinfo);
+
+ test_fail_unless( len == 5);
+ test_fail_unless( stream[0] == CINFO_VALID);
+ test_fail_unless( stream[1] == MAC_CONTENTION);
+ test_fail_unless( stream[2] == USER_PRIORITY_CAP0);
+ test_fail_unless( stream[3] == ATS_FOR_HLE);
+ test_fail_unless( stream[4] == SMOOTHING_REQUESTED);
+
+ }test_end;
+}
+
+
+void
+conn_test_get_cinfo_from_stream(test_t t)
+{
+ cinfo_t local_cinfo;
+ len_t len;
+
+ test_case_begin(t, "TEST set_cinfo_from_stream");
+
+ test_begin(t, "test case 1 : cinfo valid")
+ {
+ u8 stream = CINFO_NOT_VALID;
+
+ msg_field_cinfo_init( &local_cinfo );
+
+ len = msg_field_cinfo_get_from_stream(&stream, &local_cinfo);
+
+ test_fail_unless( len == 1);
+ test_fail_unless( local_cinfo.valid == CINFO_NOT_VALID);
+
+
+ }test_end;
+
+ test_begin(t, "test case 2 : cinfo not valid")
+ {
+
+ u8 stream[5] = {CINFO_VALID, 0X00, 0X01, 0X01, 0X00};
+
+ msg_field_cinfo_init(&local_cinfo);
+
+ len = msg_field_cinfo_get_from_stream(stream, &local_cinfo);
+
+ test_fail_unless( len == 5);
+ test_fail_unless( local_cinfo.valid == CINFO_VALID);
+ test_fail_unless( local_cinfo.mac_service_type == 0x00);
+ test_fail_unless( local_cinfo.user_priority == 0x01);
+ test_fail_unless( local_cinfo.ats == 0x01);
+ test_fail_unless( local_cinfo.smoothing == 0x00);
+ }test_end;
+}
+
+
+
+void conn_test_get_classifier_rules_from_stream (test_t t)
+{
+ classifier_rules_t local_classifier;
+ classifier_rules_data_t data_classifier;
+ u8 stream[255];
+ len_t len;
+
+ test_case_begin (t, "TEST get_classifier_rule_from_cm_conn_new_req");
+
+ test_begin(t, "test case 1 : IPV4 connexion - tcp")
+ {
+
+ stream[0 ] = 0x00; // Classifier Version Classifier_rule
+ stream[1 ] = 0x09; // Number of classifier rule (8 Homeplug + 1 Vendor Specific)
+ stream[2 ] = 0x01; // Classifier Rule identifier //Ethernet Source Address
+ stream[3 ] = 0x06; // Classifier Rule data
+ stream[4 ] = 0x05; // Classifier Rule data
+ stream[5 ] = 0x04; // Classifier Rule data
+ stream[6 ] = 0x03; // Classifier Rule data
+ stream[7 ] = 0x02; // Classifier Rule data
+ stream[8 ] = 0x01; // Classifier Rule data
+ stream[9 ] = 0x00; // Classifier Rule identifier //Ethernet Destination Address
+ stream[10] = 0x01; // Classifier Rule data
+ stream[11] = 0x02; // Classifier Rule data
+ stream[12] = 0x03; // Classifier Rule data
+ stream[13] = 0x04; // Classifier Rule data
+ stream[14] = 0x05; // Classifier Rule data
+ stream[15] = 0x06; // Classifier Rule data
+ stream[16] = 0X04; // Classifier Rule identifier //IPV4 type of service
+ stream[17] = 0x08; // Classifier Rule data
+ stream[18] = 0x05; // Classifier Rule identifier //IPV4 Proto
+ stream[19] = 0x02; // Classifier Rule data
+ stream[20] = 0x06; // Classifier Rule identifier //IPV4 source addr
+ stream[21] = 0x04; // Classifier Rule data
+ stream[22] = 0x04; // Classifier Rule data
+ stream[23] = 0x04; // Classifier Rule data
+ stream[24] = 0x04; // Classifier Rule data
+ stream[25] = 0x07; // Classifier Rule identifier //IPV4 destination addr
+ stream[26] = 0x34; // Classifier Rule data
+ stream[27] = 0x34; // Classifier Rule data
+ stream[28] = 0x34; // Classifier Rule data
+ stream[29] = 0x34; // Classifier Rule data
+ stream[30] = 0x0D; // Classifier Rule identifier //TCP Dest port
+ stream[31] = 0x34; // Classifier Rule data
+ stream[32] = 0x54; // Classifier Rule data
+ stream[33] = 0x0C; // Classifier Rule identifier //TCP Source port
+ stream[34] = 0x54; // Classifier Rule data
+ stream[35] = 0X32; // Classifier Rule data
+ stream[36] = 0xE0; // Classifier Rule identifier //Vendor Specific
+ stream[37] = 0xAA; // Classifier Rule data
+
+
+ msg_field_classifier_init(&local_classifier);
+
+ len = msg_field_classifier_get_from_stream( stream, &local_classifier );
+ data_classifier = local_classifier.data;
+
+ //test_fail_unless( len == 36, "invalid length : %i", len);
+
+ test_fail_unless( local_classifier.classifier_version == CLASSIFIER_CURRENT_VERSION);
+ test_fail_unless( local_classifier.nbr_rules == 8 );
+ test_fail_unless( data_classifier.classifier_rules_available.ethernet_destination_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ethernet_source_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.vlan_user_priority_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.vlan_id_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_type_of_protocol_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_protocol_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_source_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_destination_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_traffic_class_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_flow_label_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_source_address_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_destination_address_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.tcp_source_port_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.tcp_destination_port_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.udp_source_port_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.udp_destination_port_field_available == 0 );
+
+ test_fail_unless( data_classifier.ethernet_destination_address[0] == 0x01 );
+ test_fail_unless( data_classifier.ethernet_destination_address[1] == 0x02 );
+ test_fail_unless( data_classifier.ethernet_destination_address[2] == 0x03 );
+ test_fail_unless( data_classifier.ethernet_destination_address[3] == 0x04 );
+ test_fail_unless( data_classifier.ethernet_destination_address[4] == 0x05 );
+ test_fail_unless( data_classifier.ethernet_destination_address[5] == 0x06 );
+
+ test_fail_unless( data_classifier.ethernet_source_address[0] == 0x06 );
+ test_fail_unless( data_classifier.ethernet_source_address[1] == 0x05 );
+ test_fail_unless( data_classifier.ethernet_source_address[2] == 0x04 );
+ test_fail_unless( data_classifier.ethernet_source_address[3] == 0x03 );
+ test_fail_unless( data_classifier.ethernet_source_address[4] == 0x02 );
+ test_fail_unless( data_classifier.ethernet_source_address[5] == 0x01 );
+
+ test_fail_unless( data_classifier.ipv4_type_of_service == 0x08 );
+
+ test_fail_unless( data_classifier.ipv4_protocol == 0x02);
+
+ test_fail_unless( data_classifier.ipv4_source_address[0] == 0x04 );
+ test_fail_unless( data_classifier.ipv4_source_address[1] == 0x04 );
+ test_fail_unless( data_classifier.ipv4_source_address[2] == 0x04 );
+ test_fail_unless( data_classifier.ipv4_source_address[3] == 0x04 );
+
+ test_fail_unless( data_classifier.ipv4_destination_address[0] == 0x34 );
+ test_fail_unless( data_classifier.ipv4_destination_address[1] == 0x34 );
+ test_fail_unless( data_classifier.ipv4_destination_address[2] == 0x34 );
+ test_fail_unless( data_classifier.ipv4_destination_address[3] == 0x34 );
+
+ test_fail_unless( data_classifier.tcp_destination_port == 0x3454 );
+
+ test_fail_unless( data_classifier.tcp_source_port == 0x5432 );
+
+ }
+ test_end;
+
+ test_begin(t, "test case 2 : IPV6 connexion - udp")
+ {
+
+
+ stream[0] = 0x00; // Classifier Version
+ stream[1] = 0x0A; // Number of Classifier Rule
+ stream[2] = 0x00; // Classifier Rule Identifier // Ethernet Destination Addr
+ stream[3] = 0x22; // Classifier Rule Data
+ stream[4] = 0x22; // Classifier Rule Data
+ stream[5] = 0x22; // Classifier Rule Data
+ stream[6] = 0x22; // Classifier Rule Data
+ stream[7] = 0x22; // Classifier Rule Data
+ stream[8] = 0x22; // Classifier Rule Data
+ stream[9] = 0x01; // Classifier Rule Identifier // Ethernet Source Addr
+ stream[10] = 0x33; // Classifier Rule Data
+ stream[11] = 0x33; // Classifier Rule Data
+ stream[12] = 0x33; // Classifier Rule Data
+ stream[13] = 0x33; // Classifier Rule Data
+ stream[14] = 0x33; // Classifier Rule Data
+ stream[15] = 0x33; // Classifier Rule Data
+ stream[16] = 0x02; // Classifier Rule Identifier // VLAN User Priority
+ stream[17] = 0x34; // Classifier Rule Data
+ stream[18] = 0x03; // Classifier Rule Identifier // VLAN ID
+ stream[19] = 0x45; // Classifier Rule Data
+ stream[20] = 0x54; // Classifier Rule Data
+ stream[21] = 0x08; // Classifier Rule Identifier // IPV6 traffic Class
+ stream[22] = 0x45; // Classifier Rule Data
+ stream[23] = 0x09; // Classifier Rule Identifier // IPV6 Flow Label
+ stream[24] = 0x05; // Classifier Rule Data
+ stream[25] = 0x15; // Classifier Rule Data
+ stream[26] = 0x25; // Classifier Rule Data
+ stream[27] = 0x0A; // Classifier Rule Identifier // IPV6 Source Address
+ stream[28] = 0x05; // Classifier Rule Data 1
+ stream[29] = 0x15; // Classifier Rule Data 2
+ stream[30] = 0x25; // Classifier Rule Data 3
+ stream[31] = 0x05; // Classifier Rule Data 4
+ stream[32] = 0x15; // Classifier Rule Data 5
+ stream[33] = 0x25; // Classifier Rule Data 6
+ stream[34] = 0x05; // Classifier Rule Data 7
+ stream[35] = 0x15; // Classifier Rule Data 8
+ stream[36] = 0x25; // Classifier Rule Data 9
+ stream[37] = 0x05; // Classifier Rule Data 10
+ stream[38] = 0x15; // Classifier Rule Data 11
+ stream[39] = 0x25; // Classifier Rule Data 12
+ stream[40] = 0x05; // Classifier Rule Data 13
+ stream[41] = 0x15; // Classifier Rule Data 14
+ stream[42] = 0x25; // Classifier Rule Data 15
+ stream[43] = 0x05; // Classifier Rule Data 16
+ stream[44] = 0x0B; // Classifier Rule Identifier // IPV6 Source Address
+ stream[45] = 0x15; // Classifier Rule Data 1
+ stream[46] = 0x25; // Classifier Rule Data 2
+ stream[47] = 0x35; // Classifier Rule Data 3
+ stream[48] = 0x15; // Classifier Rule Data 4
+ stream[49] = 0x25; // Classifier Rule Data 5
+ stream[50] = 0x35; // Classifier Rule Data 6
+ stream[51] = 0x15; // Classifier Rule Data 7
+ stream[52] = 0x25; // Classifier Rule Data 8
+ stream[53] = 0x35; // Classifier Rule Data 9
+ stream[54] = 0x15; // Classifier Rule Data 10
+ stream[55] = 0x25; // Classifier Rule Data 11
+ stream[56] = 0x35; // Classifier Rule Data 12
+ stream[57] = 0x15; // Classifier Rule Data 13
+ stream[58] = 0x25; // Classifier Rule Data 14
+ stream[59] = 0x35; // Classifier Rule Data 15
+ stream[60] = 0x15; // Classifier Rule Data 16
+ stream[61] = 0x0E; // Classifier Rule Identifier // UDP Source Port
+ stream[62] = 0x34; // Classifier Rule Data
+ stream[63] = 0x83; // Classifier Rule Data
+ stream[64] = 0x0F; // Classifier Rule Identifier // UDP Destination Port
+ stream[65] = 0x83; // Classifier Rule Data
+ stream[66] = 0x43;// Classifier Rule Data
+
+ msg_field_classifier_init(&local_classifier);
+
+ len = msg_field_classifier_get_from_stream( stream, &local_classifier);
+ data_classifier = local_classifier.data;
+
+ test_fail_unless( local_classifier.classifier_version == CLASSIFIER_CURRENT_VERSION);
+ test_fail_unless( local_classifier.nbr_rules == 10 );
+
+ test_fail_unless( data_classifier.classifier_rules_available.ethernet_destination_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ethernet_source_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.vlan_user_priority_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.vlan_id_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_type_of_protocol_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_protocol_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_source_address_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv4_destination_address_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_traffic_class_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_flow_label_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_source_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.ipv6_destination_address_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.tcp_source_port_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.tcp_destination_port_field_available == 0 );
+ test_fail_unless( data_classifier.classifier_rules_available.udp_source_port_field_available == 1 );
+ test_fail_unless( data_classifier.classifier_rules_available.udp_destination_port_field_available == 1 );
+
+ test_fail_unless( data_classifier.ethernet_destination_address[0] == 0x22 );
+ test_fail_unless( data_classifier.ethernet_destination_address[1] == 0x22 );
+ test_fail_unless( data_classifier.ethernet_destination_address[2] == 0x22 );
+ test_fail_unless( data_classifier.ethernet_destination_address[3] == 0x22 );
+ test_fail_unless( data_classifier.ethernet_destination_address[4] == 0x22 );
+ test_fail_unless( data_classifier.ethernet_destination_address[5] == 0x22 );
+
+ test_fail_unless( data_classifier.ethernet_source_address[0] == 0x33 );
+ test_fail_unless( data_classifier.ethernet_source_address[1] == 0x33 );
+ test_fail_unless( data_classifier.ethernet_source_address[2] == 0x33 );
+ test_fail_unless( data_classifier.ethernet_source_address[3] == 0x33 );
+ test_fail_unless( data_classifier.ethernet_source_address[4] == 0x33 );
+ test_fail_unless( data_classifier.ethernet_source_address[5] == 0x33 );
+
+ test_fail_unless( data_classifier.vlan_user_priority == 0x34 );
+
+ test_fail_unless( data_classifier.vlan_id == 0x4554 );
+
+ test_fail_unless( data_classifier.ipv6_traffic_class == 0x45 );
+
+ test_fail_unless( data_classifier.ipv6_flow_label[0] == 0x05 );
+ test_fail_unless( data_classifier.ipv6_flow_label[1] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_flow_label[2] == 0x25 );
+
+ test_fail_unless( data_classifier.ipv6_source_address[0] == 0x05 );
+ test_fail_unless( data_classifier.ipv6_source_address[1] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_source_address[2] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_source_address[3] == 0x05 );
+ test_fail_unless( data_classifier.ipv6_source_address[4] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_source_address[5] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_source_address[6] == 0x05 );
+ test_fail_unless( data_classifier.ipv6_source_address[7] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_source_address[8] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_source_address[9] == 0x05 );
+ test_fail_unless( data_classifier.ipv6_source_address[10] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_source_address[11] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_source_address[12] == 0x05 );
+ test_fail_unless( data_classifier.ipv6_source_address[13] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_source_address[14] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_source_address[15] == 0x05 );
+
+ test_fail_unless( data_classifier.ipv6_destination_address[0] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_destination_address[1] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_destination_address[2] == 0x35 );
+ test_fail_unless( data_classifier.ipv6_destination_address[3] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_destination_address[4] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_destination_address[5] == 0x35 );
+ test_fail_unless( data_classifier.ipv6_destination_address[6] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_destination_address[7] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_destination_address[8] == 0x35 );
+ test_fail_unless( data_classifier.ipv6_destination_address[9] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_destination_address[10] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_destination_address[11] == 0x35 );
+ test_fail_unless( data_classifier.ipv6_destination_address[12] == 0x15 );
+ test_fail_unless( data_classifier.ipv6_destination_address[13] == 0x25 );
+ test_fail_unless( data_classifier.ipv6_destination_address[14] == 0x35 );
+ test_fail_unless( data_classifier.ipv6_destination_address[15] == 0x15 );
+
+ test_fail_unless( data_classifier.udp_destination_port == 0x8343 );
+
+ test_fail_unless( data_classifier.udp_source_port == 0x3483 );
+
+ }
+ test_end;
+}
+
+
+
+
+void
+conn_test_get_cspec_from_stream(test_t t)
+{
+ cspec_t cspec;
+ len_t len;
+ u8 * stream;
+
+
+ test_case_begin(t, "TEST get_cspec_from_stream");
+
+ test_begin(t, "test case 1")
+ {
+
+ stream = (test_msg_1.mm_entry) + 2;
+
+ msg_field_cspec_init(&cspec);
+
+ len = msg_field_cspec_get_from_stream(stream, &cspec);
+
+ test_fail_unless( cspec.len == 0x0152 );
+
+ // CINFO FORWARD
+ test_fail_unless( cspec.cinfo_forward.valid == CINFO_VALID);
+ test_fail_unless( cspec.cinfo_forward.mac_service_type == MAC_CONTENTION);
+ test_fail_unless( cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless( cspec.cinfo_forward.ats == ATS_FOR_HLE);
+ test_fail_unless( cspec.cinfo_forward.smoothing == SMOOTHING_REQUESTED);
+
+ // CINFO REVERSE
+ test_fail_unless( cspec.cinfo_reverse.valid == CINFO_VALID );
+ test_fail_unless( cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION );
+ test_fail_unless( cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0 );
+ test_fail_unless( cspec.cinfo_reverse.ats == ATS_FOR_HLE );
+ test_fail_unless( cspec.cinfo_reverse.smoothing == SMOOTHING_REQUESTED );
+
+ // QMP FORWARD
+ test_fail_unless( cspec.qmp_forward.forward_or_reverse == QMP_FORWARD);
+
+ test_fail_unless( cspec.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( cspec.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( cspec.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( cspec.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( cspec.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( cspec.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( cspec.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( cspec.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+
+
+ // QMP REVERSE
+ test_fail_unless( cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE);
+ test_fail_unless( cspec.qmp_reverse.valid.delay_bound_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.jitter_bound_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.average_msdu_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_msdu_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.average_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.minimum_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_burst_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.exception_policy_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.inactivity_interval_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.msdu_error_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.clst_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.cdesc_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.ats_tolerance_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.original_average_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.rx_window_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.bidirectional_burst_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.ppb_threshold_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.surplus_bandwith_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( cspec.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( cspec.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( cspec.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( cspec.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( cspec.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+ } test_end;
+
+ test_begin(t, "test case 2")
+ {
+ stream = (test_msg_2.mm_entry) + 2;
+ msg_field_cspec_init(&cspec);
+
+ len = msg_field_cspec_get_from_stream(stream, &cspec);
+
+ test_fail_unless( cspec.len == 0xAA );
+
+ // cinfo forward
+ test_fail_unless( cspec.cinfo_forward.valid == CINFO_VALID );
+ test_fail_unless( cspec.cinfo_forward.mac_service_type == MAC_CONTENTION );
+ test_fail_unless( cspec.cinfo_forward.user_priority == USER_PRIORITY_CAP0 );
+ test_fail_unless( cspec.cinfo_forward.ats == ATS_FOR_HLE );
+ test_fail_unless( cspec.cinfo_forward.smoothing == SMOOTHING_REQUESTED);
+
+ // cinfo reverse
+ test_fail_unless( (cspec.cinfo_reverse.valid == CINFO_NOT_VALID) );
+
+ // qmp forward
+ test_fail_unless( cspec.qmp_forward.forward_or_reverse == QMP_FORWARD);
+ test_fail_unless( cspec.qmp_forward.cm.delay_bound == 0x01010101);
+ test_fail_unless( cspec.qmp_forward.cm.jitter_bound == 0x10101010);
+ test_fail_unless( cspec.qmp_forward.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_forward.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_forward.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_forward.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_forward.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( cspec.qmp_forward.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( cspec.qmp_forward.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.clst == 0x00);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( cspec.qmp_forward.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( cspec.qmp_forward.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_forward.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( cspec.qmp_forward.cm.rx_window_size == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( cspec.qmp_forward.cm.bidirectional_burst == 0x01);
+ test_fail_unless( cspec.qmp_forward.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( cspec.qmp_forward.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_forward.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_forward.cco.cco_bidirectional_burst == 0x01);
+
+ // qmp reverse
+ test_fail_unless( cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE);
+
+ }test_end;
+
+ test_begin(t, "test case 3")
+ {
+
+ stream = (test_msg_3.mm_entry) + 2;
+ msg_field_cspec_init(&cspec);
+
+ len = msg_field_cspec_get_from_stream(stream, &cspec);
+
+
+ test_fail_unless( cspec.len == 0x00AF );
+
+ // cinfo forward
+ test_fail_unless( (cspec.cinfo_forward.valid == CINFO_NOT_VALID) );
+
+ // cinfo reverse
+ test_fail_unless( cspec.cinfo_reverse.valid == CINFO_VALID);
+ test_fail_unless( cspec.cinfo_reverse.mac_service_type == MAC_CONTENTION);
+ test_fail_unless( cspec.cinfo_reverse.user_priority == USER_PRIORITY_CAP0);
+ test_fail_unless( cspec.cinfo_reverse.ats == ATS_FOR_HLE);
+ test_fail_unless( cspec.cinfo_reverse.smoothing == SMOOTHING_REQUESTED);
+
+ // qmp forward
+ test_fail_unless( cspec.qmp_forward.forward_or_reverse == QMP_FORWARD);
+
+
+ // qmp reverse
+ test_fail_unless( cspec.qmp_reverse.forward_or_reverse == QMP_REVERSE);
+ test_fail_unless( cspec.qmp_reverse.valid.delay_bound_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.jitter_bound_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.average_msdu_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_msdu_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.average_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.minimum_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_burst_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.exception_policy_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.inactivity_interval_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.msdu_error_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.clst_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.cdesc_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.ats_tolerance_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.original_average_data_rate_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.rx_window_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.bidirectional_burst_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.ppb_threshold_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.surplus_bandwith_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( cspec.qmp_reverse.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( cspec.qmp_reverse.cm.delay_bound == 0x01010101);
+ test_fail_unless( cspec.qmp_reverse.cm.jitter_bound == 0x10101010);
+ test_fail_unless( cspec.qmp_reverse.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( cspec.qmp_reverse.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_reverse.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_reverse.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( cspec.qmp_reverse.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( cspec.qmp_reverse.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.clst == 0x00);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( cspec.qmp_reverse.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( cspec.qmp_reverse.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( cspec.qmp_reverse.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( cspec.qmp_reverse.cm.rx_window_size == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( cspec.qmp_reverse.cm.bidirectional_burst == 0x01);
+ test_fail_unless( cspec.qmp_reverse.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( cspec.qmp_reverse.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( cspec.qmp_reverse.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( cspec.qmp_reverse.cco.cco_bidirectional_burst == 0x01);
+
+ }test_end;
+
+ test_begin(t, "test case 4")
+ {
+ stream = (test_msg_4.mm_entry) + 2;
+ msg_field_cspec_init(&cspec);
+
+ len = msg_field_cspec_get_from_stream(stream, &cspec);
+
+
+
+ test_fail_unless( cspec.len == 0x0009 );
+
+ // cinfo forward
+ test_fail_unless( (cspec.cinfo_forward.valid == CINFO_NOT_VALID) );
+
+ // cinfo reverse
+ test_fail_unless( (cspec.cinfo_reverse.valid == CINFO_NOT_VALID) );
+
+ // qmp forward
+ // test_fail_unless( qmp_forward.forward_or_reverse == QMP_FORWARD);
+
+
+ // qmp reverse
+ // test_fail_unless( qmp_reverse.qmp_len == 0);
+
+ }test_end;
+
+}
+
+
+void
+conn_test_set_cspec_on_stream(test_t t)
+{
+ cspec_t cspec;
+ len_t len;
+ u8 stream[255];
+
+ test_case_begin(t, "TEST: set_cspec_on_stream");
+
+ test_begin(t, "test case 1")
+ {
+ msg_field_cspec_init(&cspec);
+
+ // CINFO FORWARD
+
+ cspec.cinfo_forward.valid = CINFO_VALID;
+ cspec.cinfo_forward.mac_service_type = MAC_CONTENTION;
+ cspec.cinfo_forward.user_priority = USER_PRIORITY_CAP0;
+ cspec.cinfo_forward.ats = ATS_FOR_HLE;
+ cspec.cinfo_forward.smoothing = SMOOTHING_REQUESTED;
+
+ // CINFO REVERSE
+ cspec.cinfo_reverse.valid = CINFO_VALID;
+ cspec.cinfo_reverse.mac_service_type = MAC_CONTENTION;
+ cspec.cinfo_reverse.user_priority = USER_PRIORITY_CAP0;
+ cspec.cinfo_reverse.ats = ATS_FOR_HLE;
+ cspec.cinfo_reverse.smoothing = SMOOTHING_REQUESTED;
+
+ // QMP FORWARD
+ cspec.qmp_forward.forward_or_reverse = QMP_FORWARD;
+ cspec.qmp_forward.cm.delay_bound = 0x01010101;
+ cspec.qmp_forward.cm.jitter_bound = 0x10101010;
+ cspec.qmp_forward.cm.average_msdu_size = 0XF0F0;
+ cspec.qmp_forward.cm.maximum_msdu_size = 0XF0F0;
+ cspec.qmp_forward.cm.average_data_rate = 0x0F0F;
+ cspec.qmp_forward.cm.minimum_data_rate = 0x0F0F;
+ cspec.qmp_forward.cm.maximum_data_rate = 0x0F0F;
+ cspec.qmp_forward.cm.maximum_inter_txop_time = 0xFFFF;
+ cspec.qmp_forward.cm.minimum_inter_txop_time = 0xFFFF;
+ cspec.qmp_forward.cm.maximum_burst_size = 0x00FF;
+ cspec.qmp_forward.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ cspec.qmp_forward.cm.inactivity_interval = 0X00FF00FF;
+ cspec.qmp_forward.cm.msdu_error_rate = 0x00FF;
+ cspec.qmp_forward.cm.clst = 0x00;
+ cspec.qmp_forward.cm.cdesc.ip_version = 0x00;
+ cspec.qmp_forward.cm.cdesc.ipv4_source_address[0] = 0x01;
+ cspec.qmp_forward.cm.cdesc.ipv4_source_address[1] = 0x01;
+ cspec.qmp_forward.cm.cdesc.ipv4_source_address[2] = 0x01;
+ cspec.qmp_forward.cm.cdesc.ipv4_source_address[3] = 0x01;
+ cspec.qmp_forward.cm.cdesc.source_port = 0x0FF1;
+ cspec.qmp_forward.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ cspec.qmp_forward.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ cspec.qmp_forward.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ cspec.qmp_forward.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ cspec.qmp_forward.cm.cdesc.destination_port = 0xFFF1;
+ cspec.qmp_forward.cm.cdesc.protocol_type = 0x00;
+ cspec.qmp_forward.cm.ats_tolerance = 0x00FF;
+ cspec.qmp_forward.cm.smallest_tolerable_data_rate = 0x00FF;
+ cspec.qmp_forward.cm.original_average_data_rate = 0x000F;
+ cspec.qmp_forward.cm.rx_window_size = 0x100F;
+ cspec.qmp_forward.cm.smoothing_buffer_size = 0x100F10;
+ cspec.qmp_forward.cm.bidirectional_burst = 0x01;
+ cspec.qmp_forward.cco.txops_per_beacon_period = 0x15;
+ cspec.qmp_forward.cco.average_number_of_pbs_per_txop = 0x100F;
+ cspec.qmp_forward.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ cspec.qmp_forward.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ cspec.qmp_forward.cco.ppb_threshold = 0x0FF0;
+ cspec.qmp_forward.cco.surplus_bandwith = 0x0FF0;
+ cspec.qmp_forward.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ cspec.qmp_forward.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ cspec.qmp_forward.cco.cco_bidirectional_burst = 0x01;
+
+
+ // QMP REVERSE
+ cspec.qmp_reverse.forward_or_reverse = QMP_REVERSE;
+ cspec.qmp_reverse.valid.delay_bound_available = true;
+ cspec.qmp_reverse.valid.jitter_bound_available = true;
+ cspec.qmp_reverse.valid.average_msdu_size_available = true;
+ cspec.qmp_reverse.valid.maximum_msdu_size_available = true;
+ cspec.qmp_reverse.valid.average_data_rate_available = true;
+ cspec.qmp_reverse.valid.minimum_data_rate_available = true;
+ cspec.qmp_reverse.valid.maximum_data_rate_available = true;
+ cspec.qmp_reverse.valid.minimum_inter_txop_time_available = true;
+ cspec.qmp_reverse.valid.maximum_inter_txop_time_available = true;
+ cspec.qmp_reverse.valid.maximum_burst_size_available = true;
+ cspec.qmp_reverse.valid.exception_policy_available = true;
+ cspec.qmp_reverse.valid.inactivity_interval_available = true;
+ cspec.qmp_reverse.valid.msdu_error_rate_available = true;
+ cspec.qmp_reverse.valid.clst_available = true;
+ cspec.qmp_reverse.valid.cdesc_available = true;
+ cspec.qmp_reverse.valid.ats_tolerance_available = true;
+ cspec.qmp_reverse.valid.smallest_tolerable_data_rate_available = true;
+ cspec.qmp_reverse.valid.original_average_data_rate_available = true;
+ cspec.qmp_reverse.valid.rx_window_size_available = true;
+ cspec.qmp_reverse.valid.smoothing_buffer_size_available = true;
+ cspec.qmp_reverse.valid.bidirectional_burst_available = true;
+ cspec.qmp_reverse.valid.txops_per_beacon_period_available = true;
+ cspec.qmp_reverse.valid.average_number_of_pbs_per_txop_available = true;
+ cspec.qmp_reverse.valid.minimum_number_of_pbs_per_txop_available = true;
+ cspec.qmp_reverse.valid.maximum_number_of_pbs_per_txop_available = true;
+ cspec.qmp_reverse.valid.ppb_threshold_available = true;
+ cspec.qmp_reverse.valid.surplus_bandwith_available = true;
+ cspec.qmp_reverse.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ cspec.qmp_reverse.valid.original_average_number_of_pbs_per_txop_available = true;
+ cspec.qmp_reverse.valid.cco_bidirectional_burst_available = true;
+ cspec.qmp_reverse.cm.delay_bound = 0x01010101;
+ cspec.qmp_reverse.cm.jitter_bound = 0x10101010;
+ cspec.qmp_reverse.cm.average_msdu_size = 0XF0F0;
+ cspec.qmp_reverse.cm.maximum_msdu_size = 0XF0F0;
+ cspec.qmp_reverse.cm.average_data_rate = 0x0F0F;
+ cspec.qmp_reverse.cm.minimum_data_rate = 0x0F0F;
+ cspec.qmp_reverse.cm.maximum_data_rate = 0x0F0F;
+ cspec.qmp_reverse.cm.maximum_inter_txop_time = 0xFFFF;
+ cspec.qmp_reverse.cm.minimum_inter_txop_time = 0xFFFF;
+ cspec.qmp_reverse.cm.maximum_burst_size = 0x00FF;
+ cspec.qmp_reverse.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ cspec.qmp_reverse.cm.inactivity_interval = 0X00FF00FF;
+ cspec.qmp_reverse.cm.msdu_error_rate = 0x00FF;
+ cspec.qmp_reverse.cm.clst = 0x00;
+ cspec.qmp_reverse.cm.cdesc.ip_version = 0x00;
+ cspec.qmp_reverse.cm.cdesc.ipv4_source_address[0] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.ipv4_source_address[1] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.ipv4_source_address[2] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.ipv4_source_address[3] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.source_port = 0x0FF1;
+ cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ cspec.qmp_reverse.cm.cdesc.destination_port = 0xFFF1;
+ cspec.qmp_reverse.cm.cdesc.protocol_type = 0x00;
+ cspec.qmp_reverse.cm.ats_tolerance = 0x00FF;
+ cspec.qmp_reverse.cm.smallest_tolerable_data_rate = 0x00FF;
+ cspec.qmp_reverse.cm.original_average_data_rate = 0x000F;
+ cspec.qmp_reverse.cm.rx_window_size = 0x100F;
+ cspec.qmp_reverse.cm.smoothing_buffer_size = 0x100F10;
+ cspec.qmp_reverse.cm.bidirectional_burst = 0x01;
+ cspec.qmp_reverse.cco.txops_per_beacon_period = 0x15;
+ cspec.qmp_reverse.cco.average_number_of_pbs_per_txop = 0x100F;
+ cspec.qmp_reverse.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ cspec.qmp_reverse.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ cspec.qmp_reverse.cco.ppb_threshold = 0x0FF0;
+ cspec.qmp_reverse.cco.surplus_bandwith = 0x0FF0;
+ cspec.qmp_reverse.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ cspec.qmp_reverse.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ cspec.qmp_reverse.cco.cco_bidirectional_burst = 0x01;
+
+ len = msg_field_cspec_set_on_stream(stream, &cspec);
+
+ test_fail_unless(true);
+
+ } test_end;
+}
+
+void
+conn_test_set_classifier_rules_on_stream(test_t t)
+{
+ msg_mme_t msg;
+ classifier_rules_t classifier_rule;
+
+
+ test_case_begin(t, "TEST save_classifier_rules");
+
+ test_begin(t, "test case 1")
+ {
+ classifier_rule.classifier_version = CLASSIFIER_CURRENT_VERSION;
+ classifier_rule.nbr_rules = 10;
+
+ classifier_rule.data.classifier_rules_available.ethernet_destination_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ethernet_source_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.vlan_user_priority_field_available = 1;
+ classifier_rule.data.classifier_rules_available.vlan_id_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv4_type_of_protocol_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv4_protocol_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv4_source_address_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv4_destination_address_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv6_traffic_class_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv6_flow_label_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv6_source_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv6_destination_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.tcp_source_port_field_available = 0;
+ classifier_rule.data.classifier_rules_available.tcp_destination_port_field_available = 0;
+ classifier_rule.data.classifier_rules_available.udp_source_port_field_available = 1;
+ classifier_rule.data.classifier_rules_available.udp_destination_port_field_available = 1;
+
+ classifier_rule.data.ethernet_destination_address[0] = 0x22;
+ classifier_rule.data.ethernet_destination_address[1] = 0x22;
+ classifier_rule.data.ethernet_destination_address[2] = 0x22;
+ classifier_rule.data.ethernet_destination_address[3] = 0x22;
+ classifier_rule.data.ethernet_destination_address[4] = 0x22;
+ classifier_rule.data.ethernet_destination_address[5] = 0x22;
+
+ classifier_rule.data.ethernet_source_address[0] = 0x33;
+ classifier_rule.data.ethernet_source_address[1] = 0x33;
+ classifier_rule.data.ethernet_source_address[2] = 0x33;
+ classifier_rule.data.ethernet_source_address[3] = 0x33;
+ classifier_rule.data.ethernet_source_address[4] = 0x33;
+ classifier_rule.data.ethernet_source_address[5] = 0x33;
+
+ classifier_rule.data.vlan_user_priority = 0x34;
+ classifier_rule.data.vlan_id = 0x4554;
+ classifier_rule.data.ipv6_traffic_class = 0x45;
+
+ classifier_rule.data.ipv6_flow_label[0] = 0x05;
+ classifier_rule.data.ipv6_flow_label[1] = 0x15;
+ classifier_rule.data.ipv6_flow_label[2] = 0x25;
+
+ classifier_rule.data.ipv6_source_address[0] = 0x05;
+ classifier_rule.data.ipv6_source_address[1] = 0x15;
+ classifier_rule.data.ipv6_source_address[2] = 0x25;
+ classifier_rule.data.ipv6_source_address[3] = 0x05;
+ classifier_rule.data.ipv6_source_address[4] = 0x15;
+ classifier_rule.data.ipv6_source_address[5] = 0x25;
+ classifier_rule.data.ipv6_source_address[6] = 0x05;
+ classifier_rule.data.ipv6_source_address[7] = 0x15;
+ classifier_rule.data.ipv6_source_address[8] = 0x25;
+ classifier_rule.data.ipv6_source_address[9] = 0x05;
+ classifier_rule.data.ipv6_source_address[10] = 0x15;
+ classifier_rule.data.ipv6_source_address[11] = 0x25;
+ classifier_rule.data.ipv6_source_address[12] = 0x05;
+ classifier_rule.data.ipv6_source_address[13] = 0x15;
+ classifier_rule.data.ipv6_source_address[14] = 0x25;
+ classifier_rule.data.ipv6_source_address[15] = 0x05;
+ classifier_rule.data.ipv6_destination_address[0] = 0x15;
+ classifier_rule.data.ipv6_destination_address[1] = 0x25;
+ classifier_rule.data.ipv6_destination_address[2] = 0x35;
+ classifier_rule.data.ipv6_destination_address[3] = 0x15;
+ classifier_rule.data.ipv6_destination_address[4] = 0x25;
+ classifier_rule.data.ipv6_destination_address[5] = 0x35;
+ classifier_rule.data.ipv6_destination_address[6] = 0x15;
+ classifier_rule.data.ipv6_destination_address[7] = 0x25;
+ classifier_rule.data.ipv6_destination_address[8] = 0x35;
+ classifier_rule.data.ipv6_destination_address[9] = 0x15;
+ classifier_rule.data.ipv6_destination_address[10] = 0x25;
+ classifier_rule.data.ipv6_destination_address[11] = 0x35;
+ classifier_rule.data.ipv6_destination_address[12] = 0x15;
+ classifier_rule.data.ipv6_destination_address[13] = 0x25;
+ classifier_rule.data.ipv6_destination_address[14] = 0x35;
+ classifier_rule.data.ipv6_destination_address[15] = 0x15;
+
+ classifier_rule.data.udp_destination_port = 0x8343;
+
+ classifier_rule.data.udp_source_port = 0x3483;
+
+ msg_field_classifier_set_on_stream((u8*)&msg.mm_entry, &classifier_rule );
+
+ test_fail_unless(msg.mm_entry[0] == 0x00);
+ test_fail_unless(msg.mm_entry[1] == 0x0A);
+ test_fail_unless(msg.mm_entry[2] == 0x00);
+ test_fail_unless(msg.mm_entry[3] == 0x22);
+ test_fail_unless(msg.mm_entry[4] == 0x22);
+ test_fail_unless(msg.mm_entry[5] == 0x22);
+ test_fail_unless(msg.mm_entry[6] == 0x22);
+ test_fail_unless(msg.mm_entry[7] == 0x22);
+ test_fail_unless(msg.mm_entry[8] == 0x22);
+ test_fail_unless(msg.mm_entry[9] == 0x01);
+ test_fail_unless(msg.mm_entry[10] == 0x33);
+ test_fail_unless(msg.mm_entry[11] == 0x33);
+ test_fail_unless(msg.mm_entry[12] == 0x33);
+ test_fail_unless(msg.mm_entry[13] == 0x33);
+ test_fail_unless(msg.mm_entry[14] == 0x33);
+ test_fail_unless(msg.mm_entry[15] == 0x33);
+ test_fail_unless(msg.mm_entry[16] == 0x02);
+ test_fail_unless(msg.mm_entry[17] == 0x34);
+ test_fail_unless(msg.mm_entry[18] == 0x03);
+ test_fail_unless(msg.mm_entry[19] == 0x45);
+ test_fail_unless(msg.mm_entry[20] == 0x54);
+ test_fail_unless(msg.mm_entry[21] == 0x08);
+ test_fail_unless(msg.mm_entry[22] == 0x45);
+ test_fail_unless(msg.mm_entry[23] == 0x09);
+ test_fail_unless(msg.mm_entry[24] == 0x05);
+ test_fail_unless(msg.mm_entry[25] == 0x15);
+ test_fail_unless(msg.mm_entry[26] == 0x25);
+ test_fail_unless(msg.mm_entry[27] == 0x0A);
+ test_fail_unless(msg.mm_entry[28] == 0x05);
+ test_fail_unless(msg.mm_entry[29] == 0x15);
+ test_fail_unless(msg.mm_entry[30] == 0x25);
+ test_fail_unless(msg.mm_entry[31] == 0x05);
+ test_fail_unless(msg.mm_entry[32] == 0x15);
+ test_fail_unless(msg.mm_entry[33] == 0x25);
+ test_fail_unless(msg.mm_entry[34] == 0x05);
+ test_fail_unless(msg.mm_entry[35] == 0x15);
+ test_fail_unless(msg.mm_entry[36] == 0x25);
+ test_fail_unless(msg.mm_entry[37] == 0x05);
+ test_fail_unless(msg.mm_entry[38] == 0x15);
+ test_fail_unless(msg.mm_entry[39] == 0x25);
+ test_fail_unless(msg.mm_entry[40] == 0x05);
+ test_fail_unless(msg.mm_entry[41] == 0x15);
+ test_fail_unless(msg.mm_entry[42] == 0x25);
+ test_fail_unless(msg.mm_entry[43] == 0x05);
+ test_fail_unless(msg.mm_entry[44] == 0x0B);
+ test_fail_unless(msg.mm_entry[45] == 0x15);
+ test_fail_unless(msg.mm_entry[46] == 0x25);
+ test_fail_unless(msg.mm_entry[47] == 0x35);
+ test_fail_unless(msg.mm_entry[48] == 0x15);
+ test_fail_unless(msg.mm_entry[49] == 0x25);
+ test_fail_unless(msg.mm_entry[50] == 0x35);
+ test_fail_unless(msg.mm_entry[51] == 0x15);
+ test_fail_unless(msg.mm_entry[52] == 0x25);
+ test_fail_unless(msg.mm_entry[53] == 0x35);
+ test_fail_unless(msg.mm_entry[54] == 0x15);
+ test_fail_unless(msg.mm_entry[55] == 0x25);
+ test_fail_unless(msg.mm_entry[56] == 0x35);
+ test_fail_unless(msg.mm_entry[57] == 0x15);
+ test_fail_unless(msg.mm_entry[58] == 0x25);
+ test_fail_unless(msg.mm_entry[59] == 0x35);
+ test_fail_unless(msg.mm_entry[60] == 0x15);
+ test_fail_unless(msg.mm_entry[61] == 0x0E);
+ test_fail_unless(msg.mm_entry[62] == 0x34);
+ test_fail_unless(msg.mm_entry[63] == 0x83);
+ test_fail_unless(msg.mm_entry[64] == 0x0F);
+ test_fail_unless(msg.mm_entry[65] == 0x83);
+ test_fail_unless(msg.mm_entry[66] == 0x43);
+
+
+ test_fail_unless(true);
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+
+ classifier_rule.classifier_version = CLASSIFIER_CURRENT_VERSION;
+ classifier_rule.nbr_rules = 8;
+ classifier_rule.data.classifier_rules_available.ethernet_destination_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ethernet_source_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.vlan_user_priority_field_available = 0;
+ classifier_rule.data.classifier_rules_available.vlan_id_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv4_type_of_protocol_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv4_protocol_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv4_source_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv4_destination_address_field_available = 1;
+ classifier_rule.data.classifier_rules_available.ipv6_traffic_class_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv6_flow_label_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv6_source_address_field_available = 0;
+ classifier_rule.data.classifier_rules_available.ipv6_destination_address_field_available = 0;
+ classifier_rule.data.classifier_rules_available.tcp_source_port_field_available = 1;
+ classifier_rule.data.classifier_rules_available.tcp_destination_port_field_available = 1;
+ classifier_rule.data.classifier_rules_available.udp_source_port_field_available = 0;
+ classifier_rule.data.classifier_rules_available.udp_destination_port_field_available = 0;
+
+ classifier_rule.data.ethernet_destination_address[0] = 0x01;
+ classifier_rule.data.ethernet_destination_address[1] = 0x02;
+ classifier_rule.data.ethernet_destination_address[2] = 0x03;
+ classifier_rule.data.ethernet_destination_address[3] = 0x04;
+ classifier_rule.data.ethernet_destination_address[4] = 0x05;
+ classifier_rule.data.ethernet_destination_address[5] = 0x06;
+
+ classifier_rule.data.ethernet_source_address[0] = 0x06;
+ classifier_rule.data.ethernet_source_address[1] = 0x05;
+ classifier_rule.data.ethernet_source_address[2] = 0x04;
+ classifier_rule.data.ethernet_source_address[3] = 0x03;
+ classifier_rule.data.ethernet_source_address[4] = 0x02;
+ classifier_rule.data.ethernet_source_address[5] = 0x01;
+
+ classifier_rule.data.ipv4_type_of_service = 0x08;
+
+ classifier_rule.data.ipv4_protocol = 0x0;
+
+ classifier_rule.data.ipv4_source_address[0] = 0x04;
+ classifier_rule.data.ipv4_source_address[1] = 0x04;
+ classifier_rule.data.ipv4_source_address[2] = 0x04;
+ classifier_rule.data.ipv4_source_address[3] = 0x04;
+
+ classifier_rule.data.ipv4_destination_address[0] = 0x34;
+ classifier_rule.data.ipv4_destination_address[1] = 0x34;
+ classifier_rule.data.ipv4_destination_address[2] = 0x34;
+ classifier_rule.data.ipv4_destination_address[3] = 0x34;
+
+ classifier_rule.data.tcp_destination_port = 0x3454;
+
+ classifier_rule.data.tcp_source_port = 0x5432;
+
+ msg_field_classifier_set_on_stream((u8*)&msg.mm_entry, &classifier_rule );
+
+ test_fail_unless(msg.mm_entry[0] == 0x00);
+ test_fail_unless(msg.mm_entry[1] == 0x08);
+ test_fail_unless(msg.mm_entry[2] == 0x00);
+ test_fail_unless(msg.mm_entry[3] == 0x01);
+ test_fail_unless(msg.mm_entry[4] == 0x02);
+ test_fail_unless(msg.mm_entry[5] == 0x03);
+ test_fail_unless(msg.mm_entry[6] == 0x04);
+ test_fail_unless(msg.mm_entry[7] == 0x05);
+ test_fail_unless(msg.mm_entry[8] == 0x06);
+ test_fail_unless(msg.mm_entry[9] == 0x01);
+ test_fail_unless(msg.mm_entry[10] == 0x06);
+ test_fail_unless(msg.mm_entry[11] == 0x05);
+ test_fail_unless(msg.mm_entry[12] == 0x04);
+ test_fail_unless(msg.mm_entry[13] == 0x03);
+ test_fail_unless(msg.mm_entry[14] == 0x02);
+ test_fail_unless(msg.mm_entry[15] == 0x01);
+ test_fail_unless(msg.mm_entry[16] == 0X04);
+ test_fail_unless(msg.mm_entry[17] == 0x08);
+ test_fail_unless(msg.mm_entry[18] == 0x05);
+ test_fail_unless(msg.mm_entry[19] == 0x00);
+ test_fail_unless(msg.mm_entry[20] == 0x06);
+ test_fail_unless(msg.mm_entry[21] == 0x04);
+ test_fail_unless(msg.mm_entry[22] == 0x04);
+ test_fail_unless(msg.mm_entry[23] == 0x04);
+ test_fail_unless(msg.mm_entry[24] == 0x04);
+ test_fail_unless(msg.mm_entry[25] == 0x07);
+ test_fail_unless(msg.mm_entry[26] == 0x34);
+ test_fail_unless(msg.mm_entry[27] == 0x34);
+ test_fail_unless(msg.mm_entry[28] == 0x34);
+ test_fail_unless(msg.mm_entry[29] == 0x34);
+ test_fail_unless(msg.mm_entry[30] == 0x0C);
+ test_fail_unless(msg.mm_entry[31] == 0x54);
+ test_fail_unless(msg.mm_entry[32] == 0X32);
+ test_fail_unless(msg.mm_entry[33] == 0x0D);
+ test_fail_unless(msg.mm_entry[34] == 0x34);
+ test_fail_unless(msg.mm_entry[35] == 0x54);
+
+
+ }test_end;
+}
+
+
+void conn_test_set_qmp_on_stream(test_t t)
+{
+ qmp_t qmp;
+ u8 msg[256];
+ u32 len;
+ int i;
+
+ test_case_begin(t, "TEST set_qmp");
+
+
+ test_begin(t, "test case 1 - forward")
+ {
+ msg_field_qmp_init(&qmp);
+
+ qmp.forward_or_reverse = QMP_FORWARD;
+ qmp.valid.delay_bound_available = true;
+ qmp.valid.jitter_bound_available = true;
+ qmp.valid.average_msdu_size_available = true;
+ qmp.valid.maximum_msdu_size_available = true;
+ qmp.valid.average_data_rate_available = true;
+ qmp.valid.minimum_data_rate_available = true;
+ qmp.valid.maximum_data_rate_available = true;
+ qmp.valid.minimum_inter_txop_time_available = true;
+ qmp.valid.maximum_inter_txop_time_available = true;
+ qmp.valid.maximum_burst_size_available = true;
+ qmp.valid.exception_policy_available = true;
+ qmp.valid.inactivity_interval_available = true;
+ qmp.valid.msdu_error_rate_available = true;
+ qmp.valid.clst_available = true;
+ qmp.valid.cdesc_available = true;
+ qmp.valid.ats_tolerance_available = true;
+ qmp.valid.smallest_tolerable_data_rate_available = true;
+ qmp.valid.original_average_data_rate_available = true;
+ qmp.valid.rx_window_size_available = true;
+ qmp.valid.smoothing_buffer_size_available = true;
+ qmp.valid.bidirectional_burst_available = true;
+ qmp.valid.txops_per_beacon_period_available = true;
+ qmp.valid.average_number_of_pbs_per_txop_available = true;
+ qmp.valid.minimum_number_of_pbs_per_txop_available = true;
+ qmp.valid.maximum_number_of_pbs_per_txop_available = true;
+ qmp.valid.ppb_threshold_available = true;
+ qmp.valid.surplus_bandwith_available = true;
+ qmp.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ qmp.valid.original_average_number_of_pbs_per_txop_available = true;
+ qmp.valid.cco_bidirectional_burst_available = true;
+ qmp.cm.delay_bound = 0x01010101;
+ qmp.cm.jitter_bound = 0x10101010;
+ qmp.cm.average_msdu_size = 0XF0F0;
+ qmp.cm.maximum_msdu_size = 0XF0F0;
+ qmp.cm.average_data_rate = 0x0F0F;
+ qmp.cm.minimum_data_rate = 0x0F0F;
+ qmp.cm.maximum_data_rate = 0x0F0F;
+ qmp.cm.maximum_inter_txop_time = 0xFFFF;
+ qmp.cm.minimum_inter_txop_time = 0xFFFF;
+ qmp.cm.maximum_burst_size = 0x00FF;
+ qmp.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ qmp.cm.inactivity_interval = 0X00FF00FF;
+ qmp.cm.msdu_error_rate = 0x00FF;
+ qmp.cm.clst = 0x00;
+ qmp.cm.cdesc.ip_version = 0x00;
+ qmp.cm.cdesc.ipv4_source_address[0] = 0x01;
+ qmp.cm.cdesc.ipv4_source_address[1] = 0x01;
+ qmp.cm.cdesc.ipv4_source_address[2] = 0x01;
+ qmp.cm.cdesc.ipv4_source_address[3] = 0x01;
+ qmp.cm.cdesc.source_port = 0x0FF1;
+ qmp.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ qmp.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ qmp.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ qmp.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ qmp.cm.cdesc.destination_port = 0xFFF1;
+ qmp.cm.cdesc.protocol_type = 0x00;
+ qmp.cm.ats_tolerance = 0x00FF;
+ qmp.cm.smallest_tolerable_data_rate = 0x00FF;
+ qmp.cm.original_average_data_rate = 0x000F;
+ qmp.cm.rx_window_size = 0x100F;
+ qmp.cm.smoothing_buffer_size = 0x100F10;
+ qmp.cm.bidirectional_burst = 0x01;
+ qmp.cco.txops_per_beacon_period = 0x15;
+ qmp.cco.average_number_of_pbs_per_txop = 0x100F;
+ qmp.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ qmp.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ qmp.cco.ppb_threshold = 0x0FF0;
+ qmp.cco.surplus_bandwith = 0x0FF0;
+ qmp.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ qmp.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ qmp.cco.cco_bidirectional_burst = 0x01;
+
+
+ len = msg_field_qmp_set_on_stream(msg,&qmp);
+
+
+ test_fail_unless( len == 164, "Invalid value - current value %i", len );
+
+ for(i = 0; i < 164; i++)
+ {
+ test_fail_unless(msg[i] == test_stream_forward_1[i], "i=%i unvalid ",i);
+ }
+
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+ msg_field_qmp_init(&qmp);
+
+ qmp.valid.delay_bound_available = true;
+ qmp.valid.jitter_bound_available = true;
+ qmp.valid.average_msdu_size_available = true;
+ qmp.valid.maximum_msdu_size_available = true;
+ qmp.valid.average_data_rate_available = true;
+ qmp.valid.minimum_data_rate_available = true;
+ qmp.valid.maximum_data_rate_available = true;
+ qmp.valid.minimum_inter_txop_time_available = true;
+ qmp.valid.maximum_inter_txop_time_available = true;
+ qmp.valid.maximum_burst_size_available = true;
+ qmp.valid.exception_policy_available = true;
+ qmp.valid.inactivity_interval_available = true;
+ qmp.valid.msdu_error_rate_available = true;
+ qmp.valid.clst_available = true;
+ qmp.valid.cdesc_available = true;
+ qmp.valid.ats_tolerance_available = true;
+ qmp.valid.smallest_tolerable_data_rate_available = true;
+ qmp.valid.original_average_data_rate_available = true;
+ qmp.valid.rx_window_size_available = true;
+ qmp.valid.smoothing_buffer_size_available = true;
+ qmp.valid.bidirectional_burst_available = true;
+ qmp.valid.txops_per_beacon_period_available = true;
+ qmp.valid.average_number_of_pbs_per_txop_available = true;
+ qmp.valid.minimum_number_of_pbs_per_txop_available = true;
+ qmp.valid.maximum_number_of_pbs_per_txop_available = true;
+ qmp.valid.ppb_threshold_available = true;
+ qmp.valid.surplus_bandwith_available = true;
+ qmp.valid.smallest_tolerable_average_number_of_pbs_per_txop_available = true;
+ qmp.valid.original_average_number_of_pbs_per_txop_available = true;
+ qmp.valid.cco_bidirectional_burst_available = true;
+ qmp.cm.delay_bound = 0x01010101;
+ qmp.cm.jitter_bound = 0x10101010;
+ qmp.cm.average_msdu_size = 0XF0F0;
+ qmp.cm.maximum_msdu_size = 0XF0F0;
+ qmp.cm.average_data_rate = 0x0F0F;
+ qmp.cm.minimum_data_rate = 0x0F0F;
+ qmp.cm.maximum_data_rate = 0x0F0F;
+ qmp.cm.maximum_inter_txop_time = 0xFFFF;
+ qmp.cm.minimum_inter_txop_time = 0xFFFF;
+ qmp.cm.maximum_burst_size = 0x00FF;
+ qmp.cm.exception_policy = EXCEPTION_RECONFIGURE_CONNEXION;
+ qmp.cm.inactivity_interval = 0X00FF00FF;
+ qmp.cm.msdu_error_rate = 0x00FF;
+ qmp.cm.clst = 0x00;
+ qmp.cm.cdesc.ip_version = 0x00;
+ qmp.cm.cdesc.ipv4_source_address[0] = 0x01;
+ qmp.cm.cdesc.ipv4_source_address[1] = 0x01;
+ qmp.cm.cdesc.ipv4_source_address[2] = 0x01;
+ qmp.cm.cdesc.ipv4_source_address[3] = 0x01;
+ qmp.cm.cdesc.source_port = 0x0FF1;
+ qmp.cm.cdesc.ipv4_destination_address[0] = 0x01;
+ qmp.cm.cdesc.ipv4_destination_address[1] = 0x01;
+ qmp.cm.cdesc.ipv4_destination_address[2] = 0x01;
+ qmp.cm.cdesc.ipv4_destination_address[3] = 0x01;
+ qmp.cm.cdesc.destination_port = 0xFFF1;
+ qmp.cm.cdesc.protocol_type = 0x00;
+ qmp.cm.ats_tolerance = 0x00FF;
+ qmp.cm.smallest_tolerable_data_rate = 0x00FF;
+ qmp.cm.original_average_data_rate = 0x000F;
+ qmp.cm.rx_window_size = 0x100F;
+ qmp.cm.smoothing_buffer_size = 0x100F10;
+ qmp.cm.bidirectional_burst = 0x01;
+ qmp.cco.txops_per_beacon_period = 0x15;
+ qmp.cco.average_number_of_pbs_per_txop = 0x100F;
+ qmp.cco.minimum_number_of_pbs_per_txop = 0x100F;
+ qmp.cco.maximum_number_of_pbs_per_txop = 0x100F;
+ qmp.cco.ppb_threshold = 0x0FF0;
+ qmp.cco.surplus_bandwith = 0x0FF0;
+ qmp.cco.smallest_tolerable_average_number_of_pbs_per_txop = 0x0FF0;
+ qmp.cco.original_average_number_of_pbs_per_txop = 0x0FF0;
+ qmp.cco.cco_bidirectional_burst = 0x01;
+
+ len = msg_field_qmp_set_on_stream(msg, &qmp);
+
+ test_fail_unless( len == 164);
+
+ for(i = 0; i < 164; i++)
+ {
+ test_fail_unless(msg[i] == test_stream_forward_1[i], "i=%i unvalid ",i);
+ }
+
+
+ }test_end;
+}
+
+
+
+void
+conn_test_set_cid_on_stream (test_t t)
+{
+ cid_t cid;
+ len_t len;
+ u8 stream[4];
+
+ test_case_begin(t, "TEST set_cid_on_stream");
+
+ test_begin(t, "test case 1")
+ {
+ cid = 0X4352;
+
+ len = msg_field_cid_set_on_stream(stream, &cid);
+
+ test_fail_unless( len == 2);
+ test_fail_unless( stream[0] = 0x43);
+ test_fail_unless( stream[1] = 0x52);
+
+ }test_end;
+
+}
+
+
+void
+conn_test_get_cid_from_stream(test_t t)
+{
+ cid_t cid;
+ len_t len;
+ u8 stream[2] = { 0x34,0x76};
+
+ test_case_begin(t, "TEST get_cid_from_stream");
+
+ test_begin(t, "test case 1")
+ {
+ msg_field_cid_init(&cid);
+
+
+ len = msg_field_cid_get_from_stream(stream, &cid);
+
+ test_fail_unless( len == 2 );
+ test_fail_unless( cid == 0x3476);
+
+ }test_end;
+}
+
+
+void
+conn_test_get_qmp_from_stream(test_t t)
+{
+ qmp_t qmp;
+ len_t len;
+
+ test_case_begin(t, "TEST get_from_stream");
+
+ test_begin(t, "test case 1")
+ {
+ msg_field_qmp_init(&qmp);
+
+ len = msg_field_qmp_get_from_stream(test_stream_forward_1, test_stream_forward_1 + 164, &qmp, QMP_FORWARD);
+
+ test_fail_unless( len == 164);
+ test_fail_unless( qmp.valid.delay_bound_available == true);
+ test_fail_unless( qmp.valid.jitter_bound_available == true);
+ test_fail_unless( qmp.valid.average_msdu_size_available == true);
+ test_fail_unless( qmp.valid.maximum_msdu_size_available == true);
+ test_fail_unless( qmp.valid.average_data_rate_available == true);
+ test_fail_unless( qmp.valid.minimum_data_rate_available == true);
+ test_fail_unless( qmp.valid.maximum_data_rate_available == true);
+ test_fail_unless( qmp.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( qmp.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( qmp.valid.maximum_burst_size_available == true);
+ test_fail_unless( qmp.valid.exception_policy_available == true);
+ test_fail_unless( qmp.valid.inactivity_interval_available == true);
+ test_fail_unless( qmp.valid.msdu_error_rate_available == true);
+ test_fail_unless( qmp.valid.clst_available == true);
+ test_fail_unless( qmp.valid.cdesc_available == true);
+ test_fail_unless( qmp.valid.ats_tolerance_available == true);
+ test_fail_unless( qmp.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( qmp.valid.original_average_data_rate_available == true);
+ test_fail_unless( qmp.valid.rx_window_size_available == true);
+ test_fail_unless( qmp.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( qmp.valid.bidirectional_burst_available == true);
+ test_fail_unless( qmp.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( qmp.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.ppb_threshold_available == true);
+ test_fail_unless( qmp.valid.surplus_bandwith_available == true);
+ test_fail_unless( qmp.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.cco_bidirectional_burst_available == true);
+
+ test_fail_unless( qmp.cm.delay_bound == 0x01010101);
+ test_fail_unless( qmp.cm.jitter_bound == 0x10101010);
+ test_fail_unless( qmp.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( qmp.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( qmp.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( qmp.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( qmp.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( qmp.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( qmp.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( qmp.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( qmp.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( qmp.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( qmp.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( qmp.cm.clst == 0x00);
+ test_fail_unless( qmp.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( qmp.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( qmp.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( qmp.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( qmp.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( qmp.cm.rx_window_size == 0x100F);
+ test_fail_unless( qmp.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( qmp.cm.bidirectional_burst == 0x01);
+ test_fail_unless( qmp.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( qmp.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( qmp.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( qmp.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( qmp.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( qmp.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( qmp.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( qmp.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( qmp.cco.cco_bidirectional_burst == 0x01);
+ }test_end;
+
+ test_begin(t, "test case 2")
+ {
+ msg_field_qmp_init(&qmp);
+
+ msg_field_qmp_get_from_stream(test_stream_reverse_1, test_stream_reverse_1 + 164, &qmp, QMP_REVERSE);
+
+ test_fail_unless( qmp.valid.delay_bound_available == true);
+ test_fail_unless( qmp.valid.jitter_bound_available == true);
+ test_fail_unless( qmp.valid.average_msdu_size_available == true);
+ test_fail_unless( qmp.valid.maximum_msdu_size_available == true);
+ test_fail_unless( qmp.valid.average_data_rate_available == true);
+ test_fail_unless( qmp.valid.minimum_data_rate_available == true);
+ test_fail_unless( qmp.valid.maximum_data_rate_available == true);
+ test_fail_unless( qmp.valid.minimum_inter_txop_time_available == true);
+ test_fail_unless( qmp.valid.maximum_inter_txop_time_available == true);
+ test_fail_unless( qmp.valid.maximum_burst_size_available == true);
+ test_fail_unless( qmp.valid.exception_policy_available == true);
+ test_fail_unless( qmp.valid.inactivity_interval_available == true);
+ test_fail_unless( qmp.valid.msdu_error_rate_available == true);
+ test_fail_unless( qmp.valid.clst_available == true);
+ test_fail_unless( qmp.valid.cdesc_available == true);
+ test_fail_unless( qmp.valid.ats_tolerance_available == true);
+ test_fail_unless( qmp.valid.smallest_tolerable_data_rate_available == true);
+ test_fail_unless( qmp.valid.original_average_data_rate_available == true);
+ test_fail_unless( qmp.valid.rx_window_size_available == true);
+ test_fail_unless( qmp.valid.smoothing_buffer_size_available == true);
+ test_fail_unless( qmp.valid.bidirectional_burst_available == true);
+ test_fail_unless( qmp.valid.txops_per_beacon_period_available == true);
+ test_fail_unless( qmp.valid.average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.minimum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.maximum_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.ppb_threshold_available == true);
+ test_fail_unless( qmp.valid.surplus_bandwith_available == true);
+ test_fail_unless( qmp.valid.smallest_tolerable_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.original_average_number_of_pbs_per_txop_available == true);
+ test_fail_unless( qmp.valid.cco_bidirectional_burst_available == true);
+ test_fail_unless( qmp.cm.delay_bound == 0x01010101);
+ test_fail_unless( qmp.cm.jitter_bound == 0x10101010);
+ test_fail_unless( qmp.cm.average_msdu_size == 0XF0F0);
+ test_fail_unless( qmp.cm.maximum_msdu_size == 0XF0F0);
+ test_fail_unless( qmp.cm.average_data_rate == 0x0F0F);
+ test_fail_unless( qmp.cm.minimum_data_rate == 0x0F0F);
+ test_fail_unless( qmp.cm.maximum_data_rate == 0x0F0F);
+ test_fail_unless( qmp.cm.maximum_inter_txop_time == 0xFFFF);
+ test_fail_unless( qmp.cm.minimum_inter_txop_time == 0xFFFF);
+ test_fail_unless( qmp.cm.maximum_burst_size == 0x00FF);
+ test_fail_unless( qmp.cm.exception_policy == EXCEPTION_RECONFIGURE_CONNEXION);
+ test_fail_unless( qmp.cm.inactivity_interval == 0X00FF00FF);
+ test_fail_unless( qmp.cm.msdu_error_rate == 0x00FF);
+ test_fail_unless( qmp.cm.clst == 0x00);
+ test_fail_unless( qmp.cm.cdesc.ip_version == 0x00);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[0] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[1] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[2] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_source_address[3] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.source_port == 0x0FF1);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[0] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[1] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[2] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.ipv4_destination_address[3] == 0x01);
+ test_fail_unless( qmp.cm.cdesc.destination_port == 0xFFF1);
+ test_fail_unless( qmp.cm.cdesc.protocol_type == 0x00);
+ test_fail_unless( qmp.cm.ats_tolerance == 0x00FF);
+ test_fail_unless( qmp.cm.smallest_tolerable_data_rate == 0x00FF);
+ test_fail_unless( qmp.cm.original_average_data_rate == 0x000F);
+ test_fail_unless( qmp.cm.rx_window_size == 0x100F);
+ test_fail_unless( qmp.cm.smoothing_buffer_size == 0x100F10);
+ test_fail_unless( qmp.cm.bidirectional_burst == 0x01);
+ test_fail_unless( qmp.cco.txops_per_beacon_period == 0x15);
+ test_fail_unless( qmp.cco.average_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( qmp.cco.minimum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( qmp.cco.maximum_number_of_pbs_per_txop == 0x100F);
+ test_fail_unless( qmp.cco.ppb_threshold == 0x0FF0);
+ test_fail_unless( qmp.cco.surplus_bandwith == 0x0FF0);
+ test_fail_unless( qmp.cco.smallest_tolerable_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( qmp.cco.original_average_number_of_pbs_per_txop == 0x0FF0);
+ test_fail_unless( qmp.cco.cco_bidirectional_burst == 0x01);
+ }test_end;
+}
+
+
+
+
+
+
+void
+test_msg_field (test_t t)
+{
+ dbg_assert (t);
+
+ test_suite_begin (t, "TEST MESSAGE FIELD");
+
+ conn_test_get_cid_from_stream(t);
+ conn_test_set_cid_on_stream(t);
+
+ conn_test_set_cinfo_on_stream(t);
+ conn_test_get_cinfo_from_stream(t);
+
+ conn_test_set_qmp_on_stream(t);
+ conn_test_get_qmp_from_stream(t);
+
+ conn_test_set_classifier_rules_on_stream(t);
+ conn_test_get_classifier_rules_from_stream (t);
+
+ conn_test_get_cspec_from_stream( t);
+ conn_test_set_cspec_on_stream(t);
+}
+
+