840 lines
23 KiB
C
840 lines
23 KiB
C
#include "ac.h"
|
|
#include "capwap_dfa.h"
|
|
#include "ac_backend.h"
|
|
#include "ac_soap.h"
|
|
#include "ac_session.h"
|
|
#include <json/json.h>
|
|
|
|
/* */
|
|
#define AC_BACKEND_WAIT_TIMEOUT 10000
|
|
#define SOAP_PROTOCOL_RESPONSE_WAIT_EVENT_TIMEOUT 70000
|
|
|
|
/* */
|
|
struct ac_backend_t {
|
|
pthread_t threadid;
|
|
int endthread;
|
|
|
|
capwap_event_t wait;
|
|
capwap_lock_t lock;
|
|
capwap_lock_t backendlock;
|
|
|
|
/* Backend Soap */
|
|
int activebackend;
|
|
int backendstatus;
|
|
int errorjoinbackend;
|
|
|
|
/* Session */
|
|
char* backendsessionid;
|
|
|
|
/* Soap Request */
|
|
struct ac_http_soap_request* soaprequest;
|
|
};
|
|
|
|
static struct ac_backend_t g_ac_backend;
|
|
|
|
/* */
|
|
static int ac_backend_parsing_closewtpsession_event(const char* idevent, struct json_object* jsonparams) {
|
|
int result = 0;
|
|
struct ac_session_t* session;
|
|
struct json_object* jsonwtpid;
|
|
|
|
/* Params CloseWTPSession Action
|
|
{
|
|
WTPId: [string]
|
|
}
|
|
*/
|
|
|
|
/* WTPId */
|
|
jsonwtpid = compat_json_object_object_get(jsonparams, "WTPId");
|
|
if (!jsonwtpid || (json_object_get_type(jsonwtpid) != json_type_string)) {
|
|
return 0;
|
|
}
|
|
|
|
/* Get session */
|
|
session = ac_search_session_from_wtpid(json_object_get_string(jsonwtpid));
|
|
if (session) {
|
|
struct ac_session_notify_event_t notify;
|
|
|
|
/* Notify Request to Complete Event */
|
|
strcpy(notify.idevent, idevent);
|
|
notify.action = NOTIFY_ACTION_CHANGE_STATE;
|
|
notify.session_state = CAPWAP_DEAD_STATE;
|
|
ac_session_send_action(session, AC_SESSION_ACTION_NOTIFY_EVENT, 0, (void*)¬ify, sizeof(struct ac_session_notify_event_t));
|
|
|
|
/* Async close session */
|
|
capwap_logging_debug("Receive close wtp session for WTP %s", session->wtpid);
|
|
ac_session_send_action(session, AC_SESSION_ACTION_CLOSE, 0, NULL, 0);
|
|
|
|
/* */
|
|
ac_session_release_reference(session);
|
|
result = 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_parsing_resetwtp_event(const char* idevent, struct json_object* jsonparams) {
|
|
int result = 0;
|
|
struct ac_session_t* session;
|
|
struct json_object* jsonwtpid;
|
|
struct json_object* jsonimage;
|
|
struct json_object* jsonvendor;
|
|
struct json_object* jsondata;
|
|
|
|
/* Params ResetWTP Action
|
|
{
|
|
WTPId: [string],
|
|
ImageIdentifier: {
|
|
Vendor: [int],
|
|
Data: [string]
|
|
}
|
|
}
|
|
*/
|
|
|
|
/* WTPId */
|
|
jsonwtpid = compat_json_object_object_get(jsonparams, "WTPId");
|
|
if (!jsonwtpid || (json_object_get_type(jsonwtpid) != json_type_string)) {
|
|
return 0;
|
|
}
|
|
|
|
/* ImageIdentifier */
|
|
jsonimage = compat_json_object_object_get(jsonparams, "ImageIdentifier");
|
|
if (!jsonimage || (json_object_get_type(jsonimage) != json_type_object)) {
|
|
return 0;
|
|
}
|
|
|
|
jsonvendor = compat_json_object_object_get(jsonimage, "Vendor");
|
|
jsondata = compat_json_object_object_get(jsonimage, "Data");
|
|
if (!jsonvendor || !jsondata || (json_object_get_type(jsonvendor) != json_type_int) || (json_object_get_type(jsondata) != json_type_string)) {
|
|
return 0;
|
|
}
|
|
|
|
/* Get session */
|
|
session = ac_search_session_from_wtpid(json_object_get_string(jsonwtpid));
|
|
if (session) {
|
|
const char* name = json_object_get_string(jsondata);
|
|
if (name && *name) {
|
|
int length;
|
|
struct ac_notify_reset_t* reset;
|
|
struct ac_session_notify_event_t notify;
|
|
|
|
/* Notification data */
|
|
length = sizeof(struct ac_notify_reset_t) + strlen(name) + 1;
|
|
reset = (struct ac_notify_reset_t*)capwap_alloc(length);
|
|
|
|
/* */
|
|
reset->vendor = (uint32_t)json_object_get_int(jsonvendor);
|
|
strcpy((char*)reset->name, name);
|
|
|
|
/* Notify Request to Complete Event */
|
|
strcpy(notify.idevent, idevent);
|
|
notify.action = NOTIFY_ACTION_CHANGE_STATE;
|
|
notify.session_state = CAPWAP_DEAD_STATE;
|
|
ac_session_send_action(session, AC_SESSION_ACTION_NOTIFY_EVENT, 0, (void*)¬ify, sizeof(struct ac_session_notify_event_t));
|
|
|
|
/* Notify Action */
|
|
capwap_logging_debug("Receive reset request for WTP %s", session->wtpid);
|
|
ac_session_send_action(session, AC_SESSION_ACTION_RESET_WTP, 0, (void*)reset, length);
|
|
result = 1;
|
|
|
|
/* */
|
|
capwap_free(reset);
|
|
}
|
|
|
|
ac_session_release_reference(session);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_parsing_addwlan_event(const char* idevent, struct json_object* jsonparams) {
|
|
int result = 0;
|
|
struct ac_session_t* session;
|
|
struct json_object* jsonwtpid;
|
|
struct json_object* jsonradioid;
|
|
struct json_object* jsonwlanid;
|
|
struct json_object* jsoncapability;
|
|
struct json_object* jsonqos;
|
|
struct json_object* jsonauthtype;
|
|
struct json_object* jsonmacmode;
|
|
struct json_object* jsontunnelmode;
|
|
struct json_object* jsonhidessid;
|
|
struct json_object* jsonssid;
|
|
const char* ssid;
|
|
|
|
/* Params AddWLAN Action
|
|
{
|
|
WTPId: [string],
|
|
RadioId: [int],
|
|
VirtualAPId: [int],
|
|
Capability: [int],
|
|
Key: {
|
|
TODO
|
|
},
|
|
DefaultQoS: [int],
|
|
AuthType: [int],
|
|
MACMode: [int],
|
|
TunnelMode: [int],
|
|
SuppressSSID: [bool],
|
|
SSID: [string],
|
|
IE: {
|
|
TODO
|
|
}
|
|
}
|
|
*/
|
|
|
|
/* WTPId */
|
|
jsonwtpid = compat_json_object_object_get(jsonparams, "WTPId");
|
|
if (!jsonwtpid || (json_object_get_type(jsonwtpid) != json_type_string)) {
|
|
return 0;
|
|
}
|
|
|
|
/* RadioId */
|
|
jsonradioid = compat_json_object_object_get(jsonparams, "RadioId");
|
|
if (!jsonradioid || (json_object_get_type(jsonradioid) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* VirtualAPId */
|
|
jsonwlanid = compat_json_object_object_get(jsonparams, "VirtualAPId");
|
|
if (!jsonwlanid || (json_object_get_type(jsonwlanid) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* Capability */
|
|
jsoncapability = compat_json_object_object_get(jsonparams, "Capability");
|
|
if (!jsoncapability || (json_object_get_type(jsoncapability) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* Key */
|
|
/* TODO */
|
|
|
|
/* DefaultQoS */
|
|
jsonqos = compat_json_object_object_get(jsonparams, "DefaultQoS");
|
|
if (!jsonqos || (json_object_get_type(jsonqos) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* AuthType */
|
|
jsonauthtype = compat_json_object_object_get(jsonparams, "AuthType");
|
|
if (!jsonauthtype || (json_object_get_type(jsonauthtype) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* MACMode */
|
|
jsonmacmode = compat_json_object_object_get(jsonparams, "MACMode");
|
|
if (!jsonmacmode || (json_object_get_type(jsonmacmode) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* TunnelMode */
|
|
jsontunnelmode = compat_json_object_object_get(jsonparams, "TunnelMode");
|
|
if (!jsontunnelmode || (json_object_get_type(jsontunnelmode) != json_type_int)) {
|
|
return 0;
|
|
}
|
|
|
|
/* SuppressSSID */
|
|
jsonhidessid = compat_json_object_object_get(jsonparams, "SuppressSSID");
|
|
if (!jsonhidessid || (json_object_get_type(jsonhidessid) != json_type_boolean)) {
|
|
return 0;
|
|
}
|
|
|
|
/* SSID */
|
|
jsonssid = compat_json_object_object_get(jsonparams, "SSID");
|
|
if (jsonssid && (json_object_get_type(jsonssid) == json_type_string)) {
|
|
ssid = json_object_get_string(jsonssid);
|
|
if (strlen(ssid) > CAPWAP_ADD_WLAN_SSID_LENGTH) {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
/* IE */
|
|
/* TODO */
|
|
|
|
/* Get session */
|
|
session = ac_search_session_from_wtpid(json_object_get_string(jsonwtpid));
|
|
if (session) {
|
|
int length;
|
|
struct ac_notify_addwlan_t* addwlan;
|
|
struct ac_session_notify_event_t notify;
|
|
|
|
/* Notification data */
|
|
length = sizeof(struct ac_notify_addwlan_t);
|
|
addwlan = (struct ac_notify_addwlan_t*)capwap_alloc(length);
|
|
|
|
/* */
|
|
addwlan->radioid = (uint8_t)json_object_get_int(jsonradioid);
|
|
addwlan->wlanid = (uint8_t)json_object_get_int(jsonwlanid);
|
|
addwlan->capability = (uint16_t)json_object_get_int(jsoncapability);
|
|
addwlan->qos = (uint8_t)json_object_get_int(jsonqos);
|
|
addwlan->authmode = (uint8_t)json_object_get_int(jsonauthtype);
|
|
addwlan->macmode = (uint8_t)json_object_get_int(jsonmacmode);
|
|
addwlan->tunnelmode = (uint8_t)json_object_get_int(jsontunnelmode);
|
|
addwlan->suppressssid = (uint8_t)(json_object_get_boolean(jsonhidessid) ? 1 : 0);
|
|
strcpy(addwlan->ssid, ssid);
|
|
|
|
/* Notify Request to Complete Event */
|
|
strcpy(notify.idevent, idevent);
|
|
notify.action = NOTIFY_ACTION_RECEIVE_RESPONSE_CONTROLMESSAGE;
|
|
notify.ctrlmsg_type = CAPWAP_IEEE80211_WLAN_CONFIGURATION_RESPONSE;
|
|
ac_session_send_action(session, AC_SESSION_ACTION_NOTIFY_EVENT, 0, (void*)¬ify, sizeof(struct ac_session_notify_event_t));
|
|
|
|
/* Notify Action */
|
|
capwap_logging_debug("Receive AddWLAN request for WTP %s with SSID: %s", session->wtpid, addwlan->ssid);
|
|
ac_session_send_action(session, AC_SESSION_ACTION_ADDWLAN, 0, (void*)addwlan, length);
|
|
|
|
/* */
|
|
ac_session_release_reference(session);
|
|
capwap_free(addwlan);
|
|
result = 1;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_parsing_updatewlan_event(const char* idevent, struct json_object* jsonparams) {
|
|
int result = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_parsing_deletewlan_event(const char* idevent, struct json_object* jsonparams) {
|
|
int result = 0;
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_soap_update_event(const char* idevent, int status) {
|
|
int result = 0;
|
|
char buffer[256];
|
|
struct ac_soap_request* request;
|
|
struct ac_http_soap_server* server;
|
|
|
|
ASSERT(g_ac_backend.soaprequest == NULL);
|
|
ASSERT(g_ac_backend.backendsessionid != NULL);
|
|
|
|
/* Get HTTP Soap Server */
|
|
server = *(struct ac_http_soap_server**)capwap_array_get_item_pointer(g_ac.availablebackends, g_ac_backend.activebackend);
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Build Soap Request */
|
|
if (!g_ac_backend.endthread) {
|
|
request = ac_soapclient_create_request("updateBackendEvent", SOAP_NAMESPACE_URI);
|
|
if (request) {
|
|
ac_soapclient_add_param(request, "xs:string", "idsession", g_ac_backend.backendsessionid);
|
|
ac_soapclient_add_param(request, "xs:string", "idevent", idevent);
|
|
ac_soapclient_add_param(request, "xs:int", "status", capwap_itoa(status, buffer));
|
|
g_ac_backend.soaprequest = ac_soapclient_prepare_request(request, server);
|
|
}
|
|
}
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
/* */
|
|
if (!g_ac_backend.soaprequest) {
|
|
if (request) {
|
|
ac_soapclient_free_request(request);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Send Request & Recv Response */
|
|
if (ac_soapclient_send_request(g_ac_backend.soaprequest, "")) {
|
|
struct ac_soap_response* response = ac_soapclient_recv_response(g_ac_backend.soaprequest);
|
|
if (response) {
|
|
ac_soapclient_free_response(response);
|
|
}
|
|
}
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Free resource */
|
|
ac_soapclient_close_request(g_ac_backend.soaprequest, 1);
|
|
g_ac_backend.soaprequest = NULL;
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static void ac_backend_parsing_event(struct json_object* jsonitem) {
|
|
struct json_object* jsonvalue;
|
|
|
|
ASSERT(jsonitem != NULL);
|
|
|
|
/* Receive event into JSON result
|
|
{
|
|
EventID: [int],
|
|
Action: [string],
|
|
Params: {
|
|
<Depends on the Action>
|
|
}
|
|
}
|
|
*/
|
|
|
|
/* Get EventID */
|
|
jsonvalue = compat_json_object_object_get(jsonitem, "EventID");
|
|
if (jsonvalue && (json_object_get_type(jsonvalue) == json_type_string)) {
|
|
const char* idevent = json_object_get_string(jsonvalue);
|
|
|
|
/* Get Action */
|
|
jsonvalue = compat_json_object_object_get(jsonitem, "Action");
|
|
if (jsonvalue && (json_object_get_type(jsonvalue) == json_type_string)) {
|
|
const char* action = json_object_get_string(jsonvalue);
|
|
if (action) {
|
|
jsonvalue = compat_json_object_object_get(jsonitem, "Params");
|
|
if (jsonvalue && (json_object_get_type(jsonvalue) == json_type_object)) {
|
|
int result = 0;
|
|
|
|
/* Parsing params according to the action */
|
|
if (!strcmp(action, "CloseWTPSession")) {
|
|
result = ac_backend_parsing_closewtpsession_event(idevent, jsonvalue);
|
|
} else if (!strcmp(action, "ResetWTP")) {
|
|
result = ac_backend_parsing_resetwtp_event(idevent, jsonvalue);
|
|
} else if (!strcmp(action, "AddWLAN")) {
|
|
result = ac_backend_parsing_addwlan_event(idevent, jsonvalue);
|
|
} else if (!strcmp(action, "UpdateWLAN")) {
|
|
result = ac_backend_parsing_updatewlan_event(idevent, jsonvalue);
|
|
} else if (!strcmp(action, "DeleteWLAN")) {
|
|
result = ac_backend_parsing_deletewlan_event(idevent, jsonvalue);
|
|
}
|
|
|
|
/* Notify result action */
|
|
ac_backend_soap_update_event(idevent, (result ? SOAP_EVENT_STATUS_RUNNING : SOAP_EVENT_STATUS_GENERIC_ERROR));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_soap_join(int forcereset) {
|
|
int result = 0;
|
|
struct ac_soap_request* request;
|
|
struct ac_http_soap_server* server;
|
|
|
|
ASSERT(g_ac_backend.soaprequest == NULL);
|
|
ASSERT(g_ac_backend.backendsessionid == NULL);
|
|
|
|
/* Get HTTP Soap Server */
|
|
server = *(struct ac_http_soap_server**)capwap_array_get_item_pointer(g_ac.availablebackends, g_ac_backend.activebackend);
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Build Soap Request */
|
|
if (!g_ac_backend.endthread) {
|
|
request = ac_soapclient_create_request("joinBackend", SOAP_NAMESPACE_URI);
|
|
if (request) {
|
|
ac_soapclient_add_param(request, "xs:string", "idac", g_ac.backendacid);
|
|
ac_soapclient_add_param(request, "xs:string", "version", g_ac.backendversion);
|
|
ac_soapclient_add_param(request, "xs:boolean", "forcereset", (forcereset ? "true" : "false"));
|
|
g_ac_backend.soaprequest = ac_soapclient_prepare_request(request, server);
|
|
}
|
|
}
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
/* */
|
|
if (!g_ac_backend.soaprequest) {
|
|
if (request) {
|
|
ac_soapclient_free_request(request);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Send Request & Recv Response */
|
|
if (ac_soapclient_send_request(g_ac_backend.soaprequest, "")) {
|
|
struct ac_soap_response* response = ac_soapclient_recv_response(g_ac_backend.soaprequest);
|
|
if (response) {
|
|
/* Get join result */
|
|
if ((response->responsecode == HTTP_RESULT_OK) && response->xmlResponseReturn) {
|
|
xmlChar* xmlResult = xmlNodeGetContent(response->xmlResponseReturn);
|
|
if (xmlStrlen(xmlResult)) {
|
|
result = 1;
|
|
g_ac_backend.backendsessionid = capwap_duplicate_string((const char*)xmlResult);
|
|
}
|
|
|
|
xmlFree(xmlResult);
|
|
}
|
|
|
|
/* */
|
|
ac_soapclient_free_response(response);
|
|
}
|
|
}
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Free resource */
|
|
ac_soapclient_close_request(g_ac_backend.soaprequest, 1);
|
|
g_ac_backend.soaprequest = NULL;
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static int ac_backend_soap_waitevent(void) {
|
|
int result = -1;
|
|
struct ac_soap_request* request;
|
|
struct ac_http_soap_server* server;
|
|
struct json_object* jsonroot = NULL;
|
|
|
|
ASSERT(g_ac_backend.soaprequest == NULL);
|
|
ASSERT(g_ac_backend.backendsessionid != NULL);
|
|
|
|
/* Get HTTP Soap Server */
|
|
server = *(struct ac_http_soap_server**)capwap_array_get_item_pointer(g_ac.availablebackends, g_ac_backend.activebackend);
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Build Soap Request */
|
|
if (!g_ac_backend.endthread) {
|
|
request = ac_soapclient_create_request("waitBackendEvent", SOAP_NAMESPACE_URI);
|
|
if (request) {
|
|
ac_soapclient_add_param(request, "xs:string", "idsession", g_ac_backend.backendsessionid);
|
|
g_ac_backend.soaprequest = ac_soapclient_prepare_request(request, server);
|
|
|
|
/* Change result timeout */
|
|
g_ac_backend.soaprequest->responsetimeout = SOAP_PROTOCOL_RESPONSE_WAIT_EVENT_TIMEOUT;
|
|
}
|
|
}
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
/* */
|
|
if (!g_ac_backend.soaprequest) {
|
|
if (request) {
|
|
ac_soapclient_free_request(request);
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/* Send Request & Recv Response */
|
|
if (ac_soapclient_send_request(g_ac_backend.soaprequest, "")) {
|
|
struct ac_soap_response* response = ac_soapclient_recv_response(g_ac_backend.soaprequest);
|
|
if (response) {
|
|
/* Wait event result */
|
|
if ((response->responsecode == HTTP_RESULT_OK) && response->xmlResponseReturn) {
|
|
int length;
|
|
char* json;
|
|
xmlChar* xmlResult;
|
|
|
|
/* Decode base64 result */
|
|
xmlResult = xmlNodeGetContent(response->xmlResponseReturn);
|
|
if (!xmlResult) {
|
|
return CAPWAP_RESULTCODE_FAILURE;
|
|
}
|
|
|
|
length = xmlStrlen(xmlResult);
|
|
if (!length) {
|
|
xmlFree(xmlResult);
|
|
return CAPWAP_RESULTCODE_FAILURE;
|
|
}
|
|
|
|
json = (char*)capwap_alloc(AC_BASE64_DECODE_LENGTH(length));
|
|
ac_base64_string_decode((const char*)xmlResult, json);
|
|
|
|
xmlFree(xmlResult);
|
|
|
|
/* Parsing JSON result */
|
|
jsonroot = json_tokener_parse(json);
|
|
capwap_free(json);
|
|
}
|
|
|
|
/* */
|
|
ac_soapclient_free_response(response);
|
|
}
|
|
}
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Free resource */
|
|
ac_soapclient_close_request(g_ac_backend.soaprequest, 1);
|
|
g_ac_backend.soaprequest = NULL;
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
/* Parsing JSON command after close event request */
|
|
if (jsonroot) {
|
|
if (json_object_get_type(jsonroot) == json_type_array) {
|
|
int i;
|
|
int length;
|
|
|
|
/* Parsing every message into JSON result */
|
|
length = json_object_array_length(jsonroot);
|
|
for (i = 0; i < length; i++) {
|
|
struct json_object* jsonitem = json_object_array_get_idx(jsonroot, i);
|
|
if (jsonitem && (json_object_get_type(jsonitem) == json_type_object)) {
|
|
ac_backend_parsing_event(jsonitem);
|
|
}
|
|
}
|
|
|
|
/* Parsing complete */
|
|
result = 0;
|
|
}
|
|
|
|
/* Free JSON */
|
|
json_object_put(jsonroot);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/* */
|
|
static void ac_backend_soap_leave(void) {
|
|
struct ac_soap_request* request;
|
|
struct ac_http_soap_server* server;
|
|
|
|
ASSERT(g_ac_backend.soaprequest == NULL);
|
|
|
|
/* */
|
|
if (!g_ac_backend.backendstatus || !g_ac_backend.backendsessionid) {
|
|
return;
|
|
}
|
|
|
|
/* Get HTTP Soap Server */
|
|
server = *(struct ac_http_soap_server**)capwap_array_get_item_pointer(g_ac.availablebackends, g_ac_backend.activebackend);
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Build Soap Request */
|
|
request = ac_soapclient_create_request("leaveBackend", SOAP_NAMESPACE_URI);
|
|
if (request) {
|
|
ac_soapclient_add_param(request, "xs:string", "idsession", g_ac_backend.backendsessionid);
|
|
g_ac_backend.soaprequest = ac_soapclient_prepare_request(request, server);
|
|
}
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
|
|
/* */
|
|
if (!g_ac_backend.soaprequest) {
|
|
if (request) {
|
|
ac_soapclient_free_request(request);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/* Send Request & Recv Response */
|
|
if (ac_soapclient_send_request(g_ac_backend.soaprequest, "")) {
|
|
struct ac_soap_response* response = ac_soapclient_recv_response(g_ac_backend.soaprequest);
|
|
if (response) {
|
|
ac_soapclient_free_response(response);
|
|
}
|
|
}
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
/* Free resource */
|
|
ac_soapclient_close_request(g_ac_backend.soaprequest, 1);
|
|
g_ac_backend.soaprequest = NULL;
|
|
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
}
|
|
|
|
/* */
|
|
static void ac_backend_run(void) {
|
|
int result;
|
|
int connected = 0;
|
|
int forcereset = 1;
|
|
|
|
capwap_lock_enter(&g_ac_backend.backendlock);
|
|
|
|
while (!g_ac_backend.endthread) {
|
|
if (connected) {
|
|
result = ac_backend_soap_waitevent();
|
|
if (result < 0) {
|
|
if (g_ac_backend.endthread) {
|
|
break;
|
|
}
|
|
|
|
/* Connection error, change Backend Server */
|
|
connected = 0;
|
|
capwap_logging_debug("Lost connection with Backend Server");
|
|
capwap_lock_enter(&g_ac_backend.backendlock);
|
|
|
|
/* Lost session id */
|
|
capwap_free(g_ac_backend.backendsessionid);
|
|
g_ac_backend.backendsessionid = NULL;
|
|
|
|
/* Change backend */
|
|
g_ac_backend.activebackend = (g_ac_backend.activebackend + 1) % g_ac.availablebackends->count;
|
|
}
|
|
} else {
|
|
/* Join with a Backend Server */
|
|
if (ac_backend_soap_join(forcereset)) {
|
|
capwap_logging_debug("Joined with Backend Server");
|
|
|
|
/* Join Complete */
|
|
connected = 1;
|
|
forcereset = 0;
|
|
g_ac_backend.backendstatus = 1;
|
|
g_ac_backend.errorjoinbackend = 0;
|
|
capwap_lock_exit(&g_ac_backend.backendlock);
|
|
} else {
|
|
/* Change Backend Server */
|
|
g_ac_backend.activebackend = (g_ac_backend.activebackend + 1) % g_ac.availablebackends->count;
|
|
g_ac_backend.errorjoinbackend++;
|
|
|
|
/* Wait timeout before continue */
|
|
if (g_ac_backend.errorjoinbackend >= g_ac.availablebackends->count) {
|
|
capwap_logging_debug("Unable to join with Backend Server");
|
|
|
|
/* */
|
|
forcereset = 1;
|
|
g_ac_backend.backendstatus = 0;
|
|
g_ac_backend.errorjoinbackend = 0;
|
|
|
|
/* Wait before retry join to backend server */
|
|
capwap_lock_exit(&g_ac_backend.backendlock);
|
|
capwap_event_wait_timeout(&g_ac_backend.wait, AC_BACKEND_WAIT_TIMEOUT);
|
|
capwap_lock_enter(&g_ac_backend.backendlock);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Leave Backend */
|
|
ac_backend_soap_leave();
|
|
g_ac_backend.backendstatus = 0;
|
|
|
|
/* */
|
|
if (g_ac_backend.backendsessionid) {
|
|
capwap_free(g_ac_backend.backendsessionid);
|
|
g_ac_backend.backendsessionid = NULL;
|
|
}
|
|
|
|
/* */
|
|
if (!connected) {
|
|
capwap_lock_exit(&g_ac_backend.backendlock);
|
|
}
|
|
}
|
|
|
|
/* */
|
|
static void* ac_backend_thread(void* param) {
|
|
capwap_logging_debug("Backend start");
|
|
ac_backend_run();
|
|
capwap_logging_debug("Backend stop");
|
|
|
|
/* Thread exit */
|
|
pthread_exit(NULL);
|
|
return NULL;
|
|
}
|
|
|
|
/* */
|
|
int ac_backend_isconnect(void) {
|
|
return (g_ac_backend.backendstatus ? 1 : 0);
|
|
}
|
|
|
|
/* */
|
|
struct ac_http_soap_request* ac_backend_createrequest_with_session(char* method, char* uri) {
|
|
struct ac_http_soap_server* server;
|
|
struct ac_soap_request* request;
|
|
struct ac_http_soap_request* soaprequest = NULL;
|
|
|
|
/* Get active connection only if Backend Management Thread is not trying to connect with a Backend Server */
|
|
capwap_lock_enter(&g_ac_backend.backendlock);
|
|
|
|
if (ac_backend_isconnect()) {
|
|
server = *(struct ac_http_soap_server**)capwap_array_get_item_pointer(g_ac.availablebackends, g_ac_backend.activebackend);
|
|
|
|
/* Build Soap Request */
|
|
request = ac_soapclient_create_request(method, SOAP_NAMESPACE_URI);
|
|
if (request) {
|
|
soaprequest = ac_soapclient_prepare_request(request, server);
|
|
if (soaprequest) {
|
|
ac_soapclient_add_param(request, "xs:string", "idsession", g_ac_backend.backendsessionid);
|
|
} else {
|
|
ac_soapclient_free_request(request);
|
|
}
|
|
}
|
|
}
|
|
|
|
capwap_lock_exit(&g_ac_backend.backendlock);
|
|
|
|
return soaprequest;
|
|
}
|
|
|
|
/* */
|
|
int ac_backend_start(void) {
|
|
int result;
|
|
|
|
memset(&g_ac_backend, 0, sizeof(struct ac_backend_t));
|
|
|
|
/* */
|
|
if (!g_ac.backendacid) {
|
|
capwap_logging_error("AC Backend ID isn't set");
|
|
return 0;
|
|
} else if (!g_ac.backendversion) {
|
|
capwap_logging_error("Backend Protocol Version isn't set");
|
|
return 0;
|
|
} else if (!g_ac.availablebackends->count) {
|
|
capwap_logging_error("List of available backends is empty");
|
|
return 0;
|
|
}
|
|
|
|
/* Init */
|
|
capwap_lock_init(&g_ac_backend.lock);
|
|
capwap_lock_init(&g_ac_backend.backendlock);
|
|
capwap_event_init(&g_ac_backend.wait);
|
|
|
|
/* Create thread */
|
|
result = pthread_create(&g_ac_backend.threadid, NULL, ac_backend_thread, NULL);
|
|
if (result) {
|
|
capwap_logging_debug("Unable create backend thread");
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* */
|
|
void ac_backend_stop(void) {
|
|
void* dummy;
|
|
|
|
g_ac_backend.endthread = 1;
|
|
|
|
/* Critical section */
|
|
capwap_lock_enter(&g_ac_backend.lock);
|
|
|
|
if (g_ac_backend.soaprequest) {
|
|
ac_soapclient_shutdown_request(g_ac_backend.soaprequest);
|
|
}
|
|
|
|
/* */
|
|
capwap_lock_exit(&g_ac_backend.lock);
|
|
capwap_event_signal(&g_ac_backend.wait);
|
|
|
|
/* Wait close thread */
|
|
pthread_join(g_ac_backend.threadid, &dummy);
|
|
}
|
|
|
|
/* */
|
|
void ac_backend_free(void) {
|
|
capwap_event_destroy(&g_ac_backend.wait);
|
|
capwap_lock_destroy(&g_ac_backend.lock);
|
|
capwap_lock_destroy(&g_ac_backend.backendlock);
|
|
}
|