int analyzer_eap_ce_priv_cleanup(void *obj, void *priv) {
struct analyzer *analyzer = obj;
struct analyzer_eap_ce_priv *cpriv = priv;
int res = analyzer_eap_finalize(analyzer->priv, cpriv);
if (cpriv->evt_request)
event_refcount_dec(cpriv->evt_request);
if (cpriv->evt_response)
event_refcount_dec(cpriv->evt_response);
if (cpriv->evt_result)
event_refcount_dec(cpriv->evt_result);
if (cpriv->client)
ptype_cleanup(cpriv->client);
if (cpriv->server)
ptype_cleanup(cpriv->server);
if (cpriv->vlan)
ptype_cleanup(cpriv->vlan);
free(priv);
return res;
}
int event_process_end(struct event *evt) {
debug_event("Processing event end %s", evt->reg->info->name);
if (!(evt->flags & EVENT_FLAG_PROCESS_BEGAN)) {
pomlog(POMLOG_ERR "Internal error: event %s processing hasn't begun", evt->reg->info->name);
event_cleanup(evt);
return POM_ERR;
}
if (evt->flags & EVENT_FLAG_PROCESS_DONE) {
pomlog(POMLOG_ERR "Internal error: event %s has already been processed entirely", evt->reg->info->name);
event_cleanup(evt);
return POM_ERR;
}
struct event_listener *lst;
for (lst = evt->reg->listeners; lst; lst = lst->next) {
if (lst->process_end && lst->process_end(evt, lst->obj) != POM_OK) {
pomlog(POMLOG_WARN "An error occured while processing event %s", evt->reg->info->name);
}
}
for (lst = evt->tmp_listeners; lst; lst = lst->next) {
if (lst->process_end && lst->process_end(evt, lst->obj) != POM_OK) {
pomlog(POMLOG_WARN "An error occured while processing event %s", evt->reg->info->name);
}
registry_perf_dec(evt->reg->perf_listeners, 1);
}
evt->ce = NULL;
evt->flags |= EVENT_FLAG_PROCESS_DONE;
registry_perf_dec(evt->reg->perf_ongoing, 1);
registry_perf_inc(evt->reg->perf_processed, 1);
return event_refcount_dec(evt);
}
int analyzer_ppp_pap_finalize(struct analyzer_ppp_pap_priv *apriv, struct analyzer_ppp_pap_ce_priv *cpriv) {
if (!cpriv->evt_request)
return POM_OK;
struct event *evt = NULL;
struct data *evt_data = NULL;
struct data *evt_req_data = event_get_data(cpriv->evt_request);
evt = event_alloc(apriv->evt_auth);
if (!evt)
return POM_ERR;
evt_data = event_get_data(evt);
if (ptype_copy(evt_data[analyzer_ppp_pap_auth_peer_id].value, evt_req_data[evt_ppp_pap_request_peer_id].value) != POM_OK) {
event_cleanup(evt);
return POM_ERR;
}
data_set(evt_data[analyzer_ppp_pap_auth_peer_id]);
if (ptype_copy(evt_data[analyzer_ppp_pap_auth_password].value, evt_req_data[evt_ppp_pap_request_password].value) != POM_OK) {
event_cleanup(evt);
return POM_ERR;
}
data_set(evt_data[analyzer_ppp_pap_auth_password]);
if (cpriv->client) {
evt_data[analyzer_ppp_pap_auth_client].value = cpriv->client;
data_set(evt_data[analyzer_ppp_pap_auth_client]);
data_do_clean(evt_data[analyzer_ppp_pap_auth_client]);
cpriv->client = NULL;
}
if (cpriv->server) {
evt_data[analyzer_ppp_pap_auth_server].value = cpriv->server;
data_set(evt_data[analyzer_ppp_pap_auth_server]);
data_do_clean(evt_data[analyzer_ppp_pap_auth_server]);
cpriv->server = NULL;
}
if (cpriv->vlan) {
evt_data[analyzer_ppp_pap_auth_vlan].value = cpriv->vlan;
data_set(evt_data[analyzer_ppp_pap_auth_vlan]);
data_do_clean(evt_data[analyzer_ppp_pap_auth_vlan]);
cpriv->vlan = NULL;
}
if (cpriv->top_proto) {
PTYPE_STRING_SETVAL(evt_data[analyzer_ppp_pap_auth_top_proto].value, cpriv->top_proto);
data_set(evt_data[analyzer_ppp_pap_auth_top_proto]);
}
if (ptype_copy(evt_data[analyzer_ppp_pap_auth_identifier].value, evt_req_data[evt_ppp_pap_request_identifier].value) != POM_OK) {
event_cleanup(evt);
return POM_ERR;
}
data_set(evt_data[analyzer_ppp_pap_auth_identifier]);
if (cpriv->evt_ack_nack) {
struct data *evt_ack_data = event_get_data(cpriv->evt_ack_nack);
uint8_t code = *PTYPE_UINT8_GETVAL(evt_ack_data[evt_ppp_pap_ack_nack_code].value);
if (code == 2) {
PTYPE_BOOL_SETVAL(evt_data[analyzer_ppp_pap_auth_success].value, 1);
} else {
PTYPE_BOOL_SETVAL(evt_data[analyzer_ppp_pap_auth_success].value, 0);
}
data_set(evt_data[analyzer_ppp_pap_auth_success]);
event_refcount_dec(cpriv->evt_ack_nack);
cpriv->evt_ack_nack = NULL;
}
ptime ts = event_get_timestamp(cpriv->evt_request);
event_refcount_dec(cpriv->evt_request);
cpriv->evt_request = NULL;
return event_process(evt, NULL, 0, ts);
}
int analyzer_eap_finalize(struct analyzer_eap_priv *apriv, struct analyzer_eap_ce_priv *cpriv) {
if (!cpriv->evt_request || !cpriv->evt_response)
return POM_OK;
struct event *evt = NULL;
struct data *evt_data = NULL;
struct data *evt_req_data = event_get_data(cpriv->evt_request);
struct data *evt_rsp_data = event_get_data(cpriv->evt_response);
if (!data_is_set(evt_rsp_data[evt_eap_md5_challenge_value]))
return POM_OK;
if (!data_is_set(evt_req_data[evt_eap_md5_challenge_value]))
return POM_OK;
evt = event_alloc(apriv->evt_md5_auth);
if (!evt)
return POM_ERR;
evt_data = event_get_data(evt);
if (ptype_copy(evt_data[analyzer_eap_md5_challenge].value, evt_req_data[evt_eap_md5_challenge_value].value) != POM_OK)
return POM_ERR;
data_set(evt_data[analyzer_eap_md5_challenge]);
if (ptype_copy(evt_data[analyzer_eap_md5_response].value, evt_rsp_data[evt_eap_md5_challenge_value].value) != POM_OK)
return POM_ERR;
data_set(evt_data[analyzer_eap_md5_response]);
if (cpriv->client) {
evt_data[analyzer_eap_common_client].value = cpriv->client;
data_set(evt_data[analyzer_eap_common_client]);
data_do_clean(evt_data[analyzer_eap_common_client]);
cpriv->client = NULL;
}
if (cpriv->server) {
evt_data[analyzer_eap_common_server].value = cpriv->server;
data_set(evt_data[analyzer_eap_common_server]);
data_do_clean(evt_data[analyzer_eap_common_server]);
cpriv->server = NULL;
}
if (cpriv->vlan) {
evt_data[analyzer_eap_common_vlan].value = cpriv->vlan;
data_set(evt_data[analyzer_eap_common_vlan]);
data_do_clean(evt_data[analyzer_eap_common_vlan]);
cpriv->vlan = NULL;
}
if (cpriv->top_proto) {
PTYPE_STRING_SETVAL(evt_data[analyzer_eap_common_top_proto].value, cpriv->top_proto);
data_set(evt_data[analyzer_eap_common_top_proto]);
}
if (ptype_copy(evt_data[analyzer_eap_common_identifier].value, evt_req_data[evt_eap_common_identifier].value) != POM_OK)
return POM_ERR;
data_set(evt_data[analyzer_eap_common_identifier]);
if (!data_is_set(evt_rsp_data[evt_eap_md5_challenge_name]))
return POM_OK;
if (ptype_copy(evt_data[analyzer_eap_common_username].value, evt_rsp_data[evt_eap_md5_challenge_name].value) != POM_OK)
return POM_ERR;
data_set(evt_data[analyzer_eap_common_username]);
if (cpriv->evt_result) {
struct data *evt_res_data = event_get_data(cpriv->evt_result);
ptype_copy(evt_data[analyzer_eap_common_success].value, evt_res_data[evt_eap_success_failure_success].value);
data_set(evt_data[analyzer_eap_common_success]);
event_refcount_dec(cpriv->evt_result);
cpriv->evt_result = NULL;
}
ptime ts = event_get_timestamp(cpriv->evt_response);
event_refcount_dec(cpriv->evt_request);
cpriv->evt_request = NULL;
event_refcount_dec(cpriv->evt_response);
cpriv->evt_response = NULL;
return event_process(evt, NULL, 0, ts);
}
