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

More work on typeless

Browse Source
This commit is contained in:
7u83
2022-08-13 09:47:12 +02:00
parent add6ffa314
commit 370942ef7e
69 changed files with 1030 additions and 507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/cw/bstr.h
View File

@ -140,7 +140,7 @@ static inline int bstr16_ncpy(uint8_t *dst,uint8_t*src,uint16_t len)
bstr16_t bstr16_create(const uint8_t *data, uint16_t len);
uint8_t * bstr16_create_from_str(const char *s);
bstr16_t bstr16_create_from_str(const char *s);
extern uint8_t * bstr16_create_from_cfgstr(const char * s);
#define bstr16_replace bstr_replace

2
src/cw/bstr16_create_from_str.c
View File

@ -2,7 +2,7 @@
#include "format.h"
uint8_t * bstr16_create_from_str(const char *s)
bstr16_t bstr16_create_from_str(const char *s)
{
uint8_t * mem;
int msize;

18
src/cw/bstrv_create.c
View File

@ -1,18 +0,0 @@
#include "bstr.h"
/*
uint8_t * bstrv_create(uint32_t vendor_id, uint8_t *data, uint8_t len)
{
uint8_t * str = malloc(bstrv_size(len));
if (!str)
return 0;
bstrv_set_vendor_id(str,vendor_id);
bstrv_set_len(str,len);
memcpy(bstrv_data(str),data,len);
*(bstrv_data(str)+bstrv_len(str))=0;
return str;
}
*/

107
src/cw/cfg.c
View File

@ -3,10 +3,13 @@
#include <mavl.h>
#include "cw.h"
#include "cfg.h"
#include "val.h"
#include "cfg.h"
#include "dbg.h"
#include "log.h"
#include "cw.h"
static const char *nextc(const char *s)
{
@ -119,6 +122,30 @@ const char *cw_cfg_get(cw_Cfg_t * cfg, const char *key, const char *def)
return r->val;
}
const char *cw_cfg_get2(cw_Cfg_t *cfg1, cw_Cfg_t *cfg2, const char *key, const char *def)
{
return cw_cfg_get(cfg1, key, cw_cfg_get(cfg2,key,def));
}
bstr16_t cw_cfg_get_bstr16(cw_Cfg_t * cfg, const char * key, const char *def)
{
const char *s;
s = cw_cfg_get(cfg,key,def);
if(s==NULL)
return NULL;
return bstr16_create_from_str(s);
}
int cw_cfg_set_bstr16(cw_Cfg_t * cfg, const char * key, bstr16_t str)
{
CW_TYPE_BSTR16->read(cfg,key,bstr16_data(str),bstr16_len(str),NULL);
return 0;
}
void cw_cfg_dump(cw_Cfg_t * cfg)
@ -492,27 +519,95 @@ int cw_cfg_get_bool(cw_Cfg_t * cfg, const char * key, const char *def)
}
uint8_t cw_cfg_get_byte(cw_Cfg_t * cfg, char *key, const char * def)
uint8_t cw_cfg_get_byte(cw_Cfg_t * cfg, char *key, uint8_t def)
{
struct cw_Val v;
const char *s = cw_cfg_get(cfg,key,def);
memset(&v,0,sizeof(struct cw_Val));
const char *s = cw_cfg_get(cfg,key,NULL);
if (s==NULL)
return def;
CW_TYPE_BYTE->from_str(&v,s);
return v.val.word;
}
uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, const char * def)
uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, uint16_t def)
{
struct cw_Val v;
const char *s = cw_cfg_get(cfg,key,def);
const char *s = cw_cfg_get(cfg,key,NULL);
if (s==NULL)
return def;
CW_TYPE_WORD->from_str(&v,s);
return v.val.word;
}
/*
int cw_cfg_get_word(cw_Cfg_t * cfg, char *key, const char * def)
{
const char *s;
s=cw_cfg_get(cfg,key,def);
if (s==NULL)
return 0;
}
*/
void cw_cfg_set_int(cw_Cfg_t * cfg, const char * key, int val)
{
char a[128];
sprintf(a,"%d",val);
cw_cfg_set(cfg,key,a);
}
int cw_cfg_get_next_index(cw_Cfg_t * cfg, const char *key)
{
char ikey[CW_CFG_MAX_KEY_LEN];
struct cw_Cfg_entry search, * result;
char *d;
sprintf(ikey,"%s.%d",key,65536);
search.key=ikey;
/*//result = ktvn(ktv,&search);*/
result = mavl_get_last(cfg,&search);
if (result == NULL){
return 0;
}
d = strchr(result->key,'.');
if (d==NULL){
return 0;
}
if (strncmp(result->key,ikey,d-result->key)!=0)
return 0;
return atoi(d+1)+1;
}
int cw_cfg_set_val(cw_Cfg_t * cfg, const char *key, const struct cw_Type *type, const void * valguard, const uint8_t * data, int len)
{
cw_Val_t mdata, *mresult;
char str[2048];
memset(&mdata,0,sizeof(cw_Val_t));
mdata.type=type;
mdata.valguard=valguard;
cw_dbg(DBG_X,"SETVAL FOR TYPE: %s",type->name);
mresult = type->get(&mdata,data,len);
if (!mresult){
cw_log(LOG_ERR, "Can't create cfg element for key %s of type %s: %s",
key,type->name, strerror(errno));
free(mdata.key);
return 0;
}
type->to_str(&mdata,str,2048);
cw_cfg_set(cfg,key,str);
if (type->del)
type->del(&mdata);
return 1;
}

18
src/cw/cfg.h
View File

@ -2,6 +2,8 @@
#define _CFG_H
#include <mavl.h>
#include "val.h"
#include "bstr.h"
#define CW_CFG_MAX_KEY_LEN 1024
@ -30,9 +32,21 @@ const char *cw_cfg_iter_next(struct cw_Cfg_iter *cfi, const char *key);
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);
uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, uint16_t def);
void cw_cfg_set_int(cw_Cfg_t * cfg, const char * key, int val);
uint8_t cw_cfg_get_byte(cw_Cfg_t * cfg, char *key, const char * def);
uint8_t cw_cfg_get_byte(cw_Cfg_t * cfg, char *key, uint8_t def);
bstr16_t cw_cfg_get_bstr16(cw_Cfg_t * cfg, const char * key, const char *def);
int cw_cfg_set_bstr16(cw_Cfg_t * cfg, const char * key, bstr16_t str);
int cw_cfg_get_next_index(cw_Cfg_t * cfg, const char *key);
int cw_cfg_set_val(cw_Cfg_t * cfg, const char *key, const struct cw_Type *t, const void * valguard, const uint8_t * data, int len);
#define cw_cfg_get_word2(cfg1,cfg2,key,def) \
cw_cfg_get_word(cfg1,key,cw_cfg_get_word(cfg2,key,def))
#define cw_dget(fun,cfg1,cfg2,key,def)\
fun(cfg1,key,fun(cfg2,key,def))
#endif

19
src/cw/conn.c
View File

@ -54,7 +54,7 @@ int cw_assemble_message(struct cw_Conn *conn, uint8_t * rawout)
struct mlistelem * elem;
int len,l;
cw_dbg(DBG_INFO, "Number of elements in ktv: %d",conn->local_cfg->count);
//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");*/
/* rawout is already initialized, so we can get
@ -86,14 +86,13 @@ int cw_assemble_message(struct cw_Conn *conn, uint8_t * rawout)
data = mlistelem_dataptr(elem);
handler = cw_msgset_get_elemhandler(conn->msgset,data->proto,data->vendor,data->id);
printf("Elem: %d %d %d %s\n", data->proto, data->vendor, data->id, handler->name);
// cw_dbg(DBG_X,"Elem: %d %d %d %s\n", data->proto, data->vendor, data->id, handler->name);
if (handler==NULL){
cw_log(LOG_ERR,"Can't put message element %d %d %d, no handler defined.",
data->proto,data->vendor,data->id);
continue;
}
cw_dbg(DBG_X,"Hello!");
if (handler->put == NULL){
if (data->mand){
@ -104,11 +103,10 @@ cw_dbg(DBG_X,"Hello!");
continue;
}
/* params.conn=conn;*/
params.local_cfg=conn->local_cfg;
params.remote_cfg=conn->remote_cfg;
params.conn=conn;
params.cfg=conn->remote_cfg;
params.default_cfg=conn->default_cfg;
params.global_cfg=conn->global_cfg;
params.msgset=conn->msgset;
@ -123,11 +121,9 @@ cw_dbg(DBG_X,"Hello!");
cisco/ap-led-flash-config/flash-enable
}*/
cw_dbg(DBG_X,"Calling Handler put for %s",handler->name);
l = handler->put(handler,&params,dst+len);
cw_dbg(DBG_X,"L = %d",l);
/* if(l>0)
cw_dbg_elem(DBG_ELEM_OUT,conn,type,handler,dst+len,l);
@ -156,11 +152,12 @@ cw_dbg(DBG_X,"L = %d",l);
uint8_t *msg_ptr = rawout + offset;
int elems_len = cw_get_msg_elems_len(msg_ptr);
elems_ptr = cw_get_msg_elems_ptr(msg_ptr);
mavl_t * cfg = cw_ktv_create();
mavl_t * cfg = cw_cfg_create();
struct cw_ElemHandlerParams params;
params.remote_cfg=cfg;
params.cfg=cfg;
params.default_cfg=NULL;
params.msgset=conn->msgset;
params.msgdata=msg;

2
src/cw/conn.h
View File

@ -235,6 +235,8 @@ struct cw_Conn {
int detected;
void (*setup_complete)(struct cw_Conn *conn);
// void * mods;

28
src/cw/conn_process_packet.c
View File

@ -274,7 +274,7 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
}
/* Detect the connecting AC type */
/* Detect the connecting WTP type */
if (!conn->detected) {
struct cw_MsgSet *set =
@ -289,6 +289,10 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
conn->cmod->setup_cfg(conn);
conn->msgset = set;
conn->detected = 1;
if (conn->setup_complete)
conn->setup_complete(conn);
}
/** debug the received message */
@ -365,16 +369,6 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
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;
mand_found = mavl_create_conststr();
@ -386,8 +380,14 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
cw_dbg(DBG_MSG_PARSING, "*** Parsing message of type %d - (%s) ***",
message->type, message->name);
params.cfg = cw_cfg_create(); //conn->remote_cfg;
params.default_cfg = NULL;
params.from = from;
params.msgdata = message;
params.mand_found = mand_found;
params.msgset=conn->msgset;
params.conn = conn;
params.cfg = cw_cfg_create();
cw_decode_elements(&params,elems_ptr, elems_len);
/* all message elements are processed, do now after processing
@ -407,7 +407,8 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
if (message->postprocess) {
message->postprocess(conn);
// message->postprocess(conn);
message->postprocess(&params,elems_ptr, elems_len);
}
@ -660,7 +661,6 @@ int cw_read_messages(struct cw_Conn *conn)
{
uint8_t buf[2024];
int len = 2024;
cw_dbg(DBG_X,"Conn cw_read_messages from dsco request");
int n = conn->read(conn, buf, len);
if (n < 0)

2
src/cw/cw.h
View File

@ -527,7 +527,7 @@ int cw_put_elem_radio_administrative_state(uint8_t * dst, int rid, int state);
int cw_put_local_ip_address(uint8_t *dst, int id, int ipv_id, int ipv6_id,
uint8_t *src, int len);
int cw_detect_nat(struct cw_Conn *conn);
int cw_detect_nat(struct cw_ElemHandlerParams *conn);
uint8_t *cw_init_data_keep_alive_msg(uint8_t * buffer,uint8_t *rmac);

14
src/cw/cw_detect_nat.c
View File

@ -10,15 +10,13 @@
* @retval 1 NAT detected
* @retval 0 no NAT was detected
*/
int cw_detect_nat(struct cw_Conn *conn)
int cw_detect_nat(struct cw_ElemHandlerParams *params)
{
cw_Val_t * result;
const char * remote_str;
char local_str[128];
char remote_str[128];
result = cw_ktv_get(conn->remote_cfg,"capwap-local-ip-address",CW_TYPE_IPADDRESS);
if (result == NULL){
remote_str = cw_cfg_get(params->cfg,"capwap-local-ip-address",NULL);
if (remote_str == NULL){
cw_dbg(DBG_WARN,"Can't detect NAT. No local IP from peer received.");
return 0;
}
@ -26,8 +24,7 @@ int cw_detect_nat(struct cw_Conn *conn)
/* convert remote connected and sent ip addresse to
* strings */
sock_addrtostr((struct sockaddr*)&conn->addr,local_str,128,0);
result->type->to_str(result,remote_str,128);
sock_addrtostr((struct sockaddr*)&(params->conn->addr),local_str,128,0);
/* if connected and sent address is the same, there is
@ -37,3 +34,4 @@ int cw_detect_nat(struct cw_Conn *conn)
/* otherwise ther must be something between AC and WTP */
return 1;
}

41
src/cw/cw_in_generic.c
View File

@ -3,48 +3,35 @@
#include "msgset.h"
#include "val.h"
#include "log.h"
#include "dbg.h"
int cw_in_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
uint8_t * elem_data, int elem_len)
{
cw_Val_t * result;
cw_Val_t val;
cw_Type_t * type;
int n;
char strval[2048];
memset(&val,0,sizeof(cw_Val_t));
type = (cw_Type_t*)handler->type;
char mkey[CW_KTV_MAX_KEY_LEN];
const char *key;
if (!type){
cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
}
type->read(params->local_cfg, handler->key,elem_data,elem_len,handler->param);
// exit(0);
/* if (!result){
cw_log(LOG_ERR, "Can't create kvstore element for key %s of type %s: %s",
handler->key,type->name, strerror(errno));
return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
if (handler->mkkey != NULL){
handler->mkkey(handler->key,elem_data,elem_len, mkey);
key = mkey;
}
*/
else{
key = handler->key;
}
// n = type->to_str(&val,strval,2048);
// printf("SETTING: %s: %s (%d)\n",handler->key,strval,n);
// result = cw_ktv_add(params->remote_cfg, handler->key,
// handler->type,NULL, elem_data,elem_len);
// params->elem=result;
/* cw_dbg(DBG_X, "READ: %s / %s",type->name,key);*/
type->read(params->cfg, key,elem_data,elem_len,handler->param);
return CAPWAP_RESULT_SUCCESS;
}

9
src/cw/cw_in_generic_indexed_enum.c
View File

@ -1,6 +1,8 @@
#include "cw.h"
#include "cfg.h"
static const cw_ValEnum_t * get_enum(const cw_ValEnum_t * e, int val){
@ -21,7 +23,7 @@ int cw_in_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemHa
const cw_ValEnum_t * e;
const cw_ValIndexed_t * ie;
char key[CW_KTV_MAX_KEY_LEN];
char key[CW_CFG_MAX_KEY_LEN];
struct cw_ElemHandler thandler;
ie = handler->type;
@ -46,8 +48,11 @@ int cw_in_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemHa
}
memset(&thandler,0,sizeof(thandler));
thandler.type=e->type;
thandler.key=key;
thandler.type=e->type;
thandler.param=e->param;
return e->fun_in(&thandler,params,elem_data+f,elem_len-l);
}

6
src/cw/cw_in_generic_struct.c
View File

@ -3,12 +3,16 @@
#include "msgset.h"
#include "val.h"
#include "log.h"
#include "dbg.h"
int cw_in_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
uint8_t * elem_data, int elem_len)
{
cw_dbg(DBG_X,"STRUCT KEY: %s",handler->key);
stop();
const char * key;
char tmpkey[CW_KTV_MAX_KEY_LEN];
if (handler->mkkey != NULL){
handler->mkkey(key,elem_data,elem_len, tmpkey);
@ -29,7 +33,7 @@ printf("CW_IN_GENERIC STRUCT: %s\n",key);
return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
}
cw_ktv_read_struct(params->remote_cfg,handler->type,key,elem_data,elem_len);
cw_ktv_read_struct(params->cfg,handler->type,key,elem_data,elem_len);
return CAPWAP_RESULT_SUCCESS;
}

8
src/cw/cw_in_generic_with_index.c
View File

@ -1,4 +1,5 @@
#include "cw.h"
#include "dbg.h"
int cw_in_generic_with_index(struct cw_ElemHandler *eh,
struct cw_ElemHandlerParams *params,
@ -6,9 +7,12 @@ int cw_in_generic_with_index(struct cw_ElemHandler *eh,
{
char key[CW_KTV_MAX_KEY_LEN];
int idx;
cw_dbg(DBG_X,"Fix cw_in_generic_with_index");
stop();
idx = cw_get_byte(data);
sprintf(key,"%s.%d",eh->key,idx);
cw_ktv_add(params->remote_cfg,key,eh->type,NULL,data+1,len-1);
// cw_cfg_add(params->cfg,key,eh->type,NULL,data+1,len-1);
return 1;
}

7
src/cw/cw_in_idx_generic.c
View File

@ -1,9 +1,12 @@
#include "cw.h"
#include "log.h"
#include "dbg.h"
int cw_in_idx_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
uint8_t * elem_data, int elem_len)
{
stop();
/*
char key[CW_KTV_MAX_KEY_LEN];
cw_Val_t * result;
int idx;
@ -16,10 +19,10 @@ int cw_in_idx_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerPara
idx=cw_get_byte(elem_data);
sprintf(key,handler->key,idx);
result = cw_ktv_add(params->remote_cfg, key,
result = cw_ktv_add(params->cfg, key,
handler->type, NULL, elem_data+1,elem_len-1);
// params->elem=result;
*/
return CAPWAP_RESULT_SUCCESS;
}

8
src/cw/cw_in_idx_generic_struct.c
View File

@ -4,12 +4,18 @@
#include "val.h"
#include "log.h"
#include "cw.h"
#include "dbg.h"
int cw_in_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
uint8_t * elem_data, int elem_len)
{
char key[CW_KTV_MAX_KEY_LEN];
int idx;
cw_dbg(DBG_X,"Fix cw_in_idx_generic_struct");
exit(1);
if (!handler->type){
cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
@ -19,7 +25,7 @@ int cw_in_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHand
idx = cw_get_byte(elem_data);
sprintf(key, handler->key, idx);
cw_ktv_read_struct(params->remote_cfg,handler->type,key,elem_data+1,elem_len-1);
cw_ktv_read_struct(params->cfg,handler->type,key,elem_data+1,elem_len-1);
return CAPWAP_RESULT_SUCCESS;
}

7
src/cw/cw_in_radio_generic_struct.c
View File

@ -5,9 +5,14 @@
#include "log.h"
#include "cw.h"
#include "dbg.h"
int cw_in_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
uint8_t * elem_data, int elem_len)
{
stop();
char key[CW_KTV_MAX_KEY_LEN];
int radio;
@ -19,7 +24,7 @@ int cw_in_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHa
radio = cw_get_byte(elem_data);
sprintf(key,"radio.%d/%s",radio,handler->key);
cw_ktv_read_struct(params->remote_cfg,handler->type,key,elem_data+1,elem_len-1);
cw_ktv_read_struct(params->cfg,handler->type,key,elem_data+1,elem_len-1);
/*params->elem=result;*/

1
src/cw/cw_ktv_add.c
View File

@ -10,7 +10,6 @@ cw_Val_t * cw_ktv_add(mavl_t kvtstore, const char *key, const struct cw_Type *ty
{
cw_Val_t mdata, *mresult;
int exists;
mdata.key=cw_strdup(key);
mdata.valguard=valguard;

45
src/cw/cw_out_generic.c
View File

@ -12,19 +12,18 @@ int cw_out_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams
, uint8_t * dst)
{
struct cw_Val * elem;
int start, len, l;
/* Get the element */
/* search.key=(char*)handler->key;
elem = mavl_get(params->conn->local_cfg, &search);
*/
elem = cw_ktv_get(params->local_cfg,handler->key,NULL);
/* if (elem == NULL && params->conn->default_cfg !=NULL)
elem = mavl_get(params->conn->default_cfg, &search);
*/
if (elem == NULL) {
// cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
// cw_cfg_dump(params->cfg);
// cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!! ENDDUMP");
start = params->msgset->header_len(handler);
len = ((const cw_Type_t*)(handler->type))->
write(params->cfg,handler->key,dst+start,handler->param);
if (len == -1) {
const char *vendor="";
if ( handler->vendor ) {
vendor=cw_strvendor(handler->vendor);
@ -46,31 +45,7 @@ int cw_out_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams
return 0;
}
/* Size for msg elem header depends on
vendor specific payload */
/* start = handler->vendor ? 10 : 4; */
start = params->msgset->header_len(handler);
if (cw_ktv_cast(elem,handler->type)==NULL){
cw_log(LOG_ERR,"Can't put element '%s'- can't cast from %s to %s for key: %s", handler->name,
elem->type->name, ((const cw_Type_t*)handler->type)->name, handler->key);
return 0;
}
len = ((const cw_Type_t*)(handler->type))->put(elem,dst+start);
/* ((const cw_Type_t*)(handler->type))->to_str(elem,detail,120);
sprintf(params->debug_details, " Value = %s", detail);
params->elem = elem;*/
/* if (handler->vendor)
return len + cw_put_elem_vendor_hdr(dst, handler->vendor, handler->id, len);
l = len + cw_put_elem_hdr(dst, handler->id, len); */
l = params->msgset->write_header(handler,dst,len);
cw_dbg_elem(DBG_ELEM_OUT,NULL,params->msgdata->type,handler,dst,l);
/* cw_dbg_elem(DBG_ELEM_OUT,params->conn,params->msgdata->type,handler,dst,l);*/
return l;
}

10
src/cw/cw_out_generic_indexed_enum.c
View File

@ -1,8 +1,14 @@
#include "cw.h"
#include"dbg.h"
int cw_out_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
, uint8_t * dst)
{
cw_dbg(DBG_X,"Fix: cw_out_generic_indexed_enum");
exit(1);
char key[CW_KTV_MAX_KEY_LEN];
int i;
cw_Val_t * result;
@ -24,7 +30,7 @@ int cw_out_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemH
//printf("Her is the Key: %s - %s\n",key, );
result = cw_ktv_base_exists(params->local_cfg,key);
result = cw_ktv_base_exists(params->cfg,key);
if (result==NULL)
continue;
start = params->msgset->header_len(handler);
@ -35,7 +41,7 @@ int cw_out_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemH
if (e[i].fun_out==NULL)
len += result->type->put(result,ob+start+len);
else
len += cw_ktv_write_struct(params->local_cfg,
len += cw_ktv_write_struct(params->cfg,
NULL,e[i].type,key,ob+start+len);
cw_set_byte(ob+start+ie->idxpos,e[i].value);

10
src/cw/cw_out_generic_struct.c
View File

@ -4,9 +4,15 @@
#include "log.h"
#include "cw.h"
#include "dbg.h"
int cw_out_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
, uint8_t * dst)
{
stop();
int start;
int len;
cw_Val_t search, *result;
@ -17,7 +23,7 @@ int cw_out_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandler
}
search.key = (char*)handler->key;
result = mavl_get_first(params->local_cfg,&search);
result = mavl_get_first(params->cfg,&search);
if (result == NULL ){
if (params->elemdata->mand)
cw_log(LOG_ERR,"Can't put mandatory message element %s, no data available",handler->name);
@ -32,7 +38,7 @@ int cw_out_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandler
start = params->msgset->header_len(handler);
len = cw_ktv_write_struct(params->local_cfg,
len = cw_ktv_write_struct(params->cfg,
params->default_cfg,
handler->type,handler->key,dst+start);

4
src/cw/cw_out_generic_with_index.c
View File

@ -1,10 +1,12 @@
#include "cw.h"
#include "dbg.h"
int cw_out_generic_with_index(struct cw_ElemHandler * eh,
struct cw_ElemHandlerParams * params, uint8_t * dst)
{
stop();
char key[CW_KTV_MAX_KEY_LEN];
int idx;
cw_Val_t * result, search;
@ -18,7 +20,7 @@ int cw_out_generic_with_index(struct cw_ElemHandler * eh,
do {
sprintf(key,"%s.%d",eh->key,idx);
search.key=key;
result = mavl_get_first(params->local_cfg,&search);
result = mavl_get_first(params->cfg,&search);
if (result==NULL)
break;
if (strncmp(result->key,key,strlen(key))!=0)

7
src/cw/cw_out_idx_generic_struct.c
View File

@ -5,6 +5,9 @@
int cw_out_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
, uint8_t * dst)
{
stop();
char key[CW_KTV_MAX_KEY_LEN];
struct cw_Val * elem, search;
int i;
@ -24,7 +27,7 @@ int cw_out_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHan
sprintf(key,handler->key,i);
search.key=key;
/*elem = mavl_get(params->conn->local_cfg, &search);*/
elem = mavl_get_first(params->local_cfg,&search);
elem = mavl_get_first(params->cfg,&search);
if(elem != NULL){
printf("Elem key: %s\n",elem->key);
}
@ -41,7 +44,7 @@ int cw_out_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHan
start = mdst + params->msgset->header_len(handler);
len += cw_put_byte(start+len,idx);
len += cw_ktv_write_struct(params->local_cfg,NULL, handler->type,key,start+len);
len += cw_ktv_write_struct(params->cfg,NULL, handler->type,key,start+len);
mdst += params->msgset->write_header(handler,mdst,len);

4
src/cw/cw_out_radio_generic.c
View File

@ -7,6 +7,8 @@ int cw_ktv_idx_get_next(mavl_t ktv, const char *key, int n);
int cw_out_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
, uint8_t * dst)
{
stop();
int len,i,l;
int radios;
len =0;
@ -20,7 +22,7 @@ int cw_out_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerP
idx++;
}
*/
radios = cw_ktv_get_byte(params->local_cfg,"wtp-descriptor/max-radios",0);
radios = cw_ktv_get_byte(params->cfg,"wtp-descriptor/max-radios",0);
for(i=0;i<radios;i++){
l = cw_write_radio_element(handler,params,i,dst+len);

18
src/cw/cw_out_radio_generic_struct.c
View File

@ -7,6 +7,8 @@ int cw_ktv_idx_get_next(mavl_t ktv, const char *key, int n);
int cw_out_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
, uint8_t * dst)
{
stop();
int i,l, offset;
uint8_t * cdst;
@ -21,12 +23,12 @@ int cw_out_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemH
char basekey[CW_KTV_MAX_KEY_LEN];
cw_Val_t * result;
i = cw_ktv_idx_get_next(params->local_cfg,"radio",i+1);
i = cw_ktv_idx_get_next(params->cfg,"radio",i+1);
if (i==-1)
break;
sprintf(basekey,"radio.%d/%s",i,handler->key);
result = cw_ktv_base_exists(params->local_cfg,basekey);
result = cw_ktv_base_exists(params->cfg,basekey);
if (result == NULL){
continue;
}
@ -34,7 +36,7 @@ int cw_out_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemH
l=0;
l+=cw_put_byte(cdst+offset+l,i);
l+= cw_ktv_write_struct(params->local_cfg,NULL, handler->type,basekey,cdst+offset+l);
l+= cw_ktv_write_struct(params->cfg,NULL, handler->type,basekey,cdst+offset+l);
cdst+=params->msgset->write_header(handler,cdst,l);
@ -59,7 +61,7 @@ printf("Next: %s\n", next);
if (sl==NULL){
cw_Val_t * result;
sprintf(key,"%s/%s",current,next);
result = cw_ktv_base_exists(params->local_cfg,key);
result = cw_ktv_base_exists(params->cfg,key);
if (result != NULL){
int offset;
int i,l;
@ -68,7 +70,7 @@ printf("Next: %s\n", next);
for (i=0;i<stack[0];i++){
printf("I=%i\n",stack[i+1]);
}
l= cw_ktv_write_struct(params->local_cfg,params->default_cfg,
l= cw_ktv_write_struct(params->cfg,params->default_cfg,
handler->type,key,dst+offset);
printf("Write struct len %i\n",l);
@ -96,19 +98,19 @@ printf("current is %s\n", current);
printf("Here we are %s\n",key);
cw_dbg_ktv_dump(params->local_cfg,DBG_INFO,"start"," ", "end" );
cw_dbg_ktv_dump(params->cfg,DBG_INFO,"start"," ", "end" );
i=-1;
while(1){
char basekey[CW_KTV_MAX_KEY_LEN];
cw_Val_t * result;
i = cw_ktv_idx_get_next(params->local_cfg,key,i+1);
i = cw_ktv_idx_get_next(params->cfg,key,i+1);
if (i==-1)
break;
sprintf(basekey,"%s.%d",key,i);
printf("Our basekey is %s\n",basekey);
result = cw_ktv_base_exists(params->local_cfg,basekey);
result = cw_ktv_base_exists(params->cfg,basekey);
if (result == NULL){
continue;
}

5
src/cw/cw_read_ac_descriptor.c
View File

@ -31,8 +31,9 @@ int cw_read_ac_descriptor(mavl_t store,
uint8_t *data, int len,
struct cw_DescriptorSubelemDef *allowed)
{
cw_ktv_read_struct(params->remote_cfg,acstatus,eh->key,data,len);
CW_TYPE_STRUCT->read(params->cfg,eh->key,data,len,acstatus);
// cw_ktv_read_struct(params->remote_cfg,acstatus,eh->key,data,len);
if (!allowed)
allowed=allowed_default;

17
src/cw/cw_read_radio_generic.c
View File

@ -5,26 +5,29 @@
#include "log.h"
#include "cw.h"
#include "dbg.h"
int cw_in_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
uint8_t * elem_data, int elem_len)
{
char key[CW_KTV_MAX_KEY_LEN];
cw_Val_t * result;
char key[CW_CFG_MAX_KEY_LEN];
int radio;
struct cw_Type *type;
type = (struct cw_Type*)handler->type;
if (!handler->type){
if (!type){
cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
}
radio=cw_get_byte(elem_data);
sprintf(key,"radio.%d/%s",radio,handler->key);
result = cw_ktv_add(params->remote_cfg, key,
handler->type, NULL, elem_data+1,elem_len-1);
// params->elem=result;
/*cw_cfg_set_val(params->cfg, key,
handler->type, handler->param, elem_data+1,elem_len-1);*/
type->read(params->cfg, key,elem_data+1,elem_len-1,handler->param);
return CAPWAP_RESULT_SUCCESS;
}

9
src/cw/cw_setup_dtls.c
View File

@ -1,5 +1,6 @@
#include "cw.h"
#include "cfg.h"
#include "dbg.h"
@ -47,7 +48,6 @@ int cw_setup_dtls(struct cw_Conn *conn, mavl_t cfg, const char *prefix,
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);
@ -61,9 +61,9 @@ int cw_setup_dtls(struct cw_Conn *conn, mavl_t cfg, const char *prefix,
sprintf(key, "%s/%s", prefix, "ssl-certfile");
ssl_cert = cw_cfg_get(conn->local_cfg, key, NULL);
ssl_cert = cw_cfg_get(cfg, key, NULL);
sprintf(key, "%s/%s", prefix, "ssl-keyfile");
ssl_key = cw_cfg_get(conn->local_cfg, key, NULL);
ssl_key = cw_cfg_get(cfg, key, NULL);
if (ssl_cert != NULL && ssl_key != NULL) {
conn->dtls_cert_file = ssl_cert;
@ -74,9 +74,8 @@ int cw_setup_dtls(struct cw_Conn *conn, mavl_t cfg, const char *prefix,
}
sprintf(key, "%s/%s", prefix, "ssl-dhbits");
conn->dtls_dhbits = cw_cfg_get_word(cfg, key, "1024");
conn->dtls_dhbits = cw_cfg_get_word(cfg, key, 1024);
conn->dtls_get_psk = get_psk;
return security;
}

23
src/cw/cw_type_bool.c
View File

@ -84,6 +84,25 @@ static const char * get_type_name(cw_Val_t *data)
return CW_TYPE_BOOL->name;
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
cw_Val_t val;
int l;
char str[2048];
memset(&val,0,sizeof(cw_Val_t));
val.valguard = param;
get(&val,src,len);
to_str(&val,str,2048);
cw_cfg_set(cfg,key,str);
l = val.type->len(&val);
if (val.type->del)
val.type->del(&val);
return l;
}
const struct cw_Type cw_type_bool = {
"Bool", /* name */
NULL, /* del */
@ -93,5 +112,7 @@ const struct cw_Type cw_type_bool = {
from_str, /* from_str */
len, /* len */
data, /* data */
get_type_name /* get_type_name */
get_type_name, /* get_type_name */
NULL,
bread
};

49
src/cw/cw_type_bstr16.c
View File

@ -104,7 +104,7 @@ static int cast(cw_Val_t * data)
return 0;
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, void *param)
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
char *d, *dst;
dst = malloc(len*2+3);
@ -125,9 +125,52 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, v
return d - dst;
}
static int bwrite(cw_Cfg_t *cfg, const char *key, const uint8_t *dst, void * param)
static int xput(uint8_t * dst,const char *s)
{
return 0;
int msize;
int l;
l = strlen(s);
if (s[0]!='.'){
memcpy(dst,(uint8_t*)s,l);
return l;
}
if (l<=2){
memcpy(dst,(uint8_t*)s,l);
return l;
}
if (s[1]=='.'){
memcpy(dst,(uint8_t*)s+1,l-1);
return l-1;
}
if (s[1]!='x'){
memcpy(dst,(uint8_t*)s,l);
return l;
}
/* the string starts with ".x" - read hexbytes */
l-=2;
msize=l/2;
if(l&1)
msize++;
cw_format_scan_hex_bytes(dst,s+2,l);
return msize;
}
static int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param)
{
const char *s;
s = cw_cfg_get(cfg,key,NULL);
if (s==NULL)
return -1;
return xput(dst,s);
}

19
src/cw/cw_type_byte.c
View File

@ -124,7 +124,7 @@ static int cast(cw_Val_t * data)
return 0;
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, void *param)
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
uint8_t val;
cw_ValValRange_t * valrange = (cw_ValValRange_t *) param;
@ -140,9 +140,22 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, v
return 1;
}
static int bwrite(cw_Cfg_t *cfg, const char *key, const uint8_t *dst, void * param)
static int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param)
{
return 0;
cw_Val_t val;
int l;
const char *s;
memset(&val,0,sizeof(cw_Val_t));
val.valguard=param;
s = cw_cfg_get(cfg,key,NULL);
if (s==NULL)
return -1;
from_str(&val,s);
l = put(&val,dst);
if(val.type->del)
val.type->del(&val);
return l;
}
const struct cw_Type cw_type_byte = {

40
src/cw/cw_type_dword.c
View File

@ -66,6 +66,42 @@ static int cast(cw_Val_t * data)
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
uint32_t val;
//cw_ValValRange_t * valrange = (cw_ValValRange_t *) param;
//const char *str;
val = cw_get_dword(src);
/* str = get_guardstr(val, valrange);
if (str != NULL)
cw_cfg_set(cfg,key,str);
else*/
cw_cfg_set_int(cfg,key,val);
return 4;
}
static int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param)
{
cw_Val_t val;
int l;
const char *s;
memset(&val,0,sizeof(cw_Val_t));
val.valguard=param;
s = cw_cfg_get(cfg,key,NULL);
if (s==NULL)
return -1;
from_str(&val,s);
l = put(&val,dst);
if(val.type->del)
val.type->del(&val);
return l;
}
const struct cw_Type cw_type_dword = {
"Dword", /* name */
NULL, /* del */
@ -76,6 +112,8 @@ const struct cw_Type cw_type_dword = {
NULL, /* len */
NULL, /* data */
get_type_name, /* get_type_name */
cast
cast,
bread,
bwrite
};

23
src/cw/cw_type_ipaddress.c
View File

@ -111,6 +111,24 @@ static const char * get_type_name(cw_Val_t *data)
return CW_TYPE_IPADDRESS->name;
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
char str[128];
int rc;
cw_Val_t val;
memset(&val,0,sizeof(cw_Val_t));
get(&val,src,len);
to_str(&val,str,128);
cw_cfg_set(cfg,key,str);
rc = val.type->len(&val);
del(&val);
return rc;
}
const struct cw_Type cw_type_ipaddress = {
"IPAddress", /* name */
del, /* del */
@ -120,7 +138,10 @@ const struct cw_Type cw_type_ipaddress = {
from_str, /* from_str */
len, /* len */
data, /* data */
get_type_name
get_type_name,
NULL,
bread,
};

21
src/cw/cw_type_str.c
View File

@ -90,6 +90,21 @@ static const char * get_type_name(cw_Val_t *data)
return CW_TYPE_STR->name;
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
cw_Val_t val;
int l;
char str[2048];
memset(&val,0,sizeof(cw_Val_t));
val.valguard = param;
get(&val,src,len);
to_str(&val,str,2048);
cw_cfg_set(cfg,key,str);
l = val.type->len(&val);
del(&val);
return l;
}
const struct cw_Type cw_type_str = {
@ -101,5 +116,9 @@ const struct cw_Type cw_type_str = {
from_str, /* from_str */
len, /* len */
NULL, /* data */
get_type_name /* get_type_name */
get_type_name, /* get_type_name */
NULL,
bread,
};

2
src/cw/cw_type_struct.c
View File

@ -79,7 +79,7 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
const struct cw_Type cw_type_struct = {
"Byte", /* name */
"Struct", /* name */
NULL, /* del */
NULL, /* put */
NULL, /* get */

38
src/cw/cw_type_word.c
View File

@ -63,6 +63,40 @@ static int cast(cw_Val_t * data)
return 0;
}
static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
{
uint16_t val;
//cw_ValValRange_t * valrange = (cw_ValValRange_t *) param;
//const char *str;
val = cw_get_word(src);
/* str = get_guardstr(val, valrange);
if (str != NULL)
cw_cfg_set(cfg,key,str);
else*/
cw_cfg_set_int(cfg,key,val);
return 2;
}
static int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param)
{
cw_Val_t val;
int l;
const char *s;
memset(&val,0,sizeof(cw_Val_t));
val.valguard=param;
s = cw_cfg_get(cfg,key,NULL);
if (s==NULL)
return -1;
from_str(&val,s);
l = put(&val,dst);
if(val.type->del)
val.type->del(&val);
return l;
}
const struct cw_Type cw_type_word = {
"Word", /* name */
@ -74,7 +108,9 @@ const struct cw_Type cw_type_word = {
NULL,
NULL,
get_type_name,
cast
cast,
bread,
bwrite,
};

26
src/cw/cw_write_descriptor_subelem.c
View File

@ -3,30 +3,34 @@
#include "log.h"
#include "cw.h"
#include "dbg.h"
#include "cfg.h"
int cw_write_descriptor_subelem (uint8_t *dst, mavl_t ktvstore,
int cw_write_descriptor_subelem (uint8_t *dst, cw_Cfg_t * cfg,
int subelem_id, const char * parent_key )
{
char key[256];
cw_Val_t * vendor, *version ;
uint8_t *d;
uint32_t vendor;
bstr16_t version;
const char *vendor_s;
uint8_t *d;
/* d += cw_put_dword(d, bstrv_get_vendor_id(v));
d += cw_put_dword(d, (subelem_id << 16) | bstrv_len(v));
d += cw_put_data(d, bstrv_data(v), bstrv_len(v));
*/
sprintf (key, "%s/%s", parent_key, CW_SKEY_VENDOR);
vendor = cw_ktv_get (ktvstore, key, CW_TYPE_DWORD);
vendor_s = cw_cfg_get (cfg, key, NULL);
if (vendor == NULL) {
if (vendor_s == NULL) {
cw_log (LOG_ERR, "Can't put subelem %s, no value of type Dword found.", key);
return 0;
}
vendor = atoi(vendor_s);
sprintf (key, "%s/%s", parent_key, CW_SKEY_VERSION);
version = cw_ktv_get (ktvstore, key, CW_TYPE_BSTR16);
version = cw_cfg_get_bstr16 (cfg, key, NULL);
if (version == NULL) {
cw_log (LOG_ERR, "Can't put subelem %s, no value of type Bstr16 found.", key);
@ -36,12 +40,14 @@ int cw_write_descriptor_subelem (uint8_t *dst, mavl_t ktvstore,
d = dst;
/* put vendor */
d += vendor->type->put (vendor, d);
d += cw_put_dword(d, vendor); //->type->put (vendor, d);
/* put version */
d += cw_put_dword (d, (subelem_id << 16) | version->type->len(version));
d += version->type->put(version,d);
d += cw_put_dword (d, (subelem_id << 16) | bstr16_len(version));
d += cw_put_bstr16(d, version);
free(version);
return d-dst;
}

5
src/cw/cw_write_radio_element.c
View File

@ -4,6 +4,9 @@
int cw_write_radio_element(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params, int idx
, uint8_t * dst)
{
return 0;
stop();
char key[CW_KTV_MAX_KEY_LEN];
cw_Val_t *elem, search;
int len;
@ -15,7 +18,7 @@ int cw_write_radio_element(struct cw_ElemHandler * handler, struct cw_ElemHandle
printf("Looking for readio key: %s\n",key);
search.key=key;
elem = mavl_get(params->local_cfg, &search);
elem = mavl_get(params->cfg, &search);
if (elem==NULL){
printf("Nothing found\n");

3
src/cw/dbg.h
View File

@ -234,6 +234,9 @@ void cw_dbg_ktv_dump(mavl_t ktv, uint32_t dbglevel,
*/
int cw_dbg_is_level(int level);
#define stop() printf("STOP IN %s:%d - %s\n", __FILE__, __LINE__, __FUNCTION__); exit(1)
/**
*@} LOGDBG
*/

4
src/cw/dtls_common.h
View File

@ -7,7 +7,7 @@ struct dtls_ssl_cert
uint8_t * data;
};
extern int dtls_bio_read(struct conn *conn, char *out, int maxlen);
extern int dtls_bio_write(struct conn * conn, const char *data, int len);
extern int dtls_bio_read(struct cw_Conn *conn, char *out, int maxlen);
extern int dtls_bio_write(struct cw_Conn * conn, const char *data, int len);

1
src/cw/dtls_openssl.c
View File

@ -392,7 +392,6 @@ struct dtls_openssl_data * dtls_openssl_data_create(struct cw_Conn * conn, const
SSL_CTX_set_timeout(d->ctx,30);
rc =SSL_CTX_set_max_proto_version (d->ctx,DTLS1_VERSION);
printf("MAXMAMX = %d\n",rc);
/*

10
src/cw/mod.h
View File

@ -52,7 +52,7 @@ struct cw_Mod {
* @param conn current connection
* @return 0 if notdetected
**/
int (*detect) (struct conn * conn, const uint8_t * rawmsg, int rawlen,
int (*detect) (struct cw_Conn * conn, const uint8_t * rawmsg, int rawlen,
int elems_len, struct sockaddr * from, int mode);
@ -68,7 +68,7 @@ struct cw_Mod {
/** used for private data */
void *data;
int (*setup_cfg)(struct conn *conn);
int (*setup_cfg)(struct cw_Conn *conn);
};
@ -79,7 +79,7 @@ extern struct cw_Mod mod_null;
#define MOD_NULL (&mod_null)
/*
struct cw_actiondef * mod_cache_add(struct conn *conn,struct cw_Mod *c, struct cw_Mod *b);
struct cw_actiondef * mod_cache_add(struct cw_Conn *conn,struct cw_Mod *c, struct cw_Mod *b);
*/
#define mod_init_config(mod,cfg) (mod->init_config ? mod->init_config(cfg):1)
@ -95,11 +95,11 @@ extern int mod_caching;
struct cw_Mod * cw_mod_load(const char * mod_name, mavl_t global_cfg, int role);
struct cw_Mod * cw_mod_add_to_list(struct cw_Mod * mod );
struct cw_Mod * cw_mod_detect(struct conn *conn,
struct cw_Mod * cw_mod_detect(struct cw_Conn *conn,
uint8_t * rawmsg, int len,
int elems_len, struct sockaddr *from,
int mode);
struct cw_MsgSet *cw_mod_get_msg_set(struct conn *conn,
struct cw_MsgSet *cw_mod_get_msg_set(struct cw_Conn *conn,
struct cw_Mod * capwap_mod, struct cw_Mod *bindings_mod);
void cw_mod_set_path(const char * path);

18
src/cw/msgset.c
View File

@ -387,3 +387,21 @@ struct cw_MsgData *cw_msgset_get_msgdata(struct cw_MsgSet *set, int type)
search.type = type;
return mavl_get(set->msgdata, &search);
}
typedef int (*cw_MsgCallbackFun)(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len);
cw_MsgCallbackFun cw_msgset_set_postprocess(struct cw_MsgSet * set,int msg_id,
cw_MsgCallbackFun fun)
{
struct cw_MsgData * md;
cw_MsgCallbackFun old_callback;
md = cw_msgset_get_msgdata(set,msg_id);
if (md != NULL){
old_callback = md->postprocess;
md->postprocess=fun;
}
return old_callback;
}

24
src/cw/msgset.h
View File

@ -24,7 +24,8 @@ struct cw_ElemData{
};
struct cw_ElemHandlerParams {
/* struct conn * conn;*/
struct cw_Conn * conn; /**< a connection the message belongs to*/
struct cw_MsgSet * msgset;
struct cw_MsgData * msgdata;
struct cw_ElemData * elemdata;
struct sockaddr *from;
@ -32,11 +33,7 @@ struct cw_ElemHandlerParams {
// cw_Val_t * elem;
char * debug_details;
cw_Cfg_t * cfg;
mavl_t remote_cfg;
mavl_t local_cfg;
mavl_t default_cfg;
mavl_t global_cfg;
struct cw_MsgSet * msgset;
cw_Cfg_t * default_cfg;
};
@ -90,7 +87,9 @@ struct cw_MsgDef{
struct cw_ElemDef * elements;
int (*preprocess)(struct conn * conn);
int (*postprocess)(struct conn * conn);
// int (*postprocess)(struct conn * conn);
int (*postprocess)(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len);
/* uint8_t next_state;*/
};
@ -107,7 +106,8 @@ struct cw_MsgData{
mlist_t mand_keys; /**< Keys of mandatory elements */
int (*preprocess)(struct conn * conn);
int (*postprocess)(struct conn * conn);
//int (*postprocess)(struct conn * conn);
int (*postprocess)(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len);
/* uint8_t next_state;*/
};
@ -141,4 +141,12 @@ struct cw_ElemHandler * cw_msgset_get_elemhandler(struct cw_MsgSet * set,
int proto, int vendor, int id);
#define CW_MSGSET_POSTPROCESS 1
#define CW_MSGSET_PREPROCESS 2
typedef int (*cw_MsgCallbackFun)(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len);
cw_MsgCallbackFun cw_msgset_set_postprocess(struct cw_MsgSet * set,int msg_id,
cw_MsgCallbackFun fun);
#endif

6
src/cw/val.h
View File

@ -8,7 +8,6 @@
#include "mavltypes.h"
#include "bstr.h"
#include "cfg.h"
/**
@ -24,6 +23,8 @@
#define CW_KTV_MAX_KEY_LEN 1024
typedef struct mavl cw_Cfg_t;
/**
* @struct cw_Val
* @file ktv.h
@ -93,7 +94,7 @@ struct cw_Type {
int (*cast)(cw_Val_t *);
int (*read)(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void * param);
int (*write)(cw_Cfg_t *cfg, const char *key, const uint8_t *dst, const void * param);
int (*write)(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param);
};
typedef struct cw_Type cw_Type_t;
@ -134,6 +135,7 @@ struct cw_ValEnum{
const void * type;
int (*fun_in)();
int (*fun_out)();
void *param;
};
typedef struct cw_ValEnum cw_ValEnum_t;