diff --git a/feeds/wifi-trunk/hostapd/patches/900-hapd-netlink-ubus-bridge.patch b/feeds/wifi-trunk/hostapd/patches/900-hapd-netlink-ubus-bridge.patch index a84c3a43..ae4d267b 100644 --- a/feeds/wifi-trunk/hostapd/patches/900-hapd-netlink-ubus-bridge.patch +++ b/feeds/wifi-trunk/hostapd/patches/900-hapd-netlink-ubus-bridge.patch @@ -1,7 +1,5 @@ -Index: hostapd-2020-06-08-5a8b3662/hostapd/main.c -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/hostapd/main.c -+++ hostapd-2020-06-08-5a8b3662/hostapd/main.c +--- a/hostapd/main.c ++++ b/hostapd/main.c @@ -41,7 +41,7 @@ struct hapd_global { static struct hapd_global global; static int daemonize = 0; @@ -11,10 +9,8 @@ Index: hostapd-2020-06-08-5a8b3662/hostapd/main.c #ifndef CONFIG_NO_HOSTAPD_LOGGER static void hostapd_logger_cb(void *ctx, const u8 *addr, unsigned int module, -Index: hostapd-2020-06-08-5a8b3662/src/ap/hostapd.h -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/hostapd.h -+++ hostapd-2020-06-08-5a8b3662/src/ap/hostapd.h +--- a/src/ap/hostapd.h ++++ b/src/ap/hostapd.h @@ -97,6 +97,10 @@ struct hostapd_probereq_cb { }; @@ -26,10 +22,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/hostapd.h struct hostapd_rate_data { int rate; /* rate in 100 kbps */ -Index: hostapd-2020-06-08-5a8b3662/src/ap/ieee802_11.c -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/ieee802_11.c -+++ hostapd-2020-06-08-5a8b3662/src/ap/ieee802_11.c +--- a/src/ap/ieee802_11.c ++++ b/src/ap/ieee802_11.c @@ -4928,6 +4928,7 @@ int ieee802_11_mgmt(struct hostapd_data int ret = 0; unsigned int freq; @@ -116,10 +110,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ieee802_11.c return ret; } -Index: hostapd-2020-06-08-5a8b3662/src/ap/sta_info.c -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/sta_info.c -+++ hostapd-2020-06-08-5a8b3662/src/ap/sta_info.c +--- a/src/ap/sta_info.c ++++ b/src/ap/sta_info.c @@ -423,8 +423,14 @@ void ap_handle_timer(void *eloop_ctx, vo hostapd_logger(hapd, sta->addr, HOSTAPD_MODULE_IEEE80211, HOSTAPD_LEVEL_INFO, "deauthenticated due to " @@ -167,10 +159,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/sta_info.c mlme_disassociate_indication(hapd, sta, reason); break; case STA_DEAUTH: -Index: hostapd-2020-06-08-5a8b3662/src/ap/sta_info.h -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/sta_info.h -+++ hostapd-2020-06-08-5a8b3662/src/ap/sta_info.h +--- a/src/ap/sta_info.h ++++ b/src/ap/sta_info.h @@ -77,6 +77,9 @@ struct sta_info { u8 supported_rates[WLAN_SUPP_RATES_MAX]; int supported_rates_len; @@ -181,10 +171,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/sta_info.h #ifdef CONFIG_MESH enum mesh_plink_state plink_state; -Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/ubus.c -+++ hostapd-2020-06-08-5a8b3662/src/ap/ubus.c +--- a/src/ap/ubus.c ++++ b/src/ap/ubus.c @@ -24,7 +24,10 @@ static struct ubus_context *ctx; @@ -222,7 +210,7 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c +}; + +static const struct blobmsg_policy client_session_del_policy[__CSESS_REQ_MAX] = { -+ [CSESS_REQ_SESS_ID] = { .name = "session_id", .type = BLOBMSG_TYPE_STRING }, ++ [CSESS_REQ_SESS_ID] = { .name = "session_id", .type = BLOBMSG_TYPE_INT64 }, +}; + +static int hostapd_clear_session(struct ubus_context *ctx, @@ -243,10 +231,10 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c + if (!tb[CSESS_REQ_SESS_ID]) + return UBUS_STATUS_INVALID_ARGUMENT; + ++ session_id = blobmsg_get_u64(tb[CSESS_REQ_SESS_ID]); + /* remove from AVL and ubus session object) */ + avl_for_each_element_safe(&hapd->ubus.rt_events, rec, avl, rec_next) + { -+ session_id = strtoll(blobmsg_get_string(tb[CSESS_REQ_SESS_ID]), NULL, 10); + if (session_id == rec->session_id) { + /* dec counter and delete */ + cached_events_nr -= rec->rec_nr; @@ -444,10 +432,10 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c + + /* create reply */ + blob_buf_init(&b_ev, 0); -+ a = blobmsg_open_table(&b_ev, "bss_list"); ++ a = blobmsg_open_array(&b_ev, "bss_list"); + /* check bss list from hapd */ + for (size_t i = 0; i < bss_nr; i++) { -+ b = blobmsg_open_table(&b_ev, "bss"); ++ b = blobmsg_open_table(&b_ev, NULL); + blobmsg_add_string(&b_ev, "name", bss_lst[i]); + blobmsg_close_table(&b_ev, b); + } @@ -704,10 +692,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.c int hostapd_ubus_handle_event(struct hostapd_data *hapd, struct hostapd_ubus_request *req) { struct ubus_banned_client *ban; -Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.h -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/ubus.h -+++ hostapd-2020-06-08-5a8b3662/src/ap/ubus.h +--- a/src/ap/ubus.h ++++ b/src/ap/ubus.h @@ -12,6 +12,11 @@ enum hostapd_ubus_event_type { HOSTAPD_UBUS_PROBE_REQ, HOSTAPD_UBUS_AUTH_REQ, @@ -833,10 +819,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/ubus.h static inline void hostapd_ubus_notify(struct hostapd_data *hapd, const char *type, const u8 *mac) { -Index: hostapd-2020-06-08-5a8b3662/src/ap/hostapd.c -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/hostapd.c -+++ hostapd-2020-06-08-5a8b3662/src/ap/hostapd.c +--- a/src/ap/hostapd.c ++++ b/src/ap/hostapd.c @@ -1406,19 +1406,22 @@ static int hostapd_setup_bss(struct host "Generic snooping infrastructure initialization failed"); return -1; @@ -867,10 +851,8 @@ Index: hostapd-2020-06-08-5a8b3662/src/ap/hostapd.c if (!hostapd_drv_none(hapd) && vlan_init(hapd)) { wpa_printf(MSG_ERROR, "VLAN initialization failed."); -Index: hostapd-2020-06-08-5a8b3662/src/ap/dhcp_snoop.c -=================================================================== ---- hostapd-2020-06-08-5a8b3662.orig/src/ap/dhcp_snoop.c -+++ hostapd-2020-06-08-5a8b3662/src/ap/dhcp_snoop.c +--- a/src/ap/dhcp_snoop.c ++++ b/src/ap/dhcp_snoop.c @@ -40,6 +40,7 @@ static void handle_dhcp(void *ctx, const int res, msgtype = 0, prefixlen = 32; u32 subnet_mask = 0; diff --git a/feeds/wlan-ap/opensync/patches/19-events-protobuf-definitions.patch b/feeds/wlan-ap/opensync/patches/19-events-protobuf-definitions.patch index 5590b437..0510b7d0 100644 --- a/feeds/wlan-ap/opensync/patches/19-events-protobuf-definitions.patch +++ b/feeds/wlan-ap/opensync/patches/19-events-protobuf-definitions.patch @@ -88,17 +88,17 @@ Index: opensync-2.0.5.0/interfaces/opensync_stats.proto } message ClientReport { -@@ -664,6 +668,128 @@ message VideoVoiceReport { +@@ -664,6 +668,137 @@ message VideoVoiceReport { optional uint64 timestamp_ms = 7; } +message EventReport { + /* Client Association Event */ + message ClientAssocEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; -+ optional string ssid = 3; -+ optional RadioBandType band = 4; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; ++ required string ssid = 3; ++ required RadioBandType band = 4; + optional AssocType assoc_type = 5; + optional uint32 status = 6; + optional int32 rssi = 7; @@ -106,21 +106,23 @@ Index: opensync-2.0.5.0/interfaces/opensync_stats.proto + optional bool using11k = 9; + optional bool using11r = 10; + optional bool using11v = 11; ++ optional uint32 timestamp_ms = 12; + } + + /* Client Authentication Event */ + message ClientAuthEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; -+ optional string ssid = 3; -+ optional RadioBandType band = 4; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; ++ required string ssid = 3; ++ required RadioBandType band = 4; + optional uint32 auth_status = 5; ++ optional uint32 timestamp_ms = 6; + } + + /* Client Disconnect Event */ + message ClientDisconnectEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; + optional uint32 reason = 3; + optional DeviceType dev_type = 4; + optional FrameType fr_type = 5; @@ -128,17 +130,18 @@ Index: opensync-2.0.5.0/interfaces/opensync_stats.proto + optional uint64 lrcv_up_ts_in_us = 7; + optional uint32 internal_rc = 8; + optional int32 rssi = 9; -+ optional string ssid = 10; -+ optional RadioBandType band = 11; ++ required string ssid = 10; ++ required RadioBandType band = 11; ++ optional uint32 timestamp_ms = 12; + } + + /* Client Connnect Event */ + message ClientConnectEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; -+ optional RadioBandType band = 3; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; ++ required RadioBandType band = 3; + optional AssocType assoc_type = 4; -+ optional string ssid = 5; ++ required string ssid = 5; + optional SecurityType sec_type = 6; + optional bool fbt_used = 7; + optional bytes ip_addr = 8; @@ -154,60 +157,66 @@ Index: opensync-2.0.5.0/interfaces/opensync_stats.proto + optional bool using11v = 18; + optional int64 ev_time_bootup_in_us_ip = 19; + optional int32 assoc_rssi = 20; ++ optional uint32 timestamp_ms = 21; + } + + /* Client Failure Event */ + message ClientFailureEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; -+ optional string ssid = 3; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; ++ required string ssid = 3; + optional int32 reason_code = 4; + optional string reason_str = 5; ++ optional uint32 timestamp_ms = 6; + } + + /* Client First Data Event */ + message ClientFirstDataEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; + optional uint64 fdata_tx_up_ts_in_us = 3; + optional uint64 fdata_rx_up_ts_in_us = 4; ++ optional uint32 timestamp_ms = 5; + } + + /* Client Id Event */ + message ClientIdEvent { -+ optional string clt_mac = 1; -+ optional uint64 session_id = 2; ++ required string clt_mac = 1; ++ required uint64 session_id = 2; + optional string clt_id = 3; ++ optional uint32 timestamp_ms = 4; + } + + /* Client IP Event */ + message ClientIpEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; + optional bytes ip_addr = 3; ++ optional uint32 timestamp_ms = 4; + } + + /* Client Timeout Event */ + message ClientTimeoutEvent { -+ optional string sta_mac = 1; -+ optional uint64 session_id = 2; ++ required string sta_mac = 1; ++ required uint64 session_id = 2; + optional CTReasonType r_code = 3; + optional uint64 last_sent_up_ts_in_us = 4; + optional uint64 last_rcv_up_ts_in_us = 5; ++ optional uint32 timestamp_ms = 6; + } + + /* Client Session */ + message ClientSession { + required uint64 session_id = 1; -+ repeated ClientAssocEvent client_assoc_event = 2; -+ repeated ClientAuthEvent client_auth_event = 3; -+ repeated ClientDisconnectEvent client_disconnect_event = 4; -+ repeated ClientFailureEvent client_failure_event = 5; -+ repeated ClientFirstDataEvent client_first_data_event = 6; -+ repeated ClientIdEvent client_id_event = 7; -+ repeated ClientIpEvent client_ip_event = 8; -+ repeated ClientTimeoutEvent client_timeout_event = 9; -+ repeated ClientConnectEvent client_connect_event = 10; ++ optional ClientAssocEvent client_assoc_event = 2; ++ optional ClientAuthEvent client_auth_event = 3; ++ optional ClientDisconnectEvent client_disconnect_event = 4; ++ optional ClientFailureEvent client_failure_event = 5; ++ optional ClientFirstDataEvent client_first_data_event = 6; ++ optional ClientIdEvent client_id_event = 7; ++ optional ClientIpEvent client_ip_event = 8; ++ optional ClientTimeoutEvent client_timeout_event = 9; ++ optional ClientConnectEvent client_connect_event = 10; + } + + /* Multiple Client Sessions */ @@ -217,7 +226,7 @@ Index: opensync-2.0.5.0/interfaces/opensync_stats.proto //////////////////////////////////////////////////////////////////////////////// // // Overall report that might contain all individual stats reports -@@ -680,4 +806,5 @@ message Report { +@@ -680,4 +815,5 @@ message Report { repeated RssiReport rssi_report = 8; repeated VideoVoiceReport video_voice_report = 9; repeated NetworkProbe network_probe = 101; diff --git a/feeds/wlan-ap/opensync/patches/20-dppline-event.patch b/feeds/wlan-ap/opensync/patches/20-dppline-event.patch index 842dd615..8977ca66 100644 --- a/feeds/wlan-ap/opensync/patches/20-dppline-event.patch +++ b/feeds/wlan-ap/opensync/patches/20-dppline-event.patch @@ -81,7 +81,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c } dppline_client_stats_t; typedef struct dpp_network_probe_stats -@@ -101,78 +99,106 @@ typedef struct dpp_network_probe_stats +@@ -101,78 +99,73 @@ typedef struct dpp_network_probe_stats uint64_t timestamp_ms; } dppline_network_probe_stats_t; @@ -203,47 +203,15 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + uint32_t type; } dppline_ucc_stats_t; -+typedef struct { -+ dpp_event_record_session_t *session_list; -+ uint32_t session_qty; -+ -+ dpp_event_record_assoc_t *assoc_list; -+ uint32_t assoc_qty; -+ -+ dpp_event_record_auth_t *auth_list; -+ uint32_t auth_qty; -+ -+ dpp_event_record_disconnect_t *disconnect_list; -+ uint32_t disconnect_qty; -+ -+ dpp_event_record_connect_t *connect_list; -+ uint32_t connect_qty; -+ -+ dpp_event_record_failure_t *failure_list; -+ uint32_t failure_qty; -+ -+ dpp_event_record_first_data_t *first_data_list; -+ uint32_t first_data_qty; -+ -+ dpp_event_record_id_t *id_list; -+ uint32_t id_qty; -+ -+ dpp_event_record_ip_t *ip_list; -+ uint32_t ip_qty; - -+ dpp_event_record_timeout_t *timeout_list; -+ uint32_t timeout_qty; -+ -+} dppline_event_rec_t; -+ +- +typedef struct dpp_events_stats { -+ dppline_event_rec_t *list; -+ uint32_t qty; ++ dpp_event_record_session_t *client_event_list; ++ uint32_t client_event_qty; +} dppline_events_stats_t; /* DPP stats type, used as element in internal double ds */ typedef struct dpp_stats -@@ -191,16 +217,17 @@ typedef struct dpp_stats +@@ -191,16 +184,17 @@ typedef struct dpp_stats dppline_rssi_stats_t rssi; dppline_network_probe_stats_t network_probe; dppline_ucc_stats_t ucc; @@ -265,17 +233,49 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c } /* free allocated memory for single stat */ -@@ -249,6 +276,9 @@ static void dppline_free_stat(dppline_st +@@ -249,7 +243,40 @@ static void dppline_free_stat(dppline_st break; case DPP_T_UCC: free(&s->u.ucc.record); -+ break; case DPP_T_EVENTS: -+ free(s->u.events.list); -+ break; - break; +- break; ++ break; ++ case DPP_T_EVENTS: ++ for (i=0; iu.events.client_event_qty; i++) ++ { ++ if(s->u.events.client_event_list[i].assoc_event) ++ free(s->u.events.client_event_list[i].assoc_event); ++ ++ if(s->u.events.client_event_list[i].auth_event) ++ free(s->u.events.client_event_list[i].auth_event); ++ ++ if(s->u.events.client_event_list[i].disconnect_event) ++ free(s->u.events.client_event_list[i].disconnect_event); ++ ++ if(s->u.events.client_event_list[i].connect_event) ++ free(s->u.events.client_event_list[i].connect_event); ++ ++ if(s->u.events.client_event_list[i].failure_event) ++ free(s->u.events.client_event_list[i].failure_event); ++ ++ if(s->u.events.client_event_list[i].first_data_event) ++ free(s->u.events.client_event_list[i].first_data_event); ++ ++ if(s->u.events.client_event_list[i].id_event) ++ free(s->u.events.client_event_list[i].id_event); ++ ++ if(s->u.events.client_event_list[i].ip_event) ++ free(s->u.events.client_event_list[i].ip_event); ++ ++ if(s->u.events.client_event_list[i].timeout_event) ++ free(s->u.events.client_event_list[i].timeout_event); ++ } ++ free(s->u.events.client_event_list); ++ break; ++ default:; } -@@ -258,409 +288,436 @@ static void dppline_free_stat(dppline_st + +@@ -258,409 +285,461 @@ static void dppline_free_stat(dppline_st } /* copy stats to internal buffer */ @@ -353,6 +353,284 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - result = ds_dlist_inext(&result_iter)) - { - result_entry = &result->entry; +- +- size = (dst->u.capacity.qty + 1) * sizeof(dpp_capacity_record_t); +- if (!dst->u.capacity.qty) { +- dst->u.capacity.list = calloc(1, size); +- } +- else { +- dst->u.capacity.list = realloc(dst->u.capacity.list, size); +- memset(&dst->u.capacity.list[dst->u.capacity.qty], +- 0, +- sizeof(dpp_capacity_record_t)); +- } +- memcpy(&dst->u.capacity.list[dst->u.capacity.qty++], +- result_entry, +- sizeof(dpp_capacity_record_t)); +- } +- } +- break; +- +- case DPP_T_NEIGHBOR: +- { +- dpp_neighbor_report_data_t *report_data = sts; +- dpp_neighbor_record_list_t *result = NULL; +- dpp_neighbor_record_t *result_entry = NULL; +- ds_dlist_iter_t result_iter; +- +- /* Loop through linked list of results and copy them to dppline buffer */ +- dst->u.neighbor.qty = 0; +- dst->u.neighbor.radio_type = report_data->radio_type; +- dst->u.neighbor.report_type = report_data->report_type; +- dst->u.neighbor.scan_type = report_data->scan_type; +- dst->u.neighbor.timestamp_ms = report_data->timestamp_ms; +- for ( result = ds_dlist_ifirst(&result_iter, &report_data->list); +- result != NULL; +- result = ds_dlist_inext(&result_iter)) +- { +- result_entry = &result->entry; +- +- size = (dst->u.neighbor.qty + 1) * sizeof(dpp_neighbor_record_t); +- if (!dst->u.neighbor.qty) { +- dst->u.neighbor.list = calloc(1, size); +- } +- else { +- dst->u.neighbor.list = realloc(dst->u.neighbor.list, size); +- memset(&dst->u.neighbor.list[dst->u.neighbor.qty], +- 0, +- sizeof(dpp_neighbor_record_t)); +- } +- memcpy(&dst->u.neighbor.list[dst->u.neighbor.qty++], +- result_entry, +- sizeof(dpp_neighbor_record_t)); +- } +- } +- break; +- +- case DPP_T_CLIENT: +- { +- dpp_client_report_data_t *report_data = sts; +- dpp_client_record_t *result_entry = NULL; +- ds_dlist_iter_t result_iter; +- +- dpp_client_stats_rx_t *rx = NULL; +- ds_dlist_iter_t rx_iter; +- dpp_client_stats_tx_t *tx = NULL; +- ds_dlist_iter_t tx_iter; +- dpp_client_tid_record_list_t *tid = NULL; +- ds_dlist_iter_t tid_iter; +- dpp_client_connection_events_t *events = NULL; +- ds_dlist_iter_t events_iter; +- +- /* Loop through linked list of results and copy them to dppline buffer */ +- dst->u.client.qty = 0; +- dst->u.client.radio_type = report_data->radio_type; +- dst->u.client.channel = report_data->channel; +- dst->u.client.timestamp_ms = report_data->timestamp_ms; +- for ( result_entry = ds_dlist_ifirst(&result_iter, &report_data->list); +- result_entry != NULL; +- result_entry = ds_dlist_inext(&result_iter)) +- { +- size = (dst->u.client.qty + 1) * sizeof(dppline_client_rec_t); +- if (!dst->u.client.qty) { +- dst->u.client.list = calloc(1, size); +- } +- else { +- dst->u.client.list = realloc(dst->u.client.list, size); +- memset(&dst->u.client.list[dst->u.client.qty], +- 0, +- sizeof(dppline_client_rec_t)); +- } +- memcpy(&dst->u.client.list[dst->u.client.qty].rec, +- result_entry, +- sizeof(dpp_client_record_t)); +- +- /* Add RX stats records */ +- for ( rx = ds_dlist_ifirst(&rx_iter, &result_entry->stats_rx); +- rx != NULL; +- rx = ds_dlist_inext(&rx_iter)) +- { +- size = (dst->u.client.list[dst->u.client.qty].rx_qty + 1) * sizeof(dpp_client_stats_rx_t); +- if (!dst->u.client.list[dst->u.client.qty].rx_qty) { +- dst->u.client.list[dst->u.client.qty].rx = calloc(1, size); +- } +- else { +- dst->u.client.list[dst->u.client.qty].rx = +- realloc(dst->u.client.list[dst->u.client.qty].rx, size); +- memset(&dst->u.client.list[dst->u.client.qty].rx[dst->u.client.list[dst->u.client.qty].rx_qty], +- 0, +- sizeof(dpp_client_stats_rx_t)); +- } +- memcpy(&dst->u.client.list[dst->u.client.qty].rx[dst->u.client.list[dst->u.client.qty].rx_qty], +- rx, +- sizeof(dpp_client_stats_rx_t)); +- +- dst->u.client.list[dst->u.client.qty].rx_qty++; +- } +- +- /* Add TX stats records */ +- for ( tx = ds_dlist_ifirst(&tx_iter, &result_entry->stats_tx); +- tx != NULL; +- tx = ds_dlist_inext(&tx_iter)) +- { +- size = (dst->u.client.list[dst->u.client.qty].tx_qty + 1) * sizeof(dpp_client_stats_tx_t); +- if (!dst->u.client.list[dst->u.client.qty].tx_qty) { +- dst->u.client.list[dst->u.client.qty].tx = calloc(1, size); +- } +- else { +- dst->u.client.list[dst->u.client.qty].tx = +- realloc(dst->u.client.list[dst->u.client.qty].tx, size); +- memset(&dst->u.client.list[dst->u.client.qty].tx[dst->u.client.list[dst->u.client.qty].tx_qty], +- 0, +- sizeof(dpp_client_stats_tx_t)); +- } +- memcpy(&dst->u.client.list[dst->u.client.qty].tx[dst->u.client.list[dst->u.client.qty].tx_qty], +- tx, +- sizeof(dpp_client_stats_tx_t)); +- +- dst->u.client.list[dst->u.client.qty].tx_qty++; +- } +- +- /* Add TID records */ +- for ( tid = ds_dlist_ifirst(&tid_iter, &result_entry->tid_record_list); +- tid != NULL; +- tid = ds_dlist_inext(&tid_iter)) +- { +- size = (dst->u.client.list[dst->u.client.qty].tid_qty + 1) * sizeof(dpp_client_tid_record_list_t); +- if (!dst->u.client.list[dst->u.client.qty].tid_qty) { +- dst->u.client.list[dst->u.client.qty].tid = calloc(1, size); +- } +- else { +- dst->u.client.list[dst->u.client.qty].tid = +- realloc(dst->u.client.list[dst->u.client.qty].tid, size); +- memset(&dst->u.client.list[dst->u.client.qty].tid[dst->u.client.list[dst->u.client.qty].tid_qty], +- 0, +- sizeof(dpp_client_tid_record_list_t)); +- } +- memcpy(&dst->u.client.list[dst->u.client.qty].tid[dst->u.client.list[dst->u.client.qty].tid_qty], +- tid, +- sizeof(dpp_client_tid_record_list_t)); +- +- dst->u.client.list[dst->u.client.qty].tid_qty++; +- } +- +- /* Add client connection events records */ +- for ( events = ds_dlist_ifirst(&events_iter, &result_entry->connection_events); +- events != NULL; +- events = ds_dlist_inext(&events_iter)) +- { +- size = (dst->u.client.list[dst->u.client.qty].events_qty + 1) * sizeof(dpp_client_connection_events_t); +- if (!dst->u.client.list[dst->u.client.qty].events_qty) { +- dst->u.client.list[dst->u.client.qty].events = calloc(1, size); +- } +- else { +- dst->u.client.list[dst->u.client.qty].events = +- realloc(dst->u.client.list[dst->u.client.qty].events, size); +- memset(&dst->u.client.list[dst->u.client.qty].events[dst->u.client.list[dst->u.client.qty].events_qty], +- 0, +- sizeof(dpp_client_connection_events_t)); +- } +- memcpy(&dst->u.client.list[dst->u.client.qty].events[dst->u.client.list[dst->u.client.qty].events_qty], +- events, +- sizeof(dpp_client_connection_events_t)); +- +- dst->u.client.list[dst->u.client.qty].events_qty++; +- } +- dst->u.client.qty++; +- } +- } +- break; +- +- case DPP_T_DEVICE: +- { +- dpp_device_report_data_t *report_data = sts; +- dpp_device_temp_t *result_entry = NULL; +- dpp_device_thermal_record_t *thermal_record = NULL; +- ds_dlist_iter_t result_iter; +- int thermal_size = 0; +- +- memcpy(&dst->u.device.record, &report_data->record, sizeof(dpp_device_record_t)); +- dst->u.device.timestamp_ms = report_data->timestamp_ms; +- +- /* Loop through linked list of results and copy them to dppline buffer */ +- dst->u.device.qty = 0; +- for ( result_entry = ds_dlist_ifirst(&result_iter, &report_data->temp); +- result_entry != NULL; +- result_entry = ds_dlist_inext(&result_iter)) +- { +- size = (dst->u.device.qty + 1) * sizeof(dpp_device_temp_t); +- if (!dst->u.device.qty) +- { +- dst->u.device.list = calloc(1, size); +- } +- else +- { +- dst->u.device.list = realloc(dst->u.device.list, size); +- memset(&dst->u.device.list[dst->u.device.qty], +- 0, +- sizeof(dpp_device_temp_t)); +- } +- memcpy(&dst->u.device.list[dst->u.device.qty++], +- result_entry, +- sizeof(dpp_device_temp_t)); +- } +- +- dst->u.device.thermal_qty = 0; +- for ( thermal_record = ds_dlist_ifirst(&result_iter, &report_data->thermal_records); +- thermal_record != NULL; +- thermal_record = ds_dlist_inext(&result_iter)) +- { +- thermal_size += (dst->u.device.thermal_qty + 1) * sizeof(dpp_device_thermal_record_t); +- if (!dst->u.device.thermal_qty) +- { +- dst->u.device.thermal_list = calloc(1, thermal_size); +- } +- else +- { +- dst->u.device.thermal_list = realloc(dst->u.device.thermal_list, thermal_size); +- memset(&dst->u.device.thermal_list[dst->u.device.thermal_qty], +- 0, +- sizeof(dpp_device_thermal_record_t)); +- } +- memcpy(&dst->u.device.thermal_list[dst->u.device.thermal_qty++], +- thermal_record, +- sizeof(dpp_device_thermal_record_t)); +- } +- size += thermal_size; +- } +- break; +- +- case DPP_T_BS_CLIENT: +- { +- dpp_bs_client_report_data_t *report_data = sts; +- dpp_bs_client_record_list_t *result = NULL; +- dst->u.bs_client.qty = 0; +- dst->u.bs_client.timestamp_ms = report_data->timestamp_ms; +- +- // Loop through linked list of results and copy results +- ds_dlist_foreach(&report_data->list, result) { dst->u.bs_client.qty++; } +- size = dst->u.bs_client.qty * sizeof(dpp_bs_client_record_t); +- dst->u.bs_client.list = calloc(1, size); +- int count = 0; +- ds_dlist_foreach(&report_data->list, result) +- { +- assert(count < (int)dst->u.bs_client.qty); +- memcpy(&dst->u.bs_client.list[count], +- &result->entry, +- sizeof(dpp_bs_client_record_t)); +- count++; +- } +- } +- break; +- +- case DPP_T_RSSI: +- { +- dpp_rssi_report_data_t *report_data = sts; +- dpp_rssi_record_t *result_entry = NULL; +- ds_dlist_iter_t result_iter; +- +- dpp_rssi_raw_t *raw = NULL; +- ds_dlist_iter_t raw_iter; + int size = 0; + switch (dst->type) { + case DPP_T_SURVEY: { @@ -699,6 +977,31 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + } + } break; + ++ case DPP_T_EVENTS: { ++ dpp_event_report_data_t *report_data = sts; ++ dpp_event_record_t *result = NULL; ++ dst->u.events.client_event_qty = 0; ++ ++ // Loop through linked list of results and copy results ++ ds_dlist_foreach(&report_data->client_event_list, result) ++ { ++ dst->u.events.client_event_qty++; ++ } ++ ++ size = dst->u.events.client_event_qty * sizeof(dpp_event_record_session_t); ++ dst->u.events.client_event_list = calloc(1, size); ++ int count = 0; ++ ds_dlist_foreach(&report_data->client_event_list, result) ++ { ++ assert(count < (int)dst->u.events.client_event_qty); ++ memcpy(&dst->u.events.client_event_list[count], &result->client_session, ++ sizeof(dpp_event_record_session_t)); ++ count++; ++ } ++ ++ ++ } break; ++ + case DPP_T_RSSI: { + dpp_rssi_report_data_t *report_data = sts; + dpp_rssi_record_t *result_entry = NULL; @@ -781,284 +1084,6 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + } + } break; -- size = (dst->u.capacity.qty + 1) * sizeof(dpp_capacity_record_t); -- if (!dst->u.capacity.qty) { -- dst->u.capacity.list = calloc(1, size); -- } -- else { -- dst->u.capacity.list = realloc(dst->u.capacity.list, size); -- memset(&dst->u.capacity.list[dst->u.capacity.qty], -- 0, -- sizeof(dpp_capacity_record_t)); -- } -- memcpy(&dst->u.capacity.list[dst->u.capacity.qty++], -- result_entry, -- sizeof(dpp_capacity_record_t)); -- } -- } -- break; -- -- case DPP_T_NEIGHBOR: -- { -- dpp_neighbor_report_data_t *report_data = sts; -- dpp_neighbor_record_list_t *result = NULL; -- dpp_neighbor_record_t *result_entry = NULL; -- ds_dlist_iter_t result_iter; -- -- /* Loop through linked list of results and copy them to dppline buffer */ -- dst->u.neighbor.qty = 0; -- dst->u.neighbor.radio_type = report_data->radio_type; -- dst->u.neighbor.report_type = report_data->report_type; -- dst->u.neighbor.scan_type = report_data->scan_type; -- dst->u.neighbor.timestamp_ms = report_data->timestamp_ms; -- for ( result = ds_dlist_ifirst(&result_iter, &report_data->list); -- result != NULL; -- result = ds_dlist_inext(&result_iter)) -- { -- result_entry = &result->entry; -- -- size = (dst->u.neighbor.qty + 1) * sizeof(dpp_neighbor_record_t); -- if (!dst->u.neighbor.qty) { -- dst->u.neighbor.list = calloc(1, size); -- } -- else { -- dst->u.neighbor.list = realloc(dst->u.neighbor.list, size); -- memset(&dst->u.neighbor.list[dst->u.neighbor.qty], -- 0, -- sizeof(dpp_neighbor_record_t)); -- } -- memcpy(&dst->u.neighbor.list[dst->u.neighbor.qty++], -- result_entry, -- sizeof(dpp_neighbor_record_t)); -- } -- } -- break; -- -- case DPP_T_CLIENT: -- { -- dpp_client_report_data_t *report_data = sts; -- dpp_client_record_t *result_entry = NULL; -- ds_dlist_iter_t result_iter; -- -- dpp_client_stats_rx_t *rx = NULL; -- ds_dlist_iter_t rx_iter; -- dpp_client_stats_tx_t *tx = NULL; -- ds_dlist_iter_t tx_iter; -- dpp_client_tid_record_list_t *tid = NULL; -- ds_dlist_iter_t tid_iter; -- dpp_client_connection_events_t *events = NULL; -- ds_dlist_iter_t events_iter; -- -- /* Loop through linked list of results and copy them to dppline buffer */ -- dst->u.client.qty = 0; -- dst->u.client.radio_type = report_data->radio_type; -- dst->u.client.channel = report_data->channel; -- dst->u.client.timestamp_ms = report_data->timestamp_ms; -- for ( result_entry = ds_dlist_ifirst(&result_iter, &report_data->list); -- result_entry != NULL; -- result_entry = ds_dlist_inext(&result_iter)) -- { -- size = (dst->u.client.qty + 1) * sizeof(dppline_client_rec_t); -- if (!dst->u.client.qty) { -- dst->u.client.list = calloc(1, size); -- } -- else { -- dst->u.client.list = realloc(dst->u.client.list, size); -- memset(&dst->u.client.list[dst->u.client.qty], -- 0, -- sizeof(dppline_client_rec_t)); -- } -- memcpy(&dst->u.client.list[dst->u.client.qty].rec, -- result_entry, -- sizeof(dpp_client_record_t)); -- -- /* Add RX stats records */ -- for ( rx = ds_dlist_ifirst(&rx_iter, &result_entry->stats_rx); -- rx != NULL; -- rx = ds_dlist_inext(&rx_iter)) -- { -- size = (dst->u.client.list[dst->u.client.qty].rx_qty + 1) * sizeof(dpp_client_stats_rx_t); -- if (!dst->u.client.list[dst->u.client.qty].rx_qty) { -- dst->u.client.list[dst->u.client.qty].rx = calloc(1, size); -- } -- else { -- dst->u.client.list[dst->u.client.qty].rx = -- realloc(dst->u.client.list[dst->u.client.qty].rx, size); -- memset(&dst->u.client.list[dst->u.client.qty].rx[dst->u.client.list[dst->u.client.qty].rx_qty], -- 0, -- sizeof(dpp_client_stats_rx_t)); -- } -- memcpy(&dst->u.client.list[dst->u.client.qty].rx[dst->u.client.list[dst->u.client.qty].rx_qty], -- rx, -- sizeof(dpp_client_stats_rx_t)); -- -- dst->u.client.list[dst->u.client.qty].rx_qty++; -- } -- -- /* Add TX stats records */ -- for ( tx = ds_dlist_ifirst(&tx_iter, &result_entry->stats_tx); -- tx != NULL; -- tx = ds_dlist_inext(&tx_iter)) -- { -- size = (dst->u.client.list[dst->u.client.qty].tx_qty + 1) * sizeof(dpp_client_stats_tx_t); -- if (!dst->u.client.list[dst->u.client.qty].tx_qty) { -- dst->u.client.list[dst->u.client.qty].tx = calloc(1, size); -- } -- else { -- dst->u.client.list[dst->u.client.qty].tx = -- realloc(dst->u.client.list[dst->u.client.qty].tx, size); -- memset(&dst->u.client.list[dst->u.client.qty].tx[dst->u.client.list[dst->u.client.qty].tx_qty], -- 0, -- sizeof(dpp_client_stats_tx_t)); -- } -- memcpy(&dst->u.client.list[dst->u.client.qty].tx[dst->u.client.list[dst->u.client.qty].tx_qty], -- tx, -- sizeof(dpp_client_stats_tx_t)); -- -- dst->u.client.list[dst->u.client.qty].tx_qty++; -- } -- -- /* Add TID records */ -- for ( tid = ds_dlist_ifirst(&tid_iter, &result_entry->tid_record_list); -- tid != NULL; -- tid = ds_dlist_inext(&tid_iter)) -- { -- size = (dst->u.client.list[dst->u.client.qty].tid_qty + 1) * sizeof(dpp_client_tid_record_list_t); -- if (!dst->u.client.list[dst->u.client.qty].tid_qty) { -- dst->u.client.list[dst->u.client.qty].tid = calloc(1, size); -- } -- else { -- dst->u.client.list[dst->u.client.qty].tid = -- realloc(dst->u.client.list[dst->u.client.qty].tid, size); -- memset(&dst->u.client.list[dst->u.client.qty].tid[dst->u.client.list[dst->u.client.qty].tid_qty], -- 0, -- sizeof(dpp_client_tid_record_list_t)); -- } -- memcpy(&dst->u.client.list[dst->u.client.qty].tid[dst->u.client.list[dst->u.client.qty].tid_qty], -- tid, -- sizeof(dpp_client_tid_record_list_t)); -- -- dst->u.client.list[dst->u.client.qty].tid_qty++; -- } -- -- /* Add client connection events records */ -- for ( events = ds_dlist_ifirst(&events_iter, &result_entry->connection_events); -- events != NULL; -- events = ds_dlist_inext(&events_iter)) -- { -- size = (dst->u.client.list[dst->u.client.qty].events_qty + 1) * sizeof(dpp_client_connection_events_t); -- if (!dst->u.client.list[dst->u.client.qty].events_qty) { -- dst->u.client.list[dst->u.client.qty].events = calloc(1, size); -- } -- else { -- dst->u.client.list[dst->u.client.qty].events = -- realloc(dst->u.client.list[dst->u.client.qty].events, size); -- memset(&dst->u.client.list[dst->u.client.qty].events[dst->u.client.list[dst->u.client.qty].events_qty], -- 0, -- sizeof(dpp_client_connection_events_t)); -- } -- memcpy(&dst->u.client.list[dst->u.client.qty].events[dst->u.client.list[dst->u.client.qty].events_qty], -- events, -- sizeof(dpp_client_connection_events_t)); -- -- dst->u.client.list[dst->u.client.qty].events_qty++; -- } -- dst->u.client.qty++; -- } -- } -- break; -- -- case DPP_T_DEVICE: -- { -- dpp_device_report_data_t *report_data = sts; -- dpp_device_temp_t *result_entry = NULL; -- dpp_device_thermal_record_t *thermal_record = NULL; -- ds_dlist_iter_t result_iter; -- int thermal_size = 0; -- -- memcpy(&dst->u.device.record, &report_data->record, sizeof(dpp_device_record_t)); -- dst->u.device.timestamp_ms = report_data->timestamp_ms; -- -- /* Loop through linked list of results and copy them to dppline buffer */ -- dst->u.device.qty = 0; -- for ( result_entry = ds_dlist_ifirst(&result_iter, &report_data->temp); -- result_entry != NULL; -- result_entry = ds_dlist_inext(&result_iter)) -- { -- size = (dst->u.device.qty + 1) * sizeof(dpp_device_temp_t); -- if (!dst->u.device.qty) -- { -- dst->u.device.list = calloc(1, size); -- } -- else -- { -- dst->u.device.list = realloc(dst->u.device.list, size); -- memset(&dst->u.device.list[dst->u.device.qty], -- 0, -- sizeof(dpp_device_temp_t)); -- } -- memcpy(&dst->u.device.list[dst->u.device.qty++], -- result_entry, -- sizeof(dpp_device_temp_t)); -- } -- -- dst->u.device.thermal_qty = 0; -- for ( thermal_record = ds_dlist_ifirst(&result_iter, &report_data->thermal_records); -- thermal_record != NULL; -- thermal_record = ds_dlist_inext(&result_iter)) -- { -- thermal_size += (dst->u.device.thermal_qty + 1) * sizeof(dpp_device_thermal_record_t); -- if (!dst->u.device.thermal_qty) -- { -- dst->u.device.thermal_list = calloc(1, thermal_size); -- } -- else -- { -- dst->u.device.thermal_list = realloc(dst->u.device.thermal_list, thermal_size); -- memset(&dst->u.device.thermal_list[dst->u.device.thermal_qty], -- 0, -- sizeof(dpp_device_thermal_record_t)); -- } -- memcpy(&dst->u.device.thermal_list[dst->u.device.thermal_qty++], -- thermal_record, -- sizeof(dpp_device_thermal_record_t)); -- } -- size += thermal_size; -- } -- break; -- -- case DPP_T_BS_CLIENT: -- { -- dpp_bs_client_report_data_t *report_data = sts; -- dpp_bs_client_record_list_t *result = NULL; -- dst->u.bs_client.qty = 0; -- dst->u.bs_client.timestamp_ms = report_data->timestamp_ms; -- -- // Loop through linked list of results and copy results -- ds_dlist_foreach(&report_data->list, result) { dst->u.bs_client.qty++; } -- size = dst->u.bs_client.qty * sizeof(dpp_bs_client_record_t); -- dst->u.bs_client.list = calloc(1, size); -- int count = 0; -- ds_dlist_foreach(&report_data->list, result) -- { -- assert(count < (int)dst->u.bs_client.qty); -- memcpy(&dst->u.bs_client.list[count], -- &result->entry, -- sizeof(dpp_bs_client_record_t)); -- count++; -- } -- } -- break; -- -- case DPP_T_RSSI: -- { -- dpp_rssi_report_data_t *report_data = sts; -- dpp_rssi_record_t *result_entry = NULL; -- ds_dlist_iter_t result_iter; -- -- dpp_rssi_raw_t *raw = NULL; -- ds_dlist_iter_t raw_iter; -- - /* Loop through linked list of results and copy them to dppline buffer */ - dst->u.rssi.qty = 0; - dst->u.rssi.radio_type = report_data->radio_type; @@ -1113,7 +1138,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c case DPP_T_NETWORK_PROBE: { dpp_network_probe_report_data_t *report_data = sts; -@@ -698,945 +755,1568 @@ static bool dppline_copysts(dppline_stat +@@ -698,945 +777,1006 @@ static bool dppline_copysts(dppline_stat } break; @@ -1144,568 +1169,6 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - } - dst->size = size; - return true; -+ case DPP_T_EVENTS: { -+ dpp_event_report_data_t *report_data = sts; -+ dpp_event_record_t *result_entry = NULL; -+ ds_dlist_iter_t result_iter; -+ -+ dpp_event_record_session_t *session = NULL; -+ ds_dlist_iter_t session_iter; -+ -+ dpp_event_record_assoc_t *assoc = NULL; -+ ds_dlist_iter_t assoc_iter; -+ dpp_event_record_auth_t *auth = NULL; -+ ds_dlist_iter_t auth_iter; -+ dpp_event_record_disconnect_t *disconnect = NULL; -+ ds_dlist_iter_t disconnect_iter; -+ dpp_event_record_connect_t *connect = NULL; -+ ds_dlist_iter_t connect_iter; -+ dpp_event_record_failure_t *failure = NULL; -+ ds_dlist_iter_t failure_iter; -+ dpp_event_record_first_data_t *first_data = NULL; -+ ds_dlist_iter_t first_data_iter; -+ dpp_event_record_id_t *id = NULL; -+ ds_dlist_iter_t id_iter; -+ dpp_event_record_ip_t *ip = NULL; -+ ds_dlist_iter_t ip_iter; -+ dpp_event_record_timeout_t *timeout = NULL; -+ ds_dlist_iter_t timeout_iter; -+ -+ /* Loop through linked list of results and copy them to dppline buffer */ -+ dst->u.events.qty = 0; -+ for (result_entry = -+ ds_dlist_ifirst(&result_iter, &report_data->list); -+ result_entry != NULL; -+ result_entry = ds_dlist_inext(&result_iter)) { -+ size = (dst->u.events.qty + 1) * -+ sizeof(dppline_event_rec_t); -+ if (!dst->u.events.qty) { -+ dst->u.events.list = calloc(1, size); -+ } else { -+ dst->u.events.list = -+ realloc(dst->u.events.list, size); -+ memset(&dst->u.events.list[dst->u.events.qty], -+ 0, sizeof(dppline_event_rec_t)); -+ } -+ -+ // Loop through client session -+ for (session = ds_dlist_ifirst( -+ &session_iter, -+ &result_entry->client_session); -+ session != NULL; -+ session = ds_dlist_inext(&session_iter)) { -+ size = (dst->u.events.list[dst->u.events.qty] -+ .session_qty + -+ 1) * -+ sizeof(dpp_event_record_session_t); -+ -+ if (!dst->u.events.list[dst->u.events.qty] -+ .session_qty) { -+ dst->u.events.list[dst->u.events.qty] -+ .session_list = calloc(1, size); -+ } else { -+ dst->u.events.list[dst->u.events.qty] -+ .session_list = realloc( -+ dst->u.events -+ .list[dst->u.events.qty] -+ .session_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events.qty] -+ .session_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .session_qty], -+ 0, -+ sizeof(dpp_event_record_session_t)); -+ } -+ memcpy(&dst->u.events.list[dst->u.events.qty].session_list -+ [dst->u.events -+ .list[dst->u.events.qty] -+ .session_qty], -+ session, -+ sizeof(dpp_event_record_session_t)); -+ -+ // Add assoc records -+ for (assoc = ds_dlist_ifirst( -+ &assoc_iter, &session->assoc_list); -+ assoc != NULL; -+ assoc = ds_dlist_inext(&assoc_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .assoc_qty + -+ 1) * -+ sizeof(dpp_event_record_assoc_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .assoc_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .assoc_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .assoc_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .assoc_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .assoc_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .assoc_qty], -+ 0, -+ sizeof(dpp_event_record_assoc_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .assoc_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .assoc_qty], -+ assoc, -+ sizeof(dpp_event_record_assoc_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .assoc_qty++; -+ } -+ -+ // Add auth records -+ for (auth = ds_dlist_ifirst( -+ &auth_iter, &session->auth_list); -+ auth != NULL; -+ auth = ds_dlist_inext(&auth_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .auth_qty + -+ 1) * -+ sizeof(dpp_event_record_auth_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .auth_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .auth_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .auth_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .auth_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .auth_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .auth_qty], -+ 0, -+ sizeof(dpp_event_record_auth_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .auth_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .auth_qty], -+ auth, -+ sizeof(dpp_event_record_auth_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .auth_qty++; -+ } -+ -+ // Add disconnect records -+ for (disconnect = ds_dlist_ifirst( -+ &disconnect_iter, -+ &session->disconnect_list); -+ disconnect != NULL; -+ disconnect = -+ ds_dlist_inext(&disconnect_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .disconnect_qty + -+ 1) * -+ sizeof(dpp_event_record_disconnect_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .disconnect_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .disconnect_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .disconnect_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .disconnect_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .disconnect_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .disconnect_qty], -+ 0, -+ sizeof(dpp_event_record_disconnect_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .disconnect_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .disconnect_qty], -+ disconnect, -+ sizeof(dpp_event_record_disconnect_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .disconnect_qty++; -+ } -+ -+ // Add connect records -+ for (connect = ds_dlist_ifirst( -+ &connect_iter, -+ &session->connect_list); -+ connect != NULL; -+ connect = ds_dlist_inext(&connect_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .connect_qty + -+ 1) * -+ sizeof(dpp_event_record_connect_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .connect_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .connect_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .connect_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .connect_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .connect_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .connect_qty], -+ 0, -+ sizeof(dpp_event_record_connect_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .connect_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .connect_qty], -+ connect, -+ sizeof(dpp_event_record_connect_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .connect_qty++; -+ } -+ -+ // Add failure records -+ for (failure = ds_dlist_ifirst( -+ &failure_iter, -+ &session->failure_list); -+ failure != NULL; -+ failure = ds_dlist_inext(&failure_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .failure_qty + -+ 1) * -+ sizeof(dpp_event_record_failure_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .failure_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .failure_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .failure_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .failure_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .failure_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .failure_qty], -+ 0, -+ sizeof(dpp_event_record_failure_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .failure_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .failure_qty], -+ failure, -+ sizeof(dpp_event_record_failure_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .failure_qty++; -+ } -+ -+ // Add first_data records -+ for (first_data = ds_dlist_ifirst( -+ &first_data_iter, -+ &session->first_data_list); -+ first_data != NULL; -+ first_data = -+ ds_dlist_inext(&first_data_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .first_data_qty + -+ 1) * -+ sizeof(dpp_event_record_first_data_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .first_data_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .first_data_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .first_data_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .first_data_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .first_data_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .first_data_qty], -+ 0, -+ sizeof(dpp_event_record_first_data_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .first_data_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .first_data_qty], -+ first_data, -+ sizeof(dpp_event_record_first_data_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .first_data_qty++; -+ } -+ -+ // Add id records -+ for (id = ds_dlist_ifirst(&id_iter, -+ &session->id_list); -+ id != NULL; -+ id = ds_dlist_inext(&id_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .id_qty + -+ 1) * -+ sizeof(dpp_event_record_id_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .id_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .id_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .id_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .id_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .id_list[dst->u.events -+ .list[dst->u.events -+ .qty] -+ .id_qty], -+ 0, -+ sizeof(dpp_event_record_id_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .id_list[dst->u.events -+ .list[dst->u.events -+ .qty] -+ .id_qty], -+ id, -+ sizeof(dpp_event_record_id_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .id_qty++; -+ } -+ -+ // Add ip records -+ for (ip = ds_dlist_ifirst(&ip_iter, -+ &session->ip_list); -+ ip != NULL; -+ ip = ds_dlist_inext(&ip_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .ip_qty + -+ 1) * -+ sizeof(dpp_event_record_ip_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .ip_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .ip_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .ip_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .ip_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .ip_list[dst->u.events -+ .list[dst->u.events -+ .qty] -+ .ip_qty], -+ 0, -+ sizeof(dpp_event_record_ip_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .ip_list[dst->u.events -+ .list[dst->u.events -+ .qty] -+ .ip_qty], -+ ip, -+ sizeof(dpp_event_record_ip_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .ip_qty++; -+ } -+ -+ // Add timeout records -+ for (timeout = ds_dlist_ifirst( -+ &timeout_iter, -+ &session->timeout_list); -+ timeout != NULL; -+ timeout = ds_dlist_inext(&timeout_iter)) { -+ size = (dst->u.events -+ .list[dst->u.events.qty] -+ .timeout_qty + -+ 1) * -+ sizeof(dpp_event_record_timeout_t); -+ -+ if (!dst->u.events -+ .list[dst->u.events.qty] -+ .timeout_qty) { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .timeout_list = -+ calloc(1, size); -+ } else { -+ dst->u.events -+ .list[dst->u.events.qty] -+ .timeout_list = realloc( -+ dst->u.events -+ .list[dst->u.events -+ .qty] -+ .timeout_list, -+ size); -+ memset(&dst->u.events -+ .list[dst->u.events -+ .qty] -+ .timeout_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .timeout_qty], -+ 0, -+ sizeof(dpp_event_record_timeout_t)); -+ } -+ memcpy(&dst->u.events -+ .list[dst->u.events.qty] -+ .timeout_list -+ [dst->u.events -+ .list[dst->u.events -+ .qty] -+ .timeout_qty], -+ timeout, -+ sizeof(dpp_event_record_timeout_t)); -+ -+ dst->u.events.list[dst->u.events.qty] -+ .timeout_qty++; -+ } -+ -+ dst->u.events.list[dst->u.events.qty] -+ .session_qty++; -+ } -+ -+ dst->u.events.qty++; -+ } -+ } break; -+ + default: + LOG(ERR, "Failed to copy %d stats", dst->type); + /* do nothing */ @@ -1713,36 +1176,61 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + } + dst->size = size; + return true; -+} -+ + } + +-static char * getNodeid() +static char *getNodeid() -+{ + { +- char * buff = NULL; + char *buff = NULL; -+ + +- buff = malloc(TARGET_ID_SZ); +- if (buff == NULL) +- { +- LOG(ERR, "Unable to allocate memory for node id."); +- return NULL; +- } + buff = malloc(TARGET_ID_SZ); + if (buff == NULL) { + LOG(ERR, "Unable to allocate memory for node id."); + return NULL; + } -+ + +- if (!target_id_get(buff, TARGET_ID_SZ)) +- { +- LOG(ERR, "Error acquiring node id."); +- free(buff); +- return NULL; +- } + if (!target_id_get(buff, TARGET_ID_SZ)) { + LOG(ERR, "Error acquiring node id."); + free(buff); + return NULL; + } -+ + +- return buff; + return buff; -+} -+ + } + +- +-Sts__RadioBandType dppline_to_proto_radio(radio_type_t radio_type) +Sts__AssocType dppline_to_proto_assoc_type(assoc_type_t assoc_type) -+{ + { +- switch (radio_type) +- { +- case RADIO_TYPE_2G: +- return STS__RADIO_BAND_TYPE__BAND2G; + switch (assoc_type) { + case AT_ASSOC: + return STS__ASSOC_TYPE__ASSOC; -+ + +- case RADIO_TYPE_5G: +- return STS__RADIO_BAND_TYPE__BAND5G; + case AT_REASSOC: + return STS__ASSOC_TYPE__REASSOC; -+ + +- case RADIO_TYPE_5GL: +- return STS__RADIO_BAND_TYPE__BAND5GL; + default: + assert(0); + } @@ -1754,31 +1242,50 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + switch (device_type) { + case DT_AP: + return STS__DEVICE_TYPE__DEV_AP; -+ + +- case RADIO_TYPE_5GU: +- return STS__RADIO_BAND_TYPE__BAND5GU; + case DT_STA: + return STS__DEVICE_TYPE__DEV_STA; -+ + +- default: +- assert(0); +- } +- return 0; + default: + assert(0); + } + return 0; -+} -+ + } + +-Sts__SurveyType dppline_to_proto_survey_type(radio_scan_type_t scan_type) +Sts__FrameType dppline_to_proto_frame_type(frame_type_t frame_type) -+{ + { +- switch (scan_type) +- { +- case RADIO_SCAN_TYPE_ONCHAN: +- return STS__SURVEY_TYPE__ON_CHANNEL; + switch (frame_type) { + case FT_DEAUTH: + return STS__FRAME_TYPE__FT_DEAUTH; -+ + +- case RADIO_SCAN_TYPE_OFFCHAN: +- return STS__SURVEY_TYPE__OFF_CHANNEL; + case FT_DISASSOC: + return STS__FRAME_TYPE__FT_DISASSOC; -+ + +- case RADIO_SCAN_TYPE_FULL: +- return STS__SURVEY_TYPE__FULL; + default: + assert(0); + } + return 0; +} -+ + +- default: +- assert(0); +- } +- return 0; +Sts__CTReasonType dppline_to_proto_ct_reason_type(ct_reason_t reason_type) +{ + switch (reason_type) { @@ -1792,26 +1299,43 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + assert(0); + } + return 0; -+} -+ + } + +-Sts__ReportType dppline_to_proto_report_type(report_type_t report_type) +Sts__EventType dppline_to_proto_event_type(event_type_t event_type) -+{ + { +- switch (report_type) +- { +- case REPORT_TYPE_RAW: +- return STS__REPORT_TYPE__RAW; + switch (event_type) { + case ET_CLIENT_ASSOC: + return STS__EVENT_TYPE__CLIENT_ASSOC; -+ + +- case REPORT_TYPE_AVERAGE: +- return STS__REPORT_TYPE__AVERAGE; + case ET_CLIENT_AUTH: + return STS__EVENT_TYPE__CLIENT_AUTH; -+ + +- case REPORT_TYPE_HISTOGRAM: +- return STS__REPORT_TYPE__HISTOGRAM; + case ET_CLIENT_DISCONNECT: + return STS__EVENT_TYPE__CLIENT_DISCONNECT; -+ + +- case REPORT_TYPE_PERCENTILE: +- return STS__REPORT_TYPE__PERCENTILE; + case ET_CLIENT_FAILURE: + return STS__EVENT_TYPE__CLIENT_FAILURE; -+ + +- case REPORT_TYPE_DIFF: +- return STS__REPORT_TYPE__DIFF; + case ET_CLIENT_FIRST_DATA: + return STS__EVENT_TYPE__CLIENT_FIRST_DATA; -+ + +- default: +- assert(0); +- } +- return 0; + case ET_CLIENT_ID: + return STS__EVENT_TYPE__CLIENT_ID; + @@ -1827,26 +1351,12 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + return 0; } --static char * getNodeid() +-static void dppline_add_stat_survey(Sts__Report *r, dppline_stats_t *s) +Sts__RadioBandType dppline_to_proto_radio(radio_type_t radio_type) { -- char * buff = NULL; -- -- buff = malloc(TARGET_ID_SZ); -- if (buff == NULL) -- { -- LOG(ERR, "Unable to allocate memory for node id."); -- return NULL; -- } -- -- if (!target_id_get(buff, TARGET_ID_SZ)) -- { -- LOG(ERR, "Error acquiring node id."); -- free(buff); -- return NULL; -- } -- -- return buff; +- Sts__Survey *sr = NULL; +- uint32_t i; +- dppline_survey_stats_t *survey = &s->u.survey; + switch (radio_type) { + case RADIO_TYPE_2G: + return STS__RADIO_BAND_TYPE__BAND2G; @@ -1864,137 +1374,29 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + assert(0); + } + return 0; - } ++} -- --Sts__RadioBandType dppline_to_proto_radio(radio_type_t radio_type) +- // increase the number of surveys +- r->n_survey++; +Sts__SurveyType dppline_to_proto_survey_type(radio_scan_type_t scan_type) - { -- switch (radio_type) -- { -- case RADIO_TYPE_2G: -- return STS__RADIO_BAND_TYPE__BAND2G; ++{ + switch (scan_type) { + case RADIO_SCAN_TYPE_ONCHAN: + return STS__SURVEY_TYPE__ON_CHANNEL; -- case RADIO_TYPE_5G: -- return STS__RADIO_BAND_TYPE__BAND5G; -+ case RADIO_SCAN_TYPE_OFFCHAN: -+ return STS__SURVEY_TYPE__OFF_CHANNEL; - -- case RADIO_TYPE_5GL: -- return STS__RADIO_BAND_TYPE__BAND5GL; -+ case RADIO_SCAN_TYPE_FULL: -+ return STS__SURVEY_TYPE__FULL; - -- case RADIO_TYPE_5GU: -- return STS__RADIO_BAND_TYPE__BAND5GU; -- -- default: -- assert(0); -- } -- return 0; -+ default: -+ assert(0); -+ } -+ return 0; - } - --Sts__SurveyType dppline_to_proto_survey_type(radio_scan_type_t scan_type) -+Sts__AssocType dppline_to_proto_sec_type(sec_type_t sec_type) - { -- switch (scan_type) -- { -- case RADIO_SCAN_TYPE_ONCHAN: -- return STS__SURVEY_TYPE__ON_CHANNEL; -+ switch (sec_type) { -+ case SEC_OPEN: -+ return STS__SECURITY_TYPE__SEC_OPEN; - -- case RADIO_SCAN_TYPE_OFFCHAN: -- return STS__SURVEY_TYPE__OFF_CHANNEL; -+ case SEC_RADIUS: -+ return STS__SECURITY_TYPE__SEC_RADIUS; - -- case RADIO_SCAN_TYPE_FULL: -- return STS__SURVEY_TYPE__FULL; -+ case SEC_PSK: -+ return STS__SECURITY_TYPE__SEC_PSK; - -- default: -- assert(0); -- } -- return 0; -+ default: -+ assert(0); -+ } -+ return 0; - } - - Sts__ReportType dppline_to_proto_report_type(report_type_t report_type) - { -- switch (report_type) -- { -- case REPORT_TYPE_RAW: -- return STS__REPORT_TYPE__RAW; -- -- case REPORT_TYPE_AVERAGE: -- return STS__REPORT_TYPE__AVERAGE; -- -- case REPORT_TYPE_HISTOGRAM: -- return STS__REPORT_TYPE__HISTOGRAM; -- -- case REPORT_TYPE_PERCENTILE: -- return STS__REPORT_TYPE__PERCENTILE; -- -- case REPORT_TYPE_DIFF: -- return STS__REPORT_TYPE__DIFF; -- -- default: -- assert(0); -- } -- return 0; -+ switch (report_type) { -+ case REPORT_TYPE_RAW: -+ return STS__REPORT_TYPE__RAW; -+ -+ case REPORT_TYPE_AVERAGE: -+ return STS__REPORT_TYPE__AVERAGE; -+ -+ case REPORT_TYPE_HISTOGRAM: -+ return STS__REPORT_TYPE__HISTOGRAM; -+ -+ case REPORT_TYPE_PERCENTILE: -+ return STS__REPORT_TYPE__PERCENTILE; -+ -+ case REPORT_TYPE_DIFF: -+ return STS__REPORT_TYPE__DIFF; -+ -+ default: -+ assert(0); -+ } -+ return 0; - } - - static void dppline_add_stat_survey(Sts__Report *r, dppline_stats_t *s) - { -- Sts__Survey *sr = NULL; -- uint32_t i; -- dppline_survey_stats_t *survey = &s->u.survey; -- -- // increase the number of surveys -- r->n_survey++; -- - // allocate or extend the size of surveys - r->survey = realloc(r->survey, - r->n_survey * sizeof(Sts__Survey*)); -- ++ case RADIO_SCAN_TYPE_OFFCHAN: ++ return STS__SURVEY_TYPE__OFF_CHANNEL; + - // allocate new buffer Sts__Survey - sr = malloc(sizeof(Sts__Survey)); - assert(sr); - r->survey[r->n_survey - 1] = sr; -- ++ case RADIO_SCAN_TYPE_FULL: ++ return STS__SURVEY_TYPE__FULL; + - sts__survey__init(sr); - sr->band = dppline_to_proto_radio(survey->radio_type); - sr->report_type = dppline_to_proto_report_type(survey->report_type); @@ -2043,6 +1445,56 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - CP_AVG(busy_rx, chan_rx); - CP_AVG(busy_ext, chan_busy_ext); - CP_AVG(noise, chan_noise); ++ default: ++ assert(0); ++ } ++ return 0; ++} ++ ++Sts__AssocType dppline_to_proto_sec_type(sec_type_t sec_type) ++{ ++ switch (sec_type) { ++ case SEC_OPEN: ++ return STS__SECURITY_TYPE__SEC_OPEN; ++ ++ case SEC_RADIUS: ++ return STS__SECURITY_TYPE__SEC_RADIUS; ++ ++ case SEC_PSK: ++ return STS__SECURITY_TYPE__SEC_PSK; ++ ++ default: ++ assert(0); ++ } ++ return 0; ++} ++ ++Sts__ReportType dppline_to_proto_report_type(report_type_t report_type) ++{ ++ switch (report_type) { ++ case REPORT_TYPE_RAW: ++ return STS__REPORT_TYPE__RAW; ++ ++ case REPORT_TYPE_AVERAGE: ++ return STS__REPORT_TYPE__AVERAGE; ++ ++ case REPORT_TYPE_HISTOGRAM: ++ return STS__REPORT_TYPE__HISTOGRAM; ++ ++ case REPORT_TYPE_PERCENTILE: ++ return STS__REPORT_TYPE__PERCENTILE; ++ ++ case REPORT_TYPE_DIFF: ++ return STS__REPORT_TYPE__DIFF; ++ ++ default: ++ assert(0); ++ } ++ return 0; ++} ++ ++static void dppline_add_stat_survey(Sts__Report *r, dppline_stats_t *s) ++{ + Sts__Survey *sr = NULL; + uint32_t i; + dppline_survey_stats_t *survey = &s->u.survey; @@ -2378,7 +1830,9 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c { - // slow - //sprintf(str, MAC_ADDRESS_FORMAT, MAC_ADDRESS_PRINT(rec->mac)); -- ++ // slow ++ //sprintf(str, MAC_ADDRESS_FORMAT, MAC_ADDRESS_PRINT(rec->mac)); + - // optimized - int i; - uint8_t nib; @@ -2393,9 +1847,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - } - *str = 0; -} -+ // slow -+ //sprintf(str, MAC_ADDRESS_FORMAT, MAC_ADDRESS_PRINT(rec->mac)); - +- -char* dpp_mac_str_tmp(uint8_t *mac) -{ - static mac_address_str_t str; @@ -2435,6 +1887,10 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - return STS__WMM_AC__WMM_AC_BE; - case RADIO_QUEUE_TYPE_BK: - return STS__WMM_AC__WMM_AC_BK; +- +- default: +- assert(0); +- } + switch (ac_type) { + case RADIO_QUEUE_TYPE_VI: + return STS__WMM_AC__WMM_AC_VI; @@ -2449,10 +1905,6 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + assert(0); + } -- default: -- assert(0); -- } -- - return -1; + return -1; } @@ -3544,12 +2996,13 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c sizeof(s->u.capacity) + s->u.capacity.numrec * sizeof(dpp_capacity_record_t), sizeof(Sts__Capacity*) + sizeof(Sts__Capacity) + -@@ -1714,658 +2394,1419 @@ static void dppline_add_stat_network_pro +@@ -1714,658 +1854,1129 @@ static void dppline_add_stat_network_pro } } -static void dppline_add_stat_bs_client(Sts__Report * r, dppline_stats_t * s) --{ ++static void dppline_add_stat_events(Sts__Report *r, dppline_stats_t *s) + { - Sts__BSReport *sr = NULL; - Sts__BSClient *cr; - Sts__BSClient__BSBandReport *br; @@ -3625,10 +3078,13 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - - cr->n_bs_band_report++; - } -- ++ Sts__EventReport *sr = NULL; + - cr->bs_band_report = calloc(cr->n_bs_band_report, sizeof(*cr->bs_band_report)); - assert(cr->bs_band_report); -- ++ uint32_t session = 0; ++ dppline_events_stats_t *events = &s->u.events; + - // For each band per client - for (band = 0, band_report = 0; band < c_rec->num_band_records; band++) - { @@ -3637,7 +3093,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - if (b_rec->type == RADIO_TYPE_NONE) { - continue; - } - +- - // Allocate memory for the band report - br = cr->bs_band_report[band_report] = malloc(sizeof(Sts__BSClient__BSBandReport)); - band_report++; @@ -3792,154 +3248,446 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - } - } - } --} -- --static void dppline_add_stat_ucc(Sts__Report *r, dppline_stats_t *s) ++ // increase the number of event_report ++ r->n_event_report++; ++ ++ // allocate or extend the size of event_report ++ r->event_report = ++ realloc(r->event_report, ++ r->n_event_report * sizeof(Sts__EventReport *)); ++ ++ // allocate new buffer ++ sr = malloc(sizeof(Sts__EventReport)); ++ assert(sr); ++ ++ r->event_report[r->n_event_report - 1] = sr; ++ ++ sts__event_report__init(sr); ++ ++ sr->client_session = malloc(events->client_event_qty * sizeof(*sr->client_session)); ++ assert(sr->client_session); ++ sr->n_client_session = events->client_event_qty; ++ ++ for (session = 0; session < events->client_event_qty; session++) { ++ ++ dpp_event_record_session_t *cs_rec = &events->client_event_list[session]; ++ ++ Sts__EventReport__ClientSession *cs = NULL; ++ cs = sr->client_session[session] = malloc(sizeof(**sr->client_session)); ++ assert(cs); ++ sts__event_report__client_session__init(cs); ++ ++ cs->session_id = cs_rec->session_id; ++ ++ if(cs_rec->assoc_event) { ++ //cs->has_client_assoc_event = true; ++ ++ Sts__EventReport__ClientAssocEvent *ae; ++ ae = cs->client_assoc_event = malloc(sizeof(*cs->client_assoc_event)); ++ assert(ae); ++ sts__event_report__client_assoc_event__init(ae); ++ ++ ae->session_id = cs_rec->assoc_event->session_id; ++ ae->sta_mac = strdup(cs_rec->assoc_event->sta_mac); ++ ae->ssid = strdup(cs_rec->assoc_event->ssid); ++ ae->band = dppline_to_proto_radio(cs_rec->assoc_event->band); ++ ++ if (cs_rec->assoc_event->assoc_type) { ++ ae->assoc_type = ++ dppline_to_proto_assoc_type( ++ cs_rec->assoc_event->assoc_type); ++ ae->has_assoc_type = true; ++ } ++ ++ if (cs_rec->assoc_event->status) { ++ ae->status = cs_rec->assoc_event->status; ++ ae->has_status = true; ++ } ++ ++ if (cs_rec->assoc_event->rssi) { ++ ae->rssi = cs_rec->assoc_event->rssi; ++ ae->has_rssi = true; ++ } ++ ++ if (cs_rec->assoc_event->internal_sc) { ++ ae->internal_sc = cs_rec->assoc_event->internal_sc; ++ ae->has_internal_sc = true; ++ } ++ ++ if (cs_rec->assoc_event->using11k) { ++ ae->using11k = cs_rec->assoc_event->using11k; ++ ae->has_using11k = true; ++ } ++ ++ if (cs_rec->assoc_event->using11r) { ++ ae->using11r = cs_rec->assoc_event->using11r; ++ ae->has_using11r = true; ++ } ++ ++ if (cs_rec->assoc_event->using11v) { ++ ae->using11v = cs_rec->assoc_event->using11v; ++ ae->has_using11v = true; ++ } ++ ++ if (cs_rec->assoc_event->timestamp) { ++ ae->timestamp_ms = cs_rec->assoc_event->timestamp; ++ ae->has_timestamp_ms = true; ++ } ++ } ++ ++ if(cs_rec->auth_event) { ++ //cs->has_client_auth_event = true; ++ ++ Sts__EventReport__ClientAuthEvent *authe; ++ authe = cs->client_auth_event = malloc(sizeof(*cs->client_auth_event)); ++ assert(authe); ++ sts__event_report__client_auth_event__init(authe); ++ ++ authe->sta_mac = strdup(cs_rec->auth_event->sta_mac); ++ authe->session_id = cs_rec->auth_event->session_id; ++ authe->ssid = strdup(cs_rec->auth_event->ssid); ++ authe->band = dppline_to_proto_radio( ++ cs_rec->auth_event->band); ++ ++ if (cs_rec->auth_event->auth_status) { ++ authe->auth_status = cs_rec->auth_event->auth_status; ++ authe->has_auth_status = true; ++ } ++ ++ if (cs_rec->auth_event->timestamp) { ++ authe->timestamp_ms = cs_rec->auth_event->timestamp; ++ authe->has_timestamp_ms = true; ++ } ++ } ++ ++ if(cs_rec->disconnect_event) { ++ //cs->has_client_disconnect_event = true; ++ ++ Sts__EventReport__ClientDisconnectEvent *de; ++ de = cs->client_disconnect_event = malloc(sizeof(*cs->client_disconnect_event)); ++ assert(de); ++ sts__event_report__client_disconnect_event__init(de); ++ ++ de->sta_mac = strdup(cs_rec->disconnect_event->sta_mac); ++ de->session_id = cs_rec->disconnect_event->session_id; ++ ++ if (cs_rec->disconnect_event->reason) { ++ de->reason = cs_rec->disconnect_event->reason; ++ de->has_reason = true; ++ } ++ ++ if (cs_rec->disconnect_event->dev_type) { ++ de->dev_type = ++ dppline_to_proto_device_type( ++ cs_rec->disconnect_event->dev_type); ++ de->has_dev_type = true; ++ } ++ ++ if (cs_rec->disconnect_event->fr_type) { ++ de->fr_type = ++ dppline_to_proto_frame_type( ++ cs_rec->disconnect_event->fr_type); ++ de->has_fr_type = true; ++ } ++ ++ if (cs_rec->disconnect_event->last_sent_up_ts_in_us) { ++ de->lsent_up_ts_in_us = ++ cs_rec->disconnect_event->last_sent_up_ts_in_us; ++ de->has_lsent_up_ts_in_us = true; ++ } ++ ++ if (cs_rec->disconnect_event->last_recv_up_ts_in_us) { ++ de->lrcv_up_ts_in_us = ++ cs_rec->disconnect_event->last_recv_up_ts_in_us; ++ de->has_lrcv_up_ts_in_us = true; ++ } ++ ++ if (cs_rec->disconnect_event->internal_rc) { ++ de->internal_rc = cs_rec->disconnect_event->internal_rc; ++ de->has_internal_rc = true; ++ } ++ ++ if (cs_rec->disconnect_event->rssi) { ++ de->rssi = cs_rec->disconnect_event->rssi; ++ de->has_rssi = true; ++ } ++ ++ if (cs_rec->disconnect_event->timestamp) { ++ de->timestamp_ms = cs_rec->disconnect_event->timestamp; ++ de->has_timestamp_ms = true; ++ } ++ ++ de->ssid = strdup(cs_rec->disconnect_event->ssid); ++ de->band = dppline_to_proto_radio( ++ cs_rec->disconnect_event->band); ++ } ++ ++ if(cs_rec->failure_event) { ++ //cs->has_client_failure_event = true; ++ ++ Sts__EventReport__ClientFailureEvent *cfe; ++ cfe = cs->client_failure_event = malloc(sizeof(*cs->client_failure_event)); ++ assert(cfe); ++ sts__event_report__client_failure_event__init(cfe); ++ ++ cfe->sta_mac = strdup(cs_rec->failure_event->sta_mac); ++ cfe->session_id = cs_rec->failure_event->session_id; ++ cfe->ssid = strdup(cs_rec->failure_event->ssid); ++ ++ if (cs_rec->failure_event->reason_str) { ++ cfe->reason_str = strdup(cs_rec->failure_event->reason_str); ++ } ++ ++ if (cs_rec->failure_event->reason) { ++ cfe->reason_code = cs_rec->failure_event->reason; ++ cfe->has_reason_code = true; ++ } ++ ++ if (cs_rec->failure_event->timestamp) { ++ cfe->timestamp_ms = cs_rec->failure_event->timestamp; ++ cfe->has_timestamp_ms = true; ++ } ++ } ++ ++ if(cs_rec->first_data_event) { ++ //cs->has_client_first_data_event = true; ++ ++ Sts__EventReport__ClientFirstDataEvent *fde; ++ fde = cs->client_first_data_event = malloc(sizeof(*cs->client_first_data_event)); ++ assert(fde); ++ sts__event_report__client_first_data_event__init(fde); ++ ++ fde->sta_mac = strdup(cs_rec->first_data_event->sta_mac); ++ fde->session_id = cs_rec->first_data_event->session_id; ++ ++ if(cs_rec->first_data_event->fdata_tx_up_ts_in_us) { ++ fde->fdata_tx_up_ts_in_us = cs_rec->first_data_event->fdata_tx_up_ts_in_us; ++ fde->has_fdata_tx_up_ts_in_us = true; ++ } ++ ++ if(cs_rec->first_data_event->fdata_rx_up_ts_in_us) { ++ fde->fdata_rx_up_ts_in_us = cs_rec->first_data_event->fdata_rx_up_ts_in_us; ++ fde->has_fdata_rx_up_ts_in_us = true; ++ } ++ ++ if(cs_rec->first_data_event->timestamp) { ++ fde->timestamp_ms = cs_rec->first_data_event->timestamp; ++ fde->has_timestamp_ms = true; ++ } ++ ++ } ++ ++ if(cs_rec->id_event) { ++ //cs->has_client_id_event = true; ++ ++ Sts__EventReport__ClientIdEvent *ide; ++ ide = cs->client_id_event = malloc(sizeof(*cs->client_id_event)); ++ assert(ide); ++ sts__event_report__client_id_event__init(ide); ++ ++ ide->clt_mac = malloc(MACADDR_STR_LEN); ++ //dpp_mac_to_str(ide->clt_mac, cs_rec->id_event->clt_mac); ++ ide->session_id = cs_rec->id_event->session_id; ++ ++ if(cs_rec->id_event->clt_id) { ++ ide->clt_id = strdup(ide->clt_id); ++ } ++ ++ if(cs_rec->id_event->timestamp) { ++ ide->timestamp_ms = cs_rec->id_event->timestamp; ++ ide->has_timestamp_ms = true; ++ } ++ } ++ ++ if(cs_rec->ip_event) { ++ //cs->has_client_ip_event = true; ++ ++ Sts__EventReport__ClientIpEvent *ipe; ++ ipe = cs->client_ip_event = malloc(sizeof(*cs->client_ip_event)); ++ assert(ipe); ++ sts__event_report__client_ip_event__init(ipe); ++ ++ ipe->session_id = cs_rec->ip_event->session_id; ++ ipe->sta_mac = strdup(cs_rec->ip_event->sta_mac); ++ ++ if (cs_rec->ip_event->ip_addr) { ++ ipe->ip_addr.data = malloc(16); ++ memcpy(ipe->ip_addr.data, cs_rec->ip_event->ip_addr,16); ++ ipe->ip_addr.len = 16; ++ ipe->has_ip_addr = true; ++ } ++ ++ if(cs_rec->ip_event->timestamp) { ++ ipe->timestamp_ms = cs_rec->ip_event->timestamp; ++ ipe->has_timestamp_ms = true; ++ } ++ } ++ ++ if(cs_rec->timeout_event) { ++ //cs->has_client_timeout_event = true; ++ ++ Sts__EventReport__ClientTimeoutEvent *toe; ++ toe = cs->client_timeout_event = malloc(sizeof(*cs->client_timeout_event)); ++ assert(toe); ++ sts__event_report__client_timeout_event__init(toe); ++ ++ toe->sta_mac = strdup(cs_rec->timeout_event->sta_mac); ++ toe->session_id = cs_rec->timeout_event->session_id; ++ ++ if (cs_rec->timeout_event->r_code) { ++ toe->r_code = ++ dppline_to_proto_ct_reason_type( ++ cs_rec->timeout_event->r_code); ++ toe->has_r_code = true; ++ } ++ ++ if (cs_rec->timeout_event->last_sent_up_ts_in_us) { ++ toe->last_sent_up_ts_in_us = ++ cs_rec->timeout_event->last_sent_up_ts_in_us; ++ toe->has_last_sent_up_ts_in_us = true; ++ } ++ ++ if (cs_rec->timeout_event->last_recv_up_ts_in_us) { ++ toe->last_rcv_up_ts_in_us = ++ cs_rec->timeout_event->last_recv_up_ts_in_us; ++ toe->has_last_rcv_up_ts_in_us = true; ++ } ++ ++ if(cs_rec->timeout_event->timestamp) { ++ toe->timestamp_ms = cs_rec->timeout_event->timestamp; ++ toe->has_timestamp_ms = true; ++ } ++ } ++ ++ if(cs_rec->connect_event) { ++ //cs->has_client_connect_event = true; ++ ++ Sts__EventReport__ClientConnectEvent *coe; ++ coe = cs->client_connect_event = malloc(sizeof(*cs->client_connect_event)); ++ assert(coe); ++ sts__event_report__client_connect_event__init(coe); ++ ++ coe->sta_mac = strdup(cs_rec->connect_event->sta_mac); ++ ++ ++ coe->session_id = cs_rec->connect_event->session_id; ++ coe->band = dppline_to_proto_radio( ++ cs_rec->connect_event->band); ++ ++ if (cs_rec->connect_event->assoc_type) { ++ coe->assoc_type = ++ dppline_to_proto_assoc_type( ++ cs_rec->connect_event->assoc_type); ++ coe->has_assoc_type = true; ++ } ++ ++ coe->ssid = strdup(cs_rec->connect_event->ssid); ++ ++ if (cs_rec->connect_event->sec_type) { ++ coe->sec_type = ++ dppline_to_proto_sec_type( ++ cs_rec->connect_event->sec_type); ++ coe->has_sec_type = true; ++ } ++ ++ if (cs_rec->connect_event->fbt_used) { ++ coe->fbt_used = cs_rec->connect_event->fbt_used; ++ coe->has_fbt_used = true; ++ } ++ ++ if (cs_rec->connect_event->ip_addr) { ++ coe->ip_addr.data = malloc(16); ++ memcpy(coe->ip_addr.data, cs_rec->connect_event->ip_addr, ++ 16); ++ coe->ip_addr.len = 16; ++ coe->has_ip_addr = true; ++ } ++ ++ if (cs_rec->connect_event->clt_id) { ++ coe->clt_id = strcpy(coe->clt_id, ++ cs_rec->connect_event->clt_id); ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_auth) { ++ coe->ev_time_bootup_in_us_auth = ++ cs_rec->connect_event->ev_time_bootup_in_us_auth; ++ coe->has_ev_time_bootup_in_us_auth = ++ true; ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_assoc) { ++ coe->ev_time_bootup_in_us_assoc = ++ cs_rec->connect_event->ev_time_bootup_in_us_assoc; ++ coe->has_ev_time_bootup_in_us_assoc = ++ true; ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_eapol) { ++ coe->ev_time_bootup_in_us_eapol = ++ cs_rec->connect_event->ev_time_bootup_in_us_eapol; ++ coe->has_ev_time_bootup_in_us_eapol = ++ true; ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_port_enable) { ++ coe->ev_time_bootup_in_us_port_enable = ++ cs_rec->connect_event->ev_time_bootup_in_us_port_enable; ++ coe->has_ev_time_bootup_in_us_port_enable = ++ true; ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_first_rx) { ++ coe->ev_time_bootup_in_us_first_rx = ++ cs_rec->connect_event->ev_time_bootup_in_us_first_rx; ++ coe->has_ev_time_bootup_in_us_first_rx = ++ true; ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_first_tx) { ++ coe->ev_time_bootup_in_us_first_tx = ++ cs_rec->connect_event->ev_time_bootup_in_us_first_tx; ++ coe->has_ev_time_bootup_in_us_first_tx = ++ true; ++ } ++ ++ if (cs_rec->connect_event->using11k) { ++ coe->using11k = cs_rec->connect_event->using11k; ++ coe->has_using11k = true; ++ } ++ ++ if (cs_rec->connect_event->using11r) { ++ coe->using11r = cs_rec->connect_event->using11r; ++ coe->has_using11r = true; ++ } ++ ++ if (cs_rec->connect_event->using11v) { ++ coe->using11v = cs_rec->connect_event->using11v; ++ coe->has_using11v = true; ++ } ++ ++ if (cs_rec->connect_event->ev_time_bootup_in_us_ip) { ++ coe->ev_time_bootup_in_us_ip = ++ cs_rec->connect_event->ev_time_bootup_in_us_ip; ++ coe->has_ev_time_bootup_in_us_ip = true; ++ } ++ ++ if (cs_rec->connect_event->assoc_rssi) { ++ coe->assoc_rssi = cs_rec->connect_event->assoc_rssi; ++ coe->has_assoc_rssi = true; ++ } ++ ++ if(cs_rec->connect_event->timestamp) { ++ coe->timestamp_ms = cs_rec->connect_event->timestamp; ++ coe->has_timestamp_ms = true; ++ } ++ } ++ ++ } ++ ++} ++ +static void dppline_add_stat_bs_client(Sts__Report *r, dppline_stats_t *s) - { -- Sts__VideoVoiceReport *sr = NULL; -- int size = 0; -- uint32_t i; -- dppline_ucc_stats_t *ucc = &s->u.ucc; -- -- -- // increase the number of vivo report -- r->n_video_voice_report++; -- -- // allocate or extend the size of vivo -- r->video_voice_report = realloc(r->video_voice_report, -- r->n_video_voice_report * sizeof(Sts__VideoVoiceReport*)); -- size += sizeof(Sts__VideoVoiceReport*); -- -- // allocate new buffer Sts__VideoVoiceReport -- sr = malloc(sizeof(Sts__VideoVoiceReport)); -- size += sizeof(Sts__VideoVoiceReport); -- assert(sr); -- r->video_voice_report[r->n_video_voice_report - 1] = sr; -- sts__video_voice_report__init(sr); -- -- sr->timestamp_ms = ucc->timestamp_ms; -- sr->has_timestamp_ms = true; -- -- switch (ucc->type) -- { -- case PKT_TYPE_CALL_START: -- /* Call Start report */ -- sr->call_start = malloc(sizeof(*sr->call_start)); -- size += sizeof(*sr->call_start); -- assert(sr->call_start); -- -- sts__call_start__init(sr->call_start); -- -- sr->call_start->session_id = ucc->record.sip_call_start.session_id; -- sr->call_start->has_session_id = true; -- sr->call_start->wifi_session_id = -- ucc->record.sip_call_start.wifi_session_id; -- sr->call_start->has_wifi_session_id = true; -- sr->call_start->client_mac.data = -- malloc(sizeof(ucc->record.sip_call_start.clt_mac)); -- -- size += sizeof(ucc->record.sip_call_start.clt_mac); -- assert(sr->call_start->client_mac.data); -- memcpy(sr->call_start->client_mac.data, -- &ucc->record.sip_call_start.clt_mac[0], -- sizeof(ucc->record.sip_call_start.clt_mac)); -- -- sr->call_start->client_mac.len = -- sizeof(ucc->record.sip_call_start.clt_mac); -- sr->call_start->has_client_mac = true; -- -- sr->call_start->codecs = malloc(15 * sizeof(*sr->call_start->codecs)); -- -- for (i = 0; i < 15; i++){ -- sr->call_start->codecs[i] = -- malloc(30 * sizeof(**sr->call_start->codecs)); -- memcpy(sr->call_start->codecs[i], -- &ucc->record.sip_call_start.codecs[i][0], 30); -- } -- -- size += (15 * sizeof(*sr->call_start->codecs)) + -- (30 * sizeof(**sr->call_start->codecs)); -- -- sr->call_start->n_codecs = 15; -- -- sr->call_start->provider_domain = -- malloc(sizeof(ucc->record.sip_call_start.provider_domain)); -- -- size += sizeof(ucc->record.sip_call_start.provider_domain); -- assert(sr->call_start->provider_domain); -- -- memcpy(sr->call_start->provider_domain, -- ucc->record.sip_call_start.provider_domain, -- sizeof(ucc->record.sip_call_start.provider_domain)); -- break; -- -- case PKT_TYPE_CALL_STOP: -- /* Call Stop report */ -- sr->call_stop = malloc(sizeof(*sr->call_stop)); -- size += sizeof(*sr->call_stop); -- assert(sr->call_stop); -- -- sts__call_stop__init(sr->call_stop); -- -- sr->call_stop->session_id = ucc->record.sip_call_stop.session_id; -- sr->call_stop->has_session_id = true; -- sr->call_stop->wifi_session_id = -- ucc->record.sip_call_stop.wifi_session_id; -- sr->call_stop->has_wifi_session_id = true; -- -- sr->call_stop->client_mac.data = -- malloc(sizeof(ucc->record.sip_call_stop.clt_mac)); -- -- size += sizeof(ucc->record.sip_call_stop.clt_mac); -- assert(sr->call_stop->client_mac.data); -- memcpy(sr->call_stop->client_mac.data, -- &ucc->record.sip_call_stop.clt_mac[0], -- sizeof(ucc->record.sip_call_stop.clt_mac)); -- -- sr->call_stop->client_mac.len = -- sizeof(ucc->record.sip_call_stop.clt_mac); -- sr->call_stop->has_client_mac = true; -- -- sr->call_stop->reason = ucc->record.sip_call_stop.reason; -- sr->call_stop->has_reason = true; -- break; -- -- case PKT_TYPE_CALL_REPORT: -- /* Call report */ -- sr->call_report = malloc(sizeof(*sr->call_report)); -- size += sizeof(*sr->call_report); -- assert(sr->call_report); -- -- sts__call_report__init(sr->call_report); -- -- sr->call_report->session_id = ucc->record.sip_call_report.session_id; -- sr->call_report->has_session_id = true; -- -- sr->call_report->wifi_session_id = -- ucc->record.sip_call_report.wifi_session_id; -- sr->call_report->has_wifi_session_id = true; -- -- sr->call_report->client_mac.data = -- malloc(sizeof(ucc->record.sip_call_report.clt_mac)); -- -- size += sizeof(ucc->record.sip_call_report.clt_mac); -- assert(sr->call_report->client_mac.data); -- memcpy(sr->call_report->client_mac.data, -- &ucc->record.sip_call_report.clt_mac[0], -- sizeof(ucc->record.sip_call_report.clt_mac)); -- -- sr->call_report->client_mac.len = -- sizeof(ucc->record.sip_call_report.clt_mac); -- sr->call_report->has_client_mac = true; -- -- sr->call_report->reason = ucc->record.sip_call_report.reason; -- sr->call_report->has_reason = true; -- break; -- -- default: -- break; -- } ++{ + Sts__BSReport *sr = NULL; + Sts__BSClient *cr; + Sts__BSClient__BSBandReport *br; @@ -4207,10 +3955,156 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + } } + static void dppline_add_stat_ucc(Sts__Report *r, dppline_stats_t *s) + { +- Sts__VideoVoiceReport *sr = NULL; +- int size = 0; +- uint32_t i; +- dppline_ucc_stats_t *ucc = &s->u.ucc; +- +- +- // increase the number of vivo report +- r->n_video_voice_report++; +- +- // allocate or extend the size of vivo +- r->video_voice_report = realloc(r->video_voice_report, +- r->n_video_voice_report * sizeof(Sts__VideoVoiceReport*)); +- size += sizeof(Sts__VideoVoiceReport*); +- +- // allocate new buffer Sts__VideoVoiceReport +- sr = malloc(sizeof(Sts__VideoVoiceReport)); +- size += sizeof(Sts__VideoVoiceReport); +- assert(sr); +- r->video_voice_report[r->n_video_voice_report - 1] = sr; +- sts__video_voice_report__init(sr); +- +- sr->timestamp_ms = ucc->timestamp_ms; +- sr->has_timestamp_ms = true; +- +- switch (ucc->type) +- { +- case PKT_TYPE_CALL_START: +- /* Call Start report */ +- sr->call_start = malloc(sizeof(*sr->call_start)); +- size += sizeof(*sr->call_start); +- assert(sr->call_start); +- +- sts__call_start__init(sr->call_start); +- +- sr->call_start->session_id = ucc->record.sip_call_start.session_id; +- sr->call_start->has_session_id = true; +- sr->call_start->wifi_session_id = +- ucc->record.sip_call_start.wifi_session_id; +- sr->call_start->has_wifi_session_id = true; +- sr->call_start->client_mac.data = +- malloc(sizeof(ucc->record.sip_call_start.clt_mac)); +- +- size += sizeof(ucc->record.sip_call_start.clt_mac); +- assert(sr->call_start->client_mac.data); +- memcpy(sr->call_start->client_mac.data, +- &ucc->record.sip_call_start.clt_mac[0], +- sizeof(ucc->record.sip_call_start.clt_mac)); +- +- sr->call_start->client_mac.len = +- sizeof(ucc->record.sip_call_start.clt_mac); +- sr->call_start->has_client_mac = true; +- +- sr->call_start->codecs = malloc(15 * sizeof(*sr->call_start->codecs)); +- +- for (i = 0; i < 15; i++){ +- sr->call_start->codecs[i] = +- malloc(30 * sizeof(**sr->call_start->codecs)); +- memcpy(sr->call_start->codecs[i], +- &ucc->record.sip_call_start.codecs[i][0], 30); +- } +- +- size += (15 * sizeof(*sr->call_start->codecs)) + +- (30 * sizeof(**sr->call_start->codecs)); +- +- sr->call_start->n_codecs = 15; +- +- sr->call_start->provider_domain = +- malloc(sizeof(ucc->record.sip_call_start.provider_domain)); +- +- size += sizeof(ucc->record.sip_call_start.provider_domain); +- assert(sr->call_start->provider_domain); +- +- memcpy(sr->call_start->provider_domain, +- ucc->record.sip_call_start.provider_domain, +- sizeof(ucc->record.sip_call_start.provider_domain)); +- break; +- +- case PKT_TYPE_CALL_STOP: +- /* Call Stop report */ +- sr->call_stop = malloc(sizeof(*sr->call_stop)); +- size += sizeof(*sr->call_stop); +- assert(sr->call_stop); +- +- sts__call_stop__init(sr->call_stop); +- +- sr->call_stop->session_id = ucc->record.sip_call_stop.session_id; +- sr->call_stop->has_session_id = true; +- sr->call_stop->wifi_session_id = +- ucc->record.sip_call_stop.wifi_session_id; +- sr->call_stop->has_wifi_session_id = true; +- +- sr->call_stop->client_mac.data = +- malloc(sizeof(ucc->record.sip_call_stop.clt_mac)); +- +- size += sizeof(ucc->record.sip_call_stop.clt_mac); +- assert(sr->call_stop->client_mac.data); +- memcpy(sr->call_stop->client_mac.data, +- &ucc->record.sip_call_stop.clt_mac[0], +- sizeof(ucc->record.sip_call_stop.clt_mac)); +- +- sr->call_stop->client_mac.len = +- sizeof(ucc->record.sip_call_stop.clt_mac); +- sr->call_stop->has_client_mac = true; +- +- sr->call_stop->reason = ucc->record.sip_call_stop.reason; +- sr->call_stop->has_reason = true; +- break; +- +- case PKT_TYPE_CALL_REPORT: +- /* Call report */ +- sr->call_report = malloc(sizeof(*sr->call_report)); +- size += sizeof(*sr->call_report); +- assert(sr->call_report); +- +- sts__call_report__init(sr->call_report); +- +- sr->call_report->session_id = ucc->record.sip_call_report.session_id; +- sr->call_report->has_session_id = true; +- +- sr->call_report->wifi_session_id = +- ucc->record.sip_call_report.wifi_session_id; +- sr->call_report->has_wifi_session_id = true; +- +- sr->call_report->client_mac.data = +- malloc(sizeof(ucc->record.sip_call_report.clt_mac)); +- +- size += sizeof(ucc->record.sip_call_report.clt_mac); +- assert(sr->call_report->client_mac.data); +- memcpy(sr->call_report->client_mac.data, +- &ucc->record.sip_call_report.clt_mac[0], +- sizeof(ucc->record.sip_call_report.clt_mac)); +- +- sr->call_report->client_mac.len = +- sizeof(ucc->record.sip_call_report.clt_mac); +- sr->call_report->has_client_mac = true; +- +- sr->call_report->reason = ucc->record.sip_call_report.reason; +- sr->call_report->has_reason = true; +- break; +- +- default: +- break; +- } +-} +- - -Sts__RssiPeer__RssiSource dppline_to_proto_rssi_source(rssi_source_t rssi_source) -+static void dppline_add_stat_ucc(Sts__Report *r, dppline_stats_t *s) - { +-{ - switch (rssi_source) - { - case RSSI_SOURCE_CLIENT: @@ -4401,877 +4295,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - int j; - int size = 0; - dppline_rssi_stats_t *rssi = &s->u.rssi; -+ Sts__RssiReport *sr = NULL; -+ Sts__RssiPeer *dr; // dest rec -+ uint32_t i = 0; -+ int j; -+ int size = 0; -+ dppline_rssi_stats_t *rssi = &s->u.rssi; -+ -+ // increase the number of rssi_report -+ r->n_rssi_report++; -+ -+ // allocate or extend the size of rssi_report -+ r->rssi_report = realloc(r->rssi_report, -+ r->n_rssi_report * sizeof(Sts__RssiReport *)); -+ -+ // allocate new buffer -+ sr = malloc(sizeof(Sts__RssiReport)); -+ size += sizeof(Sts__RssiReport); -+ assert(sr); -+ r->rssi_report[r->n_rssi_report - 1] = sr; -+ -+ sts__rssi_report__init(sr); -+ sr->band = dppline_to_proto_radio(rssi->radio_type); -+ sr->report_type = dppline_to_proto_report_type(rssi->report_type); -+ sr->timestamp_ms = rssi->timestamp_ms; -+ sr->has_timestamp_ms = true; -+ sr->peer_list = malloc(rssi->qty * sizeof(*sr->peer_list)); -+ size += rssi->qty * sizeof(*sr->peer_list); -+ assert(sr->peer_list); -+ sr->n_peer_list = rssi->qty; -+ for (i = 0; i < rssi->qty; i++) { -+ dpp_rssi_record_t *rec = &rssi->list[i].rec; -+ dr = sr->peer_list[i] = malloc(sizeof(**sr->peer_list)); -+ size += sizeof(**sr->peer_list); -+ assert(dr); -+ sts__rssi_peer__init(dr); -+ -+ dr->mac_address = malloc(MACADDR_STR_LEN); -+ dpp_mac_to_str(rec->mac, dr->mac_address); -+ size += MACADDR_STR_LEN; -+ -+ if (rec->source) { -+ dr->rssi_source = -+ dppline_to_proto_rssi_source(rec->source); -+ dr->has_rssi_source = true; -+ } -+ -+ if (REPORT_TYPE_RAW == rssi->report_type) { -+ dr->rssi_list = malloc(rssi->list[i].raw_qty * -+ sizeof(*dr->rssi_list)); -+ size += rssi->list[i].raw_qty * sizeof(*dr->rssi_list); -+ assert(dr->rssi_list); -+ dr->n_rssi_list = rssi->list[i].raw_qty; -+ for (j = 0; j < rssi->list[i].raw_qty; j++) { -+ Sts__RssiPeer__RssiSample *draw; -+ dpp_rssi_raw_t *sraw = &rssi->list[i].raw[j]; -+ -+ draw = dr->rssi_list[j] = -+ malloc(sizeof(**dr->rssi_list)); -+ sts__rssi_peer__rssi_sample__init(draw); -+ -+ draw->rssi = sraw->rssi; -+ if (sraw->timestamp_ms) { -+ draw->offset_ms = sr->timestamp_ms - -+ sraw->timestamp_ms; -+ draw->has_offset_ms = true; -+ } -+ } -+ } else { -+ Sts__AvgType *davg; -+ dpp_avg_t *savg = &rssi->list[i].rec.rssi.avg; -+ -+ davg = dr->rssi_avg = malloc(sizeof(*dr->rssi_avg)); -+ sts__avg_type__init(davg); -+ -+ if (savg->avg) { -+ davg->avg = savg->avg; -+ if (savg->min) { -+ davg->min = savg->min; -+ davg->has_min = true; -+ ; -+ } -+ if (savg->max) { -+ davg->max = savg->max; -+ davg->has_max = true; -+ ; -+ } -+ if (savg->num) { -+ davg->num = savg->num; -+ davg->has_num = true; -+ ; -+ } -+ } -+ } -+ -+ if (rec->rx_ppdus) { -+ dr->rx_ppdus = rec->rx_ppdus; -+ dr->has_rx_ppdus = true; -+ } -+ -+ if (rec->tx_ppdus) { -+ dr->tx_ppdus = rec->tx_ppdus; -+ dr->has_tx_ppdus = true; -+ } -+ } -+} -+ -+static void dppline_add_stat_events(Sts__Report *r, dppline_stats_t *s) -+{ -+ Sts__EventReport *sr = NULL; -+ Sts__EventReport__ClientSession *dr_client_session = NULL; -+ uint32_t i = 0; -+ uint32_t j = 0; -+ uint32_t k = 0; -+ dppline_events_stats_t *events = &s->u.events; -+ -+ // increase the number of event_report -+ r->n_event_report++; -+ -+ // allocate or extend the size of event_report -+ r->event_report = -+ realloc(r->event_report, -+ r->n_event_report * sizeof(Sts__EventReport *)); -+ -+ // allocate new buffer -+ sr = malloc(sizeof(Sts__EventReport)); -+ assert(sr); -+ r->event_report[r->n_event_report - 1] = sr; -+ -+ sts__event_report__init(sr); -+ -+ for (i = 0; i < events->qty; i++) { -+ sr->client_session = malloc(events->list[i].session_qty * -+ sizeof(*sr->client_session)); -+ assert(sr->client_session); -+ sr->n_client_session = events->list[i].session_qty; -+ -+ for (j = 0; j < events->list[i].session_qty; j++) { -+ dpp_event_record_session_t *sr_client_session = -+ &events->list[i].session_list[j]; -+ -+ dr_client_session = sr->client_session[j] = -+ malloc(sizeof(**sr->client_session)); -+ sts__event_report__client_session__init( -+ dr_client_session); -+ -+ dr_client_session->session_id = -+ sr_client_session->session_id; -+ -+ /* Client Assoc Event */ -+ uint32_t assoc_counter = 0; -+ for (k = 0; k < events->list[i].assoc_qty; k++) { -+ dpp_event_record_assoc_t *srx = -+ &events->list[i].assoc_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ assoc_counter++; -+ } -+ } -+ dr_client_session->client_assoc_event = malloc( -+ assoc_counter * -+ sizeof(*dr_client_session->client_assoc_event)); -+ assert(dr_client_session->client_assoc_event); -+ dr_client_session->n_client_assoc_event = assoc_counter; -+ -+ assoc_counter = 0; -+ for (k = 0; k < events->list[i].assoc_qty; k++) { -+ Sts__EventReport__ClientAssocEvent *drx = NULL; -+ dpp_event_record_assoc_t *srx = -+ &events->list[i].assoc_list[k]; -+ -+ drx = malloc( -+ sizeof(**dr_client_session -+ ->client_assoc_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session -+ ->client_assoc_event[assoc_counter++] = -+ drx; -+ sts__event_report__client_assoc_event__init( -+ drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ drx->ssid = strdup(srx->ssid); -+ -+ if (srx->band) { -+ drx->band = dppline_to_proto_radio( -+ srx->band); -+ drx->has_band = true; -+ } -+ -+ if (srx->assoc_type) { -+ drx->assoc_type = -+ dppline_to_proto_assoc_type( -+ srx->assoc_type); -+ drx->has_assoc_type = true; -+ } -+ -+ if (srx->status) { -+ drx->status = srx->status; -+ drx->has_status = true; -+ } -+ -+ if (srx->rssi) { -+ drx->rssi = srx->rssi; -+ drx->has_rssi = true; -+ } -+ -+ if (srx->internal_sc) { -+ drx->internal_sc = srx->internal_sc; -+ drx->has_internal_sc = true; -+ } -+ -+ if (srx->using11k) { -+ drx->using11k = srx->using11k; -+ drx->has_using11k = true; -+ } -+ -+ if (srx->using11r) { -+ drx->using11r = srx->using11r; -+ drx->has_using11r = true; -+ } -+ -+ if (srx->using11v) { -+ drx->using11v = srx->using11v; -+ drx->has_using11v = true; -+ } -+ } -+ -+ /* Client Auth Event */ -+ uint32_t auth_counter = 0; -+ for (k = 0; k < events->list[i].auth_qty; k++) { -+ dpp_event_record_auth_t *srx = -+ &events->list[i].auth_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ auth_counter++; -+ } -+ } -+ dr_client_session->client_auth_event = malloc( -+ auth_counter * -+ sizeof(*dr_client_session->client_auth_event)); -+ assert(dr_client_session->client_auth_event); -+ dr_client_session->n_client_auth_event = auth_counter; -+ -+ auth_counter = 0; -+ for (k = 0; k < events->list[i].auth_qty; k++) { -+ Sts__EventReport__ClientAuthEvent *drx = NULL; -+ dpp_event_record_auth_t *srx = -+ &events->list[i].auth_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session->client_auth_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session -+ ->client_auth_event[auth_counter++] = -+ drx; -+ sts__event_report__client_auth_event__init(drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ drx->ssid = strdup(srx->ssid); -+ -+ if (srx->band) { -+ drx->band = dppline_to_proto_radio( -+ srx->band); -+ drx->has_band = true; -+ } -+ -+ if (srx->auth_status) { -+ drx->auth_status = srx->auth_status; -+ drx->has_auth_status = true; -+ } -+ } -+ -+ /* Client Disconnect Event */ -+ uint32_t disconnect_counter = 0; -+ for (k = 0; k < events->list[i].disconnect_qty; k++) { -+ dpp_event_record_disconnect_t *srx = -+ &events->list[i].disconnect_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ disconnect_counter++; -+ } -+ } -+ dr_client_session->client_disconnect_event = malloc( -+ disconnect_counter * -+ sizeof(*dr_client_session -+ ->client_disconnect_event)); -+ assert(dr_client_session->client_disconnect_event); -+ dr_client_session->n_client_disconnect_event = -+ disconnect_counter; -+ -+ disconnect_counter = 0; -+ for (k = 0; k < events->list[i].disconnect_qty; k++) { -+ Sts__EventReport__ClientDisconnectEvent *drx = -+ NULL; -+ dpp_event_record_disconnect_t *srx = -+ &events->list[i].disconnect_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session -+ ->client_disconnect_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session->client_disconnect_event -+ [disconnect_counter++] = drx; -+ sts__event_report__client_disconnect_event__init( -+ drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ if (srx->reason) { -+ drx->reason = srx->reason; -+ drx->has_reason = true; -+ } -+ -+ if (srx->dev_type) { -+ drx->dev_type = -+ dppline_to_proto_device_type( -+ srx->dev_type); -+ drx->has_dev_type = true; -+ } -+ -+ if (srx->fr_type) { -+ drx->fr_type = -+ dppline_to_proto_frame_type( -+ srx->fr_type); -+ drx->has_fr_type = true; -+ } -+ -+ if (srx->last_sent_up_ts_in_us) { -+ drx->lsent_up_ts_in_us = -+ srx->last_sent_up_ts_in_us; -+ drx->has_lsent_up_ts_in_us = true; -+ } -+ -+ if (srx->last_recv_up_ts_in_us) { -+ drx->lrcv_up_ts_in_us = -+ srx->last_recv_up_ts_in_us; -+ drx->has_lrcv_up_ts_in_us = true; -+ } -+ -+ if (srx->internal_rc) { -+ drx->internal_rc = srx->internal_rc; -+ drx->has_internal_rc = true; -+ } -+ -+ if (srx->rssi) { -+ drx->rssi = srx->rssi; -+ drx->has_rssi = true; -+ } -+ -+ drx->ssid = strdup(srx->ssid); -+ -+ if (srx->band) { -+ drx->band = dppline_to_proto_radio( -+ srx->band); -+ drx->has_band = true; -+ } -+ } -+ -+ /* Client Connect Event */ -+ uint32_t connect_counter = 0; -+ for (k = 0; k < events->list[i].connect_qty; k++) { -+ dpp_event_record_connect_t *srx = -+ &events->list[i].connect_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ connect_counter++; -+ } -+ } -+ dr_client_session->client_connect_event = -+ malloc(connect_counter * -+ sizeof(*dr_client_session -+ ->client_connect_event)); -+ assert(dr_client_session->client_connect_event); -+ dr_client_session->n_client_connect_event = -+ connect_counter; -+ -+ connect_counter = 0; -+ for (k = 0; k < events->list[i].connect_qty; k++) { -+ Sts__EventReport__ClientConnectEvent *drx = -+ NULL; -+ dpp_event_record_connect_t *srx = -+ &events->list[i].connect_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session -+ ->client_connect_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session->client_connect_event -+ [connect_counter++] = drx; -+ sts__event_report__client_connect_event__init( -+ drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ if (srx->band) { -+ drx->band = dppline_to_proto_radio( -+ srx->band); -+ drx->has_band = true; -+ } -+ -+ if (srx->assoc_type) { -+ drx->assoc_type = -+ dppline_to_proto_assoc_type( -+ srx->assoc_type); -+ drx->has_assoc_type = true; -+ } -+ -+ drx->ssid = strdup(srx->ssid); -+ -+ if (srx->sec_type) { -+ drx->sec_type = -+ dppline_to_proto_sec_type( -+ srx->sec_type); -+ drx->has_sec_type = true; -+ } -+ -+ if (srx->fbt_used) { -+ drx->fbt_used = srx->fbt_used; -+ drx->has_fbt_used = true; -+ } -+ -+ if (srx->ip_addr) { -+ memcpy(drx->ip_addr.data, srx->ip_addr, -+ 16); -+ drx->ip_addr.len = 16; -+ drx->has_ip_addr = true; -+ } -+ -+ if (srx->clt_id) { -+ drx->clt_id = strcpy(drx->clt_id, -+ srx->clt_id); -+ } -+ -+ if (srx->ev_time_bootup_in_us_auth) { -+ drx->ev_time_bootup_in_us_auth = -+ srx->ev_time_bootup_in_us_auth; -+ drx->has_ev_time_bootup_in_us_auth = -+ true; -+ } -+ -+ if (srx->ev_time_bootup_in_us_assoc) { -+ drx->ev_time_bootup_in_us_assoc = -+ srx->ev_time_bootup_in_us_assoc; -+ drx->has_ev_time_bootup_in_us_assoc = -+ true; -+ } -+ -+ if (srx->ev_time_bootup_in_us_eapol) { -+ drx->ev_time_bootup_in_us_eapol = -+ srx->ev_time_bootup_in_us_eapol; -+ drx->has_ev_time_bootup_in_us_eapol = -+ true; -+ } -+ -+ if (srx->ev_time_bootup_in_us_port_enable) { -+ drx->ev_time_bootup_in_us_port_enable = -+ srx->ev_time_bootup_in_us_port_enable; -+ drx->ev_time_bootup_in_us_port_enable = -+ true; -+ } -+ -+ if (srx->ev_time_bootup_in_us_first_rx) { -+ drx->ev_time_bootup_in_us_first_rx = -+ srx->ev_time_bootup_in_us_first_rx; -+ drx->has_ev_time_bootup_in_us_first_rx = -+ true; -+ } -+ -+ if (srx->ev_time_bootup_in_us_first_tx) { -+ drx->ev_time_bootup_in_us_first_tx = -+ srx->ev_time_bootup_in_us_first_tx; -+ drx->has_ev_time_bootup_in_us_first_tx = -+ true; -+ } -+ -+ if (srx->using11k) { -+ drx->using11k = srx->using11k; -+ drx->has_using11k = true; -+ } -+ -+ if (srx->using11r) { -+ drx->using11r = srx->using11r; -+ drx->has_using11r = true; -+ } -+ -+ if (srx->using11v) { -+ drx->using11v = srx->using11v; -+ drx->has_using11v = true; -+ } -+ -+ if (srx->ev_time_bootup_in_us_ip) { -+ drx->ev_time_bootup_in_us_ip = -+ srx->ev_time_bootup_in_us_ip; -+ drx->has_ev_time_bootup_in_us_ip = true; -+ } -+ -+ if (srx->assoc_rssi) { -+ drx->assoc_rssi = srx->assoc_rssi; -+ drx->has_assoc_rssi = true; -+ } -+ } -+ -+ /* Client Failure Event */ -+ uint32_t failure_counter = 0; -+ for (k = 0; k < events->list[i].failure_qty; k++) { -+ dpp_event_record_failure_t *srx = -+ &events->list[i].failure_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ failure_counter++; -+ } -+ } -+ dr_client_session->client_failure_event = -+ malloc(failure_counter * -+ sizeof(*dr_client_session -+ ->client_failure_event)); -+ assert(dr_client_session->client_failure_event); -+ dr_client_session->n_client_failure_event = -+ failure_counter; -+ -+ failure_counter = 0; -+ for (k = 0; k < events->list[i].failure_qty; k++) { -+ Sts__EventReport__ClientFailureEvent *drx = -+ NULL; -+ dpp_event_record_failure_t *srx = -+ &events->list[i].failure_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session -+ ->client_failure_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session->client_failure_event -+ [failure_counter++] = drx; -+ sts__event_report__client_failure_event__init( -+ drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ drx->ssid = strdup(srx->ssid); -+ -+ if (srx->reason) { -+ drx->reason_code = srx->reason; -+ drx->has_reason_code = true; -+ } -+ -+ drx->reason_str = strdup(srx->reason_str); -+ } -+ -+ /* Client First Data Event */ -+ uint32_t first_data_counter = 0; -+ for (k = 0; k < events->list[i].first_data_qty; k++) { -+ dpp_event_record_first_data_t *srx = -+ &events->list[i].first_data_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ first_data_counter++; -+ } -+ } -+ dr_client_session->client_first_data_event = malloc( -+ first_data_counter * -+ sizeof(*dr_client_session -+ ->client_first_data_event)); -+ assert(dr_client_session->client_first_data_event); -+ dr_client_session->n_client_first_data_event = -+ first_data_counter; -+ -+ first_data_counter = 0; -+ for (k = 0; k < events->list[i].first_data_qty; k++) { -+ Sts__EventReport__ClientFirstDataEvent *drx = -+ NULL; -+ dpp_event_record_first_data_t *srx = -+ &events->list[i].first_data_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session -+ ->client_first_data_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session->client_first_data_event -+ [first_data_counter++] = drx; -+ sts__event_report__client_first_data_event__init( -+ drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ if (srx->fdata_tx_up_ts_in_us) { -+ drx->fdata_tx_up_ts_in_us = -+ srx->fdata_tx_up_ts_in_us; -+ drx->has_fdata_tx_up_ts_in_us = true; -+ } -+ -+ if (srx->fdata_rx_up_ts_in_us) { -+ drx->fdata_rx_up_ts_in_us = -+ srx->fdata_rx_up_ts_in_us; -+ drx->has_fdata_rx_up_ts_in_us = true; -+ } -+ } -+ -+ /* Client Id Event */ -+ uint32_t id_counter = 0; -+ for (k = 0; k < events->list[i].id_qty; k++) { -+ dpp_event_record_id_t *srx = -+ &events->list[i].id_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ id_counter++; -+ } -+ } -+ dr_client_session->client_id_event = malloc( -+ id_counter * -+ sizeof(*dr_client_session->client_id_event)); -+ assert(dr_client_session->client_id_event); -+ dr_client_session->n_client_id_event = id_counter; -+ -+ id_counter = 0; -+ for (k = 0; k < events->list[i].id_qty; k++) { -+ Sts__EventReport__ClientIdEvent *drx = NULL; -+ dpp_event_record_id_t *srx = -+ &events->list[i].id_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session->client_id_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session -+ ->client_id_event[id_counter++] = drx; -+ sts__event_report__client_id_event__init(drx); -+ -+ drx->clt_mac = malloc(MACADDR_STR_LEN); -+ dpp_mac_to_str(srx->clt_mac, drx->clt_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ drx->clt_id = strdup(srx->clt_id); -+ } -+ -+ /* Client Ip Event */ -+ uint32_t ip_counter = 0; -+ for (k = 0; k < events->list[i].ip_qty; k++) { -+ dpp_event_record_ip_t *srx = -+ &events->list[i].ip_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ ip_counter++; -+ } -+ } -+ dr_client_session->client_ip_event = malloc( -+ ip_counter * -+ sizeof(*dr_client_session->client_ip_event)); -+ assert(dr_client_session->client_ip_event); -+ dr_client_session->n_client_ip_event = ip_counter; -+ -+ ip_counter = 0; -+ for (k = 0; k < events->list[i].ip_qty; k++) { -+ Sts__EventReport__ClientIpEvent *drx = NULL; -+ dpp_event_record_ip_t *srx = -+ &events->list[i].ip_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session->client_ip_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session -+ ->client_ip_event[ip_counter++] = drx; -+ sts__event_report__client_ip_event__init(drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ if (srx->ip_addr) { -+ memcpy(drx->ip_addr.data, srx->ip_addr, -+ 16); -+ drx->ip_addr.len = 16; -+ drx->has_ip_addr = true; -+ } -+ } -+ -+ /* Client Timeout Event */ -+ uint32_t timeout_counter = 0; -+ for (k = 0; k < events->list[i].timeout_qty; k++) { -+ dpp_event_record_timeout_t *srx = -+ &events->list[i].timeout_list[k]; -+ if (srx->session_id == -+ dr_client_session->session_id) { -+ timeout_counter++; -+ } -+ } -+ dr_client_session->client_timeout_event = -+ malloc(timeout_counter * -+ sizeof(*dr_client_session -+ ->client_timeout_event)); -+ assert(dr_client_session->client_timeout_event); -+ dr_client_session->n_client_timeout_event = -+ timeout_counter; -+ -+ timeout_counter = 0; -+ for (k = 0; k < events->list[i].timeout_qty; k++) { -+ Sts__EventReport__ClientTimeoutEvent *drx = -+ NULL; -+ dpp_event_record_timeout_t *srx = -+ &events->list[i].timeout_list[k]; -+ -+ drx = malloc(sizeof( -+ **dr_client_session -+ ->client_timeout_event)); -+ -+ /* skip entries which are not from this session */ -+ if (srx->session_id != -+ dr_client_session->session_id) { -+ free(drx); -+ continue; -+ } -+ -+ dr_client_session->client_timeout_event -+ [timeout_counter++] = drx; -+ sts__event_report__client_timeout_event__init( -+ drx); -+ -+ drx->sta_mac = strdup(srx->sta_mac); -+ -+ if (srx->session_id) { -+ drx->session_id = srx->session_id; -+ drx->has_session_id = true; -+ } -+ -+ if (srx->r_code) { -+ drx->r_code = -+ dppline_to_proto_ct_reason_type( -+ srx->r_code); -+ drx->has_r_code = true; -+ } -+ -+ if (srx->last_sent_up_ts_in_us) { -+ drx->last_sent_up_ts_in_us = -+ srx->last_sent_up_ts_in_us; -+ drx->has_last_sent_up_ts_in_us = true; -+ } -+ -+ if (srx->last_recv_up_ts_in_us) { -+ drx->last_rcv_up_ts_in_us = -+ srx->last_recv_up_ts_in_us; -+ drx->has_last_rcv_up_ts_in_us = true; -+ } -+ } -+ } -+ } -+} -+ -+static void dppline_add_stat(Sts__Report *r, dppline_stats_t *s) -+{ -+ switch (s->type) { -+ case DPP_T_SURVEY: -+ dppline_add_stat_survey(r, s); -+ break; -+ -+ case DPP_T_CAPACITY: -+ dppline_add_stat_capacity(r, s); -+ break; -+ -+ case DPP_T_NEIGHBOR: -+ dppline_add_stat_neighbor(r, s); -+ break; -+ -+ case DPP_T_CLIENT: -+ dppline_add_stat_client(r, s); -+ break; -+ -+ case DPP_T_DEVICE: -+ dppline_add_stat_device(r, s); -+ break; -+ -+ case DPP_T_BS_CLIENT: -+ dppline_add_stat_bs_client(r, s); -+ break; -+ -+ case DPP_T_RSSI: -+ dppline_add_stat_rssi(r, s); -+ break; - +- - // increase the number of rssi_report - r->n_rssi_report++; - @@ -5394,7 +4418,143 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - case DPP_T_BS_CLIENT: - dppline_add_stat_bs_client(r, s); - break; -- ++ Sts__RssiReport *sr = NULL; ++ Sts__RssiPeer *dr; // dest rec ++ uint32_t i = 0; ++ int j; ++ int size = 0; ++ dppline_rssi_stats_t *rssi = &s->u.rssi; ++ ++ // increase the number of rssi_report ++ r->n_rssi_report++; ++ ++ // allocate or extend the size of rssi_report ++ r->rssi_report = realloc(r->rssi_report, ++ r->n_rssi_report * sizeof(Sts__RssiReport *)); ++ ++ // allocate new buffer ++ sr = malloc(sizeof(Sts__RssiReport)); ++ size += sizeof(Sts__RssiReport); ++ assert(sr); ++ r->rssi_report[r->n_rssi_report - 1] = sr; ++ ++ sts__rssi_report__init(sr); ++ sr->band = dppline_to_proto_radio(rssi->radio_type); ++ sr->report_type = dppline_to_proto_report_type(rssi->report_type); ++ sr->timestamp_ms = rssi->timestamp_ms; ++ sr->has_timestamp_ms = true; ++ sr->peer_list = malloc(rssi->qty * sizeof(*sr->peer_list)); ++ size += rssi->qty * sizeof(*sr->peer_list); ++ assert(sr->peer_list); ++ sr->n_peer_list = rssi->qty; ++ for (i = 0; i < rssi->qty; i++) { ++ dpp_rssi_record_t *rec = &rssi->list[i].rec; ++ dr = sr->peer_list[i] = malloc(sizeof(**sr->peer_list)); ++ size += sizeof(**sr->peer_list); ++ assert(dr); ++ sts__rssi_peer__init(dr); ++ ++ dr->mac_address = malloc(MACADDR_STR_LEN); ++ dpp_mac_to_str(rec->mac, dr->mac_address); ++ size += MACADDR_STR_LEN; ++ ++ if (rec->source) { ++ dr->rssi_source = ++ dppline_to_proto_rssi_source(rec->source); ++ dr->has_rssi_source = true; ++ } ++ ++ if (REPORT_TYPE_RAW == rssi->report_type) { ++ dr->rssi_list = malloc(rssi->list[i].raw_qty * ++ sizeof(*dr->rssi_list)); ++ size += rssi->list[i].raw_qty * sizeof(*dr->rssi_list); ++ assert(dr->rssi_list); ++ dr->n_rssi_list = rssi->list[i].raw_qty; ++ for (j = 0; j < rssi->list[i].raw_qty; j++) { ++ Sts__RssiPeer__RssiSample *draw; ++ dpp_rssi_raw_t *sraw = &rssi->list[i].raw[j]; ++ ++ draw = dr->rssi_list[j] = ++ malloc(sizeof(**dr->rssi_list)); ++ sts__rssi_peer__rssi_sample__init(draw); ++ ++ draw->rssi = sraw->rssi; ++ if (sraw->timestamp_ms) { ++ draw->offset_ms = sr->timestamp_ms - ++ sraw->timestamp_ms; ++ draw->has_offset_ms = true; ++ } ++ } ++ } else { ++ Sts__AvgType *davg; ++ dpp_avg_t *savg = &rssi->list[i].rec.rssi.avg; ++ ++ davg = dr->rssi_avg = malloc(sizeof(*dr->rssi_avg)); ++ sts__avg_type__init(davg); ++ ++ if (savg->avg) { ++ davg->avg = savg->avg; ++ if (savg->min) { ++ davg->min = savg->min; ++ davg->has_min = true; ++ ; ++ } ++ if (savg->max) { ++ davg->max = savg->max; ++ davg->has_max = true; ++ ; ++ } ++ if (savg->num) { ++ davg->num = savg->num; ++ davg->has_num = true; ++ ; ++ } ++ } ++ } ++ ++ if (rec->rx_ppdus) { ++ dr->rx_ppdus = rec->rx_ppdus; ++ dr->has_rx_ppdus = true; ++ } ++ ++ if (rec->tx_ppdus) { ++ dr->tx_ppdus = rec->tx_ppdus; ++ dr->has_tx_ppdus = true; ++ } ++ } ++} ++ ++static void dppline_add_stat(Sts__Report *r, dppline_stats_t *s) ++{ ++ switch (s->type) { ++ case DPP_T_SURVEY: ++ dppline_add_stat_survey(r, s); ++ break; ++ ++ case DPP_T_CAPACITY: ++ dppline_add_stat_capacity(r, s); ++ break; ++ ++ case DPP_T_NEIGHBOR: ++ dppline_add_stat_neighbor(r, s); ++ break; ++ ++ case DPP_T_CLIENT: ++ dppline_add_stat_client(r, s); ++ break; ++ ++ case DPP_T_DEVICE: ++ dppline_add_stat_device(r, s); ++ break; ++ ++ case DPP_T_BS_CLIENT: ++ dppline_add_stat_bs_client(r, s); ++ break; ++ ++ case DPP_T_RSSI: ++ dppline_add_stat_rssi(r, s); ++ break; + - case DPP_T_RSSI: - dppline_add_stat_rssi(r, s); - break; @@ -5475,7 +4635,8 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c +static bool dppline_put(DPP_STS_TYPE type, void *rpt) { - dppline_stats_t *s = NULL; -- ++ dppline_stats_t *s = NULL; + - /* allocate buffer */ - s = dpp_alloc_stat(); - if (!s) @@ -5493,24 +4654,6 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c - dppline_free_stat(s); - return false; - } -- -- /* insert new element into stats queue */ -- ds_dlist_insert_tail(&g_dppline_list, s); -+ dppline_stats_t *s = NULL; - -- // update counters -- queue_depth++; -- queue_size += s->size; -- -- // drop old entries if queue too long -- if (queue_depth > DPP_MAX_QUEUE_DEPTH -- || queue_size > DPP_MAX_QUEUE_SIZE_BYTES) -- { -- LOG(DEBUG, "Queue size exceeded %d > %d || %d > %d", -- queue_depth, DPP_MAX_QUEUE_DEPTH, -- queue_size, DPP_MAX_QUEUE_SIZE_BYTES); -- dppline_remove_head(); -- } + /* allocate buffer */ + s = dpp_alloc_stat(); + if (!s) { @@ -5543,9 +4686,26 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c + dppline_remove_head(); + } -- dppline_log_queue(); +- /* insert new element into stats queue */ +- ds_dlist_insert_tail(&g_dppline_list, s); + dppline_log_queue(); +- // update counters +- queue_depth++; +- queue_size += s->size; +- +- // drop old entries if queue too long +- if (queue_depth > DPP_MAX_QUEUE_DEPTH +- || queue_size > DPP_MAX_QUEUE_SIZE_BYTES) +- { +- LOG(DEBUG, "Queue size exceeded %d > %d || %d > %d", +- queue_depth, DPP_MAX_QUEUE_DEPTH, +- queue_size, DPP_MAX_QUEUE_SIZE_BYTES); +- dppline_remove_head(); +- } +- +- dppline_log_queue(); +- - return true; + return true; } @@ -5570,7 +4730,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c } /* -@@ -2373,15 +3814,15 @@ bool dpp_init() +@@ -2373,15 +2984,15 @@ bool dpp_init() */ bool dpp_put_survey(dpp_survey_report_data_t *rpt) { @@ -5589,7 +4749,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c } /* -@@ -2389,7 +3830,7 @@ bool dpp_put_capacity(dpp_capacity_repor +@@ -2389,7 +3000,7 @@ bool dpp_put_capacity(dpp_capacity_repor */ bool dpp_put_neighbor(dpp_neighbor_report_data_t *rpt) { @@ -5598,7 +4758,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c } /* -@@ -2397,32 +3838,32 @@ bool dpp_put_neighbor(dpp_neighbor_repor +@@ -2397,32 +3008,32 @@ bool dpp_put_neighbor(dpp_neighbor_repor */ bool dpp_put_client(dpp_client_report_data_t *rpt) { @@ -5641,7 +4801,7 @@ Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c } /* -@@ -2436,250 +3877,240 @@ bool dpp_put_network_probe(dpp_network_p +@@ -2436,250 +3047,240 @@ bool dpp_put_network_probe(dpp_network_p /* * Put Video/voice stats to internal queue */ diff --git a/feeds/wlan-ap/opensync/patches/23-add-timestamp-to-events.patch b/feeds/wlan-ap/opensync/patches/23-add-timestamp-to-events.patch deleted file mode 100644 index 828decc5..00000000 --- a/feeds/wlan-ap/opensync/patches/23-add-timestamp-to-events.patch +++ /dev/null @@ -1,254 +0,0 @@ -Index: opensync-2.0.5.0/interfaces/opensync_stats.proto -=================================================================== ---- opensync-2.0.5.0.orig/interfaces/opensync_stats.proto -+++ opensync-2.0.5.0/interfaces/opensync_stats.proto -@@ -692,6 +692,7 @@ message EventReport { - optional bool using11k = 9; - optional bool using11r = 10; - optional bool using11v = 11; -+ optional uint32 timestamp_ms = 12; - } - - /* Client Authentication Event */ -@@ -701,6 +702,7 @@ message EventReport { - optional string ssid = 3; - optional RadioBandType band = 4; - optional uint32 auth_status = 5; -+ optional uint32 timestamp_ms = 6; - } - - /* Client Disconnect Event */ -@@ -716,6 +718,7 @@ message EventReport { - optional int32 rssi = 9; - optional string ssid = 10; - optional RadioBandType band = 11; -+ optional uint32 timestamp_ms = 12; - } - - /* Client Connnect Event */ -@@ -740,6 +743,7 @@ message EventReport { - optional bool using11v = 18; - optional int64 ev_time_bootup_in_us_ip = 19; - optional int32 assoc_rssi = 20; -+ optional uint32 timestamp_ms = 21; - } - - /* Client Failure Event */ -@@ -749,6 +753,7 @@ message EventReport { - optional string ssid = 3; - optional int32 reason_code = 4; - optional string reason_str = 5; -+ optional uint32 timestamp_ms = 6; - } - - /* Client First Data Event */ -@@ -757,6 +762,7 @@ message EventReport { - optional uint64 session_id = 2; - optional uint64 fdata_tx_up_ts_in_us = 3; - optional uint64 fdata_rx_up_ts_in_us = 4; -+ optional uint32 timestamp_ms = 5; - } - - /* Client Id Event */ -@@ -764,6 +770,7 @@ message EventReport { - optional string clt_mac = 1; - optional uint64 session_id = 2; - optional string clt_id = 3; -+ optional uint32 timestamp_ms = 4; - } - - /* Client IP Event */ -@@ -771,6 +778,7 @@ message EventReport { - optional string sta_mac = 1; - optional uint64 session_id = 2; - optional bytes ip_addr = 3; -+ optional uint32 timestamp_ms = 4; - } - - /* Client Timeout Event */ -@@ -780,6 +788,7 @@ message EventReport { - optional CTReasonType r_code = 3; - optional uint64 last_sent_up_ts_in_us = 4; - optional uint64 last_rcv_up_ts_in_us = 5; -+ optional uint32 timestamp_ms = 6; - } - - /* Client Session */ -Index: opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c -=================================================================== ---- opensync-2.0.5.0.orig/src/lib/datapipeline/src/dppline.c -+++ opensync-2.0.5.0/src/lib/datapipeline/src/dppline.c -@@ -2617,7 +2617,8 @@ static void dppline_add_stat_ucc(Sts__Re - sizeof(ucc->record.sip_call_start.provider_domain)); - sr->call_start->channel = ucc->record.sip_call_start.channel; - sr->call_start->has_channel = true; -- sr->call_start->band = dppline_to_proto_radio(ucc->record.sip_call_start.band); -+ sr->call_start->band = -+ dppline_to_proto_radio(ucc->record.sip_call_start.band); - break; - - case PKT_TYPE_CALL_STOP: -@@ -2652,16 +2653,18 @@ static void dppline_add_stat_ucc(Sts__Re - sr->call_stop->has_reason = true; - sr->call_stop->channel = ucc->record.sip_call_stop.channel; - sr->call_stop->has_channel = true; -- sr->call_stop->band = dppline_to_proto_radio(ucc->record.sip_call_stop.band); -+ sr->call_stop->band = -+ dppline_to_proto_radio(ucc->record.sip_call_stop.band); - -- sr->call_stop->provider_domain = malloc(sizeof(ucc->record.sip_call_stop.provider_domain)); -+ sr->call_stop->provider_domain = malloc( -+ sizeof(ucc->record.sip_call_stop.provider_domain)); - - size += sizeof(ucc->record.sip_call_stop.provider_domain); - assert(sr->call_stop->provider_domain); - - memcpy(sr->call_stop->provider_domain, -- ucc->record.sip_call_stop.provider_domain, -- sizeof(ucc->record.sip_call_stop.provider_domain)); -+ ucc->record.sip_call_stop.provider_domain, -+ sizeof(ucc->record.sip_call_stop.provider_domain)); - - break; - -@@ -2698,16 +2701,18 @@ static void dppline_add_stat_ucc(Sts__Re - sr->call_report->has_reason = true; - sr->call_report->channel = ucc->record.sip_call_report.channel; - sr->call_report->has_channel = true; -- sr->call_report->band = dppline_to_proto_radio(ucc->record.sip_call_report.band); -+ sr->call_report->band = dppline_to_proto_radio( -+ ucc->record.sip_call_report.band); - -- sr->call_report->provider_domain = malloc(sizeof(ucc->record.sip_call_report.provider_domain)); -+ sr->call_report->provider_domain = malloc( -+ sizeof(ucc->record.sip_call_report.provider_domain)); - - size += sizeof(ucc->record.sip_call_report.provider_domain); - assert(sr->call_report->provider_domain); - - memcpy(sr->call_report->provider_domain, -- ucc->record.sip_call_report.provider_domain, -- sizeof(ucc->record.sip_call_report.provider_domain)); -+ ucc->record.sip_call_report.provider_domain, -+ sizeof(ucc->record.sip_call_report.provider_domain)); - break; - - default: -@@ -2931,6 +2936,7 @@ static void dppline_add_stat_events(Sts_ - } - - drx->ssid = strdup(srx->ssid); -+ LOG(INFO, "drx->ssid: %s", drx->ssid); - - if (srx->band) { - drx->band = dppline_to_proto_radio( -@@ -2974,6 +2980,13 @@ static void dppline_add_stat_events(Sts_ - drx->using11v = srx->using11v; - drx->has_using11v = true; - } -+ -+ LOG(INFO, "srx->timestamp: %d", srx->timestamp); -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } -+ LOG(INFO, "drx->timestamp_ms: %d", drx->timestamp_ms); - } - - /* Client Auth Event */ -@@ -3032,6 +3045,11 @@ static void dppline_add_stat_events(Sts_ - drx->auth_status = srx->auth_status; - drx->has_auth_status = true; - } -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client Disconnect Event */ -@@ -3130,6 +3148,11 @@ static void dppline_add_stat_events(Sts_ - srx->band); - drx->has_band = true; - } -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client Connect Event */ -@@ -3286,6 +3309,11 @@ static void dppline_add_stat_events(Sts_ - drx->assoc_rssi = srx->assoc_rssi; - drx->has_assoc_rssi = true; - } -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client Failure Event */ -@@ -3344,6 +3372,11 @@ static void dppline_add_stat_events(Sts_ - } - - drx->reason_str = strdup(srx->reason_str); -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client First Data Event */ -@@ -3405,6 +3438,11 @@ static void dppline_add_stat_events(Sts_ - srx->fdata_rx_up_ts_in_us; - drx->has_fdata_rx_up_ts_in_us = true; - } -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client Id Event */ -@@ -3452,6 +3490,11 @@ static void dppline_add_stat_events(Sts_ - } - - drx->clt_id = strdup(srx->clt_id); -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client Ip Event */ -@@ -3503,6 +3546,11 @@ static void dppline_add_stat_events(Sts_ - drx->ip_addr.len = 16; - drx->has_ip_addr = true; - } -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - - /* Client Timeout Event */ -@@ -3571,6 +3619,11 @@ static void dppline_add_stat_events(Sts_ - srx->last_recv_up_ts_in_us; - drx->has_last_rcv_up_ts_in_us = true; - } -+ -+ if (srx->timestamp) { -+ drx->timestamp_ms = srx->timestamp; -+ drx->has_timestamp_ms = true; -+ } - } - } - } diff --git a/feeds/wlan-ap/opensync/src/src/lib/datapipeline/inc/dpp_events.h b/feeds/wlan-ap/opensync/src/src/lib/datapipeline/inc/dpp_events.h index 5eb26171..57af9dc8 100644 --- a/feeds/wlan-ap/opensync/src/src/lib/datapipeline/inc/dpp_events.h +++ b/feeds/wlan-ap/opensync/src/src/lib/datapipeline/inc/dpp_events.h @@ -55,8 +55,6 @@ typedef struct { bool using11k; bool using11r; bool using11v; - - ds_dlist_node_t node; } dpp_event_record_assoc_t; /* proto: ClientAuthEvent */ @@ -68,8 +66,6 @@ typedef struct { radio_essid_t ssid; radio_type_t band; uint32_t auth_status; - - ds_dlist_node_t node; } dpp_event_record_auth_t; /* proto: ClientDisconnectEvent */ @@ -87,8 +83,6 @@ typedef struct { int32_t rssi; radio_essid_t ssid; radio_type_t band; - - ds_dlist_node_t node; } dpp_event_record_disconnect_t; /* proto: ClientConnectEvent */ @@ -115,8 +109,6 @@ typedef struct { bool using11v; int64_t ev_time_bootup_in_us_ip; int32_t assoc_rssi; - - ds_dlist_node_t node; } dpp_event_record_connect_t; /* proto: ClientFailureEvent */ @@ -128,8 +120,6 @@ typedef struct { radio_essid_t ssid; int32_t reason; char reason_str[DPP_REASON_STR_LEN]; - - ds_dlist_node_t node; } dpp_event_record_failure_t; /* proto: ClientFirstDataEvent */ @@ -140,8 +130,6 @@ typedef struct { uint32_t timestamp; uint64_t fdata_tx_up_ts_in_us; uint64_t fdata_rx_up_ts_in_us; - - ds_dlist_node_t node; } dpp_event_record_first_data_t; /* proto: ClientIdEvent */ @@ -151,8 +139,6 @@ typedef struct { uint64_t session_id; uint32_t timestamp; char clt_id[DPP_CLT_ID_LEN]; - - ds_dlist_node_t node; } dpp_event_record_id_t; /* proto: ClientIpEvent */ @@ -162,8 +148,6 @@ typedef struct { uint64_t session_id; uint32_t timestamp; uint8_t ip_addr[16]; - - ds_dlist_node_t node; } dpp_event_record_ip_t; /* proto: ClientTimeoutEvent */ @@ -175,29 +159,27 @@ typedef struct { ct_reason_t r_code; uint64_t last_sent_up_ts_in_us; uint64_t last_recv_up_ts_in_us; - - ds_dlist_node_t node; } dpp_event_record_timeout_t; /* proto: ClientSession */ typedef struct { uint64_t session_id; - ds_dlist_t assoc_list; /* dpp_event_record_assoc_t */ - ds_dlist_t auth_list; /* dpp_event_record_auth_t */ - ds_dlist_t disconnect_list; /* dpp_event_record_disconnect_t */ - ds_dlist_t failure_list; /* dpp_event_record_failure_t */ - ds_dlist_t first_data_list; /* dpp_event_record_first_data_t */ - ds_dlist_t id_list; /* dpp_event_record_id_t */ - ds_dlist_t ip_list; /* dpp_event_record_ip_t */ - ds_dlist_t timeout_list; /* dpp_event_record_timeout_t */ - ds_dlist_t connect_list; /* dpp_event_record_connect_t */ + dpp_event_record_assoc_t *assoc_event; /* dpp_event_record_assoc_t */ + dpp_event_record_auth_t *auth_event; /* dpp_event_record_auth_t */ + dpp_event_record_disconnect_t *disconnect_event; /* dpp_event_record_disconnect_t */ + dpp_event_record_failure_t *failure_event; /* dpp_event_record_failure_t */ + dpp_event_record_first_data_t *first_data_event; /* dpp_event_record_first_data_t */ + dpp_event_record_id_t *id_event; /* dpp_event_record_id_t */ + dpp_event_record_ip_t *ip_event; /* dpp_event_record_ip_t */ + dpp_event_record_timeout_t *timeout_event; /* dpp_event_record_timeout_t */ + dpp_event_record_connect_t *connect_event; /* dpp_event_record_connect_t */ - ds_dlist_node_t node; } dpp_event_record_session_t; /* event record */ typedef struct { - ds_dlist_t client_session; /* dpp_event_record_session_t */ + dpp_event_record_session_t client_session; /* dpp_event_record_session_t */ + bool hasSMProcessed; ds_dlist_node_t node; } dpp_event_record_t; @@ -448,9 +430,31 @@ dpp_event_client_session_record_free(dpp_event_record_session_t *record) } } +static inline dpp_event_record_t * +dpp_event_record_alloc() +{ + dpp_event_record_t *record = NULL; + + record = calloc(1, sizeof(dpp_event_record_t)); + if (record) { + memset(record, 0, sizeof(dpp_event_record_t)); + } + return record; +} + +/* free */ +static inline void +dpp_event_record_free(dpp_event_record_t *record) +{ + if (NULL != record) { + free(record); + } +} + + /* Events report type */ typedef struct { - ds_dlist_t list; /* dpp_event_record_t */ + ds_dlist_t client_event_list; /* dpp_event_record_t */ } dpp_event_report_data_t; #endif /* DPP_EVENTS_H_INCLUDED */ diff --git a/feeds/wlan-ap/opensync/src/src/sm/src/sm_events_report.c b/feeds/wlan-ap/opensync/src/src/sm/src/sm_events_report.c index 5bf7f0ef..974f27ed 100644 --- a/feeds/wlan-ap/opensync/src/src/sm/src/sm_events_report.c +++ b/feeds/wlan-ap/opensync/src/src/sm/src/sm_events_report.c @@ -23,7 +23,7 @@ #define MODULE_ID LOG_MODULE_ID_MAIN /* global list populated by ubus_collector */ -extern dpp_event_report_data_t g_report_data; +extern dpp_event_report_data_t g_event_report; /* new part */ typedef struct { @@ -41,9 +41,6 @@ typedef struct { /* Structure pointing to upper layer events storage */ dpp_event_report_data_t report; - /* event list (only one for now) */ - ds_dlist_t record_list; - /* Reporting start timestamp used for reporting timestamp calculation */ uint64_t report_ts; } sm_events_ctx_t; @@ -88,24 +85,61 @@ static bool dpp_events_report_timer_restart(ev_timer *timer) return true; } +static void sm_events_report_clear(ds_dlist_t *report_list) +{ + ds_dlist_iter_t record_iter; + + if (ds_dlist_is_empty(report_list)) + return; + + dpp_event_record_t *record = NULL; + for (record = ds_dlist_ifirst(&record_iter, report_list); + record != NULL; + record = ds_dlist_inext(&record_iter)) { + ds_dlist_iremove(&record_iter); + dpp_event_record_free(record); + record = NULL; + } +} + static void sm_events_report(EV_P_ ev_timer *w, int revents) { sm_events_ctx_t *events_ctx = (sm_events_ctx_t *)w->data; dpp_event_report_data_t *report_ctx = &events_ctx->report; ev_timer *report_timer = &events_ctx->report_timer; + /* Event Record */ + dpp_event_record_t *dpp_record = NULL; + dpp_event_record_t *sm_record = NULL; + ds_dlist_iter_t record_iter; + dpp_events_report_timer_restart(report_timer); - memcpy(report_ctx, &g_report_data, sizeof(dpp_event_report_data_t)); + for (sm_record = ds_dlist_ifirst(&record_iter, &g_event_report.client_event_list); sm_record != NULL; sm_record = ds_dlist_inext(&record_iter)) { + dpp_record = dpp_event_record_alloc(); + dpp_record->client_session.session_id = sm_record->client_session.session_id; + dpp_record->client_session.auth_event = sm_record->client_session.auth_event; + dpp_record->client_session.assoc_event = sm_record->client_session.assoc_event; + dpp_record->client_session.first_data_event = sm_record->client_session.first_data_event; + dpp_record->client_session.disconnect_event = sm_record->client_session.disconnect_event; + dpp_record->client_session.auth_event = sm_record->client_session.auth_event; - while (!ds_dlist_is_empty(&g_report_data.list)) { - ds_dlist_remove_head(&g_report_data.list); + /* Memset all event pointers in the global event record to NULL */ + memset(&sm_record->client_session, 0, sizeof(dpp_event_record_session_t)); + sm_record->hasSMProcessed = true; + + if (ds_dlist_is_empty(&report_ctx->client_event_list)) { + ds_dlist_init(&report_ctx->client_event_list, dpp_event_record_t, node); + } + ds_dlist_insert_tail(&report_ctx->client_event_list, dpp_record); } - LOG(INFO, "Sending events report..."); - if (!ds_dlist_is_empty(&report_ctx->list)) { + if (!ds_dlist_is_empty(&report_ctx->client_event_list)) { + LOG(INFO, "Sending events report..."); dpp_put_events(report_ctx); } + + sm_events_report_clear(&report_ctx->client_event_list); } /****************************************************************************** @@ -136,11 +170,7 @@ bool sm_events_report_request(radio_entry_t *radio_cfg, LOG(INFO, "Initializing events reporting"); /* Initialize report list */ - ds_dlist_init(&report_ctx->list, dpp_event_record_t, node); - - /* Initialize event list */ - ds_dlist_init(&events_ctx->record_list, dpp_event_record_t, - node); + ds_dlist_init(&report_ctx->client_event_list, dpp_event_record_t, node); /* Initialize event lib timers and pass the global internal cache diff --git a/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.c b/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.c index 644c0dea..191dbe94 100644 --- a/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.c +++ b/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.c @@ -4,26 +4,32 @@ #include /* Global list of events received from hostapd */ -dpp_event_report_data_t g_report_data; +dpp_event_report_data_t g_event_report; /* Internal list of processed events ready to be deleted from hostapd */ -static dpp_event_report_data_t *deletion_pending = NULL; +static ds_dlist_t deletion_pending_list; +static ds_dlist_t bss_list; static struct ubus_context *ubus = NULL; -static char *ubus_object = NULL; typedef struct { uint64_t session_id; - char *bss; + char bss[UBUS_OBJ_LEN]; ds_dlist_node_t node; } delete_entry_t; +typedef struct { + char obj_name[UBUS_OBJ_LEN]; + ds_dlist_node_t node; +} bss_obj_t; + + static const struct blobmsg_policy ubus_collector_bss_list_policy[__BSS_LIST_DATA_MAX] = { - [BSS_LIST_BSS_LIST] = {.name = "bss_list", .type = BLOBMSG_TYPE_TABLE}, + [BSS_LIST_BSS_LIST] = { .name = "bss_list", .type = BLOBMSG_TYPE_ARRAY }, }; static const struct blobmsg_policy ubus_collector_bss_table_policy[__BSS_TABLE_MAX] = { - [BSS_TABLE_BSS_NAME] = {.name = "name", .type = BLOBMSG_TYPE_STRING}, + [BSS_OBJECT_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING }, }; static const struct blobmsg_policy ubus_collector_sessions_policy[__UBUS_SESSIONS_MAX] = { @@ -81,6 +87,37 @@ static const struct blobmsg_policy client_first_data_event_policy[__CLIENT_FIRST [CLIENT_FIRST_DATA_RX_TIMESTAMP] = {.name = "fdata_rx_up_ts_in_us", .type = BLOBMSG_TYPE_INT64}, }; +static int frequency_to_channel(int freq) +{ + /* see 802.11-2007 17.3.8.3.2 and Annex J */ + if (freq == 2484) + return 14; + else if (freq < 2484) + return (freq - 2407) / 5; + else if (freq >= 4910 && freq <= 4980) + return (freq - 4000) / 5; + else if (freq <= 45000) /* DMG band lower limit */ + return (freq - 5000) / 5; + else if (freq >= 58320 && freq <= 64800) + return (freq - 56160) / 2160; + else + return 0; +} + +static radio_type_t frequency_to_band(int freq) +{ + int chan = frequency_to_channel(freq); + + if (chan <= 16) + return RADIO_TYPE_2G; + else if (chan >= 32 && chan <= 68) + return RADIO_TYPE_5GL; + else if (chan >= 96) + return RADIO_TYPE_5GU; + else + return RADIO_TYPE_NONE; +} + static int client_first_data_event_cb(struct blob_attr *msg, dpp_event_record_session_t *dpp_session, uint64_t event_session_id) @@ -89,12 +126,9 @@ static int client_first_data_event_cb(struct blob_attr *msg, struct blob_attr *tb_client_first_data_event[__CLIENT_FIRST_DATA_MAX] = {}; char *mac_address = NULL; - uint64_t session_id = event_session_id; - uint32_t timestamp = 0; - uint64_t rx_ts = 0; - uint64_t tx_ts = 0; - int i = 0; - dpp_event_record_first_data_t *first_data_event_dpp = NULL; + + if (NULL == dpp_session) + return -1; error = blobmsg_parse(client_first_data_event_policy, __CLIENT_FIRST_DATA_MAX, @@ -103,42 +137,27 @@ static int client_first_data_event_cb(struct blob_attr *msg, if (error) return -1; - for (i = 0; i < __CLIENT_FIRST_DATA_MAX; i++) { - if (!tb_client_first_data_event[i]) { - LOG(INFO, - "ubus_collector: could not parse first_data event %s policy", - client_first_data_event_policy[i].name); - return -1; - } - } + dpp_session->first_data_event = dpp_event_client_first_data_record_alloc(); - mac_address = blobmsg_get_string( - tb_client_first_data_event[CLIENT_FIRST_DATA_STA_MAC]); - if (!mac_address) + if (!dpp_session->first_data_event) return -1; - timestamp = blobmsg_get_u32( - tb_client_first_data_event[CLIENT_FIRST_DATA_TIMESTAMP]); - rx_ts = blobmsg_get_u64( - tb_client_first_data_event[CLIENT_FIRST_DATA_RX_TIMESTAMP]); - tx_ts = blobmsg_get_u64( - tb_client_first_data_event[CLIENT_FIRST_DATA_TX_TIMESTAMP]); + dpp_session->first_data_event->session_id = event_session_id; - first_data_event_dpp = calloc(1, sizeof(dpp_event_record_first_data_t)); + if (tb_client_first_data_event[CLIENT_FIRST_DATA_STA_MAC]) { + mac_address = blobmsg_get_string(tb_client_first_data_event[CLIENT_FIRST_DATA_STA_MAC]); + memcpy(dpp_session->first_data_event->sta_mac, mac_address, MAC_ADDRESS_STRING_LEN); + } - memcpy(first_data_event_dpp->sta_mac, mac_address, - MAC_ADDRESS_STRING_LEN); - first_data_event_dpp->session_id = session_id; - first_data_event_dpp->timestamp = timestamp; - first_data_event_dpp->fdata_tx_up_ts_in_us = tx_ts; - first_data_event_dpp->fdata_rx_up_ts_in_us = rx_ts; + if (tb_client_first_data_event[CLIENT_FIRST_DATA_TIMESTAMP]) + dpp_session->first_data_event->timestamp = blobmsg_get_u32(tb_client_first_data_event[CLIENT_FIRST_DATA_TIMESTAMP]); - if (!ds_dlist_is_empty(&dpp_session->first_data_list)) - ds_dlist_init(&dpp_session->first_data_list, - dpp_event_record_first_data_t, node); + if (tb_client_first_data_event[CLIENT_FIRST_DATA_TX_TIMESTAMP]) + dpp_session->first_data_event->fdata_tx_up_ts_in_us = blobmsg_get_u64(tb_client_first_data_event[CLIENT_FIRST_DATA_TX_TIMESTAMP]); + + if (tb_client_first_data_event[CLIENT_FIRST_DATA_RX_TIMESTAMP]) + dpp_session->first_data_event->fdata_rx_up_ts_in_us = blobmsg_get_u64(tb_client_first_data_event[CLIENT_FIRST_DATA_RX_TIMESTAMP]); - ds_dlist_insert_tail(&dpp_session->first_data_list, - first_data_event_dpp); return 0; } @@ -147,19 +166,12 @@ static int client_disconnect_event_cb(struct blob_attr *msg, uint64_t event_session_id) { int error = 0; - int ssid_bytes = 0; struct blob_attr *tb_client_disconnect_event[__CLIENT_DISCONNECT_MAX] = {}; - char *mac_address = NULL; - radio_essid_t ssid = {}; - char *ssid_temp = NULL; - uint64_t session_id = event_session_id; - uint32_t timestamp = 0; - radio_type_t band = 0; - uint32_t rssi = 0; - uint32_t internal_rc = 0; - int i = 0; - dpp_event_record_disconnect_t *disconnect_event_dpp = NULL; + char *mac_address, *ssid = NULL; + + if (NULL == dpp_session) + return -1; error = blobmsg_parse(client_disconnect_event_policy, __CLIENT_DISCONNECT_MAX, @@ -168,52 +180,35 @@ static int client_disconnect_event_cb(struct blob_attr *msg, if (error) return -1; - for (i = 0; i < __CLIENT_DISCONNECT_MAX; i++) { - if (!tb_client_disconnect_event[i]) { - LOG(INFO, - "ubus_collector: could not parse disconnect event %s policy", - client_disconnect_event_policy[i].name); - return -1; - } + dpp_session->disconnect_event = dpp_event_client_disconnect_record_alloc(); + + if (!dpp_session->disconnect_event) + return -1; + + dpp_session->disconnect_event->session_id = event_session_id; + + if (tb_client_disconnect_event[CLIENT_DISCONNECT_STA_MAC]) { + mac_address = blobmsg_get_string(tb_client_disconnect_event[CLIENT_DISCONNECT_STA_MAC]); + memcpy(dpp_session->disconnect_event->sta_mac, mac_address, MAC_ADDRESS_STRING_LEN); } - mac_address = blobmsg_get_string( - tb_client_disconnect_event[CLIENT_DISCONNECT_STA_MAC]); - if (!mac_address) - return -1; + if (tb_client_disconnect_event[CLIENT_DISCONNECT_BAND]) + dpp_session->disconnect_event->band = frequency_to_band(blobmsg_get_u32(tb_client_disconnect_event[CLIENT_DISCONNECT_BAND])); - ssid_temp = blobmsg_get_string( - tb_client_disconnect_event[CLIENT_DISCONNECT_SSID]); - ssid_bytes = snprintf(ssid, RADIO_ESSID_LEN + 1, "%s", ssid_temp); - if (ssid_bytes > RADIO_ESSID_LEN) - return -1; + if (tb_client_disconnect_event[CLIENT_DISCONNECT_RSSI]) + dpp_session->disconnect_event->rssi = blobmsg_get_u32(tb_client_disconnect_event[CLIENT_DISCONNECT_RSSI]); - band = blobmsg_get_u32( - tb_client_disconnect_event[CLIENT_DISCONNECT_BAND]); - rssi = blobmsg_get_u32( - tb_client_disconnect_event[CLIENT_DISCONNECT_RSSI]); - timestamp = blobmsg_get_u32( - tb_client_disconnect_event[CLIENT_DISCONNECT_TIMESTAMP]); - internal_rc = blobmsg_get_u32( - tb_client_disconnect_event[CLIENT_DISCONNECT_INTERNAL_RC]); + if (tb_client_disconnect_event[CLIENT_DISCONNECT_SSID]) { + ssid = blobmsg_get_string(tb_client_disconnect_event[CLIENT_DISCONNECT_SSID]); + memcpy(dpp_session->disconnect_event->ssid, ssid, RADIO_ESSID_LEN + 1); + } - disconnect_event_dpp = calloc(1, sizeof(dpp_event_record_disconnect_t)); + if (tb_client_disconnect_event[CLIENT_DISCONNECT_TIMESTAMP]) + dpp_session->disconnect_event->timestamp = blobmsg_get_u32(tb_client_disconnect_event[CLIENT_DISCONNECT_TIMESTAMP]); - memcpy(disconnect_event_dpp->sta_mac, mac_address, - MAC_ADDRESS_STRING_LEN); - memcpy(disconnect_event_dpp->ssid, ssid, ssid_bytes + 1); - disconnect_event_dpp->session_id = session_id; - disconnect_event_dpp->timestamp = timestamp; - disconnect_event_dpp->band = band; - disconnect_event_dpp->rssi = rssi; - disconnect_event_dpp->internal_rc = internal_rc; + if (tb_client_disconnect_event[CLIENT_DISCONNECT_INTERNAL_RC]) + dpp_session->disconnect_event->internal_rc = blobmsg_get_u32(tb_client_disconnect_event[CLIENT_DISCONNECT_INTERNAL_RC]); - if (!ds_dlist_is_empty(&dpp_session->disconnect_list)) - ds_dlist_init(&dpp_session->disconnect_list, - dpp_event_record_disconnect_t, node); - - ds_dlist_insert_tail(&dpp_session->disconnect_list, - disconnect_event_dpp); return 0; } @@ -222,17 +217,11 @@ static int client_auth_event_cb(struct blob_attr *msg, uint64_t event_session_id) { int error = 0; - int ssid_bytes = 0; struct blob_attr *tb_client_auth_event[__CLIENT_ASSOC_MAX] = {}; - char *mac_address = NULL; - radio_essid_t ssid = {}; - char *ssid_temp = NULL; - uint64_t session_id = event_session_id; - uint32_t timestamp = 0; - radio_type_t band = 0; - uint32_t auth_status = 0; - int i = 0; - dpp_event_record_auth_t *auth_event_dpp = NULL; + char *mac_address, *ssid = NULL; + + if (NULL == dpp_session) + return -1; error = blobmsg_parse(client_auth_event_policy, __CLIENT_AUTH_MAX, tb_client_auth_event, blobmsg_data(msg), @@ -240,47 +229,32 @@ static int client_auth_event_cb(struct blob_attr *msg, if (error) return -1; - for (i = 0; i < __CLIENT_AUTH_MAX; i++) { - if (!tb_client_auth_event[i]) { - LOG(INFO, - "ubus_collector: could not parse auth event %s policy", - client_auth_event_policy[i].name); - return -1; - } + dpp_session->auth_event = dpp_event_client_auth_record_alloc(); + + if (!dpp_session->auth_event) + return -1; + + dpp_session->auth_event->session_id = event_session_id; + + if (tb_client_auth_event[CLIENT_AUTH_STA_MAC]) { + mac_address = blobmsg_get_string(tb_client_auth_event[CLIENT_AUTH_STA_MAC]); + memcpy(dpp_session->auth_event->sta_mac, mac_address, MAC_ADDRESS_STRING_LEN); } - mac_address = - blobmsg_get_string(tb_client_auth_event[CLIENT_AUTH_STA_MAC]); - if (!mac_address) - return -1; + if (tb_client_auth_event[CLIENT_AUTH_BAND]) + dpp_session->auth_event->band = frequency_to_band(blobmsg_get_u32(tb_client_auth_event[CLIENT_AUTH_BAND])); - ssid_temp = - blobmsg_get_string(tb_client_auth_event[CLIENT_AUTH_AUTH_SSID]); - ssid_bytes = snprintf(ssid, RADIO_ESSID_LEN + 1, "%s", ssid_temp); - if (ssid_bytes > RADIO_ESSID_LEN) - return -1; + if (tb_client_auth_event[CLIENT_AUTH_AUTH_SSID]) { + ssid = blobmsg_get_string(tb_client_auth_event[CLIENT_AUTH_AUTH_SSID]); + memcpy(dpp_session->auth_event->ssid, ssid, RADIO_ESSID_LEN + 1); + } - timestamp = - blobmsg_get_u32(tb_client_auth_event[CLIENT_AUTH_TIMESTAMP]); - band = blobmsg_get_u32(tb_client_auth_event[CLIENT_AUTH_BAND]); - auth_status = - blobmsg_get_u32(tb_client_auth_event[CLIENT_AUTH_AUTH_STATUS]); + if (tb_client_auth_event[CLIENT_AUTH_TIMESTAMP]) + dpp_session->auth_event->timestamp = blobmsg_get_u32(tb_client_auth_event[CLIENT_AUTH_TIMESTAMP]); - auth_event_dpp = calloc(1, sizeof(dpp_event_record_auth_t)); - memset(auth_event_dpp, 0, sizeof(dpp_event_record_auth_t)); + if (tb_client_auth_event[CLIENT_AUTH_AUTH_STATUS]) + dpp_session->auth_event->auth_status = blobmsg_get_u32(tb_client_auth_event[CLIENT_AUTH_AUTH_STATUS]); - memcpy(auth_event_dpp->sta_mac, mac_address, MAC_ADDRESS_STRING_LEN); - memcpy(auth_event_dpp->ssid, ssid, ssid_bytes + 1); - auth_event_dpp->session_id = session_id; - auth_event_dpp->timestamp = timestamp; - auth_event_dpp->band = band; - auth_event_dpp->auth_status = auth_status; - - if (!ds_dlist_is_empty(&dpp_session->auth_list)) - ds_dlist_init(&dpp_session->auth_list, dpp_event_record_auth_t, - node); - - ds_dlist_insert_tail(&dpp_session->auth_list, auth_event_dpp); return 0; } @@ -289,22 +263,11 @@ static int client_assoc_event_cb(struct blob_attr *msg, uint64_t event_session_id) { int error = 0; - int ssid_bytes = 0; struct blob_attr *tb_client_assoc_event[__CLIENT_ASSOC_MAX] = {}; - char *mac_address = NULL; - radio_essid_t ssid = {}; - char *ssid_temp = NULL; - uint64_t session_id = event_session_id; - uint32_t timestamp = 0; - radio_type_t band = 0; - assoc_type_t assoc_type = 0; - uint32_t rssi = 0; - uint32_t internal_sc = 0; - bool using11k = false; - bool using11r = false; - bool using11v = false; - int i = 0; - dpp_event_record_assoc_t *assoc_event_dpp = NULL; + char *mac_address, *ssid = NULL; + + if (NULL == dpp_session) + return -1; error = blobmsg_parse(client_assoc_event_policy, __CLIENT_ASSOC_MAX, tb_client_assoc_event, blobmsg_data(msg), @@ -312,64 +275,51 @@ static int client_assoc_event_cb(struct blob_attr *msg, if (error) return -1; - for (i = 0; i < __CLIENT_ASSOC_MAX; i++) { - if (!tb_client_assoc_event[i]) { - LOG(INFO, - "ubus_collector: could not parse assoc event %s policy", - client_assoc_event_policy[i].name); - return -1; - } + dpp_session->assoc_event = dpp_event_client_assoc_record_alloc(); + + if (!dpp_session->assoc_event) + return -1; + + dpp_session->assoc_event->session_id = event_session_id; + + if (tb_client_assoc_event[CLIENT_ASSOC_STA_MAC]) { + mac_address = blobmsg_get_string(tb_client_assoc_event[CLIENT_ASSOC_STA_MAC]); + memcpy(dpp_session->assoc_event->sta_mac, mac_address, MAC_ADDRESS_STRING_LEN); } - mac_address = - blobmsg_get_string(tb_client_assoc_event[CLIENT_ASSOC_STA_MAC]); - if (!mac_address) - return -1; + if (tb_client_assoc_event[CLIENT_ASSOC_SSID]) { + ssid = blobmsg_get_string(tb_client_assoc_event[CLIENT_ASSOC_SSID]); + memcpy(dpp_session->assoc_event->ssid, ssid, RADIO_ESSID_LEN + 1); + } - ssid_temp = - blobmsg_get_string(tb_client_assoc_event[CLIENT_ASSOC_SSID]); - ssid_bytes = snprintf(ssid, RADIO_ESSID_LEN + 1, "%s", ssid_temp); - if (ssid_bytes > RADIO_ESSID_LEN) - return -1; + if (tb_client_assoc_event[CLIENT_ASSOC_TIMESTAMP]) + dpp_session->assoc_event->timestamp = blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_TIMESTAMP]); - band = blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_BAND]); - assoc_type = - blobmsg_get_u8(tb_client_assoc_event[CLIENT_ASSOC_ASSOC_TYPE]); - rssi = blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_RSSI]); - timestamp = - blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_TIMESTAMP]); - internal_sc = blobmsg_get_u32( - tb_client_assoc_event[CLIENT_ASSOC_INTERNAL_SC]); - using11k = - blobmsg_get_bool(tb_client_assoc_event[CLIENT_ASSOC_USING11K]); - using11r = - blobmsg_get_bool(tb_client_assoc_event[CLIENT_ASSOC_USING11R]); - using11v = - blobmsg_get_bool(tb_client_assoc_event[CLIENT_ASSOC_USING11V]); + if (tb_client_assoc_event[CLIENT_ASSOC_INTERNAL_SC]) + dpp_session->assoc_event->internal_sc = blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_INTERNAL_SC]); - assoc_event_dpp = calloc(1, sizeof(dpp_event_record_assoc_t)); + if (tb_client_assoc_event[CLIENT_ASSOC_RSSI]) + dpp_session->assoc_event->rssi = blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_RSSI]); - strcpy(assoc_event_dpp->sta_mac, mac_address); - memcpy(assoc_event_dpp->ssid, ssid, ssid_bytes + 1); - assoc_event_dpp->session_id = session_id; - assoc_event_dpp->timestamp = timestamp; - assoc_event_dpp->band = band; - assoc_event_dpp->assoc_type = assoc_type; - assoc_event_dpp->rssi = rssi; - assoc_event_dpp->internal_sc = internal_sc; - assoc_event_dpp->using11k = using11k; - assoc_event_dpp->using11r = using11r; - assoc_event_dpp->using11v = using11v; + if (tb_client_assoc_event[CLIENT_ASSOC_BAND]) + dpp_session->assoc_event->band = frequency_to_band(blobmsg_get_u32(tb_client_assoc_event[CLIENT_ASSOC_BAND])); - if (!ds_dlist_is_empty(&dpp_session->assoc_list)) - ds_dlist_init(&dpp_session->assoc_list, - dpp_event_record_assoc_t, node); + if (tb_client_assoc_event[CLIENT_ASSOC_ASSOC_TYPE]) + dpp_session->assoc_event->assoc_type = blobmsg_get_u8(tb_client_assoc_event[CLIENT_ASSOC_ASSOC_TYPE]); + + if (tb_client_assoc_event[CLIENT_ASSOC_USING11K]) + dpp_session->assoc_event->using11k = blobmsg_get_bool(tb_client_assoc_event[CLIENT_ASSOC_USING11K]); + + if (tb_client_assoc_event[CLIENT_ASSOC_USING11R]) + dpp_session->assoc_event->using11r = blobmsg_get_bool(tb_client_assoc_event[CLIENT_ASSOC_USING11R]); + + if (tb_client_assoc_event[CLIENT_ASSOC_USING11V]) + dpp_session->assoc_event->using11v = blobmsg_get_bool(tb_client_assoc_event[CLIENT_ASSOC_USING11V]); - ds_dlist_insert_tail(&dpp_session->assoc_list, assoc_event_dpp); return 0; } -static int (*event_handler_list[__CLIENT_EVENTS_MAX - 1])( +static int (*client_event_handler_list[__CLIENT_EVENTS_MAX - 1])( struct blob_attr *msg, dpp_event_record_session_t *dpp_session, uint64_t session_id) = { client_assoc_event_cb, client_auth_event_cb, @@ -377,7 +327,15 @@ static int (*event_handler_list[__CLIENT_EVENTS_MAX - 1])( client_first_data_event_cb, NULL, }; -static void ubus_collector_cb(struct ubus_request *req, int type, + +static void ubus_collector_complete_session_cb(struct ubus_request *req, int ret) +{ + LOG(DEBUG, "ubus_collector_complete_session_cb"); + if (req) + free(req); +} + +static void ubus_collector_session_cb(struct ubus_request *req, int type, struct blob_attr *msg) { int error = 0; @@ -385,163 +343,143 @@ static void ubus_collector_cb(struct ubus_request *req, int type, struct blob_attr *tb_sessions[__UBUS_SESSIONS_MAX] = {}; struct blob_attr *tb_session = NULL; struct blob_attr *tb_client_events[__CLIENT_EVENTS_MAX] = {}; - dpp_event_record_t *dpp_client_session = NULL; - dpp_event_record_session_t *dpp_session = NULL; + dpp_event_record_t *event_record = NULL; uint64_t session_id = 0; - int session_no = 0; - char event_message[128] = {}; delete_entry_t *delete_entry = NULL; - char *bss = req->priv; int i = 0; (void)type; - if (!msg) - goto error_out; + char *ifname = (char *)req->priv; - LOG(INFO, "ubus_collector: received ubus collector message"); + dpp_event_record_t *old_session = NULL; + ds_dlist_iter_t session_iter; + + /* First remove all the old sessions from the global report which are already consumed by sm_events */ + for (old_session = ds_dlist_ifirst(&session_iter, &g_event_report.client_event_list); old_session != NULL; old_session = ds_dlist_inext(&session_iter)) { + if (old_session && old_session->hasSMProcessed) { + ds_dlist_iremove(&session_iter); + dpp_event_record_free(old_session); + old_session = NULL; + } + } + + if (!msg) + return; error = blobmsg_parse(ubus_collector_sessions_policy, __UBUS_SESSIONS_MAX, tb_sessions, blobmsg_data(msg), blobmsg_data_len(msg)); + if (error || !tb_sessions[UBUS_COLLECTOR_SESSIONS]) { - LOG(INFO, - "ubus_collector: failed while parsing session policy"); - goto error_out; + LOG(ERR, "ubus_collector: failed while parsing session policy"); + return; } - dpp_client_session = calloc(1, sizeof(dpp_event_record_t)); - if (!dpp_client_session) { - LOG(INFO, - "ubus_collector: not enough memory for dpp_client_session"); - goto error_out; - } - - ds_dlist_init(&dpp_client_session->client_session, - dpp_event_record_session_t, node); - - /* Iterating on multiple ClientSession types */ blobmsg_for_each_attr(tb_session, tb_sessions[UBUS_COLLECTOR_SESSIONS], rem) { - dpp_session = calloc(1, sizeof(dpp_event_record_session_t)); - if (!dpp_session) { - LOG(INFO, - "ubus_collector: not enough memory for dpp_session"); - goto error_out; - } - error = blobmsg_parse(client_session_events_policy, __CLIENT_EVENTS_MAX, tb_client_events, blobmsg_data(tb_session), blobmsg_data_len(tb_session)); - if (error) { - LOG(INFO, - "ubus_collector: failed while parsing client session events policy"); - goto error_out; + if (error || !tb_client_events[CLIENT_SESSION_ID]) { + LOG(ERR, "ubus_collector: failed while parsing client session events policy"); + continue; } - session_no++; - LOG(INFO, "ubus_collector: processing session no %d", - session_no); + event_record = dpp_event_record_alloc(); - if (!tb_client_events[CLIENT_SESSION_ID]) { - LOG(INFO, - "ubus_collector: failed while getting client session_id"); - goto error_out; + if (!event_record) { + LOG(ERR, "ubus_collector: not enough memory for event_record"); + continue; } - - session_id = - blobmsg_get_u64(tb_client_events[CLIENT_SESSION_ID]); - dpp_session->session_id = session_id; + session_id = blobmsg_get_u64(tb_client_events[CLIENT_SESSION_ID]); + event_record->client_session.session_id = session_id; for (i = 0; i < __CLIENT_EVENTS_MAX - 1; i++) { if (tb_client_events[i]) { - snprintf(event_message, sizeof(event_message), - "%s", - client_session_events_policy[i].name); - LOG(INFO, "ubus_collector: processing %s", - event_message); - - if (!event_handler_list[i]) { - snprintf( - event_message, - sizeof(event_message), - "Event %s - handler not implemented", - client_session_events_policy[i] - .name); - LOG(INFO, "ubus_collector: %s", - event_message); + if (!client_event_handler_list[i]) { + LOG(ERR, "ubus_collector: Event handler not implemented"); continue; } - - error = event_handler_list[i]( - tb_client_events[i], dpp_session, + client_event_handler_list[i]( + tb_client_events[i], &event_record->client_session, session_id); - if (error) { - LOG(INFO, - "ubus_collector: failed in event handler"); - goto error_out; } } - } - - ds_dlist_insert_tail(&dpp_client_session->client_session, - dpp_session); - dpp_session = NULL; + event_record->hasSMProcessed = false; + ds_dlist_insert_tail(&g_event_report.client_event_list, event_record); + event_record = NULL; /* Schedule session for deletion */ delete_entry = calloc(1, sizeof(delete_entry_t)); - delete_entry->session_id = session_id; - delete_entry->bss = strdup(bss); - - ds_dlist_insert_tail(&deletion_pending->list, delete_entry); - delete_entry = NULL; + if (delete_entry) { + memset(delete_entry, 0, sizeof(delete_entry_t)); + delete_entry->session_id = session_id; + strncpy(delete_entry->bss, ifname, UBUS_OBJ_LEN); + ds_dlist_insert_tail(&deletion_pending_list, delete_entry); + delete_entry = NULL; + } } - - /* Move all the sessions received from hostapd to global list accessible from sm_events */ - if (session_no) - ds_dlist_insert_tail(&g_report_data.list, dpp_client_session); - - goto out; - -error_out: - free(dpp_session); - free(dpp_client_session); - return; - -out: - LOG(INFO, "ubus_collector: successfull parse for AP object"); } -static void ubus_collector_complete_cb(struct ubus_request *req, int ret) +static void ubus_collector_hostapd_invoke(void *object_path) { - LOG(INFO, "ubus_collector: finished processing"); - free(req); - return; -} -static void ubus_collector_hostapd_invoke(void *arg) -{ uint32_t ubus_object_id = 0; - const char *object_path = arg; + const char *obj_path = object_path; const char *hostapd_method = "get_sessions"; - struct ubus_request *req = malloc(sizeof(struct ubus_request)); - if (ubus_lookup_id(ubus, object_path, &ubus_object_id)) { - LOG(INFO, "ubus_collector: could not find ubus object %s", - object_path); - free(req); + if (NULL == object_path) { + LOG(ERR, "ubus_collector_hostapd_invoke: Missing hostapd ubus object"); return; } - LOG(INFO, "ubus_collector: requesting hostapd data"); - ubus_invoke_async(ubus, ubus_object_id, hostapd_method, NULL, req); + struct ubus_request *request = malloc(sizeof(struct ubus_request)); - req->data_cb = (ubus_data_handler_t)ubus_collector_cb; - req->complete_cb = (ubus_complete_handler_t)ubus_collector_complete_cb; - req->priv = arg; + if (!request) { + LOG(ERR, "ubus_collector_hostapd_invoke: Failed to allocate ubus request object"); + return; + } - ubus_complete_request(ubus, req, 0); + if (ubus_lookup_id(ubus, obj_path, &ubus_object_id)) { + LOG(ERR, "ubus_collector: could not find ubus object %s", + obj_path); + if (request) + free(request); + return; + } + + ubus_invoke_async(ubus, ubus_object_id, hostapd_method, NULL, request); + request->data_cb = ubus_collector_session_cb; + request->complete_cb = ubus_collector_complete_session_cb; + request->priv = object_path; + ubus_complete_request_async(ubus, request); +} + +static void ubus_collector_complete_bss_cb(struct ubus_request *req, int ret) +{ + LOG(DEBUG, "ubus_collector_complete_bss_cb"); + if (req) + free(req); +} + +static void get_sessions(void * arg) +{ + bss_obj_t *bss_record = NULL; + ds_dlist_iter_t record_iter; + + if (ds_dlist_is_empty(&bss_list)) { + LOG(NOTICE, "No BSSs to get sessions for"); + evsched_task_reschedule(); + return; + } + + for (bss_record = ds_dlist_ifirst(&record_iter, &bss_list); + bss_record != NULL; bss_record = ds_dlist_inext(&record_iter)) { + ubus_collector_hostapd_invoke(bss_record->obj_name); + } + evsched_task_reschedule(); } static void ubus_collector_bss_cb(struct ubus_request *req, int type, @@ -550,157 +488,133 @@ static void ubus_collector_bss_cb(struct ubus_request *req, int type, int error = 0; int rem = 0; struct blob_attr *tb_bss_lst[__BSS_LIST_DATA_MAX] = {}; - struct blob_attr *tb_bss_table[__BSS_TABLE_MAX] = {}; struct blob_attr *tb_bss_tbl = NULL; - char *bss_name = NULL; - dpp_event_report_data_t *bss_list = NULL; - delete_entry_t *bss_record = NULL; + bss_obj_t *bss_record = NULL; ds_dlist_iter_t record_iter; if (!msg) return; - LOG(INFO, "ubus_collector: received ubus collector bss message"); - error = blobmsg_parse(ubus_collector_bss_list_policy, __BSS_LIST_DATA_MAX, tb_bss_lst, blobmsg_data(msg), blobmsg_data_len(msg)); + if (error || !tb_bss_lst[BSS_LIST_BSS_LIST]) { - LOG(INFO, + LOG(ERR, "ubus_collector: failed while parsing bss_list policy"); return; } - bss_list = calloc(1, sizeof(dpp_event_report_data_t)); - ds_dlist_init(&bss_list->list, delete_entry_t, node); - - /* itereate bss list */ + /* iterate bss list */ blobmsg_for_each_attr(tb_bss_tbl, tb_bss_lst[BSS_LIST_BSS_LIST], rem) { + bool obj_exists = false; + struct blob_attr *tb_bss_table[__BSS_TABLE_MAX] = {}; + error = blobmsg_parse(ubus_collector_bss_table_policy, __BSS_TABLE_MAX, tb_bss_table, blobmsg_data(tb_bss_tbl), blobmsg_data_len(tb_bss_tbl)); if (error) { - LOG(INFO, - "ubus_collector_ failed while parsing bss table policy"); + LOG(ERR, "ubus_collector_ failed while parsing bss table policy"); continue; } - bss_name = strdup( - blobmsg_get_string(tb_bss_table[BSS_TABLE_BSS_NAME])); - if (!bss_name) { - LOG(INFO, - "ubus_collector: failed while getting bss_name"); + if (!tb_bss_table[BSS_OBJECT_NAME]) continue; + + char *obj_name = blobmsg_get_string(tb_bss_table[BSS_OBJECT_NAME]); + if (!ds_dlist_is_empty(&bss_list)) { + for (bss_record = ds_dlist_ifirst(&record_iter, &bss_list); + bss_record != NULL; bss_record = ds_dlist_inext(&record_iter)) { + if (!strcmp(obj_name, bss_record->obj_name)) { + obj_exists = true; + break; + } + } + } + if (!obj_exists) { + bss_record = calloc(1, sizeof(bss_obj_t)); + strncpy(bss_record->obj_name, obj_name, UBUS_OBJ_LEN); + ds_dlist_insert_tail(&bss_list, bss_record); } - - bss_record = malloc(sizeof(delete_entry_t)); - bss_record->bss = bss_name; - - ds_dlist_insert_tail(&bss_list->list, bss_record); } - - if (ds_dlist_is_empty(&bss_list->list)) { - LOG(INFO, "ubus_collector: no bss entries found"); - free(bss_list); - return; - } - - /* get sessions from current bss */ - for (bss_record = ds_dlist_ifirst(&record_iter, &bss_list->list); - bss_record != NULL; bss_record = ds_dlist_inext(&record_iter)) { - LOG(INFO, "ubus_collector: processing bss %s", bss_record->bss); - ubus_collector_hostapd_invoke(bss_record->bss); - - free(bss_record); - } - - LOG(INFO, "ubus_collector: scanned all bss objects"); - free(bss_list); - - return; } static void ubus_collector_hostapd_bss_invoke(void *arg) { uint32_t ubus_object_id = 0; + const char *object_path = "hostapd"; const char *hostapd_method = "get_bss_list"; - struct ubus_request *req = malloc(sizeof(struct ubus_request)); if (ubus_lookup_id(ubus, object_path, &ubus_object_id)) { - LOG(INFO, "ubus_collector: could not find ubus object %s", + LOG(ERR, "ubus_collector: could not find ubus object %s", object_path); - free(req); evsched_task_reschedule(); return; } - LOG(INFO, "ubus_collector: requesting hostapd bss data"); + struct ubus_request *req = malloc(sizeof(struct ubus_request)); + + if (!req) { + LOG(ERR, "Failed to allocate req structure"); + return; + } ubus_invoke_async(ubus, ubus_object_id, hostapd_method, NULL, req); - req->data_cb = (ubus_data_handler_t)ubus_collector_bss_cb; - req->complete_cb = (ubus_complete_handler_t)ubus_collector_complete_cb; + req->data_cb = ubus_collector_bss_cb; + req->complete_cb = ubus_collector_complete_bss_cb; - ubus_complete_request(ubus, req, 0); + ubus_complete_request_async(ubus, req); evsched_task_reschedule(); } -static void ubus_collector_hostapd_clear(uint64_t session_id, char *bss) +static void ubus_collector_hostapd_clear(uint64_t session_id, char *object_path) { uint32_t ubus_object_id = 0; - const char *object_path = bss; + + if (NULL == object_path) + return; + const char *hostapd_method = "clear_session"; - struct ubus_request *req = malloc(sizeof(struct ubus_request)); if (ubus_lookup_id(ubus, object_path, &ubus_object_id)) { - LOG(INFO, - "ubus_collector: could not find the designated ubus object [%s]", - object_path); - free(req); + LOG(ERR, "ubus_collector: could not find the designated ubus object [%s]", object_path); return; } - int l = snprintf(NULL, 0, "%" PRIi64, session_id); - char str[l + 1]; - snprintf(str, l + 1, "%" PRIi64, session_id); - blob_buf_init(&b, 0); - blobmsg_add_string(&b, "session_id", str); + blobmsg_add_u64(&b, "session_id", session_id); - LOG(INFO, "ubus_collector: deleting session [%s]", str); - ubus_invoke_async(ubus, ubus_object_id, hostapd_method, b.head, req); + if (UBUS_STATUS_OK != ubus_invoke(ubus, ubus_object_id, hostapd_method, b.head, NULL, NULL, 1000)) { + LOG(ERR, "ubus call to clear session failed"); + } - req->data_cb = NULL; - req->complete_cb = (ubus_complete_handler_t)ubus_collector_complete_cb; - - ubus_complete_request_async(ubus, req); } static void ubus_garbage_collector(void *arg) { delete_entry_t *delete_entry = NULL; - if (ds_dlist_is_empty(&deletion_pending->list)) { + if (ds_dlist_is_empty(&deletion_pending_list)) { evsched_task_reschedule(); return; } /* Remove a single session from the deletion list */ - LOG(INFO, "ubus_collector: garbage collection"); - delete_entry = ds_dlist_head(&deletion_pending->list); + delete_entry = ds_dlist_head(&deletion_pending_list); if (delete_entry) { - if (delete_entry->session_id) + if (delete_entry->session_id) { ubus_collector_hostapd_clear(delete_entry->session_id, - delete_entry->bss); - - ds_dlist_remove_head(&deletion_pending->list); - free(delete_entry->bss); + delete_entry->bss); + } + ds_dlist_remove_head(&deletion_pending_list); free(delete_entry); + delete_entry = NULL; } evsched_task_reschedule(); @@ -710,34 +624,40 @@ int ubus_collector_init(void) { int sched_status = 0; - LOG(INFO, "ubus_collector: initializing"); - ubus = ubus_connect(UBUS_SOCKET); if (!ubus) { - LOG(INFO, "ubus_collector: cannot find ubus socket"); + LOG(ERR, "ubus_collector: cannot find ubus socket"); return -1; } - /* Initialize the global events and event deletion lists */ - ds_dlist_init(&g_report_data.list, dpp_event_record_session_t, node); - - deletion_pending = calloc(1, sizeof(dpp_event_record_session_t)); - ds_dlist_init(&deletion_pending->list, delete_entry_t, node); + /* Initialize the global events, session deletion and bss object lists */ + ds_dlist_init(&g_event_report.client_event_list, dpp_event_record_t, node); + ds_dlist_init(&deletion_pending_list, delete_entry_t, node); + ds_dlist_init(&bss_list, bss_obj_t, node); /* Schedule an event: invoke hostapd ubus get bss list method */ sched_status = evsched_task(&ubus_collector_hostapd_bss_invoke, NULL, - EVSCHED_SEC(UBUS_POLLING_DELAY)); + EVSCHED_SEC(UBUS_BSS_POLLING_DELAY)); if (sched_status < 1) { - LOG(INFO, "ubus_collector: failed at task creation, status %d", + LOG(ERR, "ubus_collector: failed at task creation, status %d", sched_status); return -1; } + /* Schedule an event: get sessions for all the BSSs */ + sched_status = evsched_task(&get_sessions, NULL, + EVSCHED_SEC(UBUS_SESSIONS_POLLING_DELAY)); + if (sched_status < 1) { + LOG(ERR, "ubus_collector: failed at task creation, status %d", + sched_status); + return -1; + } + /* Schedule an event: clear the hostapd sessions from opensync */ sched_status = evsched_task(&ubus_garbage_collector, NULL, EVSCHED_SEC(UBUS_GARBAGE_COLLECTION_DELAY)); if (sched_status < 1) { - LOG(INFO, "ubus_collector: failed at task creation, status %d", + LOG(ERR, "ubus_collector: failed at task creation, status %d", sched_status); return -1; } @@ -747,8 +667,5 @@ int ubus_collector_init(void) void ubus_collector_cleanup(void) { - LOG(INFO, "ubus_collector: cleaning up ubus collector"); ubus_free(ubus); - free(deletion_pending); - free(ubus_object); } diff --git a/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.h b/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.h index f9a52dcb..bd3a427a 100644 --- a/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.h +++ b/feeds/wlan-ap/opensync/src/src/sm/src/ubus_collector.h @@ -22,22 +22,22 @@ void ubus_collector_cleanup(void); #define UBUS_SOCKET "/var/run/ubus.sock" -/* Poll ubus after this many seconds */ -#define UBUS_POLLING_DELAY 7 +/* Poll bss list after this many seconds */ +#define UBUS_BSS_POLLING_DELAY 7 + +/* Poll sessions after this many seconds */ +#define UBUS_SESSIONS_POLLING_DELAY 9 /* Poll the session clearing 'garbage collector' after this many seconds */ #define UBUS_GARBAGE_COLLECTION_DELAY 1 +#define UBUS_OBJ_LEN 64 + enum { UBUS_COLLECTOR_SESSIONS, __UBUS_SESSIONS_MAX, }; -enum { - UBUS_CLIENT_SESSION, - __UBUS_SESSION_TYPES_MAX, -}; - enum { CLIENT_ASSOC_EVENT, CLIENT_AUTH_EVENT, @@ -100,7 +100,7 @@ enum { }; enum { - BSS_TABLE_BSS_NAME, + BSS_OBJECT_NAME, __BSS_TABLE_MAX, };