planix.org/actube
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Removed cw_ElemHandlerParams.elem

Browse Source
This commit is contained in:
7u83
2022-08-09 09:52:30 +02:00
parent 8aa11dccba
commit d2240646f9
18 changed files with 364 additions and 361 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/cw/Doxyfile
View File

@ -1770,7 +1770,7 @@ MAN_EXTENSION = .3
# The default value is: NO.
# This tag requires that the tag GENERATE_MAN is set to YES.
MAN_LINKS = NO
MAN_LINKS = YES
#---------------------------------------------------------------------------
# Configuration options related to the XML output

8
src/cw/cfg.c
View File

@ -606,4 +606,10 @@ uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, const char * def)
return v.val.word;
}
void cw_cfg_set_int(cw_Cfg_t * cfg, const char * key, int val)
{
char a[128];
sprintf(a,"%d",val);
printf("VVVVVV: %s\n",a);
cw_cfg_set(cfg,key,a);
}

1
src/cw/cfg.h
View File

@ -31,6 +31,7 @@ void cw_cfg_iter_init(cw_Cfg_t * cfg, struct cw_Cfg_iter *cfi, const char *base)
int cw_cfg_get_bool(cw_Cfg_t * cfg, const char * key, const char *def);
uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, const char * def);
void cw_cfg_set_int(cw_Cfg_t * cfg, const char * key, int val);
#endif

242
src/cw/conn_process_packet.c
View File

@ -47,10 +47,10 @@ void cw_init_response(struct conn *conn, uint8_t * req)
uint8_t *buffer;
int shbytes, dhbytes;
uint8_t *msgptr, *dmsgptr;
buffer = conn->resp_buffer;
shbytes = cw_get_hdr_msg_offset(req);
memcpy(buffer, req, shbytes);
cw_set_hdr_rmac(buffer, conn->base_rmac);
@ -73,7 +73,7 @@ void cw_init_request(struct conn *conn, int msg_id)
{
uint8_t *buffer = conn->req_buffer;
uint8_t *msgptr;
/* zero the first 8 bytes */
cw_set_dword(buffer + 0, 0);
cw_set_dword(buffer + 4, 0);
@ -135,11 +135,12 @@ int cw_send_response(struct conn *conn, uint8_t * rawmsg, int len)
* @param result_code result code to send
* @return 1
*/
int cw_send_error_response(struct conn *conn, uint8_t * rawmsg, uint32_t result_code)
int cw_send_error_response(struct conn *conn, uint8_t * rawmsg,
uint32_t result_code)
{
uint8_t *out,*dst;
uint8_t *out, *dst;
int l;
cw_init_response(conn, rawmsg);
out = conn->resp_buffer;
@ -155,31 +156,34 @@ int cw_send_error_response(struct conn *conn, uint8_t * rawmsg, uint32_t result_
}
static struct cw_MsgSet *load_msg_set(struct conn *conn, uint8_t * rawmsg, int len,
int elems_len, struct sockaddr *from)
static struct cw_MsgSet *load_msg_set(struct conn *conn, uint8_t * rawmsg,
int len, int elems_len,
struct sockaddr *from)
{
char sock_buf[SOCK_ADDR_BUFSIZE];
struct cw_Mod *cmod, *bmod;
cmod =
cw_mod_detect(conn, rawmsg, len, elems_len, from, CW_MOD_MODE_CAPWAP);
cw_mod_detect(conn, rawmsg, len, elems_len, from,
CW_MOD_MODE_CAPWAP);
if (cmod == MOD_NULL) {
cw_dbg(DBG_MSG_ERR,
"Can't find mod to handle connection from %s, discarding message",
sock_addr2str_p(from,sock_buf));
sock_addr2str_p(from, sock_buf));
return NULL;
}
bmod =
cw_mod_detect(conn, rawmsg, len, elems_len, from, CW_MOD_MODE_BINDINGS);
bmod =
cw_mod_detect(conn, rawmsg, len, elems_len, from,
CW_MOD_MODE_BINDINGS);
cw_dbg(DBG_INFO, "Mods deteced: %s,%s", cmod->name, bmod->name);
conn->cmod = cmod;
conn->bmod = bmod;
return cw_mod_get_msg_set(conn,cmod,bmod);
return cw_mod_get_msg_set(conn, cmod, bmod);
}
@ -217,16 +221,17 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
mavl_t mand_found;
mlist_t unrecognized;
struct cw_MsgData search;
struct cw_MsgData * message;
struct cw_MsgData *message;
int result_code;
cw_State_t *ui;
uint8_t *elems_ptr;
uint8_t *elem;
struct cw_ElemHandlerParams params;
char sock_buf[SOCK_ADDR_BUFSIZE]; /**< to hold str from sockaddr2str */
/*struct cw_action_in as, *af, *afm;*/
/*struct cw_action_in as, *af, *afm; */
int offset = cw_get_hdr_msg_offset(rawmsg);
@ -243,7 +248,8 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
if (conn->strict_hdr) {
cw_dbg(DBG_MSG_ERR,
"Discarding message from %s, msgelems len=%d, payload len=%d, (Strict CAPWAP) ",
sock_addr2str(&conn->addr,sock_buf), elems_len, payloadlen - 8);
sock_addr2str(&conn->addr, sock_buf), elems_len,
payloadlen - 8);
errno = EAGAIN;
return -1;
}
@ -252,7 +258,8 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
if (elems_len < payloadlen - 8) {
cw_dbg(DBG_RFC,
"Packet from from %s has %d bytes of extra data, ignoring.",
sock_addr2str(&conn->addr,sock_buf), payloadlen - 8 - elems_len);
sock_addr2str(&conn->addr, sock_buf),
payloadlen - 8 - elems_len);
elems_len = len - 8;
}
@ -260,7 +267,8 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
cw_dbg(DBG_RFC,
"Packet from from %s has msgelems len of %d bytes, but has only %d bytes of data, truncating.",
sock_addr2str(&conn->addr, sock_buf), elems_len, payloadlen - 8);
sock_addr2str(&conn->addr, sock_buf), elems_len,
payloadlen - 8);
elems_len = payloadlen - 8;
}
}
@ -269,16 +277,17 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
/* Detect the connecting AC type */
if (!conn->detected) {
struct cw_MsgSet *set = load_msg_set(conn, rawmsg, len, elems_len, from);
struct cw_MsgSet *set =
load_msg_set(conn, rawmsg, len, elems_len, from);
if (!set) {
/*
//cw_log(LOG_ERR, "Error");
*/
*/
errno = EAGAIN;
return -1;
}
conn->cmod->setup_cfg(conn);
conn->msgset= set;
conn->msgset = set;
conn->detected = 1;
}
@ -287,30 +296,30 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
/* prepare struct for search operation */
search.type = cw_get_msg_id(msg_ptr);
/* Search message */
message = mavl_get(conn->msgset->msgdata,&search);
message = mavl_get(conn->msgset->msgdata, &search);
result_code = 0;
if (!message){
if (!message) {
/* Message is unknown */
if (search.type & 1){
cw_dbg(DBG_MSG_ERR,
"Message type %d [%s] unrecognized, sending response.",
search.type, cw_strmsg(search.type),
cw_strstate(conn->capwap_state));
if (search.type & 1) {
cw_dbg(DBG_MSG_ERR,
"Message type %d [%s] unrecognized, sending response.",
search.type, cw_strmsg(search.type),
cw_strstate(conn->capwap_state));
result_code = CAPWAP_RESULT_MSG_UNRECOGNIZED;
cw_send_error_response(conn, rawmsg, result_code);
errno = EAGAIN;
return -1;
}
cw_dbg(DBG_MSG_ERR,
"Message type %d [%s] unrecognized, discarding.",
search.type, cw_strmsg(search.type),
cw_strstate(conn->capwap_state));
cw_dbg(DBG_MSG_ERR,
"Message type %d [%s] unrecognized, discarding.",
search.type, cw_strmsg(search.type),
cw_strstate(conn->capwap_state));
errno = EAGAIN;
return -1;
@ -332,18 +341,18 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
/* Check if current state is in state of message */
ui = message->states;
for (ui=message->states; ui->state; ui++){
for (ui = message->states; ui->state; ui++) {
/* printf("Comparing %d and %d\n", conn->capwap_state, ui->state);*/
if(ui->state==conn->capwap_state){
if (ui->state == conn->capwap_state) {
break;
}
}
if (!ui->state){
if (!ui->state) {
/* Message found, but it was in wrong state */
cw_dbg(DBG_MSG_ERR,
"Message type %d (%s) not allowed in %s State, sending response.",
search.type,cw_strmsg(search.type),
"Message type %d (%s) not allowed in %s State, sending response.",
search.type, cw_strmsg(search.type),
cw_strstate(conn->capwap_state));
result_code = CAPWAP_RESULT_MSG_INVALID_IN_CURRENT_STATE;
cw_send_error_response(conn, rawmsg, result_code);
@ -352,97 +361,53 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
}
/* if (conn->msg_start){
conn->msg_start(conn, afm, rawmsg, len, from);
}
*/
/* Execute start processor for message */
/*
// if (afm->start) {
// afm->start(conn, afm, rawmsg, len, from);
// }
*/
elems_ptr = cw_get_msg_elems_ptr(msg_ptr);
params.local_cfg = conn->local_cfg;
params.remote_cfg = conn->remote_cfg;
params.default_cfg = conn->default_cfg;
params.global_cfg = conn->global_cfg;
params.msgset = conn->msgset;
params.from = from;
params.msgdata = message;
params.mand_found = mand_found;
/* Create an avltree to catch the found mandatory elements */
/* //conn->mand = stravltree_create();*/
mand_found = mavl_create_conststr();
unrecognized = mlist_create(NULL,NULL,sizeof(uint8_t*));
cw_dbg(DBG_MSG_PARSING ,"*** Parsing message of type %d - (%s) ***",
message->type,message->name);
/* iterate through message elements */
cw_foreach_elem(elem, elems_ptr, elems_len) {
int rc;
struct cw_ElemHandlerParams params;
int elem_len, elem_id, max_len;
uint8_t * elem_data;
elem_len = cw_get_elem_len(elem);
elem_data=cw_get_elem_data(elem);
elem_id = cw_get_elem_id(elem);
max_len=elems_len-(elem_data-elems_ptr);
if (elem_len > max_len){
cw_dbg(DBG_RFC,
"Messag element claims size of %d bytes, but only %d bytes are left in the payload, truncating.",
elem_len,max_len-4);
}
unrecognized = mlist_create(NULL, NULL, sizeof(uint8_t *));
/* params.conn=conn;*/
params.local_cfg=conn->local_cfg;
params.remote_cfg=conn->remote_cfg;
params.default_cfg=conn->default_cfg;
params.global_cfg=conn->global_cfg;
params.msgset=conn->msgset;
params.from=from;
params.msgdata=message;
params.mand_found=mand_found;
rc = cw_process_element(&params,0,0,elem_id,elem_data,elem_len);
cw_dbg(DBG_MSG_PARSING, "*** Parsing message of type %d - (%s) ***",
message->type, message->name);
if (cw_result_is_ok(rc))
continue;
if (rc == CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT){
mlist_append(unrecognized,&elem);
continue;
}
if (rc < 0 ){
continue;
}
}
cw_decode_elements(&params,elems_ptr, elems_len);
exit(0);
/* all message elements are processed, do now after processing
by calling the "end" function for the message */
cw_check_missing_mand(message,mand_found);
cw_dbg(DBG_MSG_PARSING," *** Done parsing message of type %d (%s) ***",
message->type,message->name);
cw_check_missing_mand(message, mand_found);
cw_dbg(DBG_MSG_PARSING, " *** Done parsing message of type %d (%s) ***",
message->type, message->name);
mavl_destroy(mand_found);
/* cw_dbg_ktv_dump(conn->remote_cfg,DBG_CFG_DMP,
" *** Remote CFG dump ***", "CFG:", " *** End of remote CFG dump");
*/
if (message->postprocess){
if (message->postprocess) {
message->postprocess(conn);
}
@ -455,12 +420,13 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
cw_send_error_response(conn, rawmsg, result_code);
} else if (result_code == 0) {
cw_ktv_set_dword(conn->local_cfg,"result-code",result_code);
if (ui->next){
cw_ktv_set_dword(conn->local_cfg, "result-code",
result_code);
if (ui->next) {
conn->capwap_prevstate = conn->capwap_state;
conn->capwap_state = ui->next;
}
/* All is ok, send regular response message */
cw_send_response(conn, rawmsg, len);
} else {
@ -475,7 +441,7 @@ static int process_elements(struct conn *conn, uint8_t * rawmsg, int len,
*/
}
/*stravltree_destroy(conn->mand);*/
/*stravltree_destroy(conn->mand); */
return result_code;
@ -491,7 +457,7 @@ int process_message(struct conn *conn, uint8_t * rawmsg, int rawlen,
{
char sock_buf[SOCK_ADDR_BUFSIZE];
uint8_t seqnum;
int s1,s2,sd;
int s1, s2, sd;
uint8_t *msgptr = rawmsg + cw_get_hdr_msg_offset(rawmsg);
@ -522,7 +488,7 @@ int process_message(struct conn *conn, uint8_t * rawmsg, int rawlen,
if (sd != 0) {
cw_dbg(DBG_MSG_ERR,
"Discarding message from %s, old seqnum, seqnum = %d, last seqnum=%d",
sock_addr2str(&conn->addr,sock_buf), s2, s1);
sock_addr2str(&conn->addr, sock_buf), s2, s1);
errno = EAGAIN;
return -1;
}
@ -533,7 +499,7 @@ int process_message(struct conn *conn, uint8_t * rawmsg, int rawlen,
cw_dbg(DBG_MSG_ERR,
"Retransmitted request message from %s detected, seqnum=%d, type=%d",
sock_addr2str(&conn->addr,sock_buf), s2, type);
sock_addr2str(&conn->addr, sock_buf), s2, type);
if (cw_get_hdr_msg_type(conn->resp_buffer) - 1 != type) {
@ -547,7 +513,7 @@ int process_message(struct conn *conn, uint8_t * rawmsg, int rawlen,
cw_dbg(DBG_MSG_ERR, "Retransmitting response message to %s, seqnum=%d",
sock_addr2str(&conn->addr, sock_buf), s2);
/*// XXX untested*/
/*// XXX untested */
conn_send_msg(conn, conn->resp_buffer);
errno = EAGAIN;
return -1;
@ -561,13 +527,13 @@ int process_message(struct conn *conn, uint8_t * rawmsg, int rawlen,
* @param len lenght of packet data
*/
int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
struct sockaddr *from)
struct sockaddr *from)
{
char sock_buf[SOCK_ADDR_BUFSIZE];
int preamble;
int offs;
int payloadlen;
if (len < 8) {
/* packet too short */
cw_dbg(DBG_PKT_ERR,
@ -583,8 +549,8 @@ int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
/* wrong version */
cw_dbg(DBG_PKT_ERR,
"Discarding packet from %s, wrong version, version=%d, version %d expected.",
sock_addr2str(&conn->addr,sock_buf), (preamble & 0xf0) >> 4,
CAPWAP_VERSION);
sock_addr2str(&conn->addr, sock_buf),
(preamble & 0xf0) >> 4, CAPWAP_VERSION);
errno = EAGAIN;
return -1;
}
@ -593,7 +559,7 @@ int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
/* Encrypted data, this shuold never happen here */
cw_dbg(DBG_PKT_ERR,
"Discarding packet from %s, encrypted data after decryption ...",
sock_addr2str(&conn->addr,sock_buf));
sock_addr2str(&conn->addr, sock_buf));
errno = EAGAIN;
return -1;
}
@ -607,7 +573,7 @@ int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
/* Eleminate messages with wrong header size */
cw_dbg(DBG_PKT_ERR,
"Discarding packet from %s, header length (%d) greater than packet len (%d).",
sock_addr2str(&conn->addr,sock_buf), offs, len);
sock_addr2str(&conn->addr, sock_buf), offs, len);
errno = EAGAIN;
return -1;
}
@ -619,7 +585,8 @@ int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
/* wrong rmac size */
cw_dbg(DBG_PKT_ERR,
"Discarding packet from %s, wrong R-MAC size, size=%d",
sock_addr2str(&conn->addr,sock_buf), *(packet + 8));
sock_addr2str(&conn->addr, sock_buf),
*(packet + 8));
errno = EAGAIN;
return -1;
}
@ -631,7 +598,7 @@ int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
/* fragmented, add the packet to fragman */
uint8_t *f;
int rc;
f = fragman_add(conn->fragman, packet, offs, payloadlen);
if (f == NULL) {
errno = EAGAIN;
@ -656,22 +623,24 @@ int conn_process_packet2(struct conn *conn, uint8_t * packet, int len,
}
int conn_process_packet(struct conn *conn, uint8_t * packet, int len,
struct sockaddr *from){
struct sockaddr *from)
{
/* show this packet in debug output */
cw_dbg_pkt(DBG_PKT_IN, conn, packet, len, from);
return conn_process_packet2(conn,packet,len,from);
return conn_process_packet2(conn, packet, len, from);
}
int conn_process_data_packet(struct conn *conn, uint8_t * packet, int len,
struct sockaddr *from){
struct sockaddr *from)
{
/* show this packet in debug output */
cw_dbg_pkt(DBG_PKT_IN, conn, packet, len, from);
return conn_process_packet2(conn,packet,len,from);
return conn_process_packet2(conn, packet, len, from);
}
@ -705,4 +674,3 @@ int cw_read_messages(struct conn *conn)
errno = EAGAIN;
return -1;
}

4
src/cw/cw_decode_msg.c
View File

@ -11,7 +11,7 @@ int cw_decode_element(struct cw_ElemHandlerParams *params, int proto,
struct cw_ElemData *elem_data, elem_data_search;
int rc;
params->elem = NULL;
//params->elem = NULL;
/* try to retrieve a handler for this message element */
handler =
@ -66,7 +66,7 @@ int cw_decode_element(struct cw_ElemHandlerParams *params, int proto,
return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
}
printf ("USING HANDLERi TO DECODE: %d %s\n",handler->id,handler->name);
printf ("USING HANDLER TO DECODE: %d %s\n",handler->id,handler->name);
rc = handler->get(handler, params, data, len);

2
src/cw/cw_in_generic.c
View File

@ -16,6 +16,6 @@ int cw_in_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams *
result = cw_ktv_add(params->remote_cfg, handler->key,
handler->type,NULL, elem_data,elem_len);
params->elem=result;
// params->elem=result;
return CAPWAP_RESULT_SUCCESS;
}

2
src/cw/cw_in_idx_generic.c
View File

@ -19,7 +19,7 @@ int cw_in_idx_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerPara
result = cw_ktv_add(params->remote_cfg, key,
handler->type, NULL, elem_data+1,elem_len-1);
params->elem=result;
// params->elem=result;
return CAPWAP_RESULT_SUCCESS;
}

2
src/cw/cw_process_element.c
View File

@ -20,7 +20,7 @@ int cw_process_element(struct cw_ElemHandlerParams *params, int proto, int vendo
struct cw_ElemData * elem_data, elem_data_search;
int rc;
params->elem=NULL;
// params->elem=NULL;
/* try to retrieve a handler for this message element */
handler = cw_msgset_get_elemhandler(params->msgset,proto, vendor, elem_id);

5
src/cw/cw_put_msg.c
View File

@ -44,7 +44,8 @@ int cw_put_msg(struct conn *conn, uint8_t * rawout)
struct cw_MsgData * msg;
struct mlistelem * elem;
int len,l;
printf("Hello msg\n");
cw_dbg(DBG_INFO, "Number of elements in ktv: %d",conn->local_cfg->count);
/* cw_dbg_ktv_dump(conn->local_cfg,DBG_CFG_DMP,"Local CFG","LOCAL:","End Local CFG");*/
@ -104,7 +105,7 @@ printf("Elem: %d %d %d %s\n", data->proto, data->vendor, data->id, handler->name
params.elemdata = data;
params.elem=NULL;
// params.elem=NULL;
params.msgdata=msg;
params.debug_details=details;
*details=0;

2
src/cw/cw_read_radio_generic.c
View File

@ -24,7 +24,7 @@ int cw_in_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerPa
result = cw_ktv_add(params->remote_cfg, key,
handler->type, NULL, elem_data+1,elem_len-1);
params->elem=result;
// params->elem=result;
return CAPWAP_RESULT_SUCCESS;
}

73
src/cw/cw_setup_dtls.c
View File

@ -1,22 +1,24 @@
#include "cw.h"
#include "cfg.h"
static int get_psk(struct conn * conn,const char * username, uint8_t **psk, unsigned int *len)
static int get_psk(struct conn *conn, const char *username, uint8_t ** psk,
unsigned int *len)
{
char key[CW_KTV_MAX_KEY_LEN];
cw_Val_t * result;
sprintf(key,"%s/%s","psk",username);
result = cw_ktv_get(conn->local_cfg,key,CW_TYPE_BSTR16);
if (result == NULL){
if (conn->dtls_psk != NULL){
cw_Val_t *result;
sprintf(key, "%s/%s", "psk", username);
result = cw_ktv_get(conn->local_cfg, key, CW_TYPE_BSTR16);
if (result == NULL) {
if (conn->dtls_psk != NULL) {
*psk = bstr16_data(conn->dtls_psk);
*len = bstr16_len(conn->dtls_psk);
return 1;
}
return 0;
}
if (result == NULL)
return 0;
*psk = result->type->data(result);
@ -33,46 +35,47 @@ static int get_psk(struct conn * conn,const char * username, uint8_t **psk, unsi
* @param default_cipher
* @return
*/
int cw_setup_dtls(struct conn * conn, mavl_t cfg, const char *prefix, char * default_cipher)
int cw_setup_dtls(struct conn *conn, mavl_t cfg, const char *prefix,
char *default_cipher)
{
char key[CW_KTV_MAX_KEY_LEN];
char *ssl_cert,*ssl_key;
char *ssl_cert, *ssl_key;
uint8_t security;
security = 0;
sprintf(key,"%s/%s",prefix,"ssl-cipher");
conn->dtls_cipher = cw_ktv_get_str(cfg,key, default_cipher);
sprintf(key,"%s/%s",prefix,"ssl-psk");
conn->dtls_psk = cw_ktv_get_bstr16(cfg,key,NULL);
sprintf(key,"%s/%s",prefix,"ssl-psk-enable");
conn->dtls_psk_enable = cw_ktv_get_bool(cfg,key,0);
if (conn->dtls_psk_enable ){
sprintf(key, "%s/%s", prefix, "ssl-cipher");
conn->dtls_cipher = cw_cfg_get(cfg, key, default_cipher);
sprintf(key, "%s/%s", prefix, "ssl-psk");
conn->dtls_psk = cw_cfg_get(cfg, key, NULL);
sprintf(key, "%s/%s", prefix, "ssl-psk-enable");
conn->dtls_psk_enable = cw_cfg_get_bool(cfg, key, "flase");
if (conn->dtls_psk_enable) {
security |= CAPWAP_FLAG_AC_SECURITY_S;
}
sprintf(key,"%s/%s",prefix,"ssl-certfile");
ssl_cert = cw_ktv_get_str(conn->local_cfg,key,NULL);
sprintf(key,"%s/%s",prefix,"ssl-keyfile");
ssl_key = cw_ktv_get_str(conn->local_cfg,key,NULL);
if (ssl_cert != NULL && ssl_key != NULL){
sprintf(key, "%s/%s", prefix, "ssl-certfile");
ssl_cert = cw_cfg_get(conn->local_cfg, key, NULL);
sprintf(key, "%s/%s", prefix, "ssl-keyfile");
ssl_key = cw_cfg_get(conn->local_cfg, key, NULL);
if (ssl_cert != NULL && ssl_key != NULL) {
conn->dtls_cert_file = ssl_cert;
conn->dtls_key_file = ssl_key;
sprintf(key,"%s/%s",prefix,"ssl-keypass");
conn->dtls_key_pass = cw_ktv_get_str(cfg,key,NULL);
sprintf(key, "%s/%s", prefix, "ssl-keypass");
conn->dtls_key_pass = cw_cfg_get(cfg, key, NULL);
security |= CAPWAP_FLAG_AC_SECURITY_X;
}
sprintf(key,"%s/%s",prefix,"ssl-dhbits");
conn->dtls_dhbits = cw_ktv_get_word(cfg,key,1024);
sprintf(key, "%s/%s", prefix, "ssl-dhbits");
conn->dtls_dhbits = cw_cfg_get_word(cfg, key, "1024");
conn->dtls_get_psk = get_psk;
return security;

5
src/cw/msgset.h
View File

@ -6,7 +6,7 @@
#include "mavl.h"
#include "val.h"
#include "cfg.h"
struct cw_ElemDef{
int proto;
@ -29,8 +29,9 @@ struct cw_ElemHandlerParams {
struct cw_ElemData * elemdata;
struct sockaddr *from;
mavl_t mand_found;
cw_Val_t * elem;
// cw_Val_t * elem;
char * debug_details;
cw_Cfg_t * cfg;
mavl_t remote_cfg;
mavl_t local_cfg;
mavl_t default_cfg;