Index: opensync-2.0.5.0/interfaces/opensync.ovsschema =================================================================== --- opensync-2.0.5.0.orig/interfaces/opensync.ovsschema +++ opensync-2.0.5.0/interfaces/opensync.ovsschema @@ -4566,7 +4566,8 @@ "quality", "device", "rssi", - "steering" + "steering", + "network_probe" ] ] } 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 @@ -91,11 +91,27 @@ enum BSEventType { CLIENT_GHOST_DEVICE_KICK = 26; } +enum ConnectionEventType { + CLIENT_ASSOC = 0; + CLIENT_AUTH = 1; + CLIENT_DISCONNECT = 2; + CLIENT_FAILURE = 3; + CLIENT_FIRST_DATA = 4; + CLIEND_ID = 5; + CLIENT_IP = 6; + CLIENT_TIMEOUT = 7; +} + enum DisconnectSrc { LOCAL = 0; REMOTE = 1; } +enum AssocType { + ASSOC = 0; + REASSOC = 1; +} + enum DisconnectType { DISASSOC = 0; DEAUTH = 1; @@ -219,7 +235,23 @@ message Client { repeated Sojourn sojourn = 4; optional uint32 offset_ms = 5; } - + // type of ConnectionEvent is determined by ConnectionEventType enum + // all other fields are optional + // there will be more fields in the future, this is only for STA_Client_Assoc event + message ConnectionEvent { + required ConnectionEventType type = 1; + optional string sta_mac = 2; + optional uint64 session_id = 3; + optional string ssid = 4; + optional RadioBandType band = 5; + optional AssocType assoc_type = 6; + optional uint32 status = 7; + optional int32 rssi = 8; + optional uint32 internal_sc = 9; + optional bool using11k = 10; + optional bool using11r = 11; + optional bool using11v = 12; + } required string mac_address = 1; optional string ssid = 2; optional bool connected = 3; @@ -233,6 +265,7 @@ message Client { repeated TxStats tx_stats = 11; repeated TidStats tid_stats = 12; optional uint32 uapsd = 13; + repeated ConnectionEvent event_list = 14; } message ClientReport { @@ -476,6 +509,66 @@ message RssiReport { //////////////////////////////////////////////////////////////////////////////// // +// Network probe parameters +// +//////////////////////////////////////////////////////////////////////////////// +enum StateUpDown { + SUD_down = 0; + SUD_up = 1; + SUD_error = 2; +} + +message DNSProbeMetric { + optional string serverIP = 1; + optional StateUpDown state = 2; // State of the server + optional uint32 latency = 3; // Response latency in ms +} + +message VLANMetrics { + optional string vlanIF = 1; // The name of the interface (ie: brtrunk.100) + optional StateUpDown dhcpState = 2; // The state of the DHCP server according to that vlan + optional uint32 dhcpLatency = 3; + optional StateUpDown dnsState = 4; // The state of the DNS server according to that vlan + optional uint32 dnsLatency = 5; + optional StateUpDown obsV200_radiusState = 6; // The state of the Radius server according to that vlan + optional uint32 obsV200_radiusLatency = 7; + repeated DNSProbeMetric dnsProbeResults = 8; // ver=1300 + + // -- duration + optional uint32 dur_vlanIF = 501; //category Network + optional uint32 dur_dhcpState = 502; //category Network + optional uint32 dur_dhcpLatency = 503; //category Network + optional uint32 dur_dnsState = 504; //category Network + optional uint32 dur_dnsLatency = 505; //category Network + // optional uint32 obsV200_dur_radiusState = 506; + // optional uint32 obsV200_dur_radiusLatency = 507; + optional uint32 dur_dnsReport = 508; +} + +message RADIUSMetrics { + optional bytes serverIP = 1; + optional uint32 noAnswer = 2; + optional uint32 latencyMin = 3; + optional uint32 latencyMax = 4; + optional uint32 latencyAve = 5; + + // -- duration + optional uint32 dur_serverIP = 501; //category Network + optional uint32 dur_noAnswer = 502; //category Network + optional uint32 dur_latencyMin = 503; //category Network + optional uint32 dur_latencyMax = 504; //category Network + optional uint32 dur_latencyAve = 505; //category Network +} + + +message NetworkProbe { + optional DNSProbeMetric dns_probe = 1; + optional VLANMetrics vlan_probe = 2; + optional RADIUSMetrics radius_probe = 3; + optional uint64 timestamp_ms = 4; +} +//////////////////////////////////////////////////////////////////////////////// +// // Overall report that might contain all individual stats reports // //////////////////////////////////////////////////////////////////////////////// @@ -488,5 +581,5 @@ message Report { repeated Device device = 6; repeated BSReport bs_report = 7; repeated RssiReport rssi_report = 8; + repeated NetworkProbe network_probe = 101; } - Index: opensync-2.0.5.0/src/lib/datapipeline/inc/opensync_stats.pb-c.h =================================================================== --- opensync-2.0.5.0.orig/src/lib/datapipeline/inc/opensync_stats.pb-c.h +++ opensync-2.0.5.0/src/lib/datapipeline/inc/opensync_stats.pb-c.h @@ -25,6 +25,7 @@ typedef struct _Sts__Client__RxStats__Ch typedef struct _Sts__Client__TxStats Sts__Client__TxStats; typedef struct _Sts__Client__TidStats Sts__Client__TidStats; typedef struct _Sts__Client__TidStats__Sojourn Sts__Client__TidStats__Sojourn; +typedef struct _Sts__Client__ConnectionEvent Sts__Client__ConnectionEvent; typedef struct _Sts__ClientReport Sts__ClientReport; typedef struct _Sts__Survey Sts__Survey; typedef struct _Sts__Survey__SurveySample Sts__Survey__SurveySample; @@ -47,6 +48,10 @@ typedef struct _Sts__BSReport Sts__BSRep typedef struct _Sts__RssiPeer Sts__RssiPeer; typedef struct _Sts__RssiPeer__RssiSample Sts__RssiPeer__RssiSample; typedef struct _Sts__RssiReport Sts__RssiReport; +typedef struct _Sts__DNSProbeMetric Sts__DNSProbeMetric; +typedef struct _Sts__VLANMetrics Sts__VLANMetrics; +typedef struct _Sts__RADIUSMetrics Sts__RADIUSMetrics; +typedef struct _Sts__NetworkProbe Sts__NetworkProbe; typedef struct _Sts__Report Sts__Report; @@ -125,11 +130,27 @@ typedef enum _Sts__BSEventType { STS__BSEVENT_TYPE__CLIENT_GHOST_DEVICE_KICK = 26 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(STS__BSEVENT_TYPE) } Sts__BSEventType; +typedef enum _Sts__ConnectionEventType { + STS__CONNECTION_EVENT_TYPE__CLIENT_ASSOC = 0, + STS__CONNECTION_EVENT_TYPE__CLIENT_AUTH = 1, + STS__CONNECTION_EVENT_TYPE__CLIENT_DISCONNECT = 2, + STS__CONNECTION_EVENT_TYPE__CLIENT_FAILURE = 3, + STS__CONNECTION_EVENT_TYPE__CLIENT_FIRST_DATA = 4, + STS__CONNECTION_EVENT_TYPE__CLIEND_ID = 5, + STS__CONNECTION_EVENT_TYPE__CLIENT_IP = 6, + STS__CONNECTION_EVENT_TYPE__CLIENT_TIMEOUT = 7 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(STS__CONNECTION_EVENT_TYPE) +} Sts__ConnectionEventType; typedef enum _Sts__DisconnectSrc { STS__DISCONNECT_SRC__LOCAL = 0, STS__DISCONNECT_SRC__REMOTE = 1 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(STS__DISCONNECT_SRC) } Sts__DisconnectSrc; +typedef enum _Sts__AssocType { + STS__ASSOC_TYPE__ASSOC = 0, + STS__ASSOC_TYPE__REASSOC = 1 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(STS__ASSOC_TYPE) +} Sts__AssocType; typedef enum _Sts__DisconnectType { STS__DISCONNECT_TYPE__DISASSOC = 0, STS__DISCONNECT_TYPE__DEAUTH = 1 @@ -153,6 +174,17 @@ typedef enum _Sts__DiffType { STS__DIFF_TYPE__REMOVED = 1 PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(STS__DIFF_TYPE) } Sts__DiffType; +/* + * ////////////////////////////////////////////////////////////////////////////// + * Network probe parameters + * ////////////////////////////////////////////////////////////////////////////// + */ +typedef enum _Sts__StateUpDown { + STS__STATE_UP_DOWN__SUD_down = 0, + STS__STATE_UP_DOWN__SUD_up = 1, + STS__STATE_UP_DOWN__SUD_error = 2 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(STS__STATE_UP_DOWN) +} Sts__StateUpDown; /* --- messages --- */ @@ -363,6 +395,41 @@ struct _Sts__Client__TidStats /* + * type of ConnectionEvent is determined by ConnectionEventType enum + * all other fields are optional + * there will be more fields in the future, this is only for STA_Client_Assoc event + */ +struct _Sts__Client__ConnectionEvent +{ + ProtobufCMessage base; + Sts__ConnectionEventType type; + char *sta_mac; + protobuf_c_boolean has_session_id; + uint64_t session_id; + char *ssid; + protobuf_c_boolean has_band; + Sts__RadioBandType band; + protobuf_c_boolean has_assoc_type; + Sts__AssocType assoc_type; + protobuf_c_boolean has_status; + uint32_t status; + protobuf_c_boolean has_rssi; + int32_t rssi; + protobuf_c_boolean has_internal_sc; + uint32_t internal_sc; + protobuf_c_boolean has_using11k; + protobuf_c_boolean using11k; + protobuf_c_boolean has_using11r; + protobuf_c_boolean using11r; + protobuf_c_boolean has_using11v; + protobuf_c_boolean using11v; +}; +#define STS__CLIENT__CONNECTION_EVENT__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sts__client__connection_event__descriptor) \ + , STS__CONNECTION_EVENT_TYPE__CLIENT_ASSOC, NULL, 0, 0, NULL, 0, STS__RADIO_BAND_TYPE__BAND2G, 0, STS__ASSOC_TYPE__ASSOC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +/* * ////////////////////////////////////////////////////////////////////////////// * Client report: Report contains rx and tx stats for a single station * - Average stats : Averaged rx and tx stats @@ -395,10 +462,12 @@ struct _Sts__Client Sts__Client__TidStats **tid_stats; protobuf_c_boolean has_uapsd; uint32_t uapsd; + size_t n_event_list; + Sts__Client__ConnectionEvent **event_list; }; #define STS__CLIENT__INIT \ { PROTOBUF_C_MESSAGE_INIT (&sts__client__descriptor) \ - , NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0,NULL, 0,NULL, 0,NULL, 0, 0 } + , NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0,NULL, 0,NULL, 0,NULL, 0, 0, 0,NULL } struct _Sts__ClientReport @@ -932,6 +1001,160 @@ struct _Sts__RssiReport , STS__RADIO_BAND_TYPE__BAND2G, STS__REPORT_TYPE__RAW, 0, 0, 0,NULL } +struct _Sts__DNSProbeMetric +{ + ProtobufCMessage base; + char *serverip; + /* + * State of the server + */ + protobuf_c_boolean has_state; + Sts__StateUpDown state; + /* + * Response latency in ms + */ + protobuf_c_boolean has_latency; + uint32_t latency; +}; +#define STS__DNSPROBE_METRIC__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sts__dnsprobe_metric__descriptor) \ + , NULL, 0, STS__STATE_UP_DOWN__SUD_down, 0, 0 } + + +struct _Sts__VLANMetrics +{ + ProtobufCMessage base; + /* + * The name of the interface (ie: brtrunk.100) + */ + char *vlanif; + /* + * The state of the DHCP server according to that vlan + */ + protobuf_c_boolean has_dhcpstate; + Sts__StateUpDown dhcpstate; + protobuf_c_boolean has_dhcplatency; + uint32_t dhcplatency; + /* + * The state of the DNS server according to that vlan + */ + protobuf_c_boolean has_dnsstate; + Sts__StateUpDown dnsstate; + protobuf_c_boolean has_dnslatency; + uint32_t dnslatency; + /* + * The state of the Radius server according to that vlan + */ + protobuf_c_boolean has_obsv200_radiusstate; + Sts__StateUpDown obsv200_radiusstate; + protobuf_c_boolean has_obsv200_radiuslatency; + uint32_t obsv200_radiuslatency; + /* + * ver=1300 + */ + size_t n_dnsproberesults; + Sts__DNSProbeMetric **dnsproberesults; + /* + * -- duration + */ + /* + *category Network + */ + protobuf_c_boolean has_dur_vlanif; + uint32_t dur_vlanif; + /* + *category Network + */ + protobuf_c_boolean has_dur_dhcpstate; + uint32_t dur_dhcpstate; + /* + *category Network + */ + protobuf_c_boolean has_dur_dhcplatency; + uint32_t dur_dhcplatency; + /* + *category Network + */ + protobuf_c_boolean has_dur_dnsstate; + uint32_t dur_dnsstate; + /* + *category Network + */ + protobuf_c_boolean has_dur_dnslatency; + uint32_t dur_dnslatency; + /* + * optional uint32 obsV200_dur_radiusState = 506; + * optional uint32 obsV200_dur_radiusLatency = 507; + */ + protobuf_c_boolean has_dur_dnsreport; + uint32_t dur_dnsreport; +}; +#define STS__VLANMETRICS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sts__vlanmetrics__descriptor) \ + , NULL, 0, STS__STATE_UP_DOWN__SUD_down, 0, 0, 0, STS__STATE_UP_DOWN__SUD_down, 0, 0, 0, STS__STATE_UP_DOWN__SUD_down, 0, 0, 0,NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +struct _Sts__RADIUSMetrics +{ + ProtobufCMessage base; + protobuf_c_boolean has_serverip; + ProtobufCBinaryData serverip; + protobuf_c_boolean has_noanswer; + uint32_t noanswer; + protobuf_c_boolean has_latencymin; + uint32_t latencymin; + protobuf_c_boolean has_latencymax; + uint32_t latencymax; + protobuf_c_boolean has_latencyave; + uint32_t latencyave; + /* + * -- duration + */ + /* + *category Network + */ + protobuf_c_boolean has_dur_serverip; + uint32_t dur_serverip; + /* + *category Network + */ + protobuf_c_boolean has_dur_noanswer; + uint32_t dur_noanswer; + /* + *category Network + */ + protobuf_c_boolean has_dur_latencymin; + uint32_t dur_latencymin; + /* + *category Network + */ + protobuf_c_boolean has_dur_latencymax; + uint32_t dur_latencymax; + /* + *category Network + */ + protobuf_c_boolean has_dur_latencyave; + uint32_t dur_latencyave; +}; +#define STS__RADIUSMETRICS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sts__radiusmetrics__descriptor) \ + , 0, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } + + +struct _Sts__NetworkProbe +{ + ProtobufCMessage base; + Sts__DNSProbeMetric *dns_probe; + Sts__VLANMetrics *vlan_probe; + Sts__RADIUSMetrics *radius_probe; + protobuf_c_boolean has_timestamp_ms; + uint64_t timestamp_ms; +}; +#define STS__NETWORK_PROBE__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&sts__network_probe__descriptor) \ + , NULL, NULL, NULL, 0, 0 } + + /* * ////////////////////////////////////////////////////////////////////////////// * Overall report that might contain all individual stats reports @@ -955,10 +1178,12 @@ struct _Sts__Report Sts__BSReport **bs_report; size_t n_rssi_report; Sts__RssiReport **rssi_report; + size_t n_network_probe; + Sts__NetworkProbe **network_probe; }; #define STS__REPORT__INIT \ { PROTOBUF_C_MESSAGE_INIT (&sts__report__descriptor) \ - , NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL } + , NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL, 0,NULL } /* Sts__AvgType methods */ @@ -1020,6 +1245,9 @@ void sts__client__tid_stats__sojourn__ /* Sts__Client__TidStats methods */ void sts__client__tid_stats__init (Sts__Client__TidStats *message); +/* Sts__Client__ConnectionEvent methods */ +void sts__client__connection_event__init + (Sts__Client__ConnectionEvent *message); /* Sts__Client methods */ void sts__client__init (Sts__Client *message); @@ -1233,6 +1461,82 @@ Sts__RssiReport * void sts__rssi_report__free_unpacked (Sts__RssiReport *message, ProtobufCAllocator *allocator); +/* Sts__DNSProbeMetric methods */ +void sts__dnsprobe_metric__init + (Sts__DNSProbeMetric *message); +size_t sts__dnsprobe_metric__get_packed_size + (const Sts__DNSProbeMetric *message); +size_t sts__dnsprobe_metric__pack + (const Sts__DNSProbeMetric *message, + uint8_t *out); +size_t sts__dnsprobe_metric__pack_to_buffer + (const Sts__DNSProbeMetric *message, + ProtobufCBuffer *buffer); +Sts__DNSProbeMetric * + sts__dnsprobe_metric__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sts__dnsprobe_metric__free_unpacked + (Sts__DNSProbeMetric *message, + ProtobufCAllocator *allocator); +/* Sts__VLANMetrics methods */ +void sts__vlanmetrics__init + (Sts__VLANMetrics *message); +size_t sts__vlanmetrics__get_packed_size + (const Sts__VLANMetrics *message); +size_t sts__vlanmetrics__pack + (const Sts__VLANMetrics *message, + uint8_t *out); +size_t sts__vlanmetrics__pack_to_buffer + (const Sts__VLANMetrics *message, + ProtobufCBuffer *buffer); +Sts__VLANMetrics * + sts__vlanmetrics__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sts__vlanmetrics__free_unpacked + (Sts__VLANMetrics *message, + ProtobufCAllocator *allocator); +/* Sts__RADIUSMetrics methods */ +void sts__radiusmetrics__init + (Sts__RADIUSMetrics *message); +size_t sts__radiusmetrics__get_packed_size + (const Sts__RADIUSMetrics *message); +size_t sts__radiusmetrics__pack + (const Sts__RADIUSMetrics *message, + uint8_t *out); +size_t sts__radiusmetrics__pack_to_buffer + (const Sts__RADIUSMetrics *message, + ProtobufCBuffer *buffer); +Sts__RADIUSMetrics * + sts__radiusmetrics__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sts__radiusmetrics__free_unpacked + (Sts__RADIUSMetrics *message, + ProtobufCAllocator *allocator); +/* Sts__NetworkProbe methods */ +void sts__network_probe__init + (Sts__NetworkProbe *message); +size_t sts__network_probe__get_packed_size + (const Sts__NetworkProbe *message); +size_t sts__network_probe__pack + (const Sts__NetworkProbe *message, + uint8_t *out); +size_t sts__network_probe__pack_to_buffer + (const Sts__NetworkProbe *message, + ProtobufCBuffer *buffer); +Sts__NetworkProbe * + sts__network_probe__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void sts__network_probe__free_unpacked + (Sts__NetworkProbe *message, + ProtobufCAllocator *allocator); /* Sts__Report methods */ void sts__report__init (Sts__Report *message); @@ -1281,6 +1585,9 @@ typedef void (*Sts__Client__TidStats__So typedef void (*Sts__Client__TidStats_Closure) (const Sts__Client__TidStats *message, void *closure_data); +typedef void (*Sts__Client__ConnectionEvent_Closure) + (const Sts__Client__ConnectionEvent *message, + void *closure_data); typedef void (*Sts__Client_Closure) (const Sts__Client *message, void *closure_data); @@ -1350,6 +1657,18 @@ typedef void (*Sts__RssiPeer_Closure) typedef void (*Sts__RssiReport_Closure) (const Sts__RssiReport *message, void *closure_data); +typedef void (*Sts__DNSProbeMetric_Closure) + (const Sts__DNSProbeMetric *message, + void *closure_data); +typedef void (*Sts__VLANMetrics_Closure) + (const Sts__VLANMetrics *message, + void *closure_data); +typedef void (*Sts__RADIUSMetrics_Closure) + (const Sts__RADIUSMetrics *message, + void *closure_data); +typedef void (*Sts__NetworkProbe_Closure) + (const Sts__NetworkProbe *message, + void *closure_data); typedef void (*Sts__Report_Closure) (const Sts__Report *message, void *closure_data); @@ -1365,11 +1684,14 @@ extern const ProtobufCEnumDescriptor extern const ProtobufCEnumDescriptor sts__chan_width__descriptor; extern const ProtobufCEnumDescriptor sts__wmm_ac__descriptor; extern const ProtobufCEnumDescriptor sts__bsevent_type__descriptor; +extern const ProtobufCEnumDescriptor sts__connection_event_type__descriptor; extern const ProtobufCEnumDescriptor sts__disconnect_src__descriptor; +extern const ProtobufCEnumDescriptor sts__assoc_type__descriptor; extern const ProtobufCEnumDescriptor sts__disconnect_type__descriptor; extern const ProtobufCEnumDescriptor sts__report_type__descriptor; extern const ProtobufCEnumDescriptor sts__fs_type__descriptor; extern const ProtobufCEnumDescriptor sts__diff_type__descriptor; +extern const ProtobufCEnumDescriptor sts__state_up_down__descriptor; extern const ProtobufCMessageDescriptor sts__avg_type__descriptor; extern const ProtobufCMessageDescriptor sts__neighbor__descriptor; extern const ProtobufCMessageDescriptor sts__neighbor__neighbor_bss__descriptor; @@ -1380,6 +1702,7 @@ extern const ProtobufCMessageDescriptor extern const ProtobufCMessageDescriptor sts__client__tx_stats__descriptor; extern const ProtobufCMessageDescriptor sts__client__tid_stats__descriptor; extern const ProtobufCMessageDescriptor sts__client__tid_stats__sojourn__descriptor; +extern const ProtobufCMessageDescriptor sts__client__connection_event__descriptor; extern const ProtobufCMessageDescriptor sts__client_report__descriptor; extern const ProtobufCMessageDescriptor sts__survey__descriptor; extern const ProtobufCMessageDescriptor sts__survey__survey_sample__descriptor; @@ -1403,6 +1726,10 @@ extern const ProtobufCMessageDescriptor extern const ProtobufCMessageDescriptor sts__rssi_peer__rssi_sample__descriptor; extern const ProtobufCEnumDescriptor sts__rssi_peer__rssi_source__descriptor; extern const ProtobufCMessageDescriptor sts__rssi_report__descriptor; +extern const ProtobufCMessageDescriptor sts__dnsprobe_metric__descriptor; +extern const ProtobufCMessageDescriptor sts__vlanmetrics__descriptor; +extern const ProtobufCMessageDescriptor sts__radiusmetrics__descriptor; +extern const ProtobufCMessageDescriptor sts__network_probe__descriptor; extern const ProtobufCMessageDescriptor sts__report__descriptor; PROTOBUF_C__END_DECLS Index: opensync-2.0.5.0/src/lib/datapipeline/src/opensync_stats.pb-c.c =================================================================== --- opensync-2.0.5.0.orig/src/lib/datapipeline/src/opensync_stats.pb-c.c +++ opensync-2.0.5.0/src/lib/datapipeline/src/opensync_stats.pb-c.c @@ -139,6 +139,12 @@ void sts__client__tid_stats__init static const Sts__Client__TidStats init_value = STS__CLIENT__TID_STATS__INIT; *message = init_value; } +void sts__client__connection_event__init + (Sts__Client__ConnectionEvent *message) +{ + static const Sts__Client__ConnectionEvent init_value = STS__CLIENT__CONNECTION_EVENT__INIT; + *message = init_value; +} void sts__client__init (Sts__Client *message) { @@ -628,6 +634,186 @@ void sts__rssi_report__free_unpacked assert(message->base.descriptor == &sts__rssi_report__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } +void sts__dnsprobe_metric__init + (Sts__DNSProbeMetric *message) +{ + static const Sts__DNSProbeMetric init_value = STS__DNSPROBE_METRIC__INIT; + *message = init_value; +} +size_t sts__dnsprobe_metric__get_packed_size + (const Sts__DNSProbeMetric *message) +{ + assert(message->base.descriptor == &sts__dnsprobe_metric__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sts__dnsprobe_metric__pack + (const Sts__DNSProbeMetric *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sts__dnsprobe_metric__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sts__dnsprobe_metric__pack_to_buffer + (const Sts__DNSProbeMetric *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sts__dnsprobe_metric__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sts__DNSProbeMetric * + sts__dnsprobe_metric__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sts__DNSProbeMetric *) + protobuf_c_message_unpack (&sts__dnsprobe_metric__descriptor, + allocator, len, data); +} +void sts__dnsprobe_metric__free_unpacked + (Sts__DNSProbeMetric *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &sts__dnsprobe_metric__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sts__vlanmetrics__init + (Sts__VLANMetrics *message) +{ + static const Sts__VLANMetrics init_value = STS__VLANMETRICS__INIT; + *message = init_value; +} +size_t sts__vlanmetrics__get_packed_size + (const Sts__VLANMetrics *message) +{ + assert(message->base.descriptor == &sts__vlanmetrics__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sts__vlanmetrics__pack + (const Sts__VLANMetrics *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sts__vlanmetrics__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sts__vlanmetrics__pack_to_buffer + (const Sts__VLANMetrics *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sts__vlanmetrics__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sts__VLANMetrics * + sts__vlanmetrics__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sts__VLANMetrics *) + protobuf_c_message_unpack (&sts__vlanmetrics__descriptor, + allocator, len, data); +} +void sts__vlanmetrics__free_unpacked + (Sts__VLANMetrics *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &sts__vlanmetrics__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sts__radiusmetrics__init + (Sts__RADIUSMetrics *message) +{ + static const Sts__RADIUSMetrics init_value = STS__RADIUSMETRICS__INIT; + *message = init_value; +} +size_t sts__radiusmetrics__get_packed_size + (const Sts__RADIUSMetrics *message) +{ + assert(message->base.descriptor == &sts__radiusmetrics__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sts__radiusmetrics__pack + (const Sts__RADIUSMetrics *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sts__radiusmetrics__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sts__radiusmetrics__pack_to_buffer + (const Sts__RADIUSMetrics *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sts__radiusmetrics__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sts__RADIUSMetrics * + sts__radiusmetrics__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sts__RADIUSMetrics *) + protobuf_c_message_unpack (&sts__radiusmetrics__descriptor, + allocator, len, data); +} +void sts__radiusmetrics__free_unpacked + (Sts__RADIUSMetrics *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &sts__radiusmetrics__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void sts__network_probe__init + (Sts__NetworkProbe *message) +{ + static const Sts__NetworkProbe init_value = STS__NETWORK_PROBE__INIT; + *message = init_value; +} +size_t sts__network_probe__get_packed_size + (const Sts__NetworkProbe *message) +{ + assert(message->base.descriptor == &sts__network_probe__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t sts__network_probe__pack + (const Sts__NetworkProbe *message, + uint8_t *out) +{ + assert(message->base.descriptor == &sts__network_probe__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t sts__network_probe__pack_to_buffer + (const Sts__NetworkProbe *message, + ProtobufCBuffer *buffer) +{ + assert(message->base.descriptor == &sts__network_probe__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +Sts__NetworkProbe * + sts__network_probe__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (Sts__NetworkProbe *) + protobuf_c_message_unpack (&sts__network_probe__descriptor, + allocator, len, data); +} +void sts__network_probe__free_unpacked + (Sts__NetworkProbe *message, + ProtobufCAllocator *allocator) +{ + if(!message) + return; + assert(message->base.descriptor == &sts__network_probe__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} void sts__report__init (Sts__Report *message) { @@ -1639,7 +1825,188 @@ const ProtobufCMessageDescriptor sts__cl (ProtobufCMessageInit) sts__client__tid_stats__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor sts__client__field_descriptors[13] = +static const ProtobufCFieldDescriptor sts__client__connection_event__field_descriptors[12] = +{ + { + "type", + 1, + PROTOBUF_C_LABEL_REQUIRED, + PROTOBUF_C_TYPE_ENUM, + 0, /* quantifier_offset */ + offsetof(Sts__Client__ConnectionEvent, type), + &sts__connection_event_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "sta_mac", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sts__Client__ConnectionEvent, sta_mac), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_id", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT64, + offsetof(Sts__Client__ConnectionEvent, has_session_id), + offsetof(Sts__Client__ConnectionEvent, session_id), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "ssid", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sts__Client__ConnectionEvent, ssid), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "band", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sts__Client__ConnectionEvent, has_band), + offsetof(Sts__Client__ConnectionEvent, band), + &sts__radio_band_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "assoc_type", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sts__Client__ConnectionEvent, has_assoc_type), + offsetof(Sts__Client__ConnectionEvent, assoc_type), + &sts__assoc_type__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "status", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__Client__ConnectionEvent, has_status), + offsetof(Sts__Client__ConnectionEvent, status), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "rssi", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_INT32, + offsetof(Sts__Client__ConnectionEvent, has_rssi), + offsetof(Sts__Client__ConnectionEvent, rssi), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "internal_sc", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__Client__ConnectionEvent, has_internal_sc), + offsetof(Sts__Client__ConnectionEvent, internal_sc), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "using11k", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(Sts__Client__ConnectionEvent, has_using11k), + offsetof(Sts__Client__ConnectionEvent, using11k), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "using11r", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(Sts__Client__ConnectionEvent, has_using11r), + offsetof(Sts__Client__ConnectionEvent, using11r), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "using11v", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + offsetof(Sts__Client__ConnectionEvent, has_using11v), + offsetof(Sts__Client__ConnectionEvent, using11v), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sts__client__connection_event__field_indices_by_name[] = { + 5, /* field[5] = assoc_type */ + 4, /* field[4] = band */ + 8, /* field[8] = internal_sc */ + 7, /* field[7] = rssi */ + 2, /* field[2] = session_id */ + 3, /* field[3] = ssid */ + 1, /* field[1] = sta_mac */ + 6, /* field[6] = status */ + 0, /* field[0] = type */ + 9, /* field[9] = using11k */ + 10, /* field[10] = using11r */ + 11, /* field[11] = using11v */ +}; +static const ProtobufCIntRange sts__client__connection_event__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 12 } +}; +const ProtobufCMessageDescriptor sts__client__connection_event__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sts.Client.ConnectionEvent", + "ConnectionEvent", + "Sts__Client__ConnectionEvent", + "sts", + sizeof(Sts__Client__ConnectionEvent), + 12, + sts__client__connection_event__field_descriptors, + sts__client__connection_event__field_indices_by_name, + 1, sts__client__connection_event__number_ranges, + (ProtobufCMessageInit) sts__client__connection_event__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sts__client__field_descriptors[14] = { { "mac_address", @@ -1797,6 +2164,18 @@ static const ProtobufCFieldDescriptor st 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "event_list", + 14, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sts__Client, n_event_list), + offsetof(Sts__Client, event_list), + &sts__client__connection_event__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned sts__client__field_indices_by_name[] = { 3, /* field[3] = connect_count */ @@ -1805,6 +2184,7 @@ static const unsigned sts__client__field 4, /* field[4] = disconnect_count */ 6, /* field[6] = disconnect_offset_ms */ 7, /* field[7] = duration_ms */ + 13, /* field[13] = event_list */ 0, /* field[0] = mac_address */ 9, /* field[9] = rx_stats */ 1, /* field[1] = ssid */ @@ -1816,7 +2196,7 @@ static const unsigned sts__client__field static const ProtobufCIntRange sts__client__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 13 } + { 0, 14 } }; const ProtobufCMessageDescriptor sts__client__descriptor = { @@ -1826,7 +2206,7 @@ const ProtobufCMessageDescriptor sts__cl "Sts__Client", "sts", sizeof(Sts__Client), - 13, + 14, sts__client__field_descriptors, sts__client__field_indices_by_name, 1, sts__client__number_ranges, @@ -4168,7 +4548,513 @@ const ProtobufCMessageDescriptor sts__rs (ProtobufCMessageInit) sts__rssi_report__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor sts__report__field_descriptors[8] = +static const ProtobufCFieldDescriptor sts__dnsprobe_metric__field_descriptors[3] = +{ + { + "serverIP", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sts__DNSProbeMetric, serverip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "state", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sts__DNSProbeMetric, has_state), + offsetof(Sts__DNSProbeMetric, state), + &sts__state_up_down__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "latency", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__DNSProbeMetric, has_latency), + offsetof(Sts__DNSProbeMetric, latency), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sts__dnsprobe_metric__field_indices_by_name[] = { + 2, /* field[2] = latency */ + 0, /* field[0] = serverIP */ + 1, /* field[1] = state */ +}; +static const ProtobufCIntRange sts__dnsprobe_metric__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor sts__dnsprobe_metric__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sts.DNSProbeMetric", + "DNSProbeMetric", + "Sts__DNSProbeMetric", + "sts", + sizeof(Sts__DNSProbeMetric), + 3, + sts__dnsprobe_metric__field_descriptors, + sts__dnsprobe_metric__field_indices_by_name, + 1, sts__dnsprobe_metric__number_ranges, + (ProtobufCMessageInit) sts__dnsprobe_metric__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sts__vlanmetrics__field_descriptors[14] = +{ + { + "vlanIF", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + offsetof(Sts__VLANMetrics, vlanif), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcpState", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sts__VLANMetrics, has_dhcpstate), + offsetof(Sts__VLANMetrics, dhcpstate), + &sts__state_up_down__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dhcpLatency", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dhcplatency), + offsetof(Sts__VLANMetrics, dhcplatency), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dnsState", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sts__VLANMetrics, has_dnsstate), + offsetof(Sts__VLANMetrics, dnsstate), + &sts__state_up_down__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dnsLatency", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dnslatency), + offsetof(Sts__VLANMetrics, dnslatency), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "obsV200_radiusState", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_ENUM, + offsetof(Sts__VLANMetrics, has_obsv200_radiusstate), + offsetof(Sts__VLANMetrics, obsv200_radiusstate), + &sts__state_up_down__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "obsV200_radiusLatency", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_obsv200_radiuslatency), + offsetof(Sts__VLANMetrics, obsv200_radiuslatency), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dnsProbeResults", + 8, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sts__VLANMetrics, n_dnsproberesults), + offsetof(Sts__VLANMetrics, dnsproberesults), + &sts__dnsprobe_metric__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_vlanIF", + 501, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dur_vlanif), + offsetof(Sts__VLANMetrics, dur_vlanif), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_dhcpState", + 502, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dur_dhcpstate), + offsetof(Sts__VLANMetrics, dur_dhcpstate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_dhcpLatency", + 503, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dur_dhcplatency), + offsetof(Sts__VLANMetrics, dur_dhcplatency), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_dnsState", + 504, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dur_dnsstate), + offsetof(Sts__VLANMetrics, dur_dnsstate), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_dnsLatency", + 505, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dur_dnslatency), + offsetof(Sts__VLANMetrics, dur_dnslatency), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_dnsReport", + 508, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__VLANMetrics, has_dur_dnsreport), + offsetof(Sts__VLANMetrics, dur_dnsreport), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sts__vlanmetrics__field_indices_by_name[] = { + 2, /* field[2] = dhcpLatency */ + 1, /* field[1] = dhcpState */ + 4, /* field[4] = dnsLatency */ + 7, /* field[7] = dnsProbeResults */ + 3, /* field[3] = dnsState */ + 10, /* field[10] = dur_dhcpLatency */ + 9, /* field[9] = dur_dhcpState */ + 12, /* field[12] = dur_dnsLatency */ + 13, /* field[13] = dur_dnsReport */ + 11, /* field[11] = dur_dnsState */ + 8, /* field[8] = dur_vlanIF */ + 6, /* field[6] = obsV200_radiusLatency */ + 5, /* field[5] = obsV200_radiusState */ + 0, /* field[0] = vlanIF */ +}; +static const ProtobufCIntRange sts__vlanmetrics__number_ranges[3 + 1] = +{ + { 1, 0 }, + { 501, 8 }, + { 508, 13 }, + { 0, 14 } +}; +const ProtobufCMessageDescriptor sts__vlanmetrics__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sts.VLANMetrics", + "VLANMetrics", + "Sts__VLANMetrics", + "sts", + sizeof(Sts__VLANMetrics), + 14, + sts__vlanmetrics__field_descriptors, + sts__vlanmetrics__field_indices_by_name, + 3, sts__vlanmetrics__number_ranges, + (ProtobufCMessageInit) sts__vlanmetrics__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sts__radiusmetrics__field_descriptors[10] = +{ + { + "serverIP", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + offsetof(Sts__RADIUSMetrics, has_serverip), + offsetof(Sts__RADIUSMetrics, serverip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "noAnswer", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_noanswer), + offsetof(Sts__RADIUSMetrics, noanswer), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "latencyMin", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_latencymin), + offsetof(Sts__RADIUSMetrics, latencymin), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "latencyMax", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_latencymax), + offsetof(Sts__RADIUSMetrics, latencymax), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "latencyAve", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_latencyave), + offsetof(Sts__RADIUSMetrics, latencyave), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_serverIP", + 501, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_dur_serverip), + offsetof(Sts__RADIUSMetrics, dur_serverip), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_noAnswer", + 502, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_dur_noanswer), + offsetof(Sts__RADIUSMetrics, dur_noanswer), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_latencyMin", + 503, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_dur_latencymin), + offsetof(Sts__RADIUSMetrics, dur_latencymin), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_latencyMax", + 504, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_dur_latencymax), + offsetof(Sts__RADIUSMetrics, dur_latencymax), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "dur_latencyAve", + 505, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + offsetof(Sts__RADIUSMetrics, has_dur_latencyave), + offsetof(Sts__RADIUSMetrics, dur_latencyave), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sts__radiusmetrics__field_indices_by_name[] = { + 9, /* field[9] = dur_latencyAve */ + 8, /* field[8] = dur_latencyMax */ + 7, /* field[7] = dur_latencyMin */ + 6, /* field[6] = dur_noAnswer */ + 5, /* field[5] = dur_serverIP */ + 4, /* field[4] = latencyAve */ + 3, /* field[3] = latencyMax */ + 2, /* field[2] = latencyMin */ + 1, /* field[1] = noAnswer */ + 0, /* field[0] = serverIP */ +}; +static const ProtobufCIntRange sts__radiusmetrics__number_ranges[2 + 1] = +{ + { 1, 0 }, + { 501, 5 }, + { 0, 10 } +}; +const ProtobufCMessageDescriptor sts__radiusmetrics__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sts.RADIUSMetrics", + "RADIUSMetrics", + "Sts__RADIUSMetrics", + "sts", + sizeof(Sts__RADIUSMetrics), + 10, + sts__radiusmetrics__field_descriptors, + sts__radiusmetrics__field_indices_by_name, + 2, sts__radiusmetrics__number_ranges, + (ProtobufCMessageInit) sts__radiusmetrics__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sts__network_probe__field_descriptors[4] = +{ + { + "dns_probe", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sts__NetworkProbe, dns_probe), + &sts__dnsprobe_metric__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "vlan_probe", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sts__NetworkProbe, vlan_probe), + &sts__vlanmetrics__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "radius_probe", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + offsetof(Sts__NetworkProbe, radius_probe), + &sts__radiusmetrics__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "timestamp_ms", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT64, + offsetof(Sts__NetworkProbe, has_timestamp_ms), + offsetof(Sts__NetworkProbe, timestamp_ms), + NULL, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned sts__network_probe__field_indices_by_name[] = { + 0, /* field[0] = dns_probe */ + 2, /* field[2] = radius_probe */ + 3, /* field[3] = timestamp_ms */ + 1, /* field[1] = vlan_probe */ +}; +static const ProtobufCIntRange sts__network_probe__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor sts__network_probe__descriptor = +{ + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, + "sts.NetworkProbe", + "NetworkProbe", + "Sts__NetworkProbe", + "sts", + sizeof(Sts__NetworkProbe), + 4, + sts__network_probe__field_descriptors, + sts__network_probe__field_indices_by_name, + 1, sts__network_probe__number_ranges, + (ProtobufCMessageInit) sts__network_probe__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor sts__report__field_descriptors[9] = { { "nodeID", @@ -4266,6 +5152,18 @@ static const ProtobufCFieldDescriptor st 0, /* flags */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "network_probe", + 101, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_MESSAGE, + offsetof(Sts__Report, n_network_probe), + offsetof(Sts__Report, network_probe), + &sts__network_probe__descriptor, + NULL, + 0, /* flags */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned sts__report__field_indices_by_name[] = { 6, /* field[6] = bs_report */ @@ -4273,14 +5171,16 @@ static const unsigned sts__report__field 4, /* field[4] = clients */ 5, /* field[5] = device */ 3, /* field[3] = neighbors */ + 8, /* field[8] = network_probe */ 0, /* field[0] = nodeID */ 7, /* field[7] = rssi_report */ 1, /* field[1] = survey */ }; -static const ProtobufCIntRange sts__report__number_ranges[1 + 1] = +static const ProtobufCIntRange sts__report__number_ranges[2 + 1] = { { 1, 0 }, - { 0, 8 } + { 101, 8 }, + { 0, 9 } }; const ProtobufCMessageDescriptor sts__report__descriptor = { @@ -4290,10 +5190,10 @@ const ProtobufCMessageDescriptor sts__re "Sts__Report", "sts", sizeof(Sts__Report), - 8, + 9, sts__report__field_descriptors, sts__report__field_indices_by_name, - 1, sts__report__number_ranges, + 2, sts__report__number_ranges, (ProtobufCMessageInit) sts__report__init, NULL,NULL,NULL /* reserved[123] */ }; @@ -4539,6 +5439,46 @@ const ProtobufCEnumDescriptor sts__bseve sts__bsevent_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; +static const ProtobufCEnumValue sts__connection_event_type__enum_values_by_number[8] = +{ + { "CLIENT_ASSOC", "STS__CONNECTION_EVENT_TYPE__CLIENT_ASSOC", 0 }, + { "CLIENT_AUTH", "STS__CONNECTION_EVENT_TYPE__CLIENT_AUTH", 1 }, + { "CLIENT_DISCONNECT", "STS__CONNECTION_EVENT_TYPE__CLIENT_DISCONNECT", 2 }, + { "CLIENT_FAILURE", "STS__CONNECTION_EVENT_TYPE__CLIENT_FAILURE", 3 }, + { "CLIENT_FIRST_DATA", "STS__CONNECTION_EVENT_TYPE__CLIENT_FIRST_DATA", 4 }, + { "CLIEND_ID", "STS__CONNECTION_EVENT_TYPE__CLIEND_ID", 5 }, + { "CLIENT_IP", "STS__CONNECTION_EVENT_TYPE__CLIENT_IP", 6 }, + { "CLIENT_TIMEOUT", "STS__CONNECTION_EVENT_TYPE__CLIENT_TIMEOUT", 7 }, +}; +static const ProtobufCIntRange sts__connection_event_type__value_ranges[] = { +{0, 0},{0, 8} +}; +static const ProtobufCEnumValueIndex sts__connection_event_type__enum_values_by_name[8] = +{ + { "CLIEND_ID", 5 }, + { "CLIENT_ASSOC", 0 }, + { "CLIENT_AUTH", 1 }, + { "CLIENT_DISCONNECT", 2 }, + { "CLIENT_FAILURE", 3 }, + { "CLIENT_FIRST_DATA", 4 }, + { "CLIENT_IP", 6 }, + { "CLIENT_TIMEOUT", 7 }, +}; +const ProtobufCEnumDescriptor sts__connection_event_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sts.ConnectionEventType", + "ConnectionEventType", + "Sts__ConnectionEventType", + "sts", + 8, + sts__connection_event_type__enum_values_by_number, + 8, + sts__connection_event_type__enum_values_by_name, + 1, + sts__connection_event_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; static const ProtobufCEnumValue sts__disconnect_src__enum_values_by_number[2] = { { "LOCAL", "STS__DISCONNECT_SRC__LOCAL", 0 }, @@ -4567,6 +5507,34 @@ const ProtobufCEnumDescriptor sts__disco sts__disconnect_src__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; +static const ProtobufCEnumValue sts__assoc_type__enum_values_by_number[2] = +{ + { "ASSOC", "STS__ASSOC_TYPE__ASSOC", 0 }, + { "REASSOC", "STS__ASSOC_TYPE__REASSOC", 1 }, +}; +static const ProtobufCIntRange sts__assoc_type__value_ranges[] = { +{0, 0},{0, 2} +}; +static const ProtobufCEnumValueIndex sts__assoc_type__enum_values_by_name[2] = +{ + { "ASSOC", 0 }, + { "REASSOC", 1 }, +}; +const ProtobufCEnumDescriptor sts__assoc_type__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sts.AssocType", + "AssocType", + "Sts__AssocType", + "sts", + 2, + sts__assoc_type__enum_values_by_number, + 2, + sts__assoc_type__enum_values_by_name, + 1, + sts__assoc_type__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +}; static const ProtobufCEnumValue sts__disconnect_type__enum_values_by_number[2] = { { "DISASSOC", "STS__DISCONNECT_TYPE__DISASSOC", 0 }, @@ -4685,3 +5653,33 @@ const ProtobufCEnumDescriptor sts__diff_ sts__diff_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; +static const ProtobufCEnumValue sts__state_up_down__enum_values_by_number[3] = +{ + { "SUD_down", "STS__STATE_UP_DOWN__SUD_down", 0 }, + { "SUD_up", "STS__STATE_UP_DOWN__SUD_up", 1 }, + { "SUD_error", "STS__STATE_UP_DOWN__SUD_error", 2 }, +}; +static const ProtobufCIntRange sts__state_up_down__value_ranges[] = { +{0, 0},{0, 3} +}; +static const ProtobufCEnumValueIndex sts__state_up_down__enum_values_by_name[3] = +{ + { "SUD_down", 0 }, + { "SUD_error", 2 }, + { "SUD_up", 1 }, +}; +const ProtobufCEnumDescriptor sts__state_up_down__descriptor = +{ + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, + "sts.StateUpDown", + "StateUpDown", + "Sts__StateUpDown", + "sts", + 3, + sts__state_up_down__enum_values_by_number, + 3, + sts__state_up_down__enum_values_by_name, + 1, + sts__state_up_down__value_ranges, + NULL,NULL,NULL,NULL /* reserved[1234] */ +};