468 lines
11 KiB
C
468 lines
11 KiB
C
#include "cw.h"
|
|
#include "log.h"
|
|
#include "dbg.h"
|
|
#include "keys.h"
|
|
|
|
int cw_in_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
|
|
uint8_t * elem_data, int elem_len)
|
|
{
|
|
cw_Type_t * type;
|
|
type = (cw_Type_t*)handler->type;
|
|
char mkey[CW_CFG_MAX_KEY_LEN];
|
|
const char *key;
|
|
|
|
// cw_dbg(DBG_X,"HK: %s",handler->key,);
|
|
|
|
if (!type){
|
|
cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
|
|
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;
|
|
}
|
|
// 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;
|
|
}
|
|
|
|
|
|
|
|
int cw_out_generic0(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst,const char *key)
|
|
{
|
|
int start, len, l;
|
|
|
|
// cw_dbg(DBG_X,"cw_out_generic (%s)%s",((struct cw_Type*)handler->type)->name,handler->key);
|
|
|
|
// cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
|
|
// cw_cfg_dump(params->cfg);
|
|
// cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!! ENDDUMP");
|
|
//
|
|
//
|
|
if (!params->elemdata->mand){
|
|
if (!cw_cfg_base_exists(params->cfg_list[0],key)){
|
|
cw_dbg(DBG_MSG_COMPOSE," Add Elem: %d %d %d %s %s - (bskip)",
|
|
params->elemdata->proto,
|
|
params->elemdata->vendor,
|
|
params->elemdata->id,
|
|
handler->name, key);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
start = params->msgset->header_len(handler);
|
|
len = ((const cw_Type_t*)(handler->type))->
|
|
write(params->cfg_list,key,dst+start,handler->param);
|
|
// cw_dbg(DBG_X, "Type result is %d",len);
|
|
|
|
if (len == -1) {
|
|
const char *vendor="";
|
|
if ( handler->vendor ) {
|
|
vendor=cw_strvendor(handler->vendor);
|
|
}
|
|
if ( params->elemdata->mand) {
|
|
cw_log(LOG_ERR,
|
|
"Can't put mandatory element %s %d-(%s) into %s. No value for '%s' found.",
|
|
vendor, handler->id, handler->name, params->msgdata->name
|
|
, key
|
|
);
|
|
}
|
|
else{
|
|
/* cw_dbg(DBG_WARN,"No output for element %s%d -(%s) in %s. Item %s not found.",
|
|
vendor,
|
|
a->elem_id, cw_strelemp(conn->actions, a->elem_id)
|
|
, cw_strmsg(a->msg_id),a->item_id);
|
|
*/
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
l = params->msgset->write_header(handler,dst,len);
|
|
|
|
return l;
|
|
|
|
|
|
}
|
|
|
|
|
|
int cw_out_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst)
|
|
{
|
|
return cw_out_generic0(handler,params,dst,handler->key);
|
|
}
|
|
|
|
|
|
|
|
int cw_in_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
|
|
uint8_t * elem_data, int elem_len)
|
|
{
|
|
char key[CW_CFG_MAX_KEY_LEN];
|
|
int radio;
|
|
struct cw_Type *type;
|
|
type = (struct cw_Type*)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);
|
|
|
|
/*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;
|
|
}
|
|
|
|
int cw_out_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst)
|
|
{
|
|
char key[CW_CFG_MAX_KEY_LEN];
|
|
struct cw_Type * type;
|
|
|
|
int len,i,l,start;
|
|
int radios;
|
|
len =0;
|
|
|
|
for (i=0; (i=cw_cfg_get_first_index_l(params->cfg_list,"radio",i))!=-1; i++){
|
|
sprintf(key,"radio.%d/%s",i,handler->key);
|
|
if (!params->elemdata->mand){
|
|
if (!cw_cfg_base_exists(params->cfg_list[0],key)){
|
|
cw_dbg(DBG_MSG_COMPOSE," Add Elem: %d %d %d %s %s - (skip)",
|
|
params->elemdata->proto,
|
|
params->elemdata->vendor,
|
|
params->elemdata->id,
|
|
handler->name, key);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
type = (struct cw_Type*)handler->type;
|
|
start = params->msgset->header_len(handler)+len;
|
|
|
|
l = type->write(params->cfg_list, key,dst+start+1,handler->param);
|
|
if (l==-1)
|
|
continue;
|
|
|
|
l += cw_put_byte(dst+start,i);
|
|
|
|
l = params->msgset->write_header(handler,dst+len,l);
|
|
len+=l;
|
|
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
|
|
|
|
|
|
radios = cw_cfg_get_byte_l(params->cfg_list,"capwap/wtp-descriptor/max-radios",0);
|
|
for(i=0;i<radios;i++){
|
|
|
|
type = (struct cw_Type*)handler->type;
|
|
start = params->msgset->header_len(handler)+len;
|
|
|
|
sprintf(key,"radio.%d/%s",i,handler->key);
|
|
//printf("RADIO KEY: %s\n",key);
|
|
|
|
// cw_dbg(DBG_X,"KEY: %s",key);
|
|
|
|
l = type->write(params->cfg_list, key,dst+start+1,handler->param);
|
|
if (l==-1)
|
|
continue;
|
|
|
|
l += cw_put_byte(dst+start,i);
|
|
|
|
l = params->msgset->write_header(handler,dst+len,l);
|
|
len+=l;
|
|
|
|
}
|
|
return len;
|
|
}
|
|
|
|
|
|
int cw_write_header(struct cw_ElemHandler * handler, uint8_t * dst, int len)
|
|
{
|
|
if (handler->vendor)
|
|
return len + cw_put_elem_vendor_hdr(dst, handler->vendor, handler->id, len);
|
|
|
|
return len + cw_put_elem_hdr(dst, handler->id, len);
|
|
}
|
|
|
|
|
|
|
|
int cw_header_len(struct cw_ElemHandler * handler)
|
|
{
|
|
return handler->vendor ? 10 : 4;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Put the "status part" of an an AC Descriptor to memory
|
|
* @param cfg_list Cfg list to read status from
|
|
* @param dst Where to put the status to
|
|
* @param parent_key prefix to each key
|
|
*/
|
|
int
|
|
cw_put_ac_status(uint8_t *dst, cw_Cfg_t ** cfg_list, const char * parent_key){
|
|
|
|
uint8_t *d = dst;
|
|
|
|
char key[CW_CFG_MAX_KEY_LEN];
|
|
|
|
/* put statiosn */
|
|
sprintf(key,"%s/%s",parent_key,"stations");
|
|
d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
|
|
|
|
/* put station limit */
|
|
sprintf(key,"%s/%s",parent_key,"station-limit");
|
|
d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
|
|
|
|
/* Put number of active WTPs */
|
|
sprintf(key,"%s/%s",parent_key,"active-wtps");
|
|
d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
|
|
|
|
/* Put max WTPs */
|
|
sprintf(key,"%s/%s",parent_key,"max-wtps");
|
|
d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
|
|
|
|
/* Put security flags */
|
|
sprintf(key,"%s/%s",parent_key,"security");
|
|
d += cw_put_byte(d,cw_cfg_get_byte_l(cfg_list,key,0));
|
|
|
|
/* Put rmac-filed */
|
|
sprintf(key,"%s/%s",parent_key,"rmac-field");
|
|
d += cw_put_byte(d,cw_cfg_get_byte_l(cfg_list,key,0));
|
|
|
|
/* reserved field, must be zero - RFC5415 */
|
|
d += cw_put_byte(d,0);
|
|
|
|
sprintf(key,"%s/%s",parent_key,"dtls-policy");
|
|
d += cw_put_byte(d,cw_cfg_get_byte_l(cfg_list,key,0));
|
|
|
|
return d - dst;
|
|
}
|
|
|
|
/**
|
|
* Put a descripter sub element like harware vendor/version etc.
|
|
* Used when putting AC Descriptors or WTP Descriptors
|
|
* @param dst Where to write to
|
|
* @param cfg_list list of cfgs
|
|
* @subelem_id Id of subelement
|
|
* @parent_key parent key
|
|
*/
|
|
int
|
|
cw_put_descriptor_subelem (uint8_t *dst, cw_Cfg_t ** cfg_list,
|
|
int subelem_id, const char * parent_key )
|
|
{
|
|
char key[256];
|
|
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_s = cw_cfg_get_l (cfg_list, key, 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);
|
|
cw_Val_t * val = cw_cfg_get_val_l(cfg_list, key, CW_TYPE_BSTR16);
|
|
|
|
//version = cw_cfg_get_bstr16 (cfg, key, NULL);
|
|
|
|
|
|
if (val == NULL) {
|
|
cw_log (LOG_ERR, "Can't put subelem %s, no value of type Bstr16 found.", key);
|
|
return 0;
|
|
}
|
|
|
|
d = dst;
|
|
|
|
/* put vendor */
|
|
d += cw_put_dword(d, vendor); //->type->put (vendor, d);
|
|
|
|
/* put version */
|
|
|
|
d += cw_put_dword (d, (subelem_id << 16) | val->type->len(val));
|
|
// d += cw_put_bstr16(d, version);
|
|
d += val->type->put(val,d);
|
|
|
|
cw_val_destroy(val);
|
|
|
|
// free(version);
|
|
|
|
return d-dst;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
int cw_out_traverse0(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst, int i, const char *current, const char * next,
|
|
int * stack)
|
|
{
|
|
char *sl;
|
|
int l;
|
|
char key[CW_CFG_MAX_KEY_LEN];
|
|
int len;
|
|
len = 0;
|
|
|
|
printf("Next: %s\n", next);
|
|
|
|
sl = strchr(next,'/');
|
|
if (sl==NULL){
|
|
cw_Val_t * result;
|
|
sprintf(key,"%s/%s",current,next);
|
|
result = cw_ktv_base_exists(params->cfg,key);
|
|
if (result != NULL){
|
|
int offset;
|
|
int i,l;
|
|
offset = params->msgset->header_len(handler);
|
|
printf("Yea! We can do it: %s\n",result->key);
|
|
for (i=0;i<stack[0];i++){
|
|
printf("I=%i\n",stack[i+1]);
|
|
}
|
|
l= cw_ktv_write_struct(params->cfg,params->cfg,
|
|
handler->type,key,dst+offset);
|
|
|
|
printf("Write struct len %i\n",l);
|
|
|
|
l=params->msgset->write_header(handler,dst,l);
|
|
printf("header wr len %d\n",l);
|
|
if (handler->patch){
|
|
handler->patch(dst+offset,stack);
|
|
}
|
|
|
|
return l;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
strcpy(key,current);
|
|
|
|
printf("current is %s\n", current);
|
|
|
|
if (key[0!=0])
|
|
strcat(key,"/");
|
|
l = sl - next;
|
|
strncat(key,next,l);
|
|
|
|
|
|
printf("Here we are %s\n",key);
|
|
cw_dbg_ktv_dump(params->cfg,DBG_INFO,"start"," ", "end" );
|
|
i=-1;
|
|
while(1){
|
|
char basekey[CW_CFG_MAX_KEY_LEN];
|
|
cw_Val_t * result;
|
|
|
|
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->cfg,basekey);
|
|
if (result == NULL){
|
|
continue;
|
|
}
|
|
|
|
stack[0]++;
|
|
stack[stack[0]]=i;
|
|
len += cw_out_traverse0(handler,params,dst+len,-1,basekey,next+l+1, stack);
|
|
printf("Len is now %d\n", len);
|
|
}
|
|
|
|
|
|
return len;
|
|
|
|
return 0;
|
|
}
|
|
*/
|
|
int cw_out_traverse(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst)
|
|
|
|
{
|
|
/* char current[CW_CFG_MAX_KEY_LEN];
|
|
int stack[10];
|
|
stack[0]=0;
|
|
current[0]=0;
|
|
// return cw_out_traverse0(handler,params,dst,-1,current,handler->key, stack);*/
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int walk0(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst, const char *current, const char * next)
|
|
{
|
|
char key[CW_CFG_MAX_KEY_LEN];
|
|
const char *sl;
|
|
int rc;
|
|
int len=0;
|
|
|
|
/* Is this the last key ? */
|
|
sl = strchr(next,'/');
|
|
if (sl){
|
|
char basekey[CW_CFG_MAX_KEY_LEN+13];
|
|
int i,l;
|
|
strcpy(key,current);
|
|
l = sl - next;
|
|
strncat(key,next,l);
|
|
|
|
for (i=0; (i=cw_cfg_get_first_index_l(params->cfg_list,key,i))!=-1; i++){
|
|
sprintf(basekey,"%s.%d%c",key,i, *(sl+1) ?'/':'\0');
|
|
rc = walk0(handler,params,dst,basekey,next+l+1);
|
|
if (rc>0)
|
|
len+=rc;
|
|
}
|
|
return len;
|
|
|
|
}
|
|
|
|
printf("Final %s [%s]\n",current,next);
|
|
return cw_out_generic0(handler,params,dst,current);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
int cw_out_generic_walk(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
|
|
, uint8_t * dst)
|
|
{
|
|
char current[CW_CFG_MAX_KEY_LEN];
|
|
// int stack[10];
|
|
// stack[0]=0;
|
|
current[0]=0;
|
|
|
|
return walk0(handler,params,dst,current,handler->key);
|
|
}
|
|
|