Added some instructions to run AC

INSTALL

@@ -1,40 +1,57 @@
 pre-requisites to build actube
 ==============================
 
+Compile 
+=======
 
-
+FreeBSD 
-
-
-On FreeBSD 10.2
 ----------------
 
-pkg install libconfuse
 pkg install wget
-pkg install libnettle
+pkg install nettle
+cd src/contrib
+sh install_libmavl
+cd ..
+make
 
 
-Ubuntu 14.04
+
-------------
+Ubuntu
+------
 
 apt-get install build-essential clang
 apt-get install nettle-dev
-apt-get install libgnutls28-dev
 apt-get install libssl-dev
-apt-get install libconfuse-dev
+apt install libedit-dev
-apt-get install libsqlite3-dev
+apt install bmake
-
-
-
-pre-requisites to build wtp
-===========================
-
-Ubuntu 14.04
-------------
-
-apt-get install cmake
-apt-get install libnl-genl-3-dev
 cd src/contrib
-sudo ./install_libuci.sh
+sh install_libmavl
+cd ..
+bmake
+
+
+
+RUN 
+---
+
+Test start the ac with some debugging:
+
+cd src/ac
+export LD_LIBRARY_PATH=../../lib/<os name>/<arch>
+./actube -d std -d info
+
+Connect shell to the running AC:
+cd src/ac
+./act -s 127.0.0.1:5000
+
+Some shell cmds:
+list - list joined APs
+select <name> - select an AP
+cfg - show cfg  of selected AC
+ucfg - show current update cfg
+set <key:bal> - set value in ucfg
+send - send ucfg to AC
+clear - clear ucfg
  
 
 

include/README

@@ -0,0 +1 @@
+this is an include directroy

src/LocalDefs-example.mak

@@ -0,0 +1,6 @@
+
+CFLAGS+=-Wall -g -O0 -fsanitize=address -fPIC
+LIBS=-lasan
+CC=clang
+
+

src/ac/Makefile

@@ -5,13 +5,15 @@ include ../Defs.mak
 OBJS = \
 	wtplist.o wtpman.o conf.o ac_main.o \
 	dataman.o \
-	ac_interface.o \
 	socklist.o \
 	discovery_cache.o\
-	shell.o\
+	rpc.o\
 	statemachine.o\
 
+ACTOBJS = \
+	act.o 
 
+ACTPRG=act
 PRG=actube
 LIBPATH=-L../../lib/$(KERNEL)/$(ARCH)/ -L/usr/local/lib -L/usr/lib 
 
@@ -23,22 +25,33 @@ LIBS+=-lc
 LIBS+=-lnettle
 LIBS+=-lssl
 LIBS+=-lcrypto
+LIBS+=-ledit
 
 INCL_DIRS=-I../ -I/usr/local/include -I./ -I../../include
 #FLAGS=-DWITH_IPV6 -DWITH_OPENSSL -DSYS_ARCH="$(ARCH)" -DSYS_ARCH="XXX"
-FLAGS=-DWITH_IPV6 -DUSE_OPENSSL -DSYS_ARCH='"$(ARCH)"'
+FLAGS=-DWITH_IPV6 -DUSE_OPENSSL -DSYS_ARCH='"$(KERNEL)/$(ARCH)"'
+
+
+
 
 .c.o:
 	@echo "  $(CC) "$<
 	$(CC) $(FLAGS) $(INCL_DIRS) -c $(CFLAGS) $< -o $@
 
+all: $(PRG) $(ACTPRG)
 
 $(PRG): $(OBJS) 
-#	$(CC) $(AC_OBJS) ../mod/modload_ac.o -o $(AC_NAME) $(LDFLAGS) $(LIBS)
 	$(CC) $(OBJS) -o $(PRG) $(LIBPATH) $(LDFLAGS) $(LIBS) 
 
+$(ACTPRG): $(ACTOBJS)
+	$(CC) $(ACTOBJS) -o $(ACTPRG) $(LIBPATH) $(LDFLAGS) $(LIBS) -ledit 
+
+
+
+
 
 clean: 
 	rm -f $(PRG) $(OBJS)
+	rm -f $(ACTPRG) $(ACTOBJS)
 
 

src/ac/ac.h

@@ -1,9 +1,7 @@
 #ifndef __ACTUBE_AC_H
 #define __ACTUBE_AC_H
 
-#include "mavl.h"
+#include "cw/cfg.h"
-#include "cw/mavltypes.h"
-
 
 extern struct ac_status ac_global_status;
 
@@ -19,7 +17,8 @@ enum {
 	AC_PROTO_UNKNOWN
 };
 
-void start_shell();
+int start_rpc(cw_Cfg_t *global_cfg);
+int test_shell();
 
 
 #endif

src/ac/ac_interface.c

@@ -1,103 +0,0 @@
-#include <stdlib.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#include "cw/sock.h"
-
-#include "socklist.h"
-#include "conf.h"
-
-#include "cw/capwap.h"
-/*//#include "cw/capwap_80211.h"*/
-/*#include "cw/aciplist.h"*/
-
-
-/*
-int pr(void *x,void *y){
-}
-*/
-
-/*
-struct radioinfo * get_radioinfo()
-{
-	
-}
-*/
-
-
-/*
-struct ac_info * get_acinfo()
-{
-	
-	struct ac_info * acinfo;
-	acinfo = malloc(sizeof(struct ac_info));
-	if(!acinfo)
-		return 0;
-
-	memset(acinfo,0,sizeof(struct ac_info));
-	acinfo->ac_name=conf_acname;
-
-	acinfo->stations=10;
-	acinfo->limit=10000;
-	acinfo->active_wtps=10;
-	acinfo->max_wtps=conf_max_wtps;
-	acinfo->rmac=1; 	
-
-	acinfo->vendor_id=conf_vendor_id;
-
-	acinfo->hardware_version=(uint8_t*)conf_hardware_version;
-	acinfo->software_version=(uint8_t*)conf_software_version;
-	acinfo->cisco_hardware_version=(uint8_t*)conf_cisco_hardware_version;
-	acinfo->cisco_software_version=(uint8_t*)conf_cisco_software_version;
-
-
-	if (conf_dtls_psk)
-		acinfo->security|=AC_SECURITY_S;
-	if (conf_sslkeyfilename && conf_sslcertfilename)
-		acinfo->security|=AC_SECURITY_X;
-
-
-//	acinfo->dtls_policy = AC_DTLS_POLICY_C | AC_DTLS_POLICY_D ;
-//	acinfo->ac_ips = conf_ac_ips;
-//	acinfo->ac_ips_len=conf_ac_ips_len;
-
-//	acinfo->salist=conf_salist;
-//	acinfo->salist_len=conf_salist_len;
-
-//	acinfo->salist = conf_ac_ips;
-//	acinfo->salist_len = conf_ac_ips_len;
-
-	//acinfo->aciplist=get_aciplist();
-
-
-	aciplist_foreach(acinfo->aciplist,pr,NULL);
-*/
-
-/*
-	int i;
-	for (i=1; i<=4; i++){
-		acinfo->radioinfos[i].type= 
-			CW_80211_RADIO_TYPE_B |
-			CW_80211_RADIO_TYPE_A | 
-			CW_80211_RADIO_TYPE_G | 
-			CW_80211_RADIO_TYPE_N;
-//		acinfo->radioinfos[i].type=0xffffffff; 
-		acinfo->radioinfos[i].rid=i;
-	}
-
-
-	return acinfo;
-
-}
-
-*/
-
-/*
-get_join_result()
-{
-	return 0;
-}
-*/
-

src/ac/ac_main.c

@@ -33,7 +33,6 @@
 
 #include "socklist.h"
 
-#include "db.h"
 
 
 #include "cw/capwap_crypto.h"
@@ -53,8 +52,34 @@ int ac_run(cw_Cfg_t * cfg);
 #include "statemachine.h"
 
 #include <getopt.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+/*
+void tshell_run(int fd)
+{
+	int rc;
+	printf("listening\n");
+	rc = listen(fd,5);
+	printf("listen returned %d\n",rc);
+	clientsock = accept (sockfd, (struct sockaddr*) &client, &client_size);
 	
 
+}
+
+void tshell()
+{
+	printf("tshell start\n");
+	struct sockaddr_un addr;
+
+	int fd = socket(AF_UNIX, SOCK_STREAM, 0);
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	strncpy(addr.sun_path, "./tsocket", sizeof(addr.sun_path)-1);
+	bind(fd, (struct sockaddr*)&addr, sizeof(addr));
+	while(1);
+}
+*/
 
 struct bootcfg {
 	const char * cfgfilename;
@@ -67,7 +92,7 @@ static int parse_args (int argc, char *argv[], struct bootcfg * bootcfg)
 	
 	bootcfg->cfgfilename = "config.ckv";
 	
-	while ( (c = getopt (argc, argv, "vc:d:p:")) != -1) {
+	while ( (c = getopt (argc, argv, "hvc:d:p:")) != -1) {
 		
 		switch (c) {
 			case 'c':
@@ -78,12 +103,18 @@ static int parse_args (int argc, char *argv[], struct bootcfg * bootcfg)
 				exit(EXIT_SUCCESS);
 				break;
 			case 'd':{
-				int b = cw_strlist_get_id(cw_dbg_strings, optarg);
+                                if (!cw_dbg_set_level_from_str(optarg)){
+                                        fprintf(stderr,"Invalid debug option: %s\n",optarg);
+                                        exit(EXIT_FAILURE);
+                                }
+
+					 
+/*				int b = cw_strlist_get_id(cw_dbg_strings, optarg);
 				if (b==-1){
 					fprintf(stderr,"Invalid debug option: %s\n",optarg);
 					exit(EXIT_FAILURE);
 				}
-				cw_dbg_set_level(b, 1);
+				cw_dbg_set_level(b, 1);*/
 				break;
 			}
 
@@ -176,13 +207,10 @@ int main (int argc, char *argv[])
 	int rc = 0;
 	struct bootcfg bootcfg;
 
-
-
 	/* parse arguments */
 	parse_args (argc, argv, &bootcfg);
 
 
-
 	global_cfg=cw_cfg_create();
 	if (!global_cfg){
 		fprintf(stderr,"Can't create global_cfg: %s\n",strerror(errno));
@@ -197,7 +225,6 @@ int main (int argc, char *argv[])
 		goto errX;
 	};
 
-
 	cw_log_name = "AC-Tube";
 
 /*
@@ -232,10 +259,6 @@ int main (int argc, char *argv[])
 	
 		
 
-	
-		
-	start_shell();
-
 	/* Init DTLS library */
 	dtls_init();
 		
@@ -250,16 +273,22 @@ int main (int argc, char *argv[])
 	if (!dataman_list_init())
 		goto errX;
 
+
+
 	ac_conf_init(global_cfg);
 
-	cw_cfg_dump(global_cfg);
+	if (!start_rpc(global_cfg))
+		goto errX;
+
+
+//	cw_cfg_dump(global_cfg);
 		
 	cw_log (LOG_INFO, "Starting AC-Tube, Name=%s, ID=%s", cw_cfg_get(global_cfg,"capwap/ac-name",NULL), conf_acid);
 	rc = ac_run(global_cfg);
 
 errX:
 	if (global_cfg)
-		mavl_destroy(global_cfg);
+		cw_cfg_destroy(global_cfg);
 
 	if (discovery_cache)
 		discovery_cache_destroy(discovery_cache);
@@ -282,6 +311,7 @@ int ac_run(cw_Cfg_t * cfg)
 {
         struct cw_Cfg_iter cfi;
 	const char *s;
+	struct cw_Cfg_entry *e;
 	int i;
 
 
@@ -292,16 +322,17 @@ int ac_run(cw_Cfg_t * cfg)
 	 * good unicast reply socket */
 	
         cw_cfg_iter_init(cfg, &cfi, "actube/listen");
-        for (i=0; (s = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
+        for (i=0; (e = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
 
 		char addr[100];
 		char port[50];
 		int proto;
+		s=e->val;
 		
 		conf_parse_listen_addr (s, addr, port, &proto);
 		socklist_add_unicast (addr, port, proto,
-				cw_cfg_get_bool(cfg,"actube/ipv4","true"),
+				cw_cfg_get_bool(cfg,"actube/ipv4",1),
-				cw_cfg_get_bool(cfg,"actube/ipv6","true")
+				cw_cfg_get_bool(cfg,"actube/ipv6",1)
 				);
         }
 	if (!i) {
@@ -337,11 +368,12 @@ int ac_run(cw_Cfg_t * cfg)
         //mavl_print(cfg,pcb,180);
 
         cw_cfg_iter_init(cfg, &cfi, "actube/bcast");
-        for (i=0; (s = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
+        for (i=0; (e = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
 //	for (i = 0; i < conf_bcast_addrs_len; i++) {
 	
 		char addr[50], port[50];
 		int proto;
+		s=e->val;
 		conf_parse_listen_addr (s, addr, port, &proto);
 		
 		socklist_add_broadcast (addr, port, proto);

src/ac/act.c

@@ -0,0 +1,401 @@
+/*	$NetBSD: tc1.c,v 1.7 2016/02/17 19:47:49 christos Exp $	*/
+
+/*-
+ * Copyright (c) 1992, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Christos Zoulas of Cornell University.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+/*
+ * test.c: A little test program
+ */
+#include <sys/wait.h>
+#include <ctype.h>
+#include <dirent.h>
+#include <locale.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <errno.h>
+
+
+#include "histedit.h"
+
+#include "cw/cfg.h"
+#include "cw/sock.h"
+
+
+static int continuation = 0;
+volatile sig_atomic_t gotsig = 0;
+
+static	unsigned char	complete(EditLine *, int);
+static	char   *prompt(EditLine *);
+static	void	sig(int);
+
+
+FILE * act_f;
+
+static int 
+get_result(FILE *f, char *str,int len)
+{
+	int n = len;
+	char *rc;
+	rc = fgets (str, len, f);
+	if (rc==NULL)
+		return 0;
+
+	n = strlen(str);
+	if (n==1 && str[0]=='\n')
+		return 0;
+
+	return  1;
+}
+
+
+
+static char *
+prompt(EditLine *el )
+{
+	static char str[64];
+	char str2[64];
+	int rc;
+
+	fprintf(act_f,"@prompt\n");
+	rc = get_result(act_f,str,64);
+	while(rc){
+		rc=get_result(act_f,str2,64);
+	}
+
+
+	return (continuation ? "> " : str);
+}
+
+static void
+sig(int i)
+{
+	gotsig = i;
+}
+
+static unsigned char
+complete(EditLine *el, int ch __attribute__((__unused__)))
+{
+	DIR *dd = opendir(".");
+	struct dirent *dp;
+	const char* ptr;
+	const LineInfo *lf = el_line(el);
+	size_t len;
+	int res = CC_ERROR;
+
+	/*
+	 * Find the last word
+	 */
+	for (ptr = lf->cursor - 1;
+	    !isspace((unsigned char)*ptr) && ptr > lf->buffer; ptr--)
+		continue;
+	len = lf->cursor - ++ptr;
+
+	for (dp = readdir(dd); dp != NULL; dp = readdir(dd)) {
+		if (len > strlen(dp->d_name))
+			continue;
+		if (strncmp(dp->d_name, ptr, len) == 0) {
+			if (el_insertstr(el, &dp->d_name[len]) == -1)
+				res = CC_ERROR;
+			else
+				res = CC_REFRESH;
+			break;
+		}
+	}
+
+	closedir(dd);
+	return res;
+}
+
+const char *cfgfilename = "config.ckv";
+const char *srvaddr;
+const char *prgname;
+
+static int 
+parse_args (int argc, char *argv[])
+{
+	int c;
+	opterr = 1;
+	
+	
+	while ( (c = getopt (argc, argv, "hvc:s:")) != -1) {
+		
+		switch (c) {
+			case 'c':
+				cfgfilename = optarg;
+				break;
+			case 'v':
+				printf("ACT shell for ACTube version 0.0.1, %s\n", SYS_ARCH);
+				exit(EXIT_SUCCESS);
+				break;
+			case 's':
+				srvaddr = optarg;
+				break;
+
+/*			case 'd':{
+                                if (!cw_dbg_set_level_from_str(optarg)){
+                                        fprintf(stderr,"Invalid debug option: %s\n",optarg);
+                                        exit(EXIT_FAILURE);
+                                }
+
+				break;
+			} */
+
+			case '?':
+				exit(EXIT_FAILURE);
+			default:
+			case 'h':
+				printf("Usage:\n");
+				printf("%s [-v | -h | -s <dst> | -c <cfg> ]\n",argv[0]);
+				printf(" -c: specify config file\n");
+				printf(" -s: specify adress to connect to \n");
+				printf(" -v: print version info\n");
+
+				exit(EXIT_SUCCESS);
+				break;
+		}
+	}
+	return 0;
+}
+
+int create_tcp_fd(const char *addr)
+{
+	struct sockaddr server;
+	
+	int rc;
+	int sockfd;
+
+	memset(&server,0,sizeof(server));
+	rc = sock_strtoaddr (addr, (struct sockaddr*) &server);
+	
+	if (! rc) {
+		fprintf(stderr, "Can't parse address '%s', %s\n", addr, strerror (errno));
+		return -1;
+	}
+	
+	sockfd = socket ( ( (struct sockaddr*) &server)->sa_family, SOCK_STREAM, 0);
+
+	rc = connect(sockfd, (struct sockaddr*)&server, sizeof(server));
+
+	if (rc ) {
+		fprintf(stderr,"%s: Error, can't connt to %s %s\n",prgname,addr,strerror(errno));
+		return -1;
+	}
+
+	return sockfd;	
+}
+
+static FILE *act_connect(const char *srvaddr)
+{
+	int fd;
+	if (srvaddr==NULL){
+		fprintf(stderr,"%s: Error, no address given.\n",prgname);
+		return NULL;
+	}
+	
+	fd=create_tcp_fd(srvaddr);
+	if (fd==-1)
+		return NULL;
+	return fdopen(fd,"a+");
+
+//	return NULL;
+}
+
+
+
+
+int
+main(int argc , char *argv[])
+{
+	prgname = argv[0];	
+	parse_args(argc,argv);
+
+	act_f = act_connect(srvaddr);
+	if (act_f==NULL){
+		return (EXIT_FAILURE);
+	}
+
+
+	EditLine *el = NULL;
+	int num;
+	const char *buf;
+	Tokenizer *tok;
+#if 0
+	int lastevent = 0;
+#endif
+	int ncontinuation;
+	History *hist;
+	HistEvent ev;
+
+	(void) setlocale(LC_CTYPE, "");
+	(void) signal(SIGINT, sig);
+	(void) signal(SIGQUIT, sig);
+	(void) signal(SIGHUP, sig);
+	(void) signal(SIGTERM, sig);
+
+	hist = history_init();		/* Init the builtin history	*/
+					/* Remember 100 events		*/
+	history(hist, &ev, H_SETSIZE, 100);
+
+	tok  = tok_init(NULL);		/* Initialize the tokenizer	*/
+
+					/* Initialize editline		*/
+	el = el_init(*argv, stdin, stdout, stderr);
+
+	el_set(el, EL_EDITOR, "emacs");	/* Default editor is vi		*/
+	el_set(el, EL_SIGNAL, 0);	/* Handle signals gracefully	*/
+
+	el_set(el, EL_PROMPT_ESC, prompt, '\1');/* Set the prompt function */
+
+			/* Tell editline to use this history interface	*/
+	el_set(el, EL_HIST, history, hist);
+
+					/* Add a user-defined function	*/
+	el_set(el, EL_ADDFN, "ed-complete", "Complete argument", complete);
+
+					/* Bind tab to it		*/
+	el_set(el, EL_BIND, "^I", "ed-complete", NULL);
+
+	/*
+	 * Bind j, k in vi command mode to previous and next line, instead
+	 * of previous and next history.
+	 */
+	el_set(el, EL_BIND, "-a", "k", "ed-prev-line", NULL);
+	el_set(el, EL_BIND, "-a", "j", "ed-next-line", NULL);
+
+	/*
+	 * Source the user's defaults file.
+	 */
+	el_source(el, NULL);
+
+	while ((buf = el_gets(el, &num)) != NULL && num != 0)  {
+		int ac, cc, co;
+		const char **av;
+		const LineInfo *li;
+		li = el_line(el);
+		if (gotsig) {
+			(void) fprintf(stderr, "Got signal %d.\n", (int)gotsig);
+			gotsig = 0;
+			el_reset(el);
+		}
+
+		if (!continuation && num == 1)
+			continue;
+
+		ac = cc = co = 0;
+		ncontinuation = tok_line(tok, li, &ac, &av, &cc, &co);
+		if (ncontinuation < 0) {
+			(void) fprintf(stderr, "Internal error\n");
+			continuation = 0;
+			continue;
+		}
+
+		/* Simpler */
+		history(hist, &ev, continuation ? H_APPEND : H_ENTER, buf);
+
+		continuation = ncontinuation;
+		ncontinuation = 0;
+		if (continuation)
+			continue;
+
+		if (strcmp(av[0], "history") == 0) {
+			int rv;
+
+			switch (ac) {
+			case 1:
+				for (rv = history(hist, &ev, H_LAST); rv != -1;
+				    rv = history(hist, &ev, H_PREV))
+					(void) fprintf(stdout, "%4d %s",
+					    ev.num, ev.str);
+				break;
+
+			case 2:
+				if (strcmp(av[1], "clear") == 0)
+					 history(hist, &ev, H_CLEAR);
+				else
+					 goto badhist;
+				break;
+
+			case 3:
+				if (strcmp(av[1], "load") == 0)
+					 history(hist, &ev, H_LOAD, av[2]);
+				else if (strcmp(av[1], "save") == 0)
+					 history(hist, &ev, H_SAVE, av[2]);
+				break;
+
+			badhist:
+			default:
+				(void) fprintf(stderr,
+				    "Bad history arguments\n");
+				break;
+			}
+		} else if (el_parse(el, ac, av) == -1) {
+			char str[2000];
+			int i;
+			char * sp ="";
+			str[0]=0;
+
+			for (i=0; i<ac; i++){
+				fprintf(act_f,"%s%s",sp,av[i]);
+				sp=" ";
+			}
+			fprintf(act_f,"\n");
+
+			fflush(act_f);
+			do {
+				int n;
+				fgets (str, 2000, act_f);
+				n = strlen(str);
+//				printf("LEN: %d\n",n);
+				if (n==1 && str[0]=='\n')
+					break;
+				fprintf(stdout,"%s",str);
+			}while(!feof(act_f));
+
+			fflush(stdout);
+
+		}
+
+		tok_reset(tok);
+	}
+
+	el_end(el);
+	tok_end(tok);
+	history_end(hist);
+
+	return (0);
+}

src/ac/conf.c

@@ -15,37 +15,20 @@
     along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include <stdlib.h>
-#include <string.h>
-#include <sys/utsname.h>
-
-
-#include "cw/capwap.h"
-#include "cw/sock.h"
-
-#include "cw/log.h"
-#include "cw/dbg.h"
 #include "cw/cw_util.h"
-#include "cw/dtls.h"
+#include "cw/dbg.h"
-
+#include "cw/cw.h"
-     #include <sys/param.h>
+#include "cw/cfg.h"
-     #include <sys/time.h>
-     #include <sys/socket.h>
-     #include <net/if.h>
-
 #include "conf.h"
 #include "ac.h"
-#include "cw/cfg.h"
 
-#include "cw/mavltypes.h"
 
-/*uint8_t conf_macaddress[12];
+uint8_t conf_macaddress[12];
 uint8_t conf_macaddress_len = 0;
-*/
+
 
 long conf_strict_capwap = 1;
 long conf_strict_headers = 0;
-/*int conf_capwap_mode = CW_MODE_CAPWAP;*/
 
 
 
@@ -53,28 +36,23 @@ char *conf_acid = NULL;
 
 char *conf_primary_if = NULL;
 
-long conf_max_wtps = CONF_DEFAULT_MAXWTPS;
-char *conf_logfilename = CONF_DEFAULT_LOGFILENAME;
-struct sockaddr_storage *conf_salist = NULL;
-
-
 
 char **conf_mcast_groups = 0;
 int conf_mcast_groups_len = 0;
 
 
-struct sockaddr_storage *conf_bsalist = NULL;
+//struct sockaddr_storage *conf_bsalist = NULL;
 
-int conf_salist_len = 0;
+//int conf_salist_len = 0;
-int conf_bsalist_len = 0;
+//int conf_bsalist_len = 0;
 
-struct sockaddr *conf_ac_ips;
+//struct sockaddr *conf_ac_ips;
-int conf_ac_ips_len;
+//int conf_ac_ips_len;
 
-char *conf_sslcertfilename = NULL;
+//char *conf_sslcertfilename = NULL;
-char *conf_sslkeyfilename = NULL;
+//char *conf_sslkeyfilename = NULL;
-char *conf_sslkeypass = NULL;
+//char *conf_sslkeypass = NULL;
-char *conf_dtls_psk = NULL;
+//char *conf_dtls_psk = NULL;
 
 int conf_security = 0;
 long conf_vendor_id = CONF_DEFAULT_VENDOR_ID;
@@ -123,11 +101,10 @@ static int init_ac_name(cw_Cfg_t * cfg)
 	int i;
 
 
-	s= cw_cfg_get(cfg,"capwap/ac-name",NULL);
+	s= (char*)cw_cfg_get(cfg,"capwap/ac-name",NULL);
 	if (s!=NULL)
 		return 1;
 
-//	primary_if = sock_get_primary_if(AF_INET6);
 	if (!primary_if)
 		primary_if = sock_get_primary_if(AF_INET);
 
@@ -158,41 +135,6 @@ static int init_ac_name(cw_Cfg_t * cfg)
 
 
 
-
-static int init_dtls()
-{
-	if (conf_dtls_psk != NULL) {
-/*
-		//              conf_security=CW_SECURITY_FLAGS_S;
-*/
-	}
-
-	return 1;
-}
-
-
-static int init_vendor_id()
-{
-	return 1;
-}
-
-static int init_control_port()
-{
-	char str[30];
-	sprintf(str, "%d", CONF_DEFAULT_CONTROL_PORT);
-	conf_control_port =
-	    (char *) cw_setstr((uint8_t **) & conf_control_port, (uint8_t *) str,
-			       strlen(str));
-
-
-#ifdef WITH_LWAPP
-	sprintf(str, "%d", CONF_DEFAULT_LW_CONTROL_PORT);
-	conf_lw_control_port = strdup(str);
-#endif
-
-	return 1;
-}
-
 #include <ifaddrs.h>
 
 static int init_listen_addrs(cw_Cfg_t * cfg)
@@ -247,7 +189,7 @@ static int init_listen_addrs(cw_Cfg_t * cfg)
 		}
 	}
 	rc = 1;
-      errX:
+      /*errX:*/
 	freeifaddrs(ifap);
 	return rc;
 }
@@ -304,13 +246,12 @@ int init_bcast_addrs(cw_Cfg_t *cfg)
 	struct cw_Cfg_iter cfi;
 	int i;
 
-//printf("BCAST INIT\n");
         cw_cfg_iter_init(cfg, &cfi, "actube/bcast");
 	if (cw_cfg_iter_next(&cfi,NULL) != NULL)
 		return 0;
 
 	
-	if (!cw_cfg_get_bool(cfg,"actube/ipv4", "true"))
+	if (!cw_cfg_get_bool(cfg,"actube/ipv4", 1))
 		return 1;
 
 	/*t = mavl_create_ptr(); */
@@ -348,16 +289,16 @@ int init_bcast_addrs(cw_Cfg_t *cfg)
 
 
 		if (ifa->ifa_broadaddr) {
-			char *s,*sr;
+			char *s; //,*sr;
 			sock_addrtostr(ifa->ifa_broadaddr, str, 100,1);
 			*strchr(str, ':') = 0;
 
 
 			s = cw_strdup(str);
-			sr = mavl_add_str(t, s);
+			mavl_add_str(t, s);
 
 
-			printf("BCAST = %p --- %p: %s\n",str,s,str);
+//			printf("BCAST = %p --- %p: %s\n",str,s,str);
 		}
 
 	}
@@ -497,7 +438,8 @@ char *conf_mods_dir = NULL;
  */ 
 static int init_mods(cw_Cfg_t *cfg){
 
-	int n, i;
+	int  i;
+	struct cw_Cfg_entry *e;
 	const char * modname;
 
 	struct cw_Cfg_iter cfi;
@@ -511,11 +453,8 @@ static int init_mods(cw_Cfg_t *cfg){
 //	cw_mod_set_path(conf_mods_dir);
 
         cw_cfg_iter_init(cfg, &cfi, "actube/mod");
-printf("iter mods\n");	
+        for (i=0; (e = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
-        for (i=0; (modname = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
+		modname = e->val;
-
-		printf("init mod name: %s\n",modname);
-
 		struct cw_Mod * mod = cw_mod_load(modname, cfg, CW_ROLE_AC);
 		
 		if (!mod)
@@ -606,28 +545,10 @@ int conf_parse_listen_addr(const char *addrstr, char *saddr, char *port, int *pr
 	return 0;
 }
 
-static void errfunc(cfg_t *cfg, const char *fmt, va_list ap){
-
-	if (cfg && cfg->filename && cfg->line)
-		fprintf(stderr, "ERROR in %s:%d: ", 
-			cfg->filename, cfg->line);
-	else if (cfg && cfg->filename)
-		fprintf(stderr, "ERROR in %s:", cfg->filename);
-	vfprintf(stderr, fmt, ap);
-	fprintf(stderr,"\n");
-}
-
-void free_config()
-{
-
-}
-
-
 
 
 void ac_conf_init(cw_Cfg_t *cfg)
 {
-	printf("ac conf\n");
 	init_listen_addrs(cfg);
 	init_bcast_addrs(cfg);
 	init_ac_name(cfg);

src/ac/conf.h

@@ -21,7 +21,6 @@
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/socket.h>
-#include <confuse.h>
 #include <sys/ioctl.h>
 #include <net/if.h>
 

src/ac/config.ckv

@@ -6,12 +6,14 @@
 #
 #capwap/ac-name
 #
-capwap/ac-name: actube
+capwap/ac-name: actube_X
 
 capwap/ssl-cipher: DHE-RSA:RSA:AES-256-CBC:AES-128-CBC:SHA1:PSK
 capwap/ssl-psk-enable: false
 capwap/ssl-psk: 123456
 capwap/ssl-dhbits: 1024
+capwap/ssl-keyfile:  "../../ssl/intermediate-ca/int-ca.key"
+capwap/ssl-certfile: "../../ssl/intermediate-ca/int-ca.crt"
 
 cisco/ssl-keyfile:  "../../ssl/intermediate-ca/int-ca.key"
 cisco/ssl-certfile: "../../ssl/intermediate-ca/int-ca.crt"
@@ -38,32 +40,36 @@ actube/mod.0: cisco
 actube/mod.1: capwap
 actube/mod.2: capwap80211
 
-
+#actube/rpc/listen: unix:/tmp/actube
-ac-descriptor/dtls-policy:  1
+actube/rpc/listen: tcp:127.0.0.1:5000
-ac-descriptor/hardware/vendor: 4232704
+actube/rpc/enable: true
-ac-descriptor/hardware/version: .x01000001
-ac-descriptor/max-wtps : 200
-ac-descriptor/active-wtps:  2
-ac-descriptor/r-mac-field: 1
-ac-descriptor/reserved1 : 0
-ac-descriptor/security : 2
-ac-descriptor/software/vendor : 0
-ac-descriptor/software/version: v0.0.1
-ac-descriptor/station-limit: 1000
-ac-descriptor/stations: 0
 
 
-capwap-control-ip-address/address.0: 192.168.0.14
+capwap/ac-descriptor/dtls-policy:  1
+capwap/ac-descriptor/hardware/vendor: 4232704
+capwap/ac-descriptor/hardware/version: .x01000001
+capwap/ac-descriptor/max-wtps : 200
+capwap/ac-descriptor/active-wtps:  2
+capwap/ac-descriptor/r-mac-field: 1
+cawpap/ac-descriptor/reserved1 : 0
+capwap/ac-descriptor/security : 2
+capwap/ac-descriptor/software/vendor : 0
+capwap/ac-descriptor/software/version: v0.0.1
+capwap/ac-descriptor/station-limit: 1000
+capwap/ac-descriptor/stations: 0
+
+
+capwap/control-ip-address/address.0: 192.168.0.24
 
 
 
 #
 # CAPWAP Timers
 #
-capwap-timers/change-state-pending-timer: Word: 3
+capwap/timers/change-state-pending-timer: Word: 3
-capwap-timers/data-check-timer: Word: 10
+capwap/timers/data-check-timer: Word: 10
-capwap-timers/echo-interval :Byte: 30
+capwap/timers/echo-interval :Byte: 30
-capwap-timers/max-discovery-interval :Byte: 10
+capwap/timers/max-discovery-interval :Byte: 10
 
 
 

src/ac/dataman.c

@@ -115,7 +115,9 @@ int dataman_process_keep_alive(struct netconn *nc, uint8_t *rawmsg, int len)
 			((uint16_t*)sessid)[0]=sessid_len;
 			memcpy(bstr16_data(sessid),cw_get_elem_data(elem),sessid_len);
 			
-			struct wtpman * wtpman = wtplist_get_by_session_id(sessid);
+			stop();
+			struct wtpman * wtpman =NULL;
+//			struct wtpman * wtpman = wtplist_get_by_session_id(sessid);
 			if (wtpman){
 				if (!dm->wtpman)
 					dm->wtpman=wtpman;

src/ac/discovery_cache.c

@@ -114,7 +114,6 @@ void discovery_cache_add(struct cw_DiscoveryCache *cache,
 		cw_dbg(DBG_X,"//////////////////////////   ADDD CAHCE ///////////////////////");
 		char str[128];
 	sock_addrtostr(addr,str,128,1);
-	printf("Add addr: %s\n",str);
 	}
 
 	struct cw_DiscoveryCacheElem * cur = cache->queue+cache->qpos;
@@ -159,7 +158,6 @@ int discovery_cache_get(struct cw_DiscoveryCache * cache,struct sockaddr *addr,
 	cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- GET ENTER");
 	char str[128];
 	sock_addrtostr(addr,str,128,1);
-	printf("Add addr: %s\n",str);
 	}
 
 	search_ptr = &search;
@@ -169,7 +167,6 @@ int discovery_cache_get(struct cw_DiscoveryCache * cache,struct sockaddr *addr,
 		cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- FOUND 1 with Port");
 		char str[128];
 		sock_addrtostr(addr,str,128,1);
-		printf("Add addr: %s\n",str);
 		}
 
 
@@ -196,7 +193,6 @@ int discovery_cache_get(struct cw_DiscoveryCache * cache,struct sockaddr *addr,
 	cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- DOUND BY ADDR");
 	char str[128];
 	sock_addrtostr(addr,str,128,1);
-	printf("Add addr: %s\n",str);
 	}
 
 
@@ -207,7 +203,7 @@ int discovery_cache_get(struct cw_DiscoveryCache * cache,struct sockaddr *addr,
 	{
 	cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- DOUND BY ADDR");
 	char str[128];
-	sock_addrtostr(&elem->addr,str,128,1);
+	sock_addrtostr((struct sockaddr*)&elem->addr,str,128,1);
 	printf("ELEM addr: %s\n",str);
 	}
 

src/ac/rpc.c

@@ -0,0 +1,722 @@
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+
+#include <arpa/telnet.h>
+#include <histedit.h>
+
+
+#include "cw/sock.h"
+#include "cw/log.h"
+#include "cw/dbg.h"
+
+
+#include "cw/connlist.h"
+
+
+#include "wtplist.h"
+
+#include "ac.h"
+
+
+struct rpcdata{
+
+	FILE *in;
+	FILE *out;
+
+	char prompt[1024];
+	cw_Cfg_t * update_cfg;
+	cw_Cfg_t * global_cfg;
+	char *history[2000];
+	char line[4096];
+	int pos;
+	char esc[8];
+	int escpos;
+	int quit;
+
+	History *hist;
+	HistEvent ev;
+	Tokenizer *tok;
+	EditLine *el;
+
+};
+
+struct sockdata{
+	const char *name;
+	int fd;
+	cw_Cfg_t * global_cfg;
+};
+
+int select_cmd(struct rpcdata *sd, const char *cmd);
+int list_cmd(struct rpcdata *sd, const char * cmd);
+int cfg_cmd(struct rpcdata *sd, const char * cmd);
+int ucfg_cmd(struct rpcdata *sd, const char * cmd);
+int set_cmd(struct rpcdata *sd, const char * cmd);
+int del_cmd(struct rpcdata *sd, const char * cmd);
+int send_cmd(struct rpcdata *sd, const char * cmd);
+int wlan0_cmd(struct rpcdata *sd, const char * cmd);
+int exit_cmd(struct rpcdata *sd, const char * cmd);
+int prompt_cmd(struct rpcdata *sd, const char * cmd);
+int global_cfg_cmd(struct rpcdata *sd, const char * cmd);
+
+//void show_cfg (FILE *out, mavl_t ktv);
+int show_aps (FILE *out);
+
+struct cw_Conn * find_ap(const char *name);
+
+struct command{
+	char * cmd;
+	int (*fun)(struct rpcdata *sd, const char *cmd);
+	
+};
+
+static struct command cmdlist[]={
+	{"exit",exit_cmd},
+	{"bumm",exit_cmd},
+	{"cfg", cfg_cmd },
+	{"del", del_cmd },
+	{"ucfg", ucfg_cmd},
+	{"list", list_cmd },
+	{"select", select_cmd },
+	{"send", send_cmd},
+	{"set", set_cmd },
+	{"wlan0",wlan0_cmd},
+	{"global_cfg", global_cfg_cmd},
+
+	{"@prompt",prompt_cmd},
+
+	
+	{NULL,NULL}
+};
+
+
+static void finish_cmd(FILE *f)
+{
+	fprintf(f,"\n");
+	fflush(f);
+}
+
+int prompt_cmd(struct rpcdata *sd, const char *cmd)
+{
+	const char *acname = cw_cfg_get(sd->global_cfg,"capwap/ac-name","actube");
+
+	fprintf(sd->out,"%s[%s]:>\n",acname,sd->prompt);
+	finish_cmd(sd->out);
+	return 0;
+}
+
+
+int global_cfg_cmd(struct rpcdata *sd, const char *cmd)
+{
+	cw_cfg_fdump(sd->out,sd->global_cfg);
+	finish_cmd(sd->out);
+	return 0;
+}
+
+
+int select_cmd(struct rpcdata *sd, const char *cmd)
+{
+	char ap [CAPWAP_MAX_WTP_NAME_LEN];
+	sscanf(cmd,"%s",ap);
+	strcpy(sd->prompt,ap);
+	finish_cmd(sd->out);
+	return 0;
+}
+
+int list_cmd(struct rpcdata *sd, const char *cmd)
+{
+	show_aps(sd->out);
+	finish_cmd(sd->out);
+	return 0;
+}
+
+int exit_cmd(struct rpcdata *sd, const char *cmd)
+{
+		//fprintf(sd->out,"Unknown command: '%s'\n\r\n\r",cmd);
+
+//	printf("Exitcmd %s\n",cmd);
+	//fprintf(sd->out,"END: %s\n\r",cmd);
+	finish_cmd(sd->out);
+	fflush(sd->out);
+	return 1;
+}
+
+
+
+int cfg_cmd(struct rpcdata *sd, const char *cmd)
+{
+	struct cw_Conn * conn;
+	wtplist_lock();
+	conn = find_ap(sd->prompt);
+	if (conn==NULL){
+		fprintf(sd->out,"WTP '%s' not found\n",sd->prompt);
+	}
+	else {
+		cw_cfg_fdump(sd->out,conn->remote_cfg);
+	}
+	finish_cmd(sd->out);
+	wtplist_unlock();
+	return 0;
+}
+
+int ucfg_cmd(struct rpcdata *sd, const char *cmd)
+{
+//	struct cw_Conn * conn;
+	stop();
+//	show_cfg(sd->out,sd->update_cfg);
+	return 0;
+}
+
+#include "wtpman.h"
+
+int
+send_cmd(struct rpcdata * sd, const char *cmd)
+{
+
+	struct cw_Conn * conn;
+	wtplist_lock();
+	conn = find_ap(sd->prompt);
+	if (conn==NULL){
+		fprintf(sd->out,"WTP '%s' not found\n",sd->prompt);
+	}
+	else {
+		conn->update_cfg=sd->update_cfg;
+	}
+	wtplist_unlock();
+	return 0;
+}
+
+int
+wlan0_cmd(struct rpcdata * sd, const char *cmd)
+{
+	stop();
+
+	struct cw_Conn * conn;
+	wtplist_lock();
+	conn = find_ap(sd->prompt);
+	if (conn==NULL){
+		fprintf(sd->out,"WTP '%s' not found\n",sd->prompt);
+	}
+	else {
+		FILE *f=fopen("wlan0.ktv","r");
+//		cw_ktv_read_file(f,sd->update_cfg,conn->msgset->types_tree);
+		//conn->update_cfg=sd->update_cfg;
+		fclose(f);
+	}
+	wtplist_unlock();
+	return 0;
+}
+
+int set_cmd(struct rpcdata *sd, const char *str)
+{
+
+	cw_Cfg_t *cfg;
+	cfg = cw_cfg_create();
+
+	cw_cfg_read_from_string(str,cfg);
+
+	cw_cfg_fdump(sd->out,cfg);
+
+	cw_cfg_destroy(cfg);
+
+	finish_cmd(sd->out);
+
+//	cw_ktv_init_str_reader(&r,str,strlen(str));
+	
+//	cw_ktv_parse_string(&r,key,type,val);
+	/*cw_ktv_parse_string(key,type,val, 2048);*/
+	
+//	fprintf(sd->out,"%s %s\n",key,val);
+//	cw_ktv_add(sd->update_cfg,key,CW_TYPE_STR,NULL,val,strlen(val));
+	return 0;
+}
+
+int del_cmd(struct rpcdata *sd, const char *str)
+{
+	char key[CW_CFG_MAX_KEY_LEN];
+	sscanf(str,"%s",key);
+	stop();
+//	cw_ktv_del_sub(sd->update_cfg,key);
+//
+	return 0;
+}
+
+
+/*
+void show_cfg (FILE *out, mavl_t ktv)
+{
+	char value[500];
+	struct cw_Val * data;
+	mavliter_t it;
+	const struct cw_Type * type;
+	
+	
+	mavliter_init(&it,ktv);
+
+	mavliter_foreach(&it){
+		
+		data = mavliter_get(&it);
+		type = data->type;
+		type->to_str(data,value,0);
+		
+		fprintf(out,"%s :%s: %s\n",data->key,type->get_type_name(data), value);
+	}
+	
+	
+}
+*/
+
+
+void print_mw(FILE *f, int w, const char * str)
+{
+	int n,i;
+	fprintf(f, "%.*s",w,str);
+	n=strlen(str);
+
+	if ( n>w ){
+		fprintf(f,"> ");
+		return;
+	}
+	n = w-n;
+
+	for(i=0;i<(n+2);i++){
+		fprintf(f,"%c",' ');
+	}
+}
+
+
+int  show_aps (FILE *out)
+{
+	struct connlist * cl;
+	mavliter_t it;
+	wtplist_lock();
+	
+	cl = wtplist_get_connlist();
+	
+	
+	mavliter_init (&it, cl->by_addr);
+	print_mw (out, 16, "AP Name");
+	print_mw (out, 16, "AP Model");
+	print_mw (out, 14, "Vendor");
+	print_mw (out, 16, "IP ");
+	fprintf(out,"\n");
+
+	mavliter_foreach (&it) {
+		char addr[SOCK_ADDR_BUFSIZE];
+		const char *vendor;
+
+		struct cw_Conn * conn;
+		conn = mavliter_get_ptr (&it);
+
+		print_mw(out,16,cw_cfg_get(conn->remote_cfg, "capwap/wtp-name", "Unknown"));
+		print_mw(out,16,cw_cfg_get(conn->remote_cfg, "capwap/wtp-board-data/model-no", "Unknown"));
+		vendor = cw_cfg_get(conn->remote_cfg, "capwap/wtp-board-data/vendor", "0");
+		print_mw(out,14,vendor);	
+		sock_addr2str_p (&conn->addr, addr);
+		print_mw(out,16,addr);
+		fprintf(out,"\n");
+
+	}
+	wtplist_unlock();
+	return 0;
+}
+
+
+
+struct cw_Conn * find_ap(const char *name)
+{
+	
+	struct connlist * cl;
+	mavliter_t it;
+
+	cl = wtplist_get_connlist();
+	
+	mavliter_init (&it, cl->by_addr);
+	mavliter_foreach (&it) {
+		const char *wtpname;
+		struct cw_Conn * conn;
+		conn = mavliter_get_ptr (&it);
+		
+		wtpname = cw_cfg_get (conn->remote_cfg, "capwap/wtp-name", NULL);
+		
+		if (wtpname == NULL)
+			continue;
+		
+		if(strcmp(wtpname,name)==0){
+			return conn;
+		}
+
+	}
+	return NULL;
+	
+}
+
+
+void con (FILE *out)
+{
+	stop();
+
+/*	
+	struct connlist * cl;
+	mavliter_t it;
+	
+	
+	
+	wtplist_lock();
+	
+	cl = wtplist_get_connlist();
+	
+	
+	mavliter_init (&it, cl->by_addr);
+	fprintf (out, "IP\t\t\twtp-name\n");
+	mavliter_foreach (&it) {
+		cw_Val_t * result;
+		char addr[SOCK_ADDR_BUFSIZE];
+		char wtp_name[CAPWAP_MAX_WTP_NAME_LEN];
+		struct cw_Conn * conn;
+		conn = mavliter_get_ptr (&it);
+		
+		sock_addr2str_p (&conn->addr, addr);
+		
+		result = cw_ktv_get (conn->remote_cfg, "wtp-name", NULL);
+		
+		if (result == NULL) {
+			strcpy (wtp_name, "");
+			
+		} else {
+			result->type->to_str (result, wtp_name, CAPWAP_MAX_WTP_NAME_LEN);
+		}
+		
+		
+		fprintf (out, "Con!! %s\t\t%s\n", addr, wtp_name);
+		
+		{
+			stop();
+
+			mavl_t update;
+//			update = cw_ktv_create();
+//			cw_ktv_set_byte(update,"radio.255/admin-state",1);
+//			conn->update_cfg=update;
+		}
+
+
+		fprintf(out,"\n");
+
+	}
+	wtplist_unlock();
+	*/
+}
+
+
+struct command * find_cmd(const char *cmd)
+{
+	struct command * search,*result;
+	
+	result=NULL;
+	search = cmdlist;
+	while (search->cmd!=NULL){
+		if (strncmp(cmd,search->cmd,strlen(cmd))==0){
+			if (result==NULL)
+				result = search;
+			else 
+				return NULL;
+		}
+		search ++;
+	}
+	return result;
+}
+
+
+int execute_cmd (struct rpcdata * sd, const char *str)
+{
+	char cmd[1024];
+	char args[1024];
+	int n;
+	struct cw_Val_Reader reader;
+	struct command * searchcmd;
+
+	args[0]=0;
+	
+	n = sscanf (str, "%s", cmd);
+	if (n<=0)
+		return 0;
+	
+	searchcmd = find_cmd(cmd);
+	if (searchcmd!=NULL){
+		if (searchcmd->fun != NULL){
+			return searchcmd->fun(sd, str+strlen(cmd));
+		}
+	}
+	else{
+		fprintf(sd->out,"Unknown command: '%s'\n",cmd);
+		finish_cmd(sd->out);
+	}
+
+	return 0;
+	
+	
+	char key[CW_CFG_MAX_KEY_LEN];
+	char type[128];
+	char val[2048];
+
+	key[0]=0;
+	type[0]=0;
+	val[0]=0;
+
+	stop();
+//	cw_ktv_init_str_reader(&reader,str, strlen(str));
+//	n = cw_ktv_parse_string(&reader, key,type,val);
+	
+	if (n==-1){
+		int i;
+		fprintf(sd->out,"Error on pos %d\n",reader.pos);
+		fprintf(sd->out,"%s",str);
+		for(i=0;i<reader.pos;i++){
+			fprintf(sd->out," ");
+		}
+		fprintf(sd->out,"^\n");
+		fprintf(sd->out,"%s\n",reader.error);
+	}
+	else{
+		fprintf(sd->out,"%s :%s: %s\n", key,type,val);
+	}
+	return 0;
+	
+	
+	n = sscanf (str, "%s%s", cmd, args);
+
+	if (n<=0)
+		return 0;
+	/*printf("CMD: %s, ARGS:\n",cmd);*/
+	
+	if (strcmp (cmd, "s") == 0) {
+		show_aps (sd->out);
+		return 0;
+	}
+	
+	if (strcmp (cmd, "con")==0){
+		con(sd->out);
+		return 0;
+	}
+	
+	return 0;
+}
+
+struct esc_strings {
+	char *str;
+	char * result;
+};
+
+struct esc_strings estr[] = {
+	{"\x1b[H", "home"},
+	{"\x1b[F", "end"},
+	{"\x1b[A", "up"},
+	{"\x1b[B", "donw"},
+	{"\x1b[D", "left"},
+	{"\x1b[C", "right"},
+
+	{NULL,NULL}
+
+};
+
+
+
+
+
+void rpc_loop (FILE *file, cw_Cfg_t *global_cfg)
+{
+	struct rpcdata sd;
+	int c;
+	c=0;
+
+	char str[2048];
+	
+	sd.in = file;
+	sd.out = file;	
+	sd.global_cfg=global_cfg;
+
+
+	sprintf(sd.prompt,"%s","*");
+	sd.quit=0;
+
+	do {
+
+		str[0]=0;
+		
+
+		fgets (str, sizeof (str), file);
+
+		if (execute_cmd (&sd, str)) {
+			break;
+		}
+
+	} while (c != EOF);
+	
+}
+
+
+void * run_rpc_server (void * arg)
+{
+	char sockstr[SOCK_ADDR_BUFSIZE];
+	struct sockdata * sockdata;
+	int clientsock;
+        struct sockaddr_storage client;
+	socklen_t client_size;
+
+	sockdata = (struct sockdata *)arg;
+
+	memset(&client,0,sizeof(client));
+	client_size=sizeof(client);
+
+	cw_dbg(DBG_INFO,"Starting RPC Service, listening on: %s (sock fd: %d)",sockdata->name, sockdata->fd);
+
+	while(1){
+		clientsock = accept (sockdata->fd, (struct sockaddr*) &client, &client_size);
+		if (clientsock == -1){
+			cw_log (LOG_ERR, "Accept error  '%s', %s", "addr", strerror (errno));
+			return NULL;
+
+		}
+		
+		if (clientsock > 0) {
+			sock_addr2str_p (&client, sockstr);
+			cw_dbg (DBG_INFO, "Accepting RPC session from %s", sockstr);
+			rpc_loop (fdopen (clientsock, "a+"),sockdata->global_cfg);
+			close (clientsock);
+		}
+		
+		
+		
+		//cw_dbg (DBG_INFO,"Accepting shell session %i, %s", rc, strerror (errno));
+	}	
+	
+	return NULL;
+}
+
+int create_tcp_fd(const char *name)
+{
+	struct sockaddr_storage server; //, client;
+	
+	int rc;
+	const char * addr = name;
+	int sockfd;
+	int yes;
+	
+	rc = sock_strtoaddr (addr, (struct sockaddr*) &server);
+	
+	if (! rc) {
+		cw_log (LOG_ERR, "Can't parse address '%s', %s", addr, strerror (errno));
+		return -1;
+	}
+	
+	sockfd = socket ( ( (struct sockaddr*) &server)->sa_family, SOCK_STREAM, 0);
+	yes = 1;
+	/* reuse address */
+	setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof (yes));
+	
+	
+	/* bind address */
+	rc =  bind (sockfd, (struct sockaddr*) &server, sizeof (struct sockaddr));
+	
+	if (rc) {
+		cw_log (LOG_ERR, "Can't bind socket address '%s', %s", addr, strerror (errno));
+		return -1;
+	}
+	
+	return sockfd;	
+}
+static int create_unix_fd(const char *name)
+{
+        //struct sockaddr_storage client;
+	//socklen_t client_size;
+	struct sockaddr_un addr;
+	int rc,fd;
+
+	unlink(name);
+	fd = socket(PF_UNIX, SOCK_STREAM, 0);
+
+	sock_addrinit((struct sockaddr_storage*)&addr,AF_UNIX);
+	strncpy(addr.sun_path, name, sizeof(addr.sun_path)-1);
+	rc = bind(fd, (struct sockaddr*)&addr, sizeof(addr));
+	if (rc) {
+		cw_log (LOG_ERR, "Can't bind socket 'unix:%s', %s", name, strerror (errno));
+		return -1;
+	}
+	//int clientsock = accept (fd, (struct sockaddr*) &client, &client_size);
+
+	return fd;
+}
+
+int start_rpc(cw_Cfg_t *global_cfg)
+{
+	struct sockdata * sockdata;
+	const char *sockname;
+	int rc; //, type;
+	int fd;
+
+	rc = cw_cfg_get_bool(global_cfg,"actube/rpc/enable",1);
+	if (!rc)
+		return 1;
+
+	sockdata = malloc(sizeof(struct sockdata));
+	if (sockdata==NULL)
+		return 0;
+
+	memset(sockdata,0,sizeof(struct sockdata));
+
+	sockdata->global_cfg = global_cfg;
+	sockdata->fd=-1;
+
+	sockname = cw_cfg_get(global_cfg,"actube/rpc/listen",NULL);
+	
+	if (sockname==NULL) {
+		cw_log (LOG_ERR, "Can't get RPC listen address from global_cfg 'actube/rpc/listen");
+		goto errX;
+	}
+
+	if (strncmp("unix:",sockname,strlen("unix:"))==0){
+		fd = create_unix_fd(strchr(sockname,':')+1);
+		if (fd==-1)
+			goto errX;
+		sockdata->name=cw_strdup(sockname);
+		sockdata->fd=fd;
+	}else if (strncmp("tcp:",sockname,strlen("tcp:"))==0){
+		fd = create_tcp_fd(strchr(sockname,':')+1);
+		if (fd==-1)
+			goto errX;
+		sockdata->name=cw_strdup(sockname);
+		sockdata->fd=fd;
+	}else {
+		fd = create_tcp_fd(sockname);
+		if (fd==-1)
+			goto errX;
+		sockdata->name=cw_strdup(sockname);
+		sockdata->fd=fd;
+	}
+
+
+	rc = listen (sockdata->fd, 5);
+	if (rc) {
+		cw_log (LOG_ERR, "Can't listen on address '%s', %s", "addr", strerror (errno));
+		goto errX;
+	}
+	
+	pthread_t thread;
+	pthread_create (&thread, NULL, run_rpc_server,
+	                sockdata);
+	return 1;
+errX:
+	if (sockdata->fd!=-1)
+		close(sockdata->fd);
+	if (sockdata->name)
+		free((void*)sockdata->name);
+
+	free(sockdata);
+	return 0;
+}

src/ac/shell.c

@@ -1,497 +0,0 @@
-
-#include <stdio.h>
-#include <errno.h>
-#include <string.h>
-
-#include <sys/types.h>
-#include <sys/socket.h>
-
-#include "cw/sock.h"
-#include "cw/log.h"
-#include "cw/dbg.h"
-
-
-#include "cw/connlist.h"
-
-
-#include "wtplist.h"
-
-
-
-
-struct shelldata{
-	FILE *out;
-	char prompt[1024];
-	mavl_t update_cfg;
-};
-
-void select_cmd(struct shelldata *sd, const char *cmd);
-void list_cmd(struct shelldata *sd, const char * cmd);
-void cfg_cmd(struct shelldata *sd, const char * cmd);
-void ucfg_cmd(struct shelldata *sd, const char * cmd);
-void set_cmd(struct shelldata *sd, const char * cmd);
-void del_cmd(struct shelldata *sd, const char * cmd);
-void send_cmd(struct shelldata *sd, const char * cmd);
-void wlan0_cmd(struct shelldata *sd, const char * cmd);
-void show_cfg (FILE *out, mavl_t ktv);
-void show_aps (FILE *out);
-
-struct cw_Conn * find_ap(const char *name);
-
-struct command{
-	char * cmd;
-	void (*fun)();
-};
-
-static struct command cmdlist[]={
-	{"cfg", cfg_cmd },
-	{"del", del_cmd },
-	{"ucfg", ucfg_cmd},
-	{"list", list_cmd },
-	{"select", select_cmd },
-	{"send", send_cmd},
-	{"set", set_cmd },
-	{"wlan0",wlan0_cmd},
-
-	
-	{NULL,NULL}
-};
-
-
-void select_cmd(struct shelldata *sd, const char *cmd)
-{
-	char ap [CAPWAP_MAX_WTP_NAME_LEN];
-	sscanf(cmd,"%s",ap);
-	strcpy(sd->prompt,ap);
-}
-
-void list_cmd(struct shelldata *sd, const char *cmd)
-{
-	show_aps(sd->out);
-}
-
-void cfg_cmd(struct shelldata *sd, const char *cmd)
-{
-	struct cw_Conn * conn;
-	wtplist_lock();
-	conn = find_ap(sd->prompt);
-	if (conn==NULL){
-		fprintf(sd->out,"WTP '%s' not found\n",sd->prompt);
-	}
-	else {
-		show_cfg(sd->out,conn->remote_cfg);
-	}
-	wtplist_unlock();
-}
-
-void ucfg_cmd(struct shelldata *sd, const char *cmd)
-{
-	struct cw_Conn * conn;
-	show_cfg(sd->out,sd->update_cfg);
-
-}
-
-#include "wtpman.h"
-
-void 
-send_cmd(struct shelldata * sd, const char *cmd)
-{
-	struct cw_Conn * conn;
-	wtplist_lock();
-	conn = find_ap(sd->prompt);
-	if (conn==NULL){
-		fprintf(sd->out,"WTP '%s' not found\n",sd->prompt);
-	}
-	else {
-		conn->update_cfg=sd->update_cfg;
-	}
-	wtplist_unlock();
-}
-
-void 
-wlan0_cmd(struct shelldata * sd, const char *cmd)
-{
-	stop();
-
-	struct cw_Conn * conn;
-	wtplist_lock();
-	conn = find_ap(sd->prompt);
-	if (conn==NULL){
-		fprintf(sd->out,"WTP '%s' not found\n",sd->prompt);
-	}
-	else {
-		FILE *f=fopen("wlan0.ktv","r");
-//		cw_ktv_read_file(f,sd->update_cfg,conn->msgset->types_tree);
-		//conn->update_cfg=sd->update_cfg;
-		fclose(f);
-	}
-	wtplist_unlock();
-
-}
-
-void set_cmd(struct shelldata *sd, const char *str)
-{
-	struct cw_Conn * conn;
-	struct cw_Val_Reader r;
-	char key[CW_CFG_MAX_KEY_LEN];
-	char type[CW_CFG_MAX_KEY_LEN];
-	char val[2048];
-
-	stop();
-
-//	cw_ktv_init_str_reader(&r,str,strlen(str));
-	
-	cw_ktv_parse_string(&r,key,type,val);
-	/*cw_ktv_parse_string(key,type,val, 2048);*/
-	
-	fprintf(sd->out,"%s :%s: %s\n",key,type,val);
-	cw_ktv_add(sd->update_cfg,key,CW_TYPE_STR,NULL,val,strlen(val));
-}
-
-void del_cmd(struct shelldata *sd, const char *str)
-{
-	char key[CW_CFG_MAX_KEY_LEN];
-	sscanf(str,"%s",key);
-	stop();
-//	cw_ktv_del_sub(sd->update_cfg,key);
-}
-
-
-
-void show_cfg (FILE *out, mavl_t ktv)
-{
-	char value[500];
-	struct cw_Val * data;
-	mavliter_t it;
-	const struct cw_Type * type;
-	
-	
-	mavliter_init(&it,ktv);
-
-	mavliter_foreach(&it){
-		
-		data = mavliter_get(&it);
-		type = data->type;
-		type->to_str(data,value,0);
-		
-		fprintf(out,"%s :%s: %s\n",data->key,type->get_type_name(data), value);
-	}
-	
-	
-}
-
-void show_aps (FILE *out)
-{
-	struct connlist * cl;
-	mavliter_t it;
-	wtplist_lock();
-	
-	cl = wtplist_get_connlist();
-	
-	
-	mavliter_init (&it, cl->by_addr);
-	fprintf (out, "IP\t\t\twtp-name\n");
-	mavliter_foreach (&it) {
-		cw_Val_t * result;
-		char addr[SOCK_ADDR_BUFSIZE];
-		char wtp_name[CAPWAP_MAX_WTP_NAME_LEN];
-		struct cw_Conn * conn;
-		conn = mavliter_get_ptr (&it);
-		
-		sock_addr2str_p (&conn->addr, addr);
-		
-		result = cw_ktv_get (conn->remote_cfg, "wtp-name", NULL);
-		
-		if (result == NULL) {
-			strcpy (wtp_name, "");
-			
-		} else {
-			result->type->to_str (result, wtp_name, CAPWAP_MAX_WTP_NAME_LEN);
-		}
-		
-		
-		fprintf (out, "%s\t\t%s\n", addr, wtp_name);
-	}
-	wtplist_unlock();
-}
-
-
-
-struct cw_Conn * find_ap(const char *name)
-{
-	struct connlist * cl;
-	mavliter_t it;
-
-	/*wtplist_lock();*/
-	cl = wtplist_get_connlist();
-	
-	
-	mavliter_init (&it, cl->by_addr);
-	mavliter_foreach (&it) {
-		cw_Val_t * result;
-		char wtp_name[CAPWAP_MAX_WTP_NAME_LEN];
-		struct cw_Conn * conn;
-		conn = mavliter_get_ptr (&it);
-		
-		result = cw_ktv_get (conn->remote_cfg, "wtp-name", NULL);
-		
-		if (result == NULL) {
-			strcpy (wtp_name, "");
-			
-		} else {
-			result->type->to_str (result, wtp_name, CAPWAP_MAX_WTP_NAME_LEN);
-		}
-	
-		printf("cmp '%s' : '%s'\n",wtp_name,name);
-		
-		if(strcmp(wtp_name,name)==0){
-			return conn;
-		}
-
-	}
-	return NULL;
-	/*wtplist_unlock();*/
-}
-
-
-void con (FILE *out)
-{
-	struct connlist * cl;
-	mavliter_t it;
-	
-	
-	
-	wtplist_lock();
-	
-	cl = wtplist_get_connlist();
-	
-	
-	mavliter_init (&it, cl->by_addr);
-	fprintf (out, "IP\t\t\twtp-name\n");
-	mavliter_foreach (&it) {
-		cw_Val_t * result;
-		char addr[SOCK_ADDR_BUFSIZE];
-		char wtp_name[CAPWAP_MAX_WTP_NAME_LEN];
-		struct cw_Conn * conn;
-		conn = mavliter_get_ptr (&it);
-		
-		sock_addr2str_p (&conn->addr, addr);
-		
-		result = cw_ktv_get (conn->remote_cfg, "wtp-name", NULL);
-		
-		if (result == NULL) {
-			strcpy (wtp_name, "");
-			
-		} else {
-			result->type->to_str (result, wtp_name, CAPWAP_MAX_WTP_NAME_LEN);
-		}
-		
-		
-		fprintf (out, "Con!! %s\t\t%s\n", addr, wtp_name);
-		
-		{
-			mavl_t update;
-			update = cw_ktv_create();
-			cw_ktv_set_byte(update,"radio.255/admin-state",1);
-			conn->update_cfg=update;
-		}
-
-
-		fprintf(out,"\n");
-
-	}
-	wtplist_unlock();
-}
-
-
-struct command * find_cmd(const char *cmd)
-{
-	struct command * search;
-	
-	search = cmdlist;
-	while (search->cmd!=NULL){
-		if (strncmp(cmd,search->cmd,strlen(cmd))==0){
-			return search;
-		}
-		search ++;
-	}
-	return NULL;
-}
-
-
-void execute_cmd (struct shelldata * sd, const char *str)
-{
-	char cmd[1024];
-	char args[1024];
-	int n;
-	struct cw_Val_Reader reader;
-	struct command * searchcmd;
-
-	args[0]=0;
-	
-	n = sscanf (str, "%s", cmd);
-	if (n<=0)
-		return;
-	
-	searchcmd = find_cmd(cmd);
-	
-	if (searchcmd!=NULL){
-		if (searchcmd->fun != NULL){
-			fprintf(sd->out,"%s %s\n", searchcmd->cmd,str+strlen(cmd));
-			searchcmd->fun(sd, str+strlen(cmd));
-		}
-	}
-	else{
-		fprintf(sd->out,"Unknown command: '%s'\n",cmd);
-	}
-
-	return;
-	
-	
-	char key[CW_CFG_MAX_KEY_LEN];
-	char type[128];
-	char val[2048];
-
-	key[0]=0;
-	type[0]=0;
-	val[0]=0;
-	cw_ktv_init_str_reader(&reader,str, strlen(str));
-	n = cw_ktv_parse_string(&reader, key,type,val);
-	
-	if (n==-1){
-		int i;
-		fprintf(sd->out,"Error on pos %d\n",reader.pos);
-		fprintf(sd->out,"%s",str);
-		for(i=0;i<reader.pos;i++){
-			fprintf(sd->out," ");
-		}
-		fprintf(sd->out,"^\n");
-		fprintf(sd->out,"%s\n",reader.error);
-	}
-	else{
-		fprintf(sd->out,"%s :%s: %s\n", key,type,val);
-	}
-	return;
-	
-	
-	n = sscanf (str, "%s%s", cmd, args);
-
-	if (n<=0)
-		return;
-	/*printf("CMD: %s, ARGS:\n",cmd);*/
-	
-	if (strcmp (cmd, "s") == 0) {
-		show_aps (sd->out);
-		return;
-	}
-	
-	if (strcmp (cmd, "con")==0){
-		con(sd->out);
-		return;
-	}
-
-}
-
-
-void shell_loop (FILE *file)
-{
-	struct shelldata sd;
-	int c;
-	c=0;
-	/*	setvbuf(file,NULL,_IONBF,0);
-		fflush(file);
-	*/
-	
-	char str[2048];
-	sd.update_cfg = cw_ktv_create();
-	
-	
-	
-	sd.out = file;
-	sprintf(sd.prompt,"%s","*");
-	
-	do {
-		fprintf (file, "actube[%s]:>", sd.prompt);
-		fflush (file);
-		str[0]=0;
-		fgets (str, sizeof (str), file);
-		execute_cmd (&sd, str);
-		
-	} while (c != EOF);
-	
-}
-
-
-void * run_shell (void * arg)
-{
-	struct sockaddr_storage server, client;
-	socklen_t client_size;
-	char sockstr[SOCK_ADDR_BUFSIZE];
-	
-	int rc;
-	const char * addr = "127.0.0.1:5000";
-	int sockfd, clientsock;
-	int yes;
-	
-
-	cw_dbg(DBG_INFO,"Staring shelli listening at: %s",addr);
-
-
-	rc = sock_strtoaddr (addr, (struct sockaddr*) &server);
-	
-	if (! rc) {
-		cw_log (LOG_ERR, "Can't parse address '%s', %s", addr, strerror (errno));
-	}
-	
-	sockfd = socket ( ( (struct sockaddr*) &server)->sa_family, SOCK_STREAM, 0);
-	
-	yes = 1;
-	/* reuse address */
-	setsockopt (sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof (yes));
-	
-	
-	/* bind address */
-	rc =  bind (sockfd, (struct sockaddr*) &server, sizeof (server));
-	
-	if (rc) {
-		cw_log (LOG_ERR, "Can't bind socket address '%s', %s", addr, strerror (errno));
-	}
-	
-	rc = listen (sockfd, 5);
-	
-	if (rc) {
-		cw_log (LOG_ERR, "Can't listen on address '%s', %s", addr, strerror (errno));
-	}
-	
-	
-	client_size = sizeof (client);
-while(1){
-	
-	clientsock = accept (sockfd, (struct sockaddr*) &client, &client_size);
-	
-	if (clientsock > 0) {
-		sock_addr2str_p (&client, sockstr);
-		cw_dbg (DBG_INFO, "Acceptiong session from %s", sockstr);
-		cw_dbg (DBG_INFO, "Start shell");
-		shell_loop (fdopen (clientsock, "a+"));
-		cw_dbg (DBG_INFO, "Stop shell");
-		close (clientsock);
-	}
-	
-	
-	
-	cw_dbg (DBG_INFO,"Accepting shell session %i, %s", rc, strerror (errno));
-}	
-	
-	
-	
-	return NULL;
-}
-
-
-void start_shell()
-{
-	pthread_t thread;
-	pthread_create (&thread, NULL, run_shell,
-	                NULL);
-}

src/ac/statemachine.c

@@ -131,7 +131,7 @@ struct mavl * cw_statemachine_load_states (struct mavl * statemachine_states, cw
                         cw_strstate(s->state));
                 s++;
         }
-        return 1;
+        return NULL;
 }
 
 

src/ac/wtplist.c

@@ -78,7 +78,7 @@ struct wtpman * wtplist_get(const struct sockaddr * addr)
 
 }
 
-struct wtpman * wtplist_get_by_session_id(bstr16_t *session_id)
+struct wtpman * wtplist_get_by_session_id(bstr16_t session_id)
 {
 	struct cw_Conn  search;
 	struct cw_Conn * conn;

src/ac/wtplist.h

@@ -13,7 +13,7 @@ extern struct wtpman * wtplist_add(struct wtpman * wtpman);
 extern void wtplist_remove(struct wtpman * wtpman);
 extern void wtplist_lock();
 extern void wtplist_unlock();
-extern struct wtpman * wtplist_get_by_session_id(bstr16_t *session_id);
+extern struct wtpman * wtplist_get_by_session_id(bstr16_t session_id);
 struct connlist * wtplist_get_connlist(void);
 
 #endif

src/ac/wtpman.c

@@ -64,11 +64,13 @@ static void wtpman_run_discovery(void *arg)
 
 	wtpman->conn->capwap_state = CAPWAP_STATE_DISCOVERY;
 
+
 	while (!cw_timer_timeout(timer)
 	       && wtpman->conn->capwap_state == CAPWAP_STATE_DISCOVERY) {
 		int rc;
 		rc = cw_read_messages(wtpman->conn);
 
+
 		if (cw_result_is_ok(rc)) {
 			wtpman->conn->capwap_state = CAPWAP_STATE_JOIN;
 
@@ -85,7 +87,6 @@ static void wtpman_run_discovery(void *arg)
 
 		}
 	}
-
 	return;
 }
 
@@ -165,7 +166,7 @@ static int wtpman_join(void *arg)
 
 
 
-static void wtpman_image_data(struct wtpman *wtpman)
+void wtpman_image_data(struct wtpman *wtpman)
 {
 /*	char sock_buf[SOCK_ADDR_BUFSIZE];
 	struct cw_Conn *conn = wtpman->conn;
@@ -299,12 +300,12 @@ int cw_run_state_machine(struct cw_Conn *conn, time_t * timer)
 
 static void *wtpman_main(void *arg)
 {
-	mavl_t r;
+	//mavl_t r;
 	int rc;
 	time_t timer;
-	char sock_buf[SOCK_ADDR_BUFSIZE];
+	//char sock_buf[SOCK_ADDR_BUFSIZE];
 	struct cw_Conn *conn;
-	int last_state;
+//	int last_state;
 	struct wtpman *wtpman = (struct wtpman *) arg;
 
 	wtpman->conn->seqnum = 0;
@@ -345,8 +346,8 @@ static void *wtpman_main(void *arg)
 
 	while (1) {
 
-		int wait_join;
+		//int wait_join;
-		int wait_change_state;
+		//int wait_change_state;
 
 
 
@@ -396,7 +397,7 @@ static void *wtpman_main(void *arg)
 
 
 	/* dtls is established, goto join state */
-
+/*
 	conn->capwap_state = CAPWAP_STATE_JOIN;
 	if (!wtpman_join(wtpman)) {
 		wtpman_remove(wtpman);
@@ -409,179 +410,11 @@ static void *wtpman_main(void *arg)
 	       sock_addr2str_p(&conn->addr, sock_buf),
 	       format_bin2hex(conn->session_id, 16));
 
+*/
 
 	exit(0);
 
-/*
-//	cw_dbg(DBG_INFO, "Creating data thread");
-//	pthread_t thread;
-//	pthread_create(&thread, NULL, (void *) wtpman_run_data, (void *) wtpman);
-*/
-
-	/* here the WTP has joined, now we assume an image data request  
-	   or a configuration status request. Nothing else. 
-	 */
-
-	rc = 0;
-	while (!cw_timer_timeout(timer)
-	       && wtpman->conn->capwap_state == CAPWAP_STATE_CONFIGURE) {
-		rc = cw_read_messages(wtpman->conn);
-		if (rc < 0) {
-			if (errno != EAGAIN)
-				break;
-		}
-	}
-
-	cw_dbg_ktv_dump(conn->remote_cfg, DBG_INFO,
-			"-------------dump------------", "DMP",
-			"---------end dump --------");
-
-	if (!cw_result_is_ok(rc)) {
-		cw_dbg(DBG_INFO, "WTP Problem: %s", cw_strrc(rc));
-		wtpman_remove(wtpman);
 	return NULL;
-
-	}
-
-
-	if (conn->capwap_state == CW_STATE_IMAGE_DATA) {
-		wtpman_image_data(wtpman);
-		return NULL;
-	}
-
-
-
-	conn->capwap_state = CAPWAP_STATE_RUN;
-/*
-	// XXX testing ...
-//	DBGX("Cofig to sql", "");
-//	props_to_sql(conn,conn->incomming,0);
-//	radios_to_sql(conn);
-*/
-
-	/*conn->msg_end=msg_end_handler; */
-	/* The main run loop */
-	reset_echointerval_timer(wtpman);
-
-	rc = 0;
-	while (wtpman->conn->capwap_state == CAPWAP_STATE_RUN) {
-		rc = cw_read_messages(wtpman->conn);
-		if (rc < 0) {
-			if (errno != EAGAIN)
-				break;
-		}
-
-/*//		cw_dbg(DBG_X, "Time left: %d",
-// */
-		/*cw_timer_timeleft(wtpman->echointerval_timer); */
-
-		if (cw_timer_timeout(wtpman->echointerval_timer)) {
-
-			cw_dbg(DBG_INFO, "Lost connection to WTP:%s",
-			       sock_addr2str_p(&conn->addr, sock_buf));
-			break;
-		}
-/*
-//		mavl_del_all(conn->outgoing);
-//		conn_clear_upd(conn,1);
-
-//	props_to_sql(conn,conn->incomming,0);
-//	radios_to_sql(conn);
-*/
-
-
-
-		r = db_get_update_tasks(conn,
-					sock_addr2str(&conn->addr, sock_buf));
-		if (r) {
-
-			/*              
-			   //                   if (!conn->outgoing->count)
-			   //                           continue;
-			 */
-			cw_dbg(DBG_INFO, "Updating WTP %s",
-			       sock_addr2str(&conn->addr, sock_buf));
-
-			rc = cw_send_request(conn,
-					     CAPWAP_MSG_CONFIGURATION_UPDATE_REQUEST);
-
-/*
-//			mavl_merge(conn->config, conn->outgoing);
-//			mavl_destroy(conn->outgoing);
-//			conn->outgoing = mbag_create();
-//			props_to_sql(conn,conn->incomming,0);
-//			radios_to_sql(conn);
-//			mavl_destroy(r);
-*/
-		}
-
-		r = db_get_radio_tasks(conn,
-				       sock_addr2str(&conn->addr, sock_buf));
-		if (r) {
-
-/*
-			//			if (!conn->radios_upd->count)
-//				continue;
-*/
-			cw_dbg(DBG_INFO, "Updating Radios for %s",
-			       sock_addr2str(&conn->addr, sock_buf));
-			rc = cw_send_request(conn,
-					     CAPWAP_MSG_CONFIGURATION_UPDATE_REQUEST);
-
-/*
-//			conn_clear_upd(conn,1);
-
-//			mavl_destroy(conn->radios_upd);
-//			conn->radios_upd=mbag_i_create();
-
-
-//			radios_to_sql(conn);
-*/
-			/*
-			   rc = cw_send_request(conn, CW_MSG_CONFIGURATION_UPDATE_REQUEST);
-			   mavl_merge(conn->config, conn->outgoing);
-			   mavl_destroy(conn->outgoing);
-			   conn->outgoing = mbag_create();
-			   config_to_sql(conn);
-			   radios_to_sql(conn);
-			   mavl_destroy(r);
-			 */
-		}
-
-
-
-	}
-
-	db_ping_wtp(sock_addr2str_p(&conn->addr, sock_buf), "");
-	wtpman_remove(wtpman);
-	return NULL;
-}
-
-
-static void wtpman_run_dtls(void *arg)
-{
-	char sock_buf[SOCK_ADDR_BUFSIZE];
-	struct wtpman *wtpman = (struct wtpman *) arg;
-
-
-
-	/* reject connections to our multi- or broadcast sockets */
-	if (socklist[wtpman->socklistindex].type != SOCKLIST_UNICAST_SOCKET) {
-		cw_dbg(DBG_DTLS,
-		       "Dropping connection from %s to non-unicast socket.",
-		       sock_addr2str_p(&wtpman->conn->addr, sock_buf));
-		wtpman_remove(wtpman);
-		return;
-	}
-/*//      time_t timer = cw_timer_start(wtpman->conn->wait_dtls);*/
-
-	/* establish dtls session */
-	if (!wtpman_dtls_setup(wtpman)) {
-		wtpman_remove(wtpman);
-		return;
-	}
-
-	wtpman_main(arg);
 }
 
 
@@ -600,25 +433,35 @@ void wtpman_destroy(struct wtpman *wtpman)
 
 static void copy(struct cw_ElemHandlerParams * params)
 {
-	struct wtpman * wtpman;
+//	struct wtpman * wtpman;
-	struct cw_Conn * conn;
+	//struct cw_Conn * conn;
-	wtpman = (struct wtpman*)params->conn->data;
+	//wtpman = (struct wtpman*)params->conn->data;
-	conn = (struct cw_Conn*)params->conn;
+	//conn = (struct cw_Conn*)params->conn;
 
 
-	cw_dbg(DBG_X,"-------------  Here is the config we ve got from WTP ---------------- ");
+//	cw_dbg(DBG_X,"-------------  Here is the config we ve got from WTP ---------------- ");
-	cw_cfg_dump(params->cfg);
+//	cw_cfg_dump(params->cfg);
-	cw_dbg(DBG_X,"-------------  This was the config we ve got from WTP ---------------- ");
+//	cw_dbg(DBG_X,"-------------  This was the config we ve got from WTP ---------------- ");
-	cw_dbg(DBG_X,"Now copying:");
+//	cw_dbg(DBG_X,"Now copying:");
-	cw_cfg_copy(params->cfg,conn->local_cfg);
+//	cw_cfg_copy(params->cfg,conn->local_cfg,0,"");
-	cw_dbg(DBG_X,"Copying done.");
+        cw_cfg_copy(params->cfg, params->conn->remote_cfg,DBG_CFG_UPDATES,"GlobalCfg");
+
+//	cw_dbg(DBG_X,"Copying done.");
 }
 
 static int discovery_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
 {
+	struct cw_Conn * conn = (struct cw_Conn*)params->conn;
+	char filename[200];
+
 	cw_dbg(DBG_X,"DISCOVERY Callback");
 	copy(params);
+
+	const char * wtpname = cw_cfg_get(conn->remote_cfg,"capwap/wtp-name","default");
+	sprintf(filename,"wtp-discovery-%s.ckv",wtpname);
+	cw_cfg_save(filename,params->cfg,NULL);
 	cw_cfg_clear(params->cfg);
+		
 	return 0;
 }
 
@@ -629,9 +472,9 @@ static int join_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, in
 
 	cw_dbg(DBG_X,"JOIN Callback");
 	copy(params);
-	const char * wtpname = cw_cfg_get(conn->local_cfg,"wtp-name","default");
+	const char * wtpname = cw_cfg_get(conn->remote_cfg,"capwap/wtp-name","default");
 	sprintf(filename,"wtp-join-%s.ckv",wtpname);
-	cw_cfg_save(filename,params->cfg);
+	cw_cfg_save(filename,params->cfg,NULL);
 	cw_cfg_clear(params->cfg);
 	return 0;
 }
@@ -646,26 +489,33 @@ static int update_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr,
 	cw_dbg(DBG_X,"UPDATE Callback");
 	copy(params);
 
-	const char * wtpname = cw_cfg_get(conn->local_cfg,"wtp-name","default");
+	const char * wtpname = cw_cfg_get(conn->remote_cfg,"capwap/wtp-name","default");
 	sprintf(filename,"wtp-status-%s.ckv",wtpname);
-	cw_cfg_save(filename,params->cfg);
+	cw_cfg_save(filename,params->cfg,NULL);
+//stop();	
+	return 0;
+}
 
+static int event_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
+{
+	struct cw_Conn * conn = (struct cw_Conn*)params->conn;
+	char filename[200];
+
+
+	
+	cw_dbg(DBG_X,"WTP EVENT Callback");
+	copy(params);
+
+	const char * wtpname = cw_cfg_get(conn->remote_cfg,"capwap/wtp-name","default");
+	sprintf(filename,"wtp-event-%s.ckv",wtpname);
+	cw_cfg_save(filename,conn->remote_cfg,NULL);
+//stop();	
 	return 0;
 }
 
 
 
 
-static setup_complete(struct cw_Conn *conn)
-{
-	struct wtpman * wtpman = (struct wtpman *)conn->data;
-//	wtpman->pjoin = cw_msgset_set_postprocess(conn->msgset,CAPWAP_MSG_JOIN_REQUEST,join_cb);
-//	wtpman->pupdate = cw_msgset_set_postprocess(conn->msgset,CAPWAP_MSG_CONFIGURATION_STATUS_REQUEST,update_cb);
-	cw_dbg(DBG_X,"SETUP COMPLETE");
-
-}
-
-
 
 struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 			     int dtlsmode, cw_Cfg_t * global_cfg)
@@ -710,7 +560,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 
 	wtpman->global_cfg = global_cfg;
 
-	wtpman->conn = cw_conn_create(sockfd, srcaddr, 5);
+	wtpman->conn = cw_conn_create(sockfd, srcaddr, 100);
 	if (!wtpman->conn) {
 		wtpman_destroy(wtpman);
 		return NULL;
@@ -723,6 +573,13 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 	wtpman->conn->role = CW_ROLE_AC;
 	wtpman->conn->data=wtpman;
 
+	wtpman->conn->cfg_list[0]=wtpman->conn->update_cfg;
+	wtpman->conn->cfg_list[1]=wtpman->conn->remote_cfg;
+	wtpman->conn->cfg_list[2]=wtpman->conn->local_cfg;
+	wtpman->conn->cfg_list[3]=wtpman->conn->global_cfg;
+	wtpman->conn->cfg_list[4]=NULL;
+
+
 	wtpman->conn->data_sock = socklist[socklistindex].data_sockfd;
 	sock_copyaddr(&wtpman->conn->data_addr,
 		      (struct sockaddr *) &wtpman->conn->addr);
@@ -739,6 +596,10 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 			CAPWAP_MSG_CONFIGURATION_STATUS_REQUEST,
 			update_cb);
 
+	cw_conn_set_msg_cb(wtpman->conn,
+			CAPWAP_MSG_WTP_EVENT_REQUEST,
+			event_cb);
+
 
 
 
@@ -747,7 +608,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 	wtpman->conn->strict_capwap = conf_strict_capwap;
 	wtpman->conn->strict_hdr = conf_strict_headers;
 
-	wtpman->conn->setup_complete = setup_complete;
+//	wtpman->conn->setup_complete = setup_complete;
 /*
 //	wtpman->conn->radios = mbag_i_create();
 //	wtpman->conn->radios_upd = mbag_i_create();
@@ -775,8 +636,8 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 			    cw_mod_get_msg_set(wtpman->conn, cmod, bmod);
 			wtpman->conn->detected = 1;
 			cmod->setup_cfg(wtpman->conn);
-	               if (wtpman->conn->setup_complete)
+//	               if (wtpman->conn->setup_complete)
-        	                wtpman->conn->setup_complete(wtpman->conn);
+//        	                wtpman->conn->setup_complete(wtpman->conn);
 
 
 		}

src/contrib/libmavl-LocalDefs.mak

@@ -4,3 +4,4 @@ PREFIX=../../..
 INSTALL_LIB_DIR := /lib/$(KERNEL)/$(ARCH)
 INSTALL_INCLUDE_DIR := /include
 
+CFLAGS+=-fPIC

src/cw/Makefile

@@ -18,7 +18,6 @@ CWSRC=\
 	cw_in_capwap_local_ipv4_address.c\
 	cw_in_capwap_local_ipv6_address.c\
 	cw_in_generic_with_index.c\
-	cw_in_generic_struct.c\
 	cw_in_radio_generic_struct.c\
 	cw_in_idx_generic.c\
 	cw_in_idx_generic_struct.c\
@@ -67,6 +66,7 @@ CWSRC=\
 	cw_write_radio_element.c\
 	cw_detect_nat.c\
 	cw_read_from.c \
+	cw_in_generic_struct.c\
 
 #	cw_in_check_disc_req.c\
 #	cw_in_check_img_data_req_ac.c\
@@ -79,36 +79,43 @@ CWSRC=\
 #	cw_process_element.c\
 
 KTVSRC=\
-	cw_ktv_add.c\
+	cfg.c\
-	cw_ktv_cast.c\
+
-	cw_ktv_replace.c\
+
+#	cw_ktv_add.c\
+	cw_ktv_idx_get.c\
+	cw_ktv_mavlcmp.c\
+	cw_ktv_mavlcmp_type_by_name.c\
+	cw_ktv_mavldel.c\
+
+
+#	cw_ktv_parser.c\
+#	cw_ktv_del_sub.c\
+#	cw_ktv_base_exists.c\
 	cw_ktv_add_from_str.c\
-	cw_ktv_get_byte.c\
+	cw_ktv_read_file.c\
+	cw_ktv_readline.c\
+	cw_ktv_save.c\
+	cw_ktv_std_types.c\
+	cw_ktv_read_struct.c\
+	cw_ktv_write_struct.c\
+
+#	cw_ktv_get_byte.c\
 	cw_ktv_get_bool.c\
 	cw_ktv_get_bstr16.c\
 	cw_ktv_set_byte.c\
 	cw_ktv_set_word.c\
 	cw_ktv_set_dword.c\
-	cw_ktv_get.c\
+
-	cw_ktv_get_word.c\
+#	cw_ktv_get_word.c\
 	cw_ktv_get_dword.c\
 	cw_ktv_get_sysptr.c\
 	cw_ktv_get_str.c\
-	cw_ktv_idx_get.c\
-	cw_ktv_mavlcmp.c\
-	cw_ktv_mavlcmp_type_by_name.c\
-	cw_ktv_mavldel.c\
-	cw_ktv_read_file.c\
-	cw_ktv_readline.c\
-	cw_ktv_read_struct.c\
-	cw_ktv_write_struct.c\
-	cw_ktv_std_types.c\
-	cw_ktv_save.c\
-	cfg.c\
 
-#	cw_ktv_parser.c\
+#	cw_ktv_cast.c\
-#	cw_ktv_del_sub.c\
+	cw_ktv_replace.c\
-#	cw_ktv_base_exists.c\
+	cw_ktv_get.c\
+
 
 LWSRC=\
 	lw_addelem.c\
@@ -203,6 +210,7 @@ MISCSRC=\
 	val.c \
 	discovery.c\
 	message.c\
+	cw_out_radio_generic_struct.c\
 
 
 #	intavltree.c\
@@ -221,7 +229,6 @@ DTLSSRC+=\
 
 
 RADIOSRC=\
-	cw_out_radio_generic_struct.c\
 	
 #	cw_in_radio_generic.c\
 #	cw_out_radio_generic.c\

src/cw/ansi_colors.h

@@ -25,4 +25,8 @@
 #define ANSI_ITALIC	"\x1b[3m"
 #define ANSI_BOLD	"\x1b[1m"
 
+
+#define ANSI_HOME	"[H"
+
+
 #endif /* __ANSI_COLORS_H */

src/cw/capwap.h

@@ -240,7 +240,7 @@
 #define CAPWAP_ELEM_ECN_SUPPORT				53
 #define CAPWAP_ELEM_IDLE_TIMEOUT			23
 #define CW_ELEM_IMAGE_DATA				24
-#define CW_ELEM_IMAGE_IDENTIFIER			25
+#define CAPWAP_ELEM_IMAGE_IDENTIFIER			25
 #define CW_ELEM_IMAGE_INFORMATION			26
 #define CW_ELEM_INITIATE_DOWNLOAD			27
 #define CAPWAP_ELEM_LOCATION_DATA			28

src/cw/capwap80211.h

@@ -83,10 +83,17 @@ enum radioelems {
 	CW_ELEM80211_WTP_RADIO_CONFIGURATION=1046,
 	/** IEEE 802.11 WTP Radio Fail Alarm Indication */
 	CW_ELEM80211_WTP_RADIO_FAIL_ALARM_IDICATION=1047,
-	/** IEEE 802.11 Radio Information Message Element */
-	CAPWAP80211_ELEM_WTP_RADIO_INFORMATION = 1048
 };
 
+
+/** IEEE 802.11 Radio Information Message Element */
+#define CAPWAP80211_ELEM_WTP_RADIO_INFORMATION		1048
+/** IEEE 802.11 Antenna Message element */
+#define CAPWAP80211_ELEM_ANTENNA			1025
+
+
+
+
 /**
  *@}
  */

src/cw/capwap_strings_elem.c

@@ -32,7 +32,7 @@ struct cw_StrListElem capwap_strings_elem[] = {
 	{CAPWAP_ELEM_ECN_SUPPORT, "ECN Support"},
 	{CAPWAP_ELEM_IDLE_TIMEOUT, "Idle Timeout"},
 	{CW_ELEM_IMAGE_DATA, "Image Data"},
-	{CW_ELEM_IMAGE_IDENTIFIER, "Image Identifier"},
+	{CAPWAP_ELEM_IMAGE_IDENTIFIER, "Image Identifier"},
 	{CW_ELEM_IMAGE_INFORMATION, "Image Information"},
 	{CW_ELEM_INITIATE_DOWNLOAD, "Initiate Download"},
 	{CAPWAP_ELEM_LOCATION_DATA, "Location Data"},

src/cw/cfg.c

@@ -83,12 +83,22 @@ static void del(void *ptr)
 
 cw_Cfg_t *cw_cfg_create()
 {
-	return mavl_create(cmp, del, sizeof(struct cw_Cfg_entry));
+	cw_Cfg_t * cfg;
+	cfg = malloc(sizeof(cw_Cfg_t));
+	if (cfg == NULL)
+		return NULL;
+	memset(cfg,0,sizeof(cw_Cfg_t));
+	cfg->cfg = mavl_create(cmp, del, sizeof(struct cw_Cfg_entry));
+	if (cfg->cfg==NULL){
+		cw_cfg_destroy(cfg);
+		return NULL;
+	}
+	return cfg;
 }
 
 int cw_cfg_set(cw_Cfg_t * cfg, const char *key, const char *val)
 {
-	cw_dbg(DBG_CFG_SET, "%s: %s",key,val);
+	cw_dbg(cfg->dbg_level, "%s%s: %s",cfg->dbg_prefix,key,val);
 
 	struct cw_Cfg_entry e;
 	int replaced;
@@ -101,7 +111,7 @@ int cw_cfg_set(cw_Cfg_t * cfg, const char *key, const char *val)
 		free((void *) e.key);
 		return 0;
 	}
-	void *rc = mavl_replace(cfg, &e, &replaced);
+	void *rc = mavl_replace(cfg->cfg, &e, &replaced);
 	if (!rc) {
 		del(&e);
 		return 0;
@@ -116,7 +126,7 @@ const char *cw_cfg_get(cw_Cfg_t * cfg, const char *key, const char *def)
 {
 	struct cw_Cfg_entry e, *r;
 	e.key = key;
-	r = mavl_get(cfg, &e);
+	r = mavl_get(cfg->cfg, &e);
 	if (!r)
 		return def;
 	return r->val;
@@ -129,7 +139,7 @@ const char *cw_cfg_get_l(cw_Cfg_t ** cfg, const char * key, const char *def)
 	for(i=0; cfg[i]!=NULL; i++){
 //		cw_dbg(DBG_X,"GET_L IN: %p",cfg[i]);
 		e.key = key;
-		r = mavl_get(cfg[i], &e);
+		r = mavl_get(cfg[i]->cfg, &e);
 		if (r!=NULL)
 			return r->val;
 	}
@@ -167,7 +177,7 @@ void cw_cfg_dump(cw_Cfg_t * cfg)
 {
 	mavliter_t it;
 	struct cw_Cfg_entry *e;
-	mavliter_init(&it, cfg);
+	mavliter_init(&it, cfg->cfg);
 	mavliter_foreach(&it) {
 
 		e = mavliter_get(&it);
@@ -176,6 +186,20 @@ void cw_cfg_dump(cw_Cfg_t * cfg)
 	}
 }
 
+void cw_cfg_fdump(FILE *f, cw_Cfg_t * cfg)
+{
+	mavliter_t it;
+	struct cw_Cfg_entry *e;
+	mavliter_init(&it, cfg->cfg);
+	mavliter_foreach(&it) {
+
+		e = mavliter_get(&it);
+		fprintf(f,"%s: '%s'\n", e->key, e->val);
+	}
+}
+
+
+
 
 struct parser {
 	int line;
@@ -471,11 +495,26 @@ int cw_cfg_load(const char *filename, cw_Cfg_t * cfg)
 	return errno;
 }
 
+int cw_cfg_read_from_string(const char *str, cw_Cfg_t *cfg)
+{
+	int errs;
+	FILE * f = fmemopen((void*)str,strlen(str),"rb");
+	if(!f)
+		return errno;
+	errs = cw_cfg_read_from_file(f, cfg);
+	fclose(f);
+
+	if (errs)
+		errno = EINVAL;
+	return errno;
+
+}
+
 int cw_cfg_write_to_file(FILE *f, cw_Cfg_t * cfg)
 {
 	mavliter_t it;
 	struct cw_Cfg_entry *e;
-	mavliter_init(&it, cfg);
+	mavliter_init(&it, cfg->cfg);
 	mavliter_foreach(&it) {
 		int n;
 		e = mavliter_get(&it);
@@ -495,12 +534,18 @@ int cw_cfg_write_to_file(FILE *f, cw_Cfg_t * cfg)
 }
 
 
-int cw_cfg_save(const char *filename, cw_Cfg_t *cfg)
+int cw_cfg_save(const char *filename, cw_Cfg_t *cfg, const char *format, ...)
 {
 	int rc;
 	FILE *f = fopen(filename, "wb");
 	if (!f)
 		return errno;
+	if (format !=NULL){
+		va_list args;
+		va_start(args,format);
+		vfprintf(f,format,args);
+		va_end(args);
+	}
 	rc = cw_cfg_write_to_file(f, cfg);
 	fclose(f);
 
@@ -513,13 +558,13 @@ void cw_cfg_iter_init(cw_Cfg_t * cfg, struct cw_Cfg_iter *cfi, const char *base)
 	struct cw_Cfg_entry search;
 	search.key = base;
 
-	mavliter_init(&(cfi->it), cfg);
+	mavliter_init(&(cfi->it), cfg->cfg);
 	mavliter_seek(&(cfi->it), &search, 0);
 	cfi->base = base;
 }
 
 
-const char *cw_cfg_iter_next(struct cw_Cfg_iter *cfi, const char *key)
+struct cw_Cfg_entry *cw_cfg_iter_next(struct cw_Cfg_iter *cfi, const char *nnkey)
 {
 	struct cw_Cfg_entry *e;
 	int bl, kl;
@@ -541,7 +586,7 @@ const char *cw_cfg_iter_next(struct cw_Cfg_iter *cfi, const char *key)
 			return NULL;
 		else {
 			mavliter_next(&(cfi->it));
-			return e->val;
+			return e;
 		}
 
 	}
@@ -556,7 +601,7 @@ const char *cw_cfg_iter_next(struct cw_Cfg_iter *cfi, const char *key)
 		return NULL;
 
 	mavliter_next(&(cfi->it));
-	return e->val;
+	return e;
 }
 
 
@@ -595,7 +640,7 @@ uint8_t cw_cfg_get_byte_l(cw_Cfg_t ** cfgs, char *key, uint8_t def)
 
 
 
-uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, uint16_t def)
+uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, const char *key, uint16_t def)
 {
 	struct cw_Val v;
 	const char *s = cw_cfg_get(cfg,key,NULL);
@@ -605,6 +650,19 @@ uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, uint16_t def)
 	return v.val.word;
 }
 
+uint16_t cw_cfg_get_word_l(cw_Cfg_t ** cfg, const char *key, uint16_t def)
+{
+	struct cw_Val v;
+	const char *s = cw_cfg_get_l(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)
 {
@@ -636,7 +694,7 @@ int cw_cfg_get_next_index(cw_Cfg_t * cfg, const char *key)
 	search.key=ikey;
 	/*//result = ktvn(ktv,&search);*/
 	
-	result = mavl_get_last(cfg,&search);
+	result = mavl_get_last(cfg->cfg,&search);
 	if (result == NULL){
 		return 0;
 	}
@@ -678,34 +736,56 @@ int cw_cfg_set_val(cw_Cfg_t * cfg, const char *key, const struct cw_Type *type,
 
 
 
-void cw_cfg_copy(cw_Cfg_t *src, cw_Cfg_t *dst)
+void cw_cfg_copy(cw_Cfg_t *src, cw_Cfg_t *dst,int dbg_level,const char *dbg_prefix)
 {
 	mavliter_t it;
-	mavliter_init(&it, src);
+	mavliter_init(&it, src->cfg);
 	mavliter_foreach(&it) {
 		int exists;
 		struct cw_Cfg_entry * old_elem,*e, new_elem;
 
+
 		e = mavliter_get(&it);
 		new_elem.key = cw_strdup(e->key);
 		new_elem.val = cw_strdup(e->val);
 
-		old_elem = mavl_insert(dst,&new_elem,&exists);
+/*		if (1){
+			const char *ov;
+			ov = cw_cfg_get(dst,e->key,NULL);
+			cw_dbg(DBG_X, "   REAL OV HERE: %s",ov);
+		}
+*/
+
+
+		old_elem = mavl_insert(dst->cfg,&new_elem,&exists);
+
+/*		cw_dbg(DBG_X, "CPY: %s: %s -> %s [%d]",new_elem.key,new_elem.val,old_elem->val,exists);
+		if (exists){
+			const char *ov;
+			ov = cw_cfg_get(dst,e->key,NULL);
+			cw_dbg(DBG_X, "   OV HERE: %s",ov);
+		}
+*/
+		
 		if (!exists){
-			cw_dbg(DBG_X, "New: %s: %s",new_elem.key,new_elem.val);
+			cw_dbg(dbg_level, "%s: [undef] -> %s",new_elem.key,new_elem.val);
 			continue;
 		}
+
+
+
 		if (strcmp(new_elem.val,old_elem->val)==0){
 			free((void*)new_elem.key);
 			free((void*)new_elem.val);
 			continue;
 		}
 
-		cw_dbg(DBG_X, "Replace: %s: %s (old: %s)",new_elem.key, new_elem.val, old_elem->val);
+		cw_dbg(dbg_level, "%s: %s -> %s",new_elem.key,old_elem->val,new_elem.val);
-		if(dst->del){
+//		cw_dbg(DBG_X, "Replace: %s: %s (old: %s)",new_elem.key, new_elem.val, old_elem->val);
-			dst->del(old_elem);
+		if(dst->cfg->del){
+			dst->cfg->del(old_elem);
 		}
-		memcpy(old_elem,&new_elem,dst->data_size);
+		memcpy(old_elem,&new_elem,dst->cfg->data_size);
 	}
 
 }
@@ -713,13 +793,15 @@ void cw_cfg_copy(cw_Cfg_t *src, cw_Cfg_t *dst)
 
 void cw_cfg_destroy(cw_Cfg_t *cfg)
 {
-	mavl_destroy(cfg);
+	if (cfg->cfg)
+		mavl_destroy(cfg->cfg);
+	free(cfg);
 }
 
 
 void cw_cfg_clear(cw_Cfg_t *cfg)
 {
-	mavl_del_all(cfg);
+	mavl_del_all(cfg->cfg);
 }
 
 
@@ -728,7 +810,7 @@ int cw_cfg_base_exists(cw_Cfg_t * cfg, const char *key)
         struct cw_Cfg_entry e, *result;
 //cw_dbg(DBG_X,"LOOX FOR: %s",key);
         e.key=key;
-        result = mavl_get_first(cfg,&e);
+        result = mavl_get_first(cfg->cfg,&e);
         if (result == NULL)
                 return 0;
 //cw_dbg(DBG_X,"BASEXXX: %s",result->key);
@@ -753,7 +835,7 @@ int cw_cfg_base_exists_l(cw_Cfg_t ** cfgs, const char *key)
 		if (cw_cfg_base_exists(cfgs[i],key))
 			return 1;
 	}
-	cw_dbg(DBG_X,"NOX EXISIS: %s in %d",key,i);
+//	cw_dbg(DBG_X,"NOX EXISIS: %s in %d",key,i);
 	return 0;
 }
 

src/cw/cfg.h

@@ -7,7 +7,14 @@
 
 #define CW_CFG_MAX_KEY_LEN 1024
 
-typedef struct mavl cw_Cfg_t;
+struct cw_Cfg {
+	struct mavl * cfg;
+	const char *name;
+	int dbg_level;
+	const char *dbg_prefix;
+};
+
+typedef struct cw_Cfg cw_Cfg_t;
 
 cw_Cfg_t * cw_cfg_create();
 int cw_cfg_set(cw_Cfg_t *cfg,const char *key, const char *val);
@@ -28,26 +35,29 @@ struct cw_Cfg_iter{
 
 const char * cw_cfg_get(cw_Cfg_t * cfg, const char *key, const char *def);
 
-const char *cw_cfg_iter_next(struct cw_Cfg_iter *cfi, const char *key);
+struct cw_Cfg_entry *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, int def);
-uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, uint16_t def);
+uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, const 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, 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);
 const char *cw_cfg_get_l(cw_Cfg_t ** cfg, const char * key, const char *def);
-void cw_cfg_copy(cw_Cfg_t *src, cw_Cfg_t *dst);
+void cw_cfg_copy(cw_Cfg_t *src, cw_Cfg_t *dst,int dbg_level,const char *dbg_prefix);
 void cw_cfg_destroy(cw_Cfg_t *cfg);
 void cw_cfg_clear(cw_Cfg_t *cfg);
 int cw_cfg_base_exists(cw_Cfg_t * cfg, const char *key);
 uint8_t cw_cfg_get_byte_l(cw_Cfg_t ** cfgs, char *key, uint8_t def);
 cw_Val_t * cw_cfg_get_val_l(cw_Cfg_t ** cfgs, const char *key, const struct cw_Type *type);
 int cw_cfg_base_exists_l(cw_Cfg_t ** cfgs, const char *key);
-int cw_cfg_save(const char *filename, cw_Cfg_t *cfg);
+int cw_cfg_save(const char *filename, cw_Cfg_t *cfg, const char *format, ...);
 
+uint16_t cw_cfg_get_word_l(cw_Cfg_t ** cfg, const char *key, uint16_t def);
+void cw_cfg_fdump(FILE *f, cw_Cfg_t * cfg);
+int cw_cfg_read_from_string(const char *str, cw_Cfg_t *cfg);
 
 
 

src/cw/conn.c

@@ -59,9 +59,9 @@ void cw_conn_init(struct cw_Conn * conn)
 	conn->msg_callbacks = mavl_create(msg_callback_cmp,NULL,sizeof(struct msg_callback));
 
 	conn->update_cfg = cw_cfg_create();
-	cw_dbg(DBG_X,"Update CFG ist %p",conn->update_cfg);
 	conn->remote_cfg = cw_cfg_create();
 	conn->local_cfg = cw_cfg_create();
+	conn->cfg_list[0]=NULL;
 }
 
 int cw_conn_set_msg_cb(struct cw_Conn *conn, int type, cw_MsgCallbackFun fun)
@@ -140,7 +140,7 @@ struct cw_Conn * cw_conn_create(int sock, struct sockaddr * addr, int qsize)
 /*	conn->send_data_packet = conn_send_data_packet;*/
 
 	conn->last_seqnum_received=-1;
-	conn->mtu=600;
+	conn->mtu=1480;
 
 
 	conn->cur_packet=0;
@@ -150,7 +150,7 @@ struct cw_Conn * cw_conn_create(int sock, struct sockaddr * addr, int qsize)
 	conn->write = conn->send_packet;
 	conn->read = conn->recv_packet;
 
-	conn->dtls_mtu = 600;
+	conn->dtls_mtu = 1480;
 
 
 
@@ -350,7 +350,8 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
 
 	/* pre-check message */
 	if (payloadlen - 8 != elems_len) {
-
+//printf ("The elems_len is %d\n",elems_len);
+//printf ("The len = %d\n",len);
 		if (conn->strict_hdr) {
 			cw_dbg(DBG_MSG_ERR,
 			       "Discarding message from %s, msgelems len=%d, payload len=%d, (Strict CAPWAP) ",
@@ -366,7 +367,7 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
 			       "Packet from from %s has %d bytes of extra data, ignoring.",
 			       sock_addr2str(&conn->addr, sock_buf),
 			       payloadlen - 8 - elems_len);
-			elems_len = len - 8;
+			//elems_len = len - 8;
 		}
 
 		if (elems_len > payloadlen - 8) {
@@ -475,9 +476,10 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
 
 	elems_ptr = cw_get_msg_elems_ptr(msg_ptr);
 
-
+/*	if (cw_dbg_is_level(DBG_ELEM_IN)){
-	cw_dbg(DBG_MSG_PARSING, "*** Parsing message of type %d - (%s) ***",
+		cw_dbg(DBG_MSG_PARSING, "Parsing message of type %d - (%s)",
 		       message->type, message->name);
+	}*/
 
 	memset(&params,0,sizeof(struct cw_ElemHandlerParams));
 	
@@ -485,15 +487,16 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
 	params.unrecognized = mlist_create(NULL, NULL, sizeof(uint8_t *));
 
 	params.cfg = cw_cfg_create();
-	params.cfg_list[0]=params.cfg;
+	params.cfg->dbg_level = DBG_ELEM_DETAIL_IN;
-	params.cfg_list[1]=conn->local_cfg;
+	params.cfg->dbg_prefix = "    ";
-	params.cfg_list[2]=conn->global_cfg;
+
-	params.cfg_list[3]=NULL;
+	params.cfg_list=conn->cfg_list;
 
 	params.from = from;
 	params.msgdata = message;
 	params.msgset=conn->msgset;
 	params.conn = conn;
+	params.dbg_level = DBG_ELEM_IN;
 
 	cw_decode_elements(&params,elems_ptr, elems_len);
 
@@ -503,8 +506,8 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
 	if (params.mand_found)
 		cw_check_missing_mand(message, params.mand_found,conn->msgset->handlers_by_key);
 
-	cw_dbg(DBG_MSG_PARSING, "*** End parsing message of type %d (%s) ***",
+//	cw_dbg(DBG_MSG_PARSING, "*** End parsing message of type %d (%s) ***",
-	       message->type, message->name);
+//	       message->type, message->name);
 
 	if (params.mand_found)
 		mavl_destroy(params.mand_found);
@@ -531,7 +534,7 @@ static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
 
 			cw_send_error_response(conn, rawmsg, result_code);
 		} else if (result_code == 0) {
-			cw_cfg_set_int(conn->update_cfg, "result-code",
+			cw_cfg_set_int(conn->update_cfg, "capwap/result-code",
 					 result_code);
 			if (ui->next) {
 				conn->capwap_prevstate = conn->capwap_state;

src/cw/conn.h

@@ -78,14 +78,16 @@ struct cw_Conn {
 	cw_Cfg_t * local_cfg;	/**< local_cfg contains overrides for global_cfg 
 				     wich are related to this conn object. */
 	
-	mavl_t remote_cfg;	/**< contains the configuration we now from the 
+	cw_Cfg_t * remote_cfg;	/**< contains the configuration we now from the 
 				     device this conn object ist connected to.
 				     Typically this is what we have got from discovery
 				     response or join response in WTP mode. 
 				     And in AC mode this contains date receive from 
 				     configuration status request.  */
 
-	mavl_t update_cfg;
+	cw_Cfg_t * update_cfg;
+
+	cw_Cfg_t * cfg_list[10];
 	
 	bstr16_t session_id;
 

src/cw/conn_q_add_packet.c

@@ -42,7 +42,6 @@ void conn_q_add_packet(struct cw_Conn * conn,uint8_t *packet,int len)
 	conn->q[qwpos]=malloc(len+4);
 	if (conn->q[qwpos]==NULL)
 		return;
-	
 	*((uint32_t*)(conn->q[qwpos]))=len;
 	memcpy(conn->q[qwpos]+4,packet,len);	
 	conn->qwpos=qwpos+1;

src/cw/conn_recv_packet.c

@@ -29,6 +29,7 @@
 
 int conn_recv_packet_(struct cw_Conn *conn, uint8_t * buf, int len, int flags)
 {
+	printf("conn_recv\n");
 	int n;
 	while ((n = recv(conn->sock, (char *) buf, len, flags)) < 0) {
 		if (errno != EINTR) {

src/cw/conn_send_msg.c

@@ -14,6 +14,43 @@ int conn_send_msg(struct cw_Conn * conn, uint8_t *rawmsg)
 	packetlen = cw_get_hdr_msg_total_len(rawmsg);
 
 	cw_dbg_msg(DBG_MSG_OUT, conn,rawmsg, packetlen,(struct sockaddr*)&conn->addr);
+	{
+	int type;
+	uint8_t *msgptr;
+	msgptr = rawmsg + cw_get_hdr_msg_offset(rawmsg);
+	struct cw_MsgData * msg;
+	type = cw_get_msg_type(msgptr);
+	msg = cw_msgset_get_msgdata(conn->msgset,type);
+	uint8_t *elems_ptr;
+
+	int offset = cw_get_hdr_msg_offset(rawmsg);
+
+	uint8_t *msg_ptr = rawmsg + offset;
+	int elems_len = cw_get_msg_elems_len(msg_ptr);
+	elems_ptr = cw_get_msg_elems_ptr(msg_ptr);
+	cw_Cfg_t * cfg = cw_cfg_create();
+	cfg->dbg_level = DBG_ELEM_DETAIL_OUT;
+	cfg->dbg_prefix = "    ";
+
+	struct cw_ElemHandlerParams params;
+	memset(&params,0,sizeof(struct cw_ElemHandlerParams));
+	
+	params.cfg=cfg;
+	params.msgset=conn->msgset;
+	params.msgdata=msg;
+	params.mand_found = mavl_create_conststr();
+	params.dbg_level = DBG_ELEM_OUT;
+
+	cw_decode_elements( &params, elems_ptr,elems_len);
+	cw_cfg_destroy(cfg);
+	if (params.mand_found){
+		cw_check_missing_mand(msg, params.mand_found,conn->msgset->handlers_by_key);
+		mavl_destroy(params.mand_found);
+	}
+
+	}
+
+
 
 
 	/* Zyxel doesn't count msg element length from

src/cw/cw.c

@@ -1,6 +1,7 @@
 #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)
@@ -117,13 +118,15 @@ int cw_out_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerP
 	int radios;
 	len =0;
 	
-	radios = cw_cfg_get_byte_l(params->cfg_list,"wtp-descriptor/max-radios",0);
+	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);
@@ -156,3 +159,114 @@ int cw_header_len(struct cw_ElemHandler * handler)
 }
 
 
+
+/**
+ * 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;
+}

src/cw/cw.h

@@ -353,7 +353,7 @@ int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys, mavl_t handle
 
 
 
-extern int cw_read_descriptor_subelems(mavl_t store, const char * key, uint8_t * data, int len,
+extern int cw_read_descriptor_subelems(cw_Cfg_t * store, const char * key, uint8_t * data, int len,
 				       struct cw_DescriptorSubelemDef *elems);
 
 /*
@@ -362,7 +362,7 @@ int cw_read_wtp_descriptor(mavl_t mbag, struct cw_Conn *conn,
 				  struct cw_DescriptorSubelemDef *allowed);
 */
 
-int cw_read_wtp_descriptor(mavl_t mbag, struct cw_Conn *conn,
+int cw_read_wtp_descriptor(cw_Cfg_t * mbag, struct cw_Conn *conn,
 			   struct cw_ElemHandler *eh, uint8_t * data, int len,
 			   struct cw_DescriptorSubelemDef *allowed);
 
@@ -373,19 +373,19 @@ int cw_write_radio_element(struct cw_ElemHandler * handler, struct cw_ElemHandle
 			 uint8_t * dst);
 			
 
-extern int cw_read_wtp_descriptor_7(mavl_t mbag, struct cw_Conn *conn,
+extern int cw_read_wtp_descriptor_7(cw_Cfg_t * cfg, struct cw_Conn *conn,
 				    struct cw_ElemHandler *eh, uint8_t * data, int len,
 				    struct cw_DescriptorSubelemDef *allowed);
 
 
-int cw_read_ac_descriptor(mavl_t store,
+int cw_read_ac_descriptor(cw_Cfg_t * store,
 			   struct cw_ElemHandler *eh,
 			   struct cw_ElemHandlerParams * params,
 			   uint8_t *data, int len, 
 			struct cw_DescriptorSubelemDef *allowed);
 
 
-int cw_setup_dtls(struct cw_Conn * conn, mavl_t cfg, const char *prefix, char  * default_cipher);
+int cw_setup_dtls(struct cw_Conn * conn, cw_Cfg_t * cfg, const char *prefix, char  * default_cipher);
 
 
 
@@ -552,8 +552,13 @@ int cw_write_header(struct cw_ElemHandler * handler, uint8_t * dst, int len);
 int cw_header_len(struct cw_ElemHandler * handler);
 
 int cw_compose_message(struct cw_Conn *conn, uint8_t * rawout);
+int cw_put_ac_status(uint8_t *dst, cw_Cfg_t ** cfg_list, const char * parent_key);
+int cw_put_descriptor_subelem (uint8_t *dst, cw_Cfg_t ** cfg_list,
+                                 int subelem_id, const char * parent_key );
 
 
+int cw_send_request(struct cw_Conn *conn,int msg_id);
+
 /**
  *@}
  */

src/cw/cw_check_missing_mand.c

@@ -10,6 +10,9 @@ int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys, mavl_t handle
 	mlist_t missing;
 	int count;
 
+	if (msgdata==NULL)
+		return 0;
+	
 	missing = mlist_create_conststr();
 	if (missing==NULL){
 		cw_log(LOG_ERR, "Can't allocate memory for check of missing mand elems: %s", strerror(errno));

src/cw/cw_dbg_set_level.c

@@ -18,9 +18,9 @@ void cw_dbg_set_level (int level, int on)
 			break;
 		default:
 			if (on)
-				cw_dbg_opt_level |= (1 << (level));
+				cw_dbg_opt_level |= (level);
 			else 
-				cw_dbg_opt_level &= (0xffffffff) ^ (1 << (level));
+				cw_dbg_opt_level &= (0xffffffff) ^ (level);
 	}
 }
 

src/cw/cw_dbg_set_level_from_str.c

@@ -9,6 +9,7 @@ int cw_dbg_set_level_from_str(const char *level)
 	switch(*level){
 		case '-':
 		case '!':
+		case '~':
 			on =0;
 			slevel=level+1;
 			break;

src/cw/cw_in_generic_struct.c

@@ -10,7 +10,7 @@ int cw_in_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerP
 {
 	cw_dbg(DBG_X,"STRUCT KEY: %s",handler->key);
 	stop();
-	const char * key;
+/*	const char * key;
 	char tmpkey[CW_CFG_MAX_KEY_LEN];
 
 	
@@ -22,11 +22,8 @@ int cw_in_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerP
 		key = handler->key;
 	}
 
-printf("CW_IN_GENERIC STRUCT: %s\n",key);	
+//printf("CW_IN_GENERIC STRUCT: %s\n",key);	
 
-/*	int (*mkkey)(struct cw_ElemHandler * handler, char *dst, struct cw_ElemHandlerParams * params, 
-		uint8_t*data, int len);
-*/
 
 	if (!handler->type){
 		cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
@@ -34,6 +31,6 @@ printf("CW_IN_GENERIC STRUCT: %s\n",key);
 	}
 
 	cw_ktv_read_struct(params->cfg,handler->type,key,elem_data,elem_len);
-
+*/
 	return CAPWAP_RESULT_SUCCESS;
 }

src/cw/cw_in_generic_with_index.c

@@ -7,12 +7,11 @@ int cw_in_generic_with_index(struct cw_ElemHandler *eh,
 {
 	char key[CW_CFG_MAX_KEY_LEN];
 	int idx;
+	struct cw_Type * type = (struct cw_Type*)eh->type;
 
-cw_dbg(DBG_X,"Fix cw_in_generic_with_index");
-stop();	
 	idx = cw_get_byte(data);
 	sprintf(key,"%s.%d",eh->key,idx);
 //	cw_cfg_add(params->cfg,key,eh->type,NULL,data+1,len-1);
-
+	type->read(params->cfg,key,data+1,len-1,eh->param);
 	return 1;
 }

src/cw/cw_ktv_add.c

@@ -1,43 +0,0 @@
-#include "val.h"
-#include "cw.h"
-
-#include "log.h"
-#include "dbg.h"
-
-cw_Val_t * cw_ktv_add(mavl_t kvtstore, const char *key, const struct cw_Type *type, 
-			const void * valguard,
-			const uint8_t * data, int len)
-{
-	cw_Val_t mdata, *mresult;
-	int exists;
-	mdata.key=cw_strdup(key);
-	mdata.valguard=valguard;
-	
-	if (!mdata.key){
-		cw_log(LOG_ERR, "Can't allocate memory for KTV key %s: %s",
-				key,strerror(errno));
-		return NULL;
-	}
-
-
-	mresult = type->get(&mdata,data,len);
-	if (!mresult){
-		cw_log(LOG_ERR, "Can't create kvstore element for key %s of type %s: %s",
-				key,type->name, strerror(errno));
-		free(mdata.key);
-		return NULL;
-	}
-
-	mavl_del(kvtstore,&mdata);
-	mresult = mavl_insert(kvtstore, &mdata, &exists);
-	if (exists){
-		cw_log(LOG_ERR, "Element already exists %s", key);
-		/* element already exists */
-		free(mdata.key);
-		if (type->del)
-			type->del(&mdata);
-		return mresult;
-	}
-
-	return mresult;
-}

src/cw/cw_ktv_add_from_str.c

@@ -1,45 +0,0 @@
-#include "val.h"
-#include "cw.h"
-
-#include "log.h"
-#include "dbg.h"
-
-const char * cw_ktv_add_from_str(mavl_t kvtstore, const char *key, 
-			const struct cw_Type *type,
-			const void * valguard,
-			const char * str)
-{
-	cw_Val_t mdata, *mresult;
-	int exists;
-
-/*	cw_dbg(DBG_ELEM,"KVStore (%p,%d) add elem (%s): %s", kvstore, kvstore->count,
-			type->name, key );
-*/
-	mdata.key=cw_strdup(key);
-	mdata.valguard=valguard;
-	if (!mdata.key){
-		cw_log(LOG_ERR, "Can't allocate memory for key %s: %s",
-				key,strerror(errno));
-		return NULL;
-	}
-
-	mresult = type->from_str(&mdata,str);
-	if (!mresult){
-		cw_log(LOG_ERR, "Can't create kvstore element for key %s of type %s: %s",
-				key,type->name, strerror(errno));
-		free(mdata.key);
-		return NULL;
-	}
-	
-	mresult = mavl_insert(kvtstore, &mdata, &exists);
-	if (exists){
-		cw_log(LOG_ERR, "Element already exists %s", key);
-		/* element already exists */
-		free(mdata.key);
-		if (type->del)
-			type->del(&mdata);
-		return key;
-	}
-
-	return mdata.key;
-}

src/cw/cw_ktv_base_exists.c

@@ -1,29 +0,0 @@
-#include "val.h"
-/**
- * @file 
- * @description Implementation of cw_ktv_base_exisits
- */
-
-
-/**
- * @brief Check if elements with e certain baskey can be found in 
- * in ktvstore.
- * @param ktvstore ktvstore to search in
- * @param basekey basekey to search for
- * @return The first ktv element belonging to the base eky, 
- * otherwise NULL if no element was found. 
- * 
- */
-cw_Val_t * cw_ktv_base_exists(mavl_t ktvstore, const char *basekey)
-{
-	cw_Val_t * result, search;
-	search.key=(char*)basekey;
-	result = mavl_get_first(ktvstore,&search);
-	if (result == NULL)
-		return NULL;
-	
-	if (strncmp(result->key,basekey,strlen(basekey))==0)
-		return result;
-
-	return NULL;
-} 

src/cw/cw_ktv_cast.c

@@ -1,14 +0,0 @@
-#include "val.h"
-
-cw_Val_t * cw_ktv_cast(cw_Val_t *v,const cw_Type_t * type)
-{
-	if (strcmp(v->type->name,type->name)==0)
-		return v;
-	if (type->cast==NULL)
-		return NULL;
-	if (!type->cast(v))
-		return NULL;
-		
-	return v;
-}
-

src/cw/cw_ktv_get.c

@@ -1,32 +0,0 @@
-
-#include "val.h"
-#include "mavl.h"
-
-/**
- * @brief Get a ktv value from a ktv store
- * @param ktv ktv store
- * @param key key to search for
- * @param type type to match
- * @return A pointer to a #cw_Val_t element, found in the ktv store or
- * NULL if no element with matching key/type is found.
- */
-cw_Val_t * cw_ktv_get(mavl_t ktv, const char *key, const cw_Type_t * type)
-{
-	cw_Val_t search, *result;
-	/* we can safely cast from const char * to char *, because
-	 * we never will use the search varaiable to store ktv values */
-	search.key=(char*)key;
-	
-	result = mavl_get(ktv,&search);
-	if (result == NULL){
-		return NULL;
-	}
-	if (type == NULL){
-		return result;
-	}
-	if (strcmp(type->name,result->type->name)==0){
-		return result;
-	}
-	
-	return NULL;
-}

src/cw/cw_ktv_get_bool.c

@@ -1,11 +0,0 @@
-#include "val.h"
-
-uint8_t cw_ktv_get_bool(mavl_t ktv,const char *key, uint8_t def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_BOOL);
-	if (k != NULL){
-		return k->val.boolean;
-	}
-	return def;
-}

src/cw/cw_ktv_get_bstr16.c

@@ -1,13 +0,0 @@
-#include "val.h"
-#include "bstr.h"
-
-bstr16_t cw_ktv_get_bstr16(mavl_t ktv,const char *key, bstr16_t def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_BSTR16);
-	if (k != NULL){
-		return bstr16_create(k->type->data(k),k->type->len(k));
-	}
-	return def;
-}
-

src/cw/cw_ktv_get_byte.c

@@ -1,11 +0,0 @@
-#include "val.h"
-
-uint8_t cw_ktv_get_byte(mavl_t ktv,const char *key, uint8_t def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_BYTE);
-	if (k != NULL){
-		return k->val.byte;
-	}
-	return def;
-}

src/cw/cw_ktv_get_dword.c

@@ -1,11 +0,0 @@
-#include "val.h"
-
-uint32_t cw_ktv_get_dword(mavl_t ktv,const char *key, uint32_t def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_DWORD);
-	if (k != NULL){
-		return k->val.dword;
-	}
-	return def;
-}

src/cw/cw_ktv_get_str.c

@@ -1,11 +0,0 @@
-#include "val.h"
-
-char * cw_ktv_get_str(mavl_t ktv,const char *key, char * def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_STR);
-	if (k != NULL){
-		return k->val.ptr;
-	}
-	return def;
-}

src/cw/cw_ktv_get_sysptr.c

@@ -1,11 +0,0 @@
-#include "val.h"
-
-void * cw_ktv_get_sysptr(mavl_t ktv,const char *key, void * def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_SYSPTR);
-	if (k != NULL){
-		return k->val.ptr;
-	}
-	return def;
-}

src/cw/cw_ktv_get_word.c

@@ -1,11 +0,0 @@
-#include "val.h"
-
-uint16_t cw_ktv_get_word(mavl_t ktv,const char *key, uint16_t def)
-{
-	cw_Val_t * k;
-	k = cw_ktv_get(ktv,key,CW_TYPE_WORD);
-	if (k != NULL){
-		return k->val.word;
-	}
-	return def;
-}

src/cw/cw_ktv_idx_get.c

@@ -1,126 +0,0 @@
-#include "val.h"
-#include "cfg.h"
-
-void * ktvn(struct mavl *t ,const void *search)
-{
-	
-	struct mavlnode *n,/**lastl,*/*lastb;
-	lastb = NULL; /*lastl=NULL;*/
-	n = t->root;
-	while(n){
-		int rc;
-/*		const cw_Val_t;*//* *c1,*c2;*/
-		/*c1=search;
-		c2=mavlnode_dataptr(n);
-		*/
-		
-		rc = t->cmp(search,mavlnode_dataptr(n));
-		
-		/*printf("Compare: %s %s = %d\n",c1->key,c2->key, rc);*/
-		
-		if (rc==0){
-			return NULL;
-			
-		}
-		
-		if (rc<0){
-			/*lastl = n;*/
-			if (n->s[0]==NULL){
-				return mavlnode_dataptr(lastb);
-				
-			}
-			n=n->s[0];
-		}
-		else{
-			lastb=n;
-			if(n->s[1]==NULL){
-				return mavlnode_dataptr(lastb);
-				
-			}
-			n=n->s[1];
-		}
-	}
-	return NULL;
-	
-}
-
-int cw_ktv_idx_get(mavl_t ktv, const char *key)
-{
-	char ikey[CW_CFG_MAX_KEY_LEN];
-	cw_Val_t search, * result;
-	char *d;
-	
-	sprintf(ikey,"%s.%d",key,65536);
-		
-	search.key=ikey;
-	/*//result = ktvn(ktv,&search);*/
-	
-	result = mavl_get_last(ktv,&search);
-	
-	if (result == NULL){
-		return -1;
-	}
-	
-	d = strchr(result->key,'.');
-	if (d==NULL){
-		return -1;
-	}
-	
-	if (strncmp(result->key,ikey,d-result->key)!=0)
-		return -1;
-	
-	return atoi(d+1);
-}
-
-
-
-int cw_ktv_idx_get_next(mavl_t ktv, const char *key, int n)
-{
-	char ikey[CW_CFG_MAX_KEY_LEN];
-	cw_Val_t search, * result;
-	char *d;
-	int i;
-	
-	sprintf(ikey,"%s.%d",key,n);
-		
-	search.key=ikey;
-	/*//result = ktvn(ktv,&search);*/
-	
-	result = mavl_get_first(ktv,&search);
-	
-	if (result == NULL){
-		return -1;
-	}
-	
-	/*d = strchr(result->key,'.');*/
-	d=NULL;
-/*	for (i = strlen(result->key); i>=0; i--){
-		if (result->key[i]=='/')
-			break;
-	}
-*/	for (i = strlen(ikey); i>=0; i--){
-
-		if (ikey[i]=='.'){
-			d = result->key+i;
-			break;
-		}
-	}
-	
-	
-	if (d==NULL){
-		return -1;
-	}
-	
-	if(result->key[i]!='.'){
-		return -1;
-	}
-	
-/*	if (strncmp(result->key,ikey,d-result->key)!=0)
-		return -1;
-*/
-	if (strncmp(result->key,ikey,i)!=0)
-		return -1;
-	
-
-	return atoi(result->key+i+1);
-}

src/cw/cw_ktv_mavlcmp.c

@@ -1,67 +0,0 @@
-
-#include <ctype.h>
-
-#include "val.h"
-/**
- * @brief Default function to compare two values of type #cw_Val_t.
- *
- * @param v1
- * @param v2
- * @return
- */
-int cw_ktv_mavlcmp (const void *v1, const void *v2)
-{
-	char *d1, *d2, *k1, *k2;
-	int l1, l2, rc, i1, i2;
-	
-	k1 = ( (cw_Val_t *) v1)->key;
-	k2 = ( (cw_Val_t *) v2)->key;
-	
-	while (1) {
-		/* Find dots in both keys */
-		d1 = strchr (k1, '.');
-		d2 = strchr (k2, '.');
-		
-		/* if there are no dots, compare keys as normal */
-		if (d1 == NULL || d2 == NULL)
-			return strcmp (k1, k2);
-			
-			
-		/* calculate the length of the key till dots */
-		l1 = d1 - k1; /*((cw_Val_t *) v1)->key;*/
-		l2 = d2 - k2; /*((cw_Val_t *) v2)->key;*/
-		
-		/* if length differs do a normal compare */
-		if (l1 != l2) {
-			return strcmp (k1, k2); /*((cw_Val_t *) v1)->key, ((cw_Val_t *) v2)->key);*/
-		}
-		
-		
-		rc = strncmp (k1, k2, l1); /*((cw_Val_t *) v1)->key,((cw_Val_t *) v2)->key,l1);*/
-		
-		if (rc != 0) {
-			return rc;
-		}
-		
-		d1++;
-		d2++;
-		i1 = atoi (d1);
-		i2 = atoi (d2);
-		
-		rc = i1 - i2;
-		
-		if (rc != 0)
-			return rc;
-			
-		while (isdigit (*d1))
-			d1++;
-			
-		while (isdigit (*d2))
-			d2++;
-		
-		k1=d1;
-		k2=d2;
-		/*return strcmp(d1,d2);*/
-		/*return cw_ktv_mavlcmp(d1,d2);*/
-	}
-}

src/cw/cw_ktv_mavlcmp_type_by_name.c

@@ -1,8 +0,0 @@
-
-#include "val.h"
-
-int cw_ktv_mavlcmp_type_by_name (const void *v1, const void *v2)
-{
-	return strcmp ( (*((struct cw_Type**) v1))->name, 
-			(*((struct cw_Type**) v2))->name);
-}

src/cw/cw_ktv_mavldel.c

@@ -1,14 +0,0 @@
-
-#include <stdlib.h>
-
-
-#include "val.h"
-
-void cw_ktv_mavldel(void *data)
-{
-	struct cw_Val *ktv = data;
-	if (ktv->type->del) {
-		ktv->type->del(data);
-	}
-	free(ktv->key);
-}

src/cw/cw_ktv_parser.c

@@ -1,359 +0,0 @@
-#include <stdint.h>
-
-#include "val.h"
-
-
-static int str_getc(struct cw_Val_Reader * r)
-{
-	if (r->next==r->maxlen)
-		return EOF;
-		
-	return *((uint8_t*)(r->data)+r->next++);
-}
-
-static void str_ungetc(struct cw_Val_Reader * r, int c)
-{
-	if (r->next>0)
-		r->next--;
-}
-
-void cw_ktv_init_str_reader(struct cw_Val_Reader *r, const char * str, int len)
-{
-	memset(r,0,sizeof(struct cw_Val_Reader));
-	r->data = str;
-	r->xgetchar=str_getc;
-	r->ungetchar=str_ungetc;
-	r->maxlen=len;
-}
-
-#include <ctype.h>
-
-#include "val.h"
-/*
-struct parser {
-	int line;
-	int pos;
-	int prevpos;
-	char error[256];
-	int quote;
-	FILE *f;
-	int (*getc)(struct parser *);
-	void (*ungetc)(struct parser *)
-};
-*/
-
-
-
-static int get_char(struct cw_Val_Reader *r)
-{
-	int c;
-	c = r->xgetchar (r);
-	r->pos++;
-	if (c=='\n'){
-		r->prevpos=r->pos;
-		r->line ++;
-		r->pos=0;
-	}
-	return c;
-}
-
-
-static void unget_char(struct cw_Val_Reader * r,int c){
-	r->ungetchar(r,c);
-	if (c=='\n'){
-		r->line--;
-		r->pos=r->prevpos;
-	}
-	else
-		r->pos--;
-}
-
-
-
-static int get_char_q(struct cw_Val_Reader *p)
-{
-	int c;
-
-	while(1) {
-		c = get_char(p);
-		if (c==EOF || c=='\n')
-			return c;
-	
-		if(c=='"' && !p->quote){
-			p->quote=1;
-			continue;
-		}
-		if(c=='"' && p->quote){
-			p->quote=0;
-			continue;
-		}
-		break;
-	}
-	
-	
-	if (!p->quote)
-		return c;
-			
-	if (c!='\\')
-		return c;
-			
-	c = get_char(p);
-	switch(c){
-		case EOF:
-			return c;
-		case 'n':
-			return '\n';
-			
-		case '\\':
-			return '\\';
-		case '"':
-			return '"';
-		default:
-			unget_char(p,c);
-			return '\\';
-	}
-			
-	/* We will never reach here */
-	/* return c;*/
-}
-
-
-
-
-
-
-
-
-
-
-
-
-static int skip_chars (struct cw_Val_Reader *r, const char * chars)
-{
-	int c;
-	
-	while ( (c = get_char (r)) != EOF) {
-		if (strchr (chars, c))
-			continue;
-		return c;
-	}
-	return c;
-}
-
-static int skip_to_chars (struct cw_Val_Reader *r, const char *chars)
-{
-	int c;
-	
-	while ( (c = get_char (r)) != EOF) {
-		if (strchr (chars, c))
-			return c;
-	}
-	return c;
-}
-
-
-
-static int read_key (struct cw_Val_Reader *r, char *key, int max_len)
-{
-	int c,n;
-
-	do {
-		c = skip_chars (r, " \t\n\a\v");
-		if (c == '#') {
-			c = skip_to_chars (r, "\n\a");
-		} else {
-			break;
-		}
-	} while (c != EOF);
-	
-	unget_char(r,c);
-	c=get_char_q(r);
-
-	n=0;
-	while(c!=EOF && n<max_len){
-		if (!r->quote && !isalnum(c) && !strchr("._/-()@#|{}[]\\",c)){
-			unget_char(r,c);
-			break;
-		}
-
-		key[n]=c;
-		c=get_char_q(r);
-		n++;
-
-	}
-	key[n]=0;
-	return n;
-}
-
-
-static int skip_to_colon(struct cw_Val_Reader * r)
-{
-	int c;
-	c = skip_chars (r, " \t");
-	if (c!=':' && c!='='){
-		if (c=='\n'){
-			unget_char(r,c);
-			sprintf(r->error,"Unexpected EOL, colon or equal sign expected.");
-			return -1;
-		}
-		sprintf(r->error,"Colon or equal sign expected.");
-		return -1;
-	}
-	return c;
-}
-
-
-static int read_type(struct cw_Val_Reader * r, char *type, int max_len)
-{
-	int c,n;
-	
-	c = skip_to_colon(r);
-	if (c==-1)
-		return -1;
-	if (c=='='){
-		unget_char(r,c);
-		return sprintf(type,"%s","Str");
-		
-	}
-
-	c = skip_chars (r, " \t");
-	
-	if (c==':'){
-		unget_char(r,c);
-		sprintf(type,"%s","Str");
-		return 0;
-	}
-		
-	if (!isalpha(c)){
-		if (c=='\n'){
-			unget_char(r,c);
-			/*sprintf(p->error,"Error at line %d, pos %d: Unexpected EOL.", p->line, p->pos);*/
-			return -1;
-		}
-		
-		/*sprintf(p->error,"Error at line %d, pos %d: Letter expected.", p->line, p->pos);*/
-		return -1;
-	}
-
-	n=0;
-	while(c!=EOF && n<max_len){
-		if (!isalnum(c) && !strchr("_/-.()@#|{}[]",c)/*strchr(": \t\n\a",c)*/){
-			unget_char(r,c);
-			break;
-		}
-
-		type[n]=c;
-		c=get_char(r);
-		n++;
-	}
-	type[n]=0;
-	return n;
-}
-
-
-static int read_val(struct cw_Val_Reader *r, char *val, int max_len){
-	int c,n,quote;
-	c = skip_to_colon(r);
-	if (c==-1)
-		return -1;
-	c = skip_chars (r, " \t");
-	if (c=='"'){
-		quote=1;
-		c=get_char(r);
-	}
-	else{
-		quote=0;
-	}
-	n=0;
-	while(c!=EOF && n<max_len){
-		if (quote && c=='"'){
-			break;
-		}
-		if (c=='\n'){
-			break;
-		}
-		if (quote){
-			if (c=='\\'){
-				c = get_char(r);
-				switch(c){
-					case 'n':
-						c='\n';
-						break;
-					case '\\':
-						break;
-					case '"':
-						break;
-					default:
-						unget_char(r,c);
-						c='\\';
-				}
-			}
-		}
-		val[n++]=c;
-		c=get_char(r);
-	}
-	
-	
-	if(!quote && n>0){
-		while(n>0){
-			if (isspace(val[n-1]))
-				n--;
-			else
-				break;
-		}
-	}
-	
-	val[n]=0;
-
-	return n;
-
-}
-
-
-/*
-int cw_ktv_parse_line (FILE *f, char * key, char * type, char *val)
-{
-	int n;
-
-	struct parser p;
-	p.line=1;
-	p.pos=0;
-	p.prevpos=0;
-	p.quote=0;
-	p.f=f;
-		
-	n = read_key (&p,key,CW_KTV_MAX_KEY_LEN);
-	n = read_type (&p,type,CW_KTV_MAX_KEY_LEN);
-	if (n==-1){
-		return -1;
-	}
-
-	n = read_val (&p,val,CW_KTV_MAX_KEY_LEN);
-	if (n==-1){
-		return -1;
-	}
-	return 0;
-}
- */
-
-
-int cw_ktv_parse_line(struct cw_Val_Reader * r)
-{
-	
-}
-
-int cw_ktv_parse_string(struct cw_Val_Reader *r, char *key, char *type, char *val)
-{
-
-	int n;
-
-	
-
-	n = read_key (r,key,CW_KTV_MAX_KEY_LEN);
-	n = read_type(r,type,200);
-	if (n==1)
-		return -1;
-	n = read_val(r,val,200);
-	return n;
-	
-}

src/cw/cw_ktv_read_file.c

@@ -1,40 +0,0 @@
-
-#include "val.h"
-#include "cfg.h"
-
-int cw_ktv_read_file(FILE * file, mavl_t ktv, mavl_t types)
-{
-	char key[CW_CFG_MAX_KEY_LEN];
-	char type[256];
-	char val[2048];
-	
-	
-	int rc;
-	struct cw_Type typesearch, *cwtype;
-
-	
-	do {
-
-		rc = cw_ktv_read_line(file,key,type,val);
-		if (rc != 0){
-			continue;
-		}
-
-		typesearch.name=type;
-
-		cwtype = mavl_get_ptr(types,&typesearch);
-		if (cwtype != NULL){
-		/*//	printf("Yes! I know the type: %s\n",cwtype->name);*/
-		}
-		else {
-			printf("Unknown type: %s\n",typesearch.name);
-			continue;
-		}
-
-		cw_ktv_add_from_str(ktv,key,cwtype,NULL,val);
-	
-
-	}while(rc==0);
-	
-	return 0;
-}

src/cw/cw_ktv_read_struct.c

@@ -1,62 +0,0 @@
-#include "val.h"
-#include "dbg.h"
-#include "cfg.h"
-
-int cw_ktv_read_struct(mavl_t ktv,const cw_ValStruct_t * stru, const char *pkey, 
-	uint8_t * data, int len)
-{
-	char key[CW_CFG_MAX_KEY_LEN];
-	int pos, i,l;
-	cw_Val_t * result;
-	
-	
-	pos=0; i=0;
-	while (stru[i].type != NULL){
-		char dbstr[100];
-		if(stru[i].position!=-1)
-			pos=stru[i].position;
-		
-		if (stru[i].key!=NULL)
-			sprintf(key,"%s/%s",pkey,stru[i].key);
-		else	
-			sprintf(key,"%s",pkey);
-		
-		switch (stru[i].len){
-			case CW_KTVSTRUCT_L8:
-				l = cw_get_byte(data+pos);
-				pos ++;
-				break;
-			case CW_KTVSTRUCT_L16:
-				l = cw_get_word(data+pos);
-				pos ++;
-				break;
-			case -1:
-				l = len-pos;
-				break;
-			default:
-				l = stru[i].len;
-				if (pos+l > len){
-					l = len-pos;
-				}
-			
-		}
-
-		result = cw_ktv_add(ktv,key,stru[i].type,stru[i].valguard,data+pos,l);
-		
-		stru[i].type->to_str(result,dbstr,100);
-		cw_dbg(DBG_ELEM_DETAIL, "Read (%d): %s: %s",pos,key,dbstr);
-		printf("READ STRUCT (%d): %s: %s\n",pos,key,dbstr);
-		
-		if (stru[i].len==-1)
-			l = result->type->len(result);
-		else 
-			l = stru[i].len;
-	
-		if(stru[i].position == -1)
-			pos+=l;
-
-		i++;
-	}
-
-	return pos;
-}

src/cw/cw_ktv_readline.c

@@ -1,306 +0,0 @@
-#include <ctype.h>
-
-#include "val.h"
-#include "cfg.h"
-
-struct parser {
-	int line;
-	int pos;
-	int prevpos;
-	char error[256];
-	int quote;
-	FILE *f;
-	int (*getc)(struct parser *);
-	void (*ungetc)(struct parser *);
-};
-
-/*
-static int pgetc(struct parser *parser)
-{
-	return fgetc(parser->f);
-}*/
-
-static int get_char(struct parser *p)
-{
-	int c;
-	c = fgetc (p->f);
-	p->pos++;
-	if (c=='\n'){
-		p->prevpos=p->pos;
-		p->line ++;
-		p->pos=0;
-	}
-	return c;
-}
-
-
-static void unget_char(struct parser *p,int c){
-	ungetc(c,p->f);
-	if (c=='\n'){
-		p->line--;
-		p->pos=p->prevpos;
-	}
-	else
-		p->pos--;
-}
-
-
-
-static int get_char_q(struct parser *p)
-{
-	int c;
-
-	while(1) {
-		c = get_char(p);
-		if (c==EOF || c=='\n')
-			return c;
-	
-		if(c=='"' && !p->quote){
-			p->quote=1;
-			continue;
-		}
-		if(c=='"' && p->quote){
-			p->quote=0;
-			continue;
-		}
-		break;
-	}
-	
-	
-	if (!p->quote)
-		return c;
-			
-	if (c!='\\')
-		return c;
-			
-	c = get_char(p);
-	switch(c){
-		case EOF:
-			return c;
-		case 'n':
-			return '\n';
-			
-		case '\\':
-			return '\\';
-		case '"':
-			return '"';
-		default:
-			unget_char(p,c);
-			return '\\';
-	}
-			
-	/* We will never reach here */
-	/* return c;*/
-}
-
-
-
-
-
-
-
-
-
-
-
-
-static int skip_chars (struct parser *p, const char * chars)
-{
-	int c;
-	
-	while ( (c = get_char (p)) != EOF) {
-		if (strchr (chars, c))
-			continue;
-		return c;
-	}
-	return c;
-}
-
-static int skip_to_chars (struct parser *p, const char *chars)
-{
-	int c;
-	
-	while ( (c = get_char (p)) != EOF) {
-		if (strchr (chars, c))
-			return c;
-	}
-	return c;
-}
-
-
-
-static int read_key (struct parser *p, char *key, int max_len)
-{
-	int c,n;
-
-	do {
-		c = skip_chars (p, " \t\n\a\v");
-		if (c == '#') {
-			c = skip_to_chars (p, "\n\a");
-			
-		} else {
-			break;
-		}
-	} while (c != EOF);
-	
-	unget_char(p,c);
-	c=get_char_q(p);
-
-	n=0;
-	while(c!=EOF && n<max_len){
-		if (!p->quote && !isalnum(c) && !strchr("._/-()@#|{}[]\\",c)/*strchr(": \t\n\a",c)*/){
-			unget_char(p,c);
-			break;
-		}
-
-		key[n]=c;
-		c=get_char_q(p);
-		n++;
-
-	}
-	key[n]=0;
-	return n;
-}
-
-
-static int skip_to_colon(FILE *f,struct parser * p)
-{
-	int c;
-	c = skip_chars (p, " \t");
-	if (c!=':'){
-		if (c=='\n'){
-			unget_char(p,c);
-			sprintf(p->error,"Error at line %d, pos %d: Unexpected EOL, collon expected.", p->line, p->pos);
-			return 0;
-		}
-		sprintf(p->error,"Error at line %d, pos %d: Collon expected.", p->line, p->pos);
-		return 0;
-	}
-	return 1;
-}
-
-
-static int read_type(struct parser *p, char *type, int max_len)
-{
-	int c,n;
-	
-	if (!skip_to_colon(p->f,p))
-		return -1;
-
-	c = skip_chars (p, " \t");
-	
-	if (c==':'){
-		unget_char(p,c);
-		sprintf(type,"%s","");
-		return 0;
-	}
-		
-	if (!isalpha(c)){
-		if (c=='\n'){
-			unget_char(p,c);
-			sprintf(p->error,"Error at line %d, pos %d: Unexpected EOL.", p->line, p->pos);
-			return -1;
-		}
-		
-		sprintf(p->error,"Error at line %d, pos %d: Letter expected.", p->line, p->pos);
-		return -1;
-	}
-
-	n=0;
-	while(c!=EOF && n<max_len){
-		if (!isalnum(c) && !strchr("_/-.()@#|{}[]",c)/*strchr(": \t\n\a",c)*/){
-			unget_char(p,c);
-			break;
-		}
-
-		type[n]=c;
-		c=get_char(p);
-		n++;
-	}
-	type[n]=0;
-	return n;
-}
-
-
-static int read_val(struct parser *p, char *val, int max_len){
-	int c,n,quote;
-	if (!skip_to_colon(p->f,p))
-		return -1;
-	c = skip_chars (p, " \t");
-	if (c=='"'){
-		quote=1;
-		c=get_char(p);
-	}
-	else{
-		quote=0;
-	}
-	n=0;
-	while(c!=EOF && n<max_len){
-		if (quote && c=='"'){
-			break;
-		}
-		if (c=='\n'){
-			break;
-		}
-		if (quote){
-			if (c=='\\'){
-				c = get_char(p);
-				switch(c){
-					case 'n':
-						c='\n';
-						break;
-					case '\\':
-						break;
-					case '"':
-						break;
-					default:
-						unget_char(p,c);
-						c='\\';
-				}
-			}
-		}
-		val[n++]=c;
-		c=get_char(p);
-	}
-	
-	
-	if(!quote && n>0){
-		while(n>0){
-			if (isspace(val[n-1]))
-				n--;
-			else
-				break;
-		}
-	}
-	
-	val[n]=0;
-
-	return n;
-
-}
-
-
-
-int cw_ktv_read_line (FILE *f, char * key, char * type, char *val)
-{
-	int n;
-
-	struct parser p;
-	p.line=1;
-	p.pos=0;
-	p.prevpos=0;
-	p.quote=0;
-	p.f=f;
-		
-	n = read_key (&p,key,CW_CFG_MAX_KEY_LEN);
-	n = read_type (&p,type,CW_CFG_MAX_KEY_LEN);
-	if (n==-1){
-		return -1;
-	}
-
-	n = read_val (&p,val,CW_CFG_MAX_KEY_LEN);
-	if (n==-1){
-		return -1;
-	}
-	return 0;
-}

src/cw/cw_ktv_replace.c

@@ -1,32 +0,0 @@
-#include "val.h"
-#include "cw.h"
-
-#include "log.h"
-#include "dbg.h"
-
-cw_Val_t * cw_ktv_replace(mavl_t kvtstore, const char *key, const struct cw_Type *type,
-			const void * valguard,
-			const uint8_t * data, int len)
-{
-	cw_Val_t mdata, *mresult;
-	int exists;
-
-	mdata.key=cw_strdup(key);
-	if (!mdata.key){
-		cw_log(LOG_ERR, "Can't allocate memory for KTV key %s: %s",
-				key,strerror(errno));
-		return NULL;
-	}
-
-	mresult = type->get(&mdata,data,len);
-	if (!mresult){
-		cw_log(LOG_ERR, "Can't create kvstore element for key %s of type %s: %s",
-				key,type->name, strerror(errno));
-		free(mdata.key);
-		return NULL;
-	}
-	
-	mresult = mavl_replace(kvtstore, &mdata, &exists);
-
-	return mresult;
-}

src/cw/cw_ktv_save.c

@@ -1,58 +0,0 @@
-
-#include "val.h"
-
-
-static int write_str(FILE *outfile,const char *str)
-{
-	if ( (strchr(str,'\\')!=NULL) || (strchr(str,'"')!=NULL) || (strchr(str,'\n')!=NULL)){
-		fprintf(outfile,"\"");
-		
-		while (*str != 0){
-			switch(*str){
-				case '\n':
-					fprintf(outfile,"\\n");
-					break;
-				case '\\':
-					fprintf(outfile,"\\\\");
-					break;
-				case '"':
-					fprintf(outfile,"\\\"");
-					break;
-				default:
-					fprintf(outfile,"%c",*str);
-					break;
-			}
-			str++;
-		}
-
-		fprintf(outfile,"\"");
-		return 1;
-	}
-	
-	fprintf(outfile,"%s",str);
-	return 1;
-}
-
-int cw_ktv_save(mavl_t ktvstore, const char * filename){
-	mavliter_t it;
-	FILE * outfile;
-	
-	outfile = fopen(filename,"w");
-	if (outfile == NULL)
-		return 0;
-	
-	mavliter_init(&it,ktvstore);
-	mavliter_foreach(&it){
-		cw_Val_t * val;
-		char buf[4000];
-		val = mavliter_get(&it);
-		val->type->to_str(val,buf,4000);
-		write_str(outfile,val->key);
-		fprintf(outfile," :%s: ",val->type->name);
-		write_str(outfile,buf);
-		fprintf(outfile,"\n");
-		
-	}
-	fclose(outfile);
-	return 1;
-}

src/cw/cw_ktv_set_byte.c

@@ -1,6 +0,0 @@
-#include "val.h"
-
-cw_Val_t * cw_ktv_set_byte(mavl_t ktv,const char * key, uint8_t byte)
-{
-	return cw_ktv_replace(ktv,key,CW_TYPE_BYTE,NULL,&byte,1);
-}

src/cw/cw_ktv_set_dword.c

@@ -1,6 +0,0 @@
-#include "val.h"
-
-cw_Val_t * cw_ktv_set_dword(mavl_t ktv,const char * key, uint32_t dword)
-{
-	return cw_ktv_replace(ktv,key,CW_TYPE_DWORD,NULL,(void*)&dword,4);
-}

src/cw/cw_ktv_set_word.c

@@ -1,6 +0,0 @@
-#include "val.h"
-
-cw_Val_t * cw_ktv_set_word(mavl_t ktv,const char * key, uint16_t word)
-{
-	return cw_ktv_replace(ktv,key,CW_TYPE_WORD,NULL,(void*)&word,2);
-}

src/cw/cw_ktv_std_types.c

@@ -1,13 +0,0 @@
-#include "val.h"
-
-const cw_Type_t * cw_ktv_std_types[] = {
-	CW_TYPE_BYTE,
-	CW_TYPE_WORD,
-	CW_TYPE_DWORD,
-	CW_TYPE_BSTR16,
-	CW_TYPE_IPADDRESS,
-	CW_TYPE_STR,
-	CW_TYPE_SYSPTR,
-	CW_TYPE_BOOL,
-	NULL
-};

src/cw/cw_ktv_write_struct.c

@@ -1,77 +0,0 @@
-#include "val.h"
-#include "dbg.h"
-#include "log.h"
-#include "cfg.h"
-
-int cw_ktv_write_struct(mavl_t ktv, mavl_t def, const cw_ValStruct_t * stru, const char *pkey, 
-	uint8_t * dst)
-{
-	char key[CW_CFG_MAX_KEY_LEN];
-	int pos, i;
-	cw_Val_t * result;
-	
-	pos=0; i=0;
-	for(i=0; stru[i].type != NULL;i++){
-	
-		if (stru[i].position!=-1){
-			pos=stru[i].position;
-		}
-		if (stru[i].len!=-1)
-			memset(dst+pos,0,stru[i].len);
-		
-		
-		if (stru[i].key!=NULL)
-			sprintf(key,"%s/%s",pkey,stru[i].key);
-		else	
-			sprintf(key,"%s",pkey);
-
-printf("Get Key: %s\n",key);
-		result = cw_ktv_get(ktv,key,NULL);
-
-		if(result)
-		{
-			char s[129];
-			result->type->to_str(result,s,128);
-			printf("Content: '%s'\n",s);
-		}	
-
-		if (result == NULL && def != NULL){
-			result = cw_ktv_get(def,key,NULL);
-		}
-
-		
-		if (result == NULL){
-			cw_log(LOG_ERR,"Can't put %s, no value found, filling zero.",key);
-			memset(dst+pos,0,stru[i].len);
-		}
-		else{
-			result->valguard=stru[i].valguard;
-			if (cw_ktv_cast(result,stru[i].type)==NULL){
-				cw_log(LOG_ERR,"Can't cast key '%s' from %s to %s",key,result->type->name,stru[i].type->name);
-			}
-/*			if (strcmp(stru[i].type->name,result->type->name)){
-				
-				
-				
-				printf("Type mismatch: %s != %s\n",stru[i].type->name,result->type->name);
-				if (stru[i].type->cast != NULL){
-					if (!stru[i].type->cast(result)){
-						cw_log(LOG_ERR,"Can't cast '%s' from %s to %s",key,result->type->name,stru[i].type->name);
-						exit(0);
-					}
-				}
-							
-
-			}
-*/		
-			result->type->put(result,dst+pos);
-		}
-		if (stru[i].len!=-1)
-			pos+=stru[i].len;
-		else	
-			pos+=result->type->len(result);
-
-	}
-
-	return pos;
-}

src/cw/cw_out_generic_with_index.c

@@ -1,42 +1,42 @@
 
 #include "cw.h"
 #include "dbg.h"
+#include "cfg.h"
 
 int cw_out_generic_with_index(struct cw_ElemHandler * eh, 
 		struct cw_ElemHandlerParams * params, uint8_t * dst)
 
 {
-	stop();
-	char key[CW_CFG_MAX_KEY_LEN];
-	int idx;
-	cw_Val_t * result, search;
 	int len,start;
 	uint8_t * ob;
+	struct cw_Cfg_entry *e;
+	struct cw_Cfg_iter cfi;
+	struct cw_Type * type = (struct cw_Type *)eh->type;
+	int i,l;
 
 
-	idx = 0;
 	ob = dst;
 
-	do {
+	cw_cfg_iter_init(params->cfg_list[0], &cfi, eh->key);
-		sprintf(key,"%s.%d",eh->key,idx);
+	for (i=0; (e = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++){
-		search.key=key;
-		result = mavl_get_first(params->cfg,&search);
-		if (result==NULL)
-			break;
-		if (strncmp(result->key,key,strlen(key))!=0)
-			break;
-	
 		start = params->msgset->header_len(eh);
-		len = cw_put_byte(ob+start,idx);
+		len = cw_put_byte(ob+start,i);
 
-		len += result->type->put(result,ob+start+len);
+		cw_dbg(DBG_X,"KV: %s -  %s",e->key,e->val);
+//		int bwrite(cw_Cfg_t ** cfgs, const char *key, uint8_t *dst, const void * param)
+		l = type->write(params->cfg_list,e->key,ob+start+len,eh->param);
+		if (l==-1)
+			continue;
+		len += l;
+
+		//len += result->type->put(result,ob+start+len);
 
 		ob += params->msgset->write_header(eh,ob,len);
 		
-		idx++;
 
-	}while(1);
+	}
-
+
-	return ob-dst;
+	return ob-dst;
+	
 }
 

src/cw/cw_out_radio_generic_struct.c

@@ -133,11 +133,11 @@ int cw_out_traverse(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams
 
 {
 
-	char current[CW_CFG_MAX_KEY_LEN];
+	//char current[CW_CFG_MAX_KEY_LEN];
-	int stack[10];
+	//int stack[10];
-	stack[0]=0;
+	//stack[0]=0;
 
-	current[0]=0;
+	//current[0]=0;
 
 	stop();
 	return 0;

src/cw/cw_read_ac_descriptor.c

@@ -25,7 +25,7 @@ cw_ValStruct_t acstatus [] = {
 
 
 
-int cw_read_ac_descriptor(mavl_t store,
+int cw_read_ac_descriptor(cw_Cfg_t * store,
 			   struct cw_ElemHandler *eh,
 			   struct cw_ElemHandlerParams * params,
 			   uint8_t *data, int len, 

src/cw/cw_read_descriptor_subelems.c

@@ -22,7 +22,7 @@
 #include "keys.h"
 
 
-int cw_read_descriptor_subelems(mavl_t cfg, const char *parent_key,
+int cw_read_descriptor_subelems(cw_Cfg_t *cfg, const char *parent_key,
 				uint8_t * data, int len,
 				struct cw_DescriptorSubelemDef *elems)
 {

src/cw/cw_read_wtp_descriptor.c

@@ -16,7 +16,7 @@ static struct cw_DescriptorSubelemDef allowed_default[] = {
 };
 
 
-int cw_read_wtp_descriptor(mavl_t cfg, struct cw_Conn *conn,
+int cw_read_wtp_descriptor(cw_Cfg_t * cfg, struct cw_Conn *conn,
 			   struct cw_ElemHandler *eh, uint8_t * data, int len,
 			   struct cw_DescriptorSubelemDef *allowed)
 {

src/cw/cw_read_wtp_descriptor_7.c

@@ -20,7 +20,7 @@ static struct cw_DescriptorSubelemDef allowed_default[] = {
 /**
  * Read WTP Descriptor in Cisco-Style (Draft 7)
  */
-int cw_read_wtp_descriptor_7(mavl_t cfg, struct cw_Conn *conn,
+int cw_read_wtp_descriptor_7(cw_Cfg_t * cfg, struct cw_Conn *conn,
 			     struct cw_ElemHandler *eh, uint8_t * data, int len,
 			     struct cw_DescriptorSubelemDef *allowed)
 {

src/cw/cw_setup_dtls.c

@@ -10,7 +10,8 @@ static int get_psk(struct cw_Conn *conn, const char *username, uint8_t ** psk,
 	char key[CW_CFG_MAX_KEY_LEN];
 	cw_Val_t *result;
 	sprintf(key, "%s/%s", "psk", username);
-	result = cw_ktv_get(conn->local_cfg, key, CW_TYPE_BSTR16);
+	stop();
+//	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);
@@ -49,10 +50,10 @@ int cw_setup_dtls(struct cw_Conn *conn, cw_Cfg_t * cfg, const char *prefix,
 	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);
+	conn->dtls_psk = (bstr16_t)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");
+	conn->dtls_psk_enable = cw_cfg_get_bool(cfg, key, 0);
 
 	if (conn->dtls_psk_enable) {
 		security |= CAPWAP_FLAG_AC_SECURITY_S;

src/cw/cw_write_radio_element.c

@@ -9,7 +9,7 @@ int cw_write_radio_element(struct cw_ElemHandler * handler, struct cw_ElemHandle
 {
 
 	char key[CW_CFG_MAX_KEY_LEN];
-	cw_Val_t *elem, search;
+//	cw_Val_t *elem;
 	int len;
 	uint8_t * d;
 	

src/cw/dbg.c

@@ -63,14 +63,13 @@ static struct cw_StrListElem theme0[] = {
 	{DBG_PKT_DMP_OUT, ANSI_BYELLOW ANSI_ITALIC},
 	
 	{DBG_MSG_IN, ANSI_BLUE ANSI_BOLD},
-	{DBG_MSG_PARSING, ANSI_BLUE },
 	
 	{DBG_MSG_OUT, ANSI_BLUE ANSI_BOLD ANSI_ITALIC},
-	{DBG_MSG_ASSEMBLY, ANSI_BLUE ANSI_ITALIC},
+	{DBG_MSG_COMPOSE, ANSI_BLUE ANSI_ITALIC},
 	
 	
-	{DBG_MSG_IN_DMP, ANSI_BBLUE },
+	{DBG_MSG_DMP_IN, ANSI_BBLUE },
-	{DBG_MSG_OUT_DMP, ANSI_BBLUE ANSI_ITALIC},
+	{DBG_MSG_DMP_OUT, ANSI_BBLUE ANSI_ITALIC},
 	
 	{DBG_ELEM_IN, ANSI_DEFAULT},
 	{DBG_ELEM_OUT, ANSI_DEFAULT ANSI_ITALIC},
@@ -79,7 +78,7 @@ static struct cw_StrListElem theme0[] = {
 	{DBG_PKT_ERR, ANSI_RED},
 	{DBG_ELEM_ERR, ANSI_RED},
 	
-	{DBG_SUBELEM, ANSI_BBLACK},
+//	{DBG_SUBELEM, ANSI_BBLACK},
 	{DBG_DTLS, ANSI_MAGENTA ANSI_BOLD},
 	{DBG_DTLS_DETAIL, ANSI_MAGENTA},
 	{DBG_DTLS_BIO, ANSI_BMAGENTA},
@@ -92,8 +91,8 @@ static struct cw_StrListElem theme0[] = {
 	{DBG_X, "\x1b[31m"},
 	{DBG_WARN, ANSI_CYAN},
 	{DBG_MOD, ANSI_WHITE},
-	{DBG_CFG_DMP, ANSI_BCYAN }, 
+//	{DBG_CFG_DMP, ANSI_BCYAN }, 
-	
+	{DBG_CFG_UPDATES,ANSI_GREEN},	
 
 	{CW_STR_STOP, ""}
 };
@@ -104,7 +103,8 @@ static struct cw_StrListElem * color_on = theme0;
 struct cw_StrListElem color_ontext[] = {
 
 /*	{DBG_ELEM_DMP, "\x1b[37m"},*/
-	{DBG_ELEM_DMP, ANSI_BBLACK ANSI_ITALIC},
+	{DBG_ELEM_DMP_OUT, ANSI_BBLACK ANSI_ITALIC},
+	{DBG_ELEM_DMP_IN,  ANSI_BBLACK},
 
 	{CW_STR_STOP, ""}
 };
@@ -118,9 +118,9 @@ static struct cw_StrListElem color_off[] = {
 
 static struct cw_StrListElem prefix[] = {
 	{DBG_INFO, 		"Info -"},
-	{DBG_PKT_IN, " Pkt IN -"},
+	{DBG_PKT_IN, 		"Pkt In  -"},
 	{DBG_PKT_OUT, 		"Pkt Out -"},
-	{DBG_MSG_IN, " Msg IN -"},
+	{DBG_MSG_IN, 		"Msg In  - "},
 	{DBG_MSG_OUT,		"Msg Out - "},
 
 	{DBG_ELEM_IN, 		"  Msg Element -"},
@@ -130,18 +130,18 @@ static struct cw_StrListElem prefix[] = {
 	{DBG_PKT_ERR, 		"  Pkt Error -"},
 	{DBG_ELEM_ERR, 		"  Elem Error -"},
 	{DBG_RFC, 		"  RFC -"},
-	{DBG_SUBELEM, " Sub-Element - "},
 	{DBG_DTLS, 		"DTLS - "},
 	{DBG_DTLS_DETAIL,	 "DTLS - "},
 	{DBG_WARN,	 	"  Warning - "},
 	{DBG_MOD, 		"Mod - "},
 	{DBG_STATE, 		"STATEMACHINE - "},
-	{DBG_CFG_SET, "    Cfg Set - "},
+	{DBG_CFG_UPDATES,	"Cfg - "},
 
 
 
 	{DBG_X, "XXXXX - "},
 
+
 	{CW_STR_STOP, ""}
 };
 
@@ -183,10 +183,13 @@ const char *get_dbg_color_ontext(int level)
 
 int cw_dbg_is_level(int level)
 {
-	if (level >= DBG_ALL ){
+	if (level > 1 && (level &1))
 		return 1;
-	}
+
-	return (cw_dbg_opt_level & (1<<level));
+/*	if (level >= DBG_ALL ){
+		return 1;
+	}*/
+	return (cw_dbg_opt_level & (level));
 }
 
 
@@ -268,7 +271,7 @@ void cw_dbg_pkt(int level, struct cw_Conn *conn, uint8_t * packet, int len,
 
 	cw_dbg(level, "%s", buf);
 		
-	if (cw_dbg_is_level(DBG_PKT_DMP)) {
+//	if (cw_dbg_is_level(DBG_PKT_DMP)) {
 		int dlevel;
 		if (level == DBG_PKT_IN){
 			dlevel=DBG_PKT_DMP_IN;
@@ -277,7 +280,7 @@ void cw_dbg_pkt(int level, struct cw_Conn *conn, uint8_t * packet, int len,
 			dlevel=DBG_PKT_DMP_OUT;
 		}
 		cw_dbg_dmp(dlevel,packet,len,"");
-	} 
+//	} 
 
 }
 
@@ -352,16 +355,16 @@ void cw_dbg_msg(int level, struct cw_Conn *conn, uint8_t * packet, int len,
 	cw_dbg(level, "%s", buf);
 	
 	
-	if (cw_dbg_is_level(DBG_MSG_DMP)){
+//	if (cw_dbg_is_level(DBG_MSG_DMP)){
 		int dlevel;
 		if(level==DBG_MSG_IN){
-			dlevel = DBG_MSG_IN_DMP;
+			dlevel = DBG_MSG_DMP_IN;
 		}
 		else{
-			dlevel = DBG_MSG_OUT_DMP;
+			dlevel = DBG_MSG_DMP_OUT;
 		}
 		cw_dbg_dmp(dlevel,packet,len,"");
-	}
+//	}
 	
 
 }
@@ -410,9 +413,11 @@ void cw_dbg_elem(int level, struct cw_Conn *conn, int msg,
 			handler->name,len);
 	
 	if (cw_dbg_is_level(DBG_ELEM_DMP)) {
-		/*dmp = cw_format_dump(msgbuf,len,NULL);*/
+		if (level == DBG_ELEM_OUT)
+			cw_dbg_dmp(DBG_ELEM_DMP_OUT,msgbuf,len,"");
+		else 
+			cw_dbg_dmp(DBG_ELEM_DMP_IN,msgbuf,len,"");
 
-		cw_dbg_dmp(DBG_ELEM_DMP,msgbuf,len,"");
 	}
 
 	return;
@@ -421,38 +426,6 @@ void cw_dbg_elem(int level, struct cw_Conn *conn, int msg,
 
 
 
-void cw_dbg_ktv_dump(mavl_t ktv, uint32_t dbglevel, 
-		const char *header, const char *prefix, const char *footer )
-{
-	char value[500];
-	struct cw_Val * data;
-	mavliter_t it;
-	const struct cw_Type * type;
-	
-	if (header != NULL)
-		cw_dbg (dbglevel, header);
-	
-	mavliter_init(&it,ktv);
-
-	mavliter_foreach(&it){
-		
-		data = mavliter_get(&it);
-		type = data->type;
-		type->to_str(data,value,0);
-		
-		cw_dbg(dbglevel,"%s%s :%s: %s",prefix,data->key,type->get_type_name(data), value);
-	}
-	
-	if (footer != NULL)
-		cw_dbg (dbglevel, footer);
-
-}
-
-
-
-
-
-
 
 
 

src/cw/dbg.h

@@ -47,95 +47,101 @@
  * Debug levels
  */ 
 enum cw_dbg_levels{
-	/** Show headers of incomming CAPWAP packets */
+	/** Show headers of incomming/outgoing CAPWAP packets */
-	DBG_PKT_IN=0,
+	DBG_PKT_IN 	= (1<<0), 
+	DBG_PKT_OUT 	= (1<<1),	
 
-	/** Show headers of outgoing CAPWAP packets */
+	/** Hex-dump incomming/outgoing CAPWAP packets */
-	DBG_PKT_OUT,
+	DBG_PKT_DMP_IN	= (1<<3),
+	DBG_PKT_DMP_OUT = (1<<4),
 
 	/** Incomming CAPWAP packets with errors, wich would
 	    usually silently discarded */ 
-	DBG_PKT_ERR,
+	DBG_PKT_ERR	= (1<<5),
 	
-	/** Dump content of incomming packets */
-	DBG_PKT_DMP,
 
-	/** Display incomming CAPWAP/LWAPP messages */
+	/** Display incomming/outgoing CAPWAP/LWAPP messages */
-	DBG_MSG_IN,
+	DBG_MSG_IN	= (1<<6),
+	DBG_MSG_OUT	= (1<<7),
 
-	/** Display outgoing CAPWAP/LWAPP messages */
+	/** Show hex-dump of messages */
-	DBG_MSG_OUT,
+	DBG_MSG_DMP_IN	= (1<<8),
-
+	DBG_MSG_DMP_OUT	= (1<<9),
-	DBG_MSG_DMP,
 
 	/** Message errors */
-	DBG_MSG_ERR,
+	DBG_MSG_ERR	= (1<<10),
 
-	/** Show message elements in incomming messages */
+	/** Show message elements in incomming/outgoing messages */
-	DBG_ELEM_IN,
+	DBG_ELEM_IN	= (1<<11),
-
+	DBG_ELEM_OUT	= (1<<12),
-	/** Show message elements assembled for outgoing messages */
-	DBG_ELEM_OUT,
 
 	/** Show message element details  */
-	DBG_ELEM_DETAIL,
+	DBG_ELEM_DETAIL_IN = (1<<13),
+	DBG_ELEM_DETAIL_OUT = (1<<14),
 
 	/** Error in msg elements */
-	DBG_ELEM_ERR,
+	DBG_ELEM_ERR	= (1<<15),
-
-	/** Show subelements */
-	DBG_SUBELEM,
-
-	/** Show dump of subelements */
-	DBG_SUBELEM_DMP,
 
 	/** hex dump elements */	
-	DBG_ELEM_DMP,
+	DBG_ELEM_DMP	= (1<<16),
 
 	/** General infos, like CAPWAP state */
-	DBG_INFO,	
+	DBG_INFO	= (1<<17),	
 
 	/** Misc. warnings */
-	DBG_WARN,
+	DBG_WARN	= (1<<18),
 
 	/** RFC related */
-	DBG_RFC,
+	DBG_RFC		= (1<<19),
 
 	/** DTLS related messages */
-	DBG_DTLS,
+	DBG_DTLS	= (1<<20),
 
 	/** DTLS BIOs in/out */
-	DBG_DTLS_BIO,
+	DBG_DTLS_BIO	= (1<<21),
 
 	/** Dump DTLS BIO i/o */
-	DBG_DTLS_BIO_DMP,
+	DBG_DTLS_BIO_DMP = (1<<22),
 
 	/** Show DTLS Details */
-	DBG_DTLS_DETAIL,
+	DBG_DTLS_DETAIL	= (1<<23),
 	
-	DBG_CFG_DMP,
+//	DBG_CFG_DMP	= (1<<20),
 
-	DBG_CFG_SET,
+//	DBG_CFG_SET	= (1<<21),
 
 	/** Debug Mods */
-	DBG_MOD,
+	DBG_MOD		= (1<<24),
 	
-	DBG_STATE, /**<Debug State machine */
+       	/**Debug State machine */
+	DBG_STATE	= (1<<25),
 	
-	DBG_ALL, 
 	
-	DBG_PKT_DMP_OUT,
+	DBG_MSG_COMPOSE	= (1<<26),
-	DBG_PKT_DMP_IN,
 
-	DBG_MSG_IN_DMP,
+	DBG_CFG_UPDATES	= (1<<27),
-	DBG_MSG_OUT_DMP,
+
+	DBG_ELEM_VNDR	= (1<<28),
+	
+
+	DBG_X		= (1<<30),
+	DBG_ALL 	= (0x7fffffff),
+
+
+	DBG_ELEM_DMP_IN	= 7,
+	DBG_ELEM_DMP_OUT = 9,
 
-	DBG_MSG_ASSEMBLY,
-	DBG_MSG_PARSING,
 
-	DBG_X
 };
 
+#define DBG_MSG (DBG_MSG_IN | DBG_MSG_OUT)
+#define DBG_PKT (DBG_PKT_IN | DBG_PKT_OUT)
+#define DBG_ELEM (DBG_ELEM_IN | DBG_ELEM_OUT)
+
+
+
+
+
 
 #define DBG_LN __FILE__,__LINE__
 

src/cw/dbg_strings.c

@@ -39,41 +39,59 @@ struct cw_StrListElem cw_dbg_strings[] = {
 	{ DBG_PKT_IN,		"pkt_in"  },
 	{ DBG_PKT_OUT,		"pkt_out" },
 	{ DBG_PKT_ERR,		"pkt_err" },
-	{ DBG_PKT_DMP,	"pkt_dmp" },
+	{ DBG_PKT_DMP_IN,	"pkt_dmp_in" },
+	{ DBG_PKT_DMP_OUT,	"pkt_dmp_out" },
+
 	{ DBG_MSG_IN,		"msg_in"  },
 	{ DBG_MSG_OUT,		"msg_out" },
-	{ DBG_MSG_DMP,	"msg_dmp" },
+	{ DBG_MSG_DMP_IN,	"msg_dmp_in"  },
+	{ DBG_MSG_DMP_OUT,	"msg_dmp_out" },
 	
 	{ DBG_MSG_ERR,		"msg_err"},
 
 	{ DBG_RFC,		"rfc", 	 },
+
 	{ DBG_ELEM_IN,  	"elem_in"},
 	{ DBG_ELEM_OUT, 	"elem_out"},
 	{ DBG_ELEM_DMP, 	"elem_dmp"},
-
-	{ DBG_SUBELEM,	"subelem"},
-	{ DBG_SUBELEM_DMP, "subelem_dmp" },
-	
-	{ DBG_ELEM_DETAIL, "elem_detail"},
-
 	{ DBG_ELEM_ERR, 	"elem_err" },
+	{ DBG_ELEM_DETAIL_IN, 	"elem_detail_in" },
+	{ DBG_ELEM_DETAIL_OUT, 	"elem_detail_out" },
+	{ DBG_ELEM_VNDR,	"elem_vndr"},	
 	
 	{ DBG_DTLS, 		"dtls" },
 	{ DBG_DTLS_BIO,		"dtls_bio" },
 	{ DBG_DTLS_BIO_DMP,	"dtls_bio_dmp"},
 	{ DBG_DTLS_DETAIL, 	"dtls_detail"},
 
-	{ DBG_CFG_SET, "cfg_set" },
+	{ DBG_CFG_UPDATES, 	"cfg_updates" },
 
 	
-	{DBG_CFG_DMP, "cfg_dmp" },
+//	{DBG_CFG_DMP, "cfg_dmp" },
 	
 	{ DBG_WARN,		"warn" },
 		
 	{ DBG_MOD,		"mod"},
 	{ DBG_STATE,		"state" },
+	{ DBG_MSG_COMPOSE,	"msg_compose" },
+
+	{ (DBG_MSG_IN | DBG_MSG_OUT), "msg" },
+	{ (DBG_PKT_IN | DBG_PKT_OUT), "pkt" },
+	{ (DBG_ELEM_IN | DBG_ELEM_OUT), "elem" },
+	{ (DBG_ELEM_DETAIL_IN | DBG_ELEM_DETAIL_OUT), "elem_detail" },
+	{ (DBG_ELEM_IN | DBG_ELEM_OUT | DBG_ELEM_DMP | DBG_ELEM_DETAIL_IN | DBG_ELEM_DETAIL_OUT), "elem_all" },
+
+	{ (	DBG_MSG_IN | DBG_MSG_OUT | 
+		DBG_ELEM_IN | DBG_ELEM_OUT |
+		DBG_MSG_ERR | DBG_ELEM_ERR |
+		DBG_PKT_ERR | DBG_RFC | DBG_WARN
+
+
+		| DBG_STATE), 			"std" },
+
 	{ DBG_ALL, 		"all"},
 
+	
 	{ CW_STR_STOP, NULL } 
 };
 

src/cw/discovery.c

@@ -69,7 +69,7 @@ void cw_discovery_results_add(struct cw_DiscoveryResults *dis,
 	} else {
 		/* Get priority for AC from 
 		 * ac-name-with-priority list */
-		sprintf(key, "ac-name-with-priority/%s", acname);
+		sprintf(key, "capwap/ac-name-with-priority/%s", acname);
 		e.prio = cw_cfg_get_byte(wtp_cfg, key, 255);
 	}
 
@@ -78,7 +78,7 @@ void cw_discovery_results_add(struct cw_DiscoveryResults *dis,
 	do {
 		const char *ipval;
 
-		sprintf(key, "capwap-control-ip-address.%d/wtps", i);
+		sprintf(key, "capwap/control-ip-address.%d/wtps", i);
 		e.wtps = cw_cfg_get_word(ac_cfg, key, 65535);
 
 
@@ -86,7 +86,7 @@ void cw_discovery_results_add(struct cw_DiscoveryResults *dis,
 		if (e.wtps == 65535)
 			break;
 
-		sprintf(key, "capwap-control-ip-address.%d/address", i);
+		sprintf(key, "capwap/control-ip-address.%d/address", i);
 		ipval = cw_cfg_get(ac_cfg, key, "");
 
 		sprintf(key, "%04d%05d%04d", e.prio, e.wtps, dis->nr);
@@ -98,7 +98,7 @@ void cw_discovery_results_add(struct cw_DiscoveryResults *dis,
 		if (e.cfg == NULL)
 			continue;
 
-		cw_cfg_copy(ac_cfg,e.cfg);
+		cw_cfg_copy(ac_cfg,e.cfg,0,"");
 		
 		strcpy(e.ip,ipval);
 

src/cw/dtls_openssl.c

@@ -224,7 +224,7 @@ int dtls_openssl_set_certs(struct cw_Conn * conn, struct dtls_openssl_data *d)
 {
 	int rc;
 	if (conn->dtls_key_file && conn->dtls_cert_file){
-		SSL_CTX_set_default_passwd_cb_userdata(d->ctx, conn->dtls_key_pass);
+		SSL_CTX_set_default_passwd_cb_userdata(d->ctx, (char*)conn->dtls_key_pass);
 		SSL_CTX_set_default_passwd_cb(d->ctx, pem_passwd_cb);
 
 
@@ -291,18 +291,18 @@ return 1;
 
 
 
-
+/*
 static unsigned int psk_server_cb(SSL *ssl,const char *identity, unsigned char * psk, unsigned int max_psk_len)
 {
 	BIO * b = SSL_get_rbio(ssl);
-	struct cw_Conn * conn = BIO_get_data(b); /*->ptr;*/
+	struct cw_Conn * conn = BIO_get_data(b); //->ptr;
 
 	int l = bstr16_len(conn->dtls_psk) < max_psk_len ? bstr16_len(conn->dtls_psk) : max_psk_len;
 	memcpy(psk,conn->dtls_psk,l);
 	return l;
 }
 
-
+*/
 
 
 
@@ -323,10 +323,8 @@ struct dtls_openssl_data * dtls_openssl_data_create(struct cw_Conn * conn, const
 	}
 
 	rc = SSL_CTX_get_security_level(d->ctx);
-	printf("Security Level is %d\n");
 
 	SSL_CTX_set_security_level(d->ctx,0);
-	printf("Security Level is %d\n");
 
 	
 

src/cw/dtls_openssl_accept.c

@@ -32,7 +32,7 @@ int dtls_openssl_accept(struct cw_Conn *conn)
 	
 	if (!conn->dtls_data)
 		conn->dtls_data =
-		    dtls_openssl_data_create(conn, DTLSv1_server_method(),
+		    dtls_openssl_data_create(conn, DTLS_server_method(),
 					     dtls_openssl_bio_method());
 
 	d = (struct dtls_openssl_data *) conn->dtls_data;

src/cw/keys.h

@@ -1,7 +1,7 @@
 #ifndef __KEYS_H
 #define __KEYS_H
 
-#define CW_KEY_WTP_DESCRIPTOR "wtp-descriptor"
+//#define CW_KEY_WTP_DESCRIPTOR "capwap/wtp-descriptor"
 
 #define CW_SKEY_HARDWARE "hardware"
 #define CW_SKEY_SOFTWARE "software"
@@ -15,8 +15,8 @@
 #define CW_SKEY_RADIOS_IN_USE	"radios-in-use"
 
 
-#define CW_KEY_WTP_NAME		"wtp-name"
+//#define CW_KEY_WTP_NAME		"wtp-name"
-#define CW_KEY_DISCOVERY_TYPE	"discovery-type"
+//#define CW_KEY_DISCOVERY_TYPE	"discovery-type"
 #define CW_KEY_WTP_MAC_TYPE	"wtp-mac-type"
 #define CW_KEY_WTP_FRAME_TUNNEL_MODE	"wtp-frame-tunnel-mode"
 

src/cw/message.c

@@ -0,0 +1,322 @@
+#include "cw.h"
+#include "log.h"
+#include "dbg.h"
+
+
+
+
+int cw_encode_elements(struct cw_ElemHandlerParams *params, mlist_t elements_list, uint8_t * dst)
+{
+	int len;
+	struct mlistelem * elem;
+
+	len =0;
+	params->len=len;
+
+	mlist_foreach(elem,elements_list){
+		int l;
+		struct cw_ElemData * data;
+		struct cw_ElemHandler * handler;
+		
+		data =  mlistelem_dataptr(elem);
+		handler = cw_msgset_get_elemhandler(params->msgset,data->proto,data->vendor,data->id);
+		params->elemdata = data;
+
+		if (handler==NULL){
+			cw_dbg(DBG_MSG_COMPOSE,"    Add Elem: %d %d %d %s", data->proto, data->vendor, data->id, handler->name);
+			cw_log(LOG_ERR,"Can't put message element %d %d %d, no handler defined.",
+					data->proto,data->vendor,data->id);
+			continue;
+		}
+
+		if (handler->put == NULL){
+			if (data->mand){
+				cw_dbg(DBG_MSG_COMPOSE,"    Add Elem: %d %d %d %s", data->proto, data->vendor, data->id, handler->name);
+				cw_log(LOG_ERR,"Error: Can't add mandatory message element %d - %s, no put method defined",
+					handler->id, handler->name);
+				
+			}
+			continue;
+		}
+
+		if (!data->mand){
+			if (!cw_cfg_base_exists(params->cfg_list[0],handler->key)){
+				cw_dbg(DBG_MSG_COMPOSE,"    Add Elem: %d %d %d %s - (skip)", 
+						data->proto, data->vendor, data->id, handler->name);
+
+				continue;
+			}
+		}
+
+
+		l = handler->put(handler,params,dst+len);
+		cw_dbg(DBG_MSG_COMPOSE,"    Add Elem: %d %d %d %s - (%d bytes)", 
+				data->proto, data->vendor, data->id, handler->name,l);
+
+		len += l;
+		params->len=len;
+	}
+
+	return len;
+}
+
+/**
+ * Put a message to a buffer
+ * This functions assumes, that a message header is
+ * alread initialized in buffer 
+ * Message alements are taken fom actiondef in #conn->action
+ */
+int cw_compose_message(struct cw_Conn *conn, uint8_t * rawout)
+{
+	char details[1024];
+	uint8_t *msgptr,*dst;
+	int type;
+	struct cw_MsgData * msg;
+	int len;
+	struct cw_ElemHandlerParams params;
+
+	/* rawout is already initialized, so we can get 
+	 * msg type from buffer */
+	msgptr = rawout + cw_get_hdr_msg_offset(rawout);
+	type = cw_get_msg_type(msgptr);
+
+	/* look for message data */
+	msg = cw_msgset_get_msgdata(conn->msgset,type);
+	if (msg == NULL){
+		cw_log(LOG_ERR,"Error: Can't create message of type %d (%s) - no definition found.",
+			type, cw_strmsg(type));
+		return CAPWAP_RESULT_MSG_UNRECOGNIZED;
+	}
+
+	if (msg->preprocess){
+		msg->preprocess(conn);
+	}
+
+	cw_dbg(DBG_MSG_COMPOSE,"Composing message of type %d (%s) ***", 
+			msg->type, msg->name);
+	
+	dst = msgptr+8;
+	len =0;
+//cw_dbg(DBG_X,"setting with update CFG");
+	params.conn=conn;
+	params.rawmsg = rawout;
+	params.cfg_list=conn->cfg_list;
+	params.msgset=conn->msgset;
+	params.msgdata=msg;
+	params.debug_details=details;
+	*details=0;
+	len = cw_encode_elements(&params,msg->elements_list,dst);
+
+/*	mlist_foreach(elem,msg->elements_list){
+		struct cw_ElemData * data;
+		struct cw_ElemHandler * handler;
+		
+		data =  mlistelem_dataptr(elem);
+		handler = cw_msgset_get_elemhandler(conn->msgset,data->proto,data->vendor,data->id);
+		cw_dbg(DBG_MSG_COMPOSE,"    Add Elem: %d %d %d %s", 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;
+		}
+
+
+		if (handler->put == NULL){
+			if (data->mand){
+				cw_log(LOG_ERR,"Error: Can't add mandatory message element %d - %s, no put method defined",
+					handler->id, handler->name);
+				
+			}
+			continue;
+		}
+*/
+/*	
+		if (!data->mand){
+			if (!cw_cfg_base_exists(params.cfg,handler->key)){
+				cw_dbg(DBG_X,"nothing todo");
+				continue;
+			}
+		
+		}
+		l = handler->put(handler,&params,dst+len);
+*/
+
+	/*	if(l>0)
+			cw_dbg_elem(DBG_ELEM_OUT,conn,type,handler,dst+len,l);
+	*	if (strlen(details)){
+			cw_dbg(DBG_ELEM_DETAIL,"  %s",params.debug_details);
+		}
+	*/	//len += l;
+//	}
+
+	cw_set_msg_elems_len(msgptr, len);
+	//cw_dbg(DBG_MSG_COMPOSE,"*** Done assenmbling message of type %d (%s) ***", 
+//			msg->type, msg->name);
+	if (type & 1) {
+		/* It's a request, so we have to set seqnum */
+		int s = conn_get_next_seqnum(conn);
+		cw_set_msg_seqnum(msgptr,s);
+	}
+
+
+	{
+//	printf ("----------------------------------- redecode -----------------------------\n");
+/*	uint8_t *elems_ptr;
+
+	int offset = cw_get_hdr_msg_offset(rawout);
+
+	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);
+	cw_Cfg_t * cfg = cw_cfg_create();
+
+	struct cw_ElemHandlerParams params;
+	memset(&params,0,sizeof(struct cw_ElemHandlerParams));
+	
+	params.cfg=cfg;
+	params.msgset=conn->msgset;
+	params.msgdata=msg;
+	params.mand_found = mavl_create_conststr();
+	params.dbg_level = DBG_ELEM_OUT;
+
+	cw_decode_elements( &params, elems_ptr,elems_len);
+	cw_cfg_destroy(cfg);
+	if (params.mand_found){
+		cw_check_missing_mand(msg, params.mand_found,conn->msgset->handlers_by_key);
+		mavl_destroy(params.mand_found);
+	}
+*/
+//	printf ("----------------------------------- end redecode -----------------------------\n");
+
+	}
+
+	return CAPWAP_RESULT_SUCCESS;
+
+}
+
+
+
+int cw_decode_element(struct cw_ElemHandlerParams *params, int proto,
+		      int vendor, int elem_id, uint8_t * data, int len)
+{
+
+	struct cw_ElemHandler *handler;
+	struct cw_ElemData *elem_data, elem_data_search;
+	int rc;
+
+	//params->elem = NULL;
+
+	/* try to retrieve a handler for this message element */
+	handler =
+	    cw_msgset_get_elemhandler(params->msgset, proto, vendor,
+				      elem_id);
+	if (!handler) {
+
+		cw_dbg(DBG_ELEM_ERR,
+		       "Unrecognized message element: %d, ignoring", elem_id);
+		return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
+	}
+
+	/* check if this message element in the current message allowed */
+	elem_data_search.id = elem_id;
+	elem_data_search.proto = proto;
+	elem_data_search.vendor = vendor;
+	if (params->msgdata)
+		elem_data = mavl_get(params->msgdata->elements_tree, &elem_data_search);
+	else
+		elem_data = NULL;
+	if (!elem_data) {
+		cw_dbg(DBG_ELEM_ERR, "Element %d - %s, not allowed here",
+		       elem_id, handler->name);
+		return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
+	}
+
+	/* check the length of the message */
+	if (len < handler->min_len) {
+		cw_dbg(DBG_ELEM_ERR,
+		       "%d (%s) message element too short, len=%d, min len=%d",
+		       handler->id, handler->name, len, handler->min_len);
+		return -1;
+	}
+
+
+	if (elem_data->mand && params->mand_found) {
+		mavl_add_str(params->mand_found, handler->key);
+	}
+
+
+	if (len > handler->max_len && handler->max_len) {
+		cw_dbg(DBG_ELEM_ERR,
+		       "%d (%s) message element too big, len=%d, max len=%d",
+		       handler->id, handler->name, len, handler->max_len);
+		/* TODO XXX truncate the element instead of return */
+		return -1;
+	}
+
+	if (!handler->flags || cw_dbg_is_level(DBG_ELEM_VNDR))
+		cw_dbg_elem(params->dbg_level, NULL, params->msgdata->type, handler,
+			    data, len);
+
+	if (handler->get == NULL) {
+		cw_log(LOG_ERR, "No get method defined for %d %s", handler->id,
+		       handler->name);
+		return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
+	}
+
+	rc = handler->get(handler, params, data, len);
+
+	return rc;
+}
+
+
+int cw_decode_elements(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
+{
+	uint8_t *elem;
+//	mavl_t mand_found;
+//	mlist_t unrecognized;
+
+	//mand_found = mavl_create_conststr();
+	//unrecognized = mlist_create(NULL,NULL,sizeof(uint8_t*));
+	cw_foreach_elem(elem, elems_ptr, elems_len) {
+		int rc;
+
+		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);
+		}
+	
+		
+
+		params->from=NULL; /*from;*/
+//		params->mand_found=mand_found;
+		
+		rc = cw_decode_element(params,0,0,elem_id,elem_data,elem_len); 
+		
+
+		if (cw_result_is_ok(rc))
+			continue;
+		
+		if (rc == CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT){
+			if (params->unrecognized)
+				mlist_append(params->unrecognized,&elem);
+			continue;
+		}
+		
+		if (rc < 0 ){
+			continue;
+		}
+
+	}
+
+	return 0;
+}

src/cw/mod.c

@@ -119,7 +119,7 @@ void cw_mod_set_path(const char *path)
  * @param mod_name Name of the module
  * @return a pointer to the module interface
  */
-struct cw_Mod *cw_mod_load(const char *mod_name, mavl_t global_cfg, int role)
+struct cw_Mod *cw_mod_load(const char *mod_name, cw_Cfg_t * global_cfg, int role)
 {
 	struct cw_Mod search;
 	struct cw_Mod *mod;

src/cw/mod.h

@@ -29,7 +29,7 @@
 
 #include "sock.h"
 #include "conn.h"
-
+#include "cfg.h"
 
 enum {
 	CW_MOD_MODE_CAPWAP,
@@ -44,7 +44,7 @@ struct cw_Mod {
 	const char *name;
 
 	/** Initializion method */
-	int (*init) (struct cw_Mod *mod, mavl_t global_cfg, int role);
+	int (*init) (struct cw_Mod *mod, cw_Cfg_t * global_cfg, int role);
 
 	/** Detect capwap 
 	 * This function is called after receiving and disassembling a complete 
@@ -93,7 +93,7 @@ extern int mod_caching;
 #define mod_set_caching(var) (mod_caching=var)
 #define mod_get_caching() (mod_caching)
 
-struct cw_Mod * cw_mod_load(const char * mod_name, mavl_t global_cfg, int role);
+struct cw_Mod * cw_mod_load(const char * mod_name, cw_Cfg_t * global_cfg, int role);
 struct cw_Mod * cw_mod_add_to_list(struct cw_Mod * mod );
 struct cw_Mod * cw_mod_detect(struct cw_Conn *conn, 
 			uint8_t * rawmsg, int len,

src/cw/msgset.c

@@ -217,6 +217,33 @@ static int update_msgdata(struct cw_MsgSet *set, struct cw_MsgData *msgdata,
 		ed.vendor = elemdef->vendor;
 		ed.mand = elemdef->mand;
 
+		/* add/delete/replace message elemeent to/from/in the elements list */
+		switch ( elemdef->op & 0xff){
+			case CW_IGNORE:
+				break;
+				continue;
+			case CW_DELETE:
+				cw_dbg(DBG_MOD, "  deleting message element %d %d %d - %s",
+				       elemdef->proto,
+				       elemdef->vendor, elemdef->id, handler->name);
+				
+				mlist_delete(msgdata->elements_list, &ed);
+				mavl_del(msgdata->elements_tree,&ed);
+				continue;
+				break;
+			case CW_APPEND:
+				mlist_append(msgdata->elements_list, &ed);
+				break;
+			default:
+			case CW_REPLACE:
+				if (mlist_replace(msgdata->elements_list, &ed)==NULL){
+					mlist_append(msgdata->elements_list, &ed);
+				}
+				break;
+		}
+
+
+
 		/* add message element to the elements tree */
 		result = mavl_replace(msgdata->elements_tree, &ed, &replaced);
 
@@ -230,23 +257,6 @@ static int update_msgdata(struct cw_MsgSet *set, struct cw_MsgData *msgdata,
 			       elemdef->vendor, elemdef->id, handler->name);
 		}
 		
-		/* add/delete/replace message elemeent to/from/in the elements list */
-		switch ( elemdef->op & 0xff){
-			case CW_IGNORE:
-				break;
-			case CW_DELETE:
-				mlist_delete(msgdata->elements_list, &ed);
-				break;
-			case CW_APPEND:
-				mlist_append(msgdata->elements_list, &ed);
-				break;
-			default:
-			case CW_REPLACE:
-				if (mlist_replace(msgdata->elements_list, &ed)==NULL){
-					mlist_append(msgdata->elements_list, &ed);
-				}
-				break;
-		}
 	}
 
 
@@ -374,6 +384,9 @@ int cw_msgset_add_states(struct cw_MsgSet * set, cw_StateMachineState_t * states
 	return 1;
 }
 
+
+
+
 /**
  * @brief Find message data to a specific message
  * @param set message set
@@ -382,9 +395,14 @@ int cw_msgset_add_states(struct cw_MsgSet * set, cw_StateMachineState_t * states
  */
 struct cw_MsgData *cw_msgset_get_msgdata(struct cw_MsgSet *set, int type)
 {
-	struct cw_MsgData search;
+
+	struct cw_MsgData search, *result;
 	search.type = type;
-	return mavl_get(set->msgdata, &search);
+	result = mavl_get(set->msgdata, &search);
+	if (result != NULL)
+		return result;
+
+	return NULL;
 }
 
 typedef int (*cw_MsgCallbackFun)(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len);

src/cw/msgset.h

@@ -25,16 +25,19 @@ struct cw_ElemData{
 
 struct cw_ElemHandlerParams {
 	struct cw_Conn * conn;  	/**< a connection the message belongs to*/
-	struct cw_MsgSet * msgset;
+	uint8_t * rawmsg;
+	struct cw_MsgSet * msgset;	/**< msgset to use */
 	struct cw_MsgData * msgdata; 
 	struct cw_ElemData * elemdata;
 	struct sockaddr *from;
-	mavl_t mand_found;
+	mavl_t mand_found;		/**< used to ad the keys of mand. msg elements
-	mlist_t unrecognized;
+					     found while parsing */
-//	cw_Val_t * elem;
+	mlist_t unrecognized;		/**< to catch ids of unreconized mss elements */
 	char * debug_details;
+	uint32_t dbg_level;
 	cw_Cfg_t * cfg;
-	cw_Cfg_t * cfg_list[10];
+	cw_Cfg_t ** cfg_list;
+	int len;
 };
 
 
@@ -57,7 +60,7 @@ struct cw_ElemHandler {
 	int (*mkkey)(const char *pkey, uint8_t*data, int len, char *dst);
 	int (*patch)(uint8_t *dst, void *data );
 	void * param;
-
+	uint8_t flags;
 };
 
 

src/cw/sock.h

@@ -35,8 +35,9 @@
 
 
 #ifdef __FreeBSD__
-#define HAVE_SIN_LEN
+#define HAVE_SIN_LEN 1
-#define HAVE_SIN6_LEN
+#define HAVE_SIN6_LEN 1
+#define HAVE_SS_LEN 1
 #endif
 
 
@@ -68,7 +69,7 @@ extern int sock_getport(struct sockaddr *addr);
 extern int sock_setport(struct sockaddr *addr, int port);
 extern int sock_getbroadcastaddr(const struct sockaddr *addr,
 				 struct sockaddr *broadcastaddr);
-extern void sock_addrinit(struct sockaddr *addr, int type);
+extern void sock_addrinit(struct sockaddr_storage *addr, int type);
 extern int sock_set_dontfrag(int sock, int val);
 
 

src/cw/sock_addrinit.c

@@ -4,19 +4,31 @@
 #include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
+#include <sys/un.h>
 
-void sock_addrinit(struct sockaddr *addr,int type)
+#include "sock.h"
+
+void sock_addrinit(struct sockaddr_storage *addr,int type)
 {
+	int len;
 	switch (type){
 		case AF_INET:
-			memset(addr,0,sizeof(struct sockaddr_in));
+			len=sizeof(struct sockaddr_in);
-			addr->sa_family=type;
+			break;
-#ifdef HAVE_SIN_LEN
+		case AF_INET6:
-			addr_sa_len=sizeof(struct sockaddr_in);
+			len=sizeof(struct sockaddr_in6);
+			break;
+		case AF_UNIX:
+			len = sizeof(struct sockaddr_un);
+			break;
+		default:
+			len=0;
+	}
+	
+	memset(addr,0,len);
+	addr->ss_family=type;
+#ifdef HAVE_SS_LEN
+	addr->ss_len=len;
 #endif	
-			return;
-
-	}
-	
 
 }

src/cw/sock_addrtostr.c

@@ -31,6 +31,7 @@
 
 #include <sys/types.h>
 #include <sys/socket.h>
+#include <sys/un.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 
@@ -104,10 +105,16 @@ char *sock_addrtostr(const struct sockaddr *sa, char *s, size_t maxlen, int addp
 		}
 			break;
 #endif	/* AF_PACKET */
+		case AF_UNIX:
+		{
+			struct sockaddr_un *addr = (struct sockaddr_un *) sa;
+			snprintf(s, maxlen, "%s", addr->sun_path);
+		}
+			break;
 
 
 		default:
-			strncpy(s, "Unknown AF", maxlen);
+			snprintf(s,maxlen, "Unknown AF: %d", sa->sa_family);
 			return NULL;
 	}
 	return s;

src/cw/val.c

@@ -0,0 +1,28 @@
+#include "val.h"
+#include "cfg.h"
+#include "dbg.h"
+
+int cw_generic_write_l(cw_Cfg_t **cfg, const struct cw_Type*type, 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.type=type;
+	val.valguard=param;
+	s = cw_cfg_get_l(cfg,key,NULL);
+	if (s==NULL)
+		return -1;
+	type->from_str(&val,s);
+	l = type->put(&val,dst);
+	if(type->del)
+		type->del(&val);
+	return l;
+}
+
+void cw_val_destroy(cw_Val_t *val)
+{
+	if (val->type->del)
+		val->type->del(val);
+	free (val);
+}

src/cw/val.h

@@ -23,7 +23,7 @@
 
 //#define CW_KTV_MAX_KEY_LEN 1024
 
-typedef struct mavl cw_Cfg_t;
+typedef struct cw_Cfg cw_Cfg_t;
 
 /**
  * @struct cw_Val
@@ -146,12 +146,6 @@ struct cw_ValIndexed{
 };
 typedef struct cw_ValIndexed cw_ValIndexed_t;
 
-int cw_ktv_read_struct(mavl_t ktv,const cw_ValStruct_t * stru, const char *pkey, 
-	uint8_t * data, int len);
-int cw_ktv_write_struct(mavl_t ktv, mavl_t def, const cw_ValStruct_t * stru, const char *pkey, 
-	uint8_t * dst);
-
-
 
 extern const struct cw_Type cw_type_byte;
 extern const struct cw_Type cw_type_word;
@@ -178,24 +172,7 @@ extern const struct cw_Type cw_type_struct;
 /*
 void cw_kvstore_mavl_delete(const void *data);
  */
-cw_Val_t *cw_ktv_add(mavl_t kvstore, const char *key, const struct cw_Type *type, 
-			const void * valguard, 
-			   const uint8_t * data, int len);
 
-void cw_ktv_del_sub(mavl_t ktvstore, const char *basekey);
-
-cw_Val_t * cw_ktv_replace(mavl_t kvtstore, const char *key, const struct cw_Type *type,
-			const void * valguard,
-			const uint8_t * data, int len);
-
-const char * cw_ktv_add_from_str(mavl_t kvtstore, const char *key, const struct cw_Type *type, 
-			const void * valguard,
-			const char * str);
-
-int cw_ktv_mavlcmp(const void *v1, const void *v2);
-int cw_ktv_mavlcmp_type_by_name(const void *v1,const void *v2);
-
-void cw_ktv_mavldel(void *data);
 
 /**
  * Create a KTV store 

src/mod/capwap/capwap_actions.c

@@ -56,11 +56,17 @@ static cw_ValStruct_t radio_operational_state[] = {
 	{NULL,NULL,0,0}
 };
 
+static cw_ValStruct_t image_identifier_stru[] = {
+	{CW_TYPE_DWORD, "vendor-id", 4,-1},
+	{CW_TYPE_BSTR16, "identifier", -1,-1},
+	{NULL,NULL,0,0}
+};
+
 
 static cw_ValValRange_t radio_admin_state_valguard[]={
-	{0,0,"reserved"},
+	{0,0,"0 - reserved"},
-	{1,1,"enabled"},
+	{1,1,"1 - enabled"},
-	{2,2,"disabled"},
+	{2,2,"2 - disabled"},
 	{0,0,NULL}
 };
 
@@ -96,7 +102,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,1,					/* min/max length */
 		CW_TYPE_BYTE,				/* type */
-		"discovery-type",			/* Key */
+		"capwap/discovery-type",		/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic,				/* put */
 		NULL,
@@ -111,7 +117,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,1,					/* min/max length */
 		CW_TYPE_BYTE,				/* type */
-		"wtp-mac-type",				/* Key */
+		"capwap/wtp-mac-type",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic,				/* put */
 		NULL,
@@ -125,18 +131,18 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		14,1024,				/* min/max length */
 		NULL,					/* type */
-		CW_KEY_WTP_BOARD_DATA,			/* Key */
+		"capwap/wtp-board-data",			/* Key */
 		capwap_in_wtp_board_data,		/* get */
 		capwap_out_wtp_board_data		/* put */
 	}
 	,
 	{ 
 		"WTP Descriptor",			/* name */
-		CAPWAP_ELEM_WTP_DESCRIPTOR,		/* Element ID */
+		CAPWAP_ELEM_WTP_DESCRIPTOR,		/* #Element ID */
 		0,0,					/* Vendor / Proto */
 		33,1024,				/* min/max length */
 		NULL,					/* type */
-		CW_KEY_WTP_DESCRIPTOR,			/* Key */
+		"capwap/wtp-descriptor",		/* Key */
 		capwap_in_wtp_descriptor,		/* get */
 		capwap_out_wtp_descriptor,		/* put */
 	}
@@ -147,7 +153,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,1,					/* min/max length */
 		CW_TYPE_BYTE,				/* type */
-		CW_KEY_WTP_FRAME_TUNNEL_MODE,		/* Key */
+		"capwap/wtp-frame-tunnel-mode",		/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -160,7 +166,13 @@ static struct cw_ElemHandler handlers[] = {
 		NULL,					/* type */
 		"vendor_specific_payload",		/* Key */
 		capwap_in_vendor_specific_payload,	/* get */
-		NULL					/* put */
+		NULL,					/* put */
+		NULL,					/* mkkey*/
+		NULL,					/* patch*/
+		NULL,					/* param */
+		1					/* flags */
+
+
 	}
 	,
 	{ 
@@ -181,7 +193,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		0,0,					/* min/max length */
 		NULL,					/* type */
-		CW_KEY_AC_DESCRIPTOR,			/* Key */
+		"capwap/ac-descriptor",			/* Key */
 		capwap_in_ac_descriptor,		/* get */
 		capwap_out_ac_descriptor		/* put */
 	}
@@ -193,7 +205,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,CAPWAP_MAX_AC_NAME_LEN,		/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"ac-name",				/* Key */
+		"capwap/ac-name",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -205,7 +217,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		6,6,					/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"capwap-control-ip-address",		/* Key */
+		"capwap/control-ip-address",		/* Key */
 		capwap_in_capwap_control_ip_address,	/* get */
 		capwap_out_capwap_control_ip_address	/* put */
 	},
@@ -216,7 +228,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		18,18,					/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"capwap-control-ip-address",		/* Key */
+		"capwap/control-ip-address",		/* Key */
 		capwap_in_capwap_control_ip_address,	/* get */
 		capwap_out_capwap_control_ip_address	/* put */
 	}
@@ -229,7 +241,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,CAPWAP_MAX_LOCATION_DATA_LEN,		/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"location-data",			/* Key */
+		"capwap/location-data",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -241,7 +253,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,CAPWAP_MAX_WTP_NAME_LEN,		/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"wtp-name",				/* Key */
+		"capwap/wtp-name",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -252,7 +264,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		CAPWAP_SESSION_ID_LEN,CAPWAP_SESSION_ID_LEN,	/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"session-id",				/* Key */
+		"capwap/session-id",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -264,7 +276,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		4,4,					/* min/max length */
 		CW_TYPE_DWORD,				/* type */
-		"result-code",				/* Key */
+		"capwap/result-code",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -276,7 +288,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,1,					/* min/max length */
 		CW_TYPE_BYTE,				/* type */
-		"ecn-support",				/* Key */
+		"capwap/ecn-support",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -288,7 +300,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		2,2,					/* min/max length */
 		CW_TYPE_WORD,				/* type */
-		"maximum-message-length",		/* Key */
+		"capwap/maximum-message-length",	/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -300,7 +312,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		4,4,					/* min/max length */
 		CW_TYPE_IPADDRESS,			/* type */
-		"capwap-local-ip-address",		/* Key */
+		"capwap/local-ip-address",		/* Key */
 		cw_in_generic,				/* get */
 		capwap_out_capwap_local_ip_address	/* put */
 	}
@@ -311,7 +323,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		16,16,					/* min/max length */
 		CW_TYPE_IPADDRESS,			/* type */
-		"capwap-local-ip-address",		/* Key */
+		"capwap/local-ip-address",		/* Key */
 		cw_in_generic,				/* get */
 		capwap_out_capwap_local_ip_address	/* put */
 	}
@@ -324,7 +336,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		2,2,					/* min/max length */
 		CW_TYPE_WORD,				/* type */
-		"statistics-timer",			/* Key */
+		"capwap/statistics-timer",		/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic				/* put */
 	}
@@ -336,7 +348,7 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		15,15,					/* min/max length */
 		CW_TYPE_STRUCT,				/* type */
-		"wtp-reboot-statistics",		/* Key */
+		"capwap/wtp-reboot-statistics",		/* Key */
 		cw_in_generic,				/* handler */
 		cw_out_generic,				/* put */
 		NULL,
@@ -352,7 +364,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		2, 2,						/* min/max length */
 		CW_TYPE_STRUCT,					/* type */
-		"admin-state",					/* Key */
+		"capwap/admin-state",				/* Key */
 		cw_in_radio_generic,				/* get */
 		cw_out_radio_generic,				/* put */
 		NULL,
@@ -368,7 +380,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,					/* Vendor / Proto */
 		2, 2,					/* min/max length */
 		CW_TYPE_STRUCT,				/* type */
-		"capwap-timers",			/* Key */
+		"capwap/timers",			/* Key */
 		cw_in_generic,				/* get */
 		cw_out_generic,				/* put */
 		NULL,
@@ -383,7 +395,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		3, 3,						/* min/max length */
 		CW_TYPE_WORD,					/* type */
-		"decryption-error-report-period",		/* Key */
+		"capwap/decryption-error-report-period",	/* Key */
 		cw_in_radio_generic,				/* get */
 		cw_out_radio_generic				/* put */
 	}
@@ -395,7 +407,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		4, 4,						/* min/max length */
 		CW_TYPE_DWORD,					/* type */
-		"idle-timeout",					/* Key */
+		"capwap/idle-timeout",				/* Key */
 		cw_in_generic,					/* get */
 		cw_out_generic					/* put */
 	}
@@ -407,7 +419,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		1, 1,						/* min/max length */
 		CW_TYPE_BYTE,					/* type */
-		"wtp-fallback",					/* Key */
+		"capwap/wtp-fallback",				/* Key */
 		cw_in_generic,					/* get */
 		cw_out_generic					/* put */
 	}
@@ -418,7 +430,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		3, 3,						/* min/max length */
 		radio_operational_state,			/* type */
-		"operational-state",				/* Key */
+		"capwap/operational-state",			/* Key */
 		cw_in_radio_generic_struct,			/* get */
 		cw_out_radio_generic_struct			/* put */
 	}
@@ -430,11 +442,26 @@ static struct cw_ElemHandler handlers[] = {
 		0,0,					/* Vendor / Proto */
 		1,513,					/* min/max length */
 		CW_TYPE_BSTR16,				/* type */
-		"ac-name-with-index",			/* Key */
+		"capwap/ac-name-with-priority",		/* Key */
 		cw_in_generic_with_index,		/* get */
 		cw_out_generic_with_index		/* put */
 	}
 	,
+
+	{ 
+		"Image Identifier",			/* name */
+		CAPWAP_ELEM_IMAGE_IDENTIFIER,		/* Element ID */
+		0,0,					/* Vendor / Proto */
+		5,1028,					/* min/max length */
+		CW_TYPE_STRUCT,				/* type */
+		"capwap/image-identifier",		/* Key */
+		cw_in_generic,				/* get */
+		cw_out_generic,				/* put */
+		NULL,
+		NULL,
+		image_identifier_stru			/* param */
+	}
+	,		
 	{0,0,0,0,0,0,0,0}
 
 };
@@ -552,7 +579,7 @@ static struct cw_ElemDef configuration_update_request_elements[] ={
 
 	{0,0,CAPWAP_ELEM_RADIO_ADMINISTRATIVE_STATE,	0, 0},
 	{0,0,CAPWAP_ELEM_STATISTICS_TIMER,		0, 0},
-
+	{0,0,CAPWAP_ELEM_IMAGE_IDENTIFIER,		0, 0},
 
 	{0,0,CAPWAP_ELEM_VENDOR_SPECIFIC_PAYLOAD,	0, CW_IGNORE},
 	{0,0,0,0,0}

src/mod/capwap/capwap_in_ac_descriptor.c

@@ -9,15 +9,12 @@ int capwap_in_ac_descriptor(struct cw_ElemHandler *eh,
 			struct cw_ElemHandlerParams *params, 
 			uint8_t * data, int len)
 {
-	stop();
-
 	static struct cw_DescriptorSubelemDef allowed[] = {
 		{0,CAPWAP_SUBELEM_AC_HARDWARE_VERSION, "hardware", 1024,1},
 		{0,CAPWAP_SUBELEM_AC_SOFTWARE_VERSION, "software", 1024,1},
 		{0,0, NULL,0, 0}
 	};
 
-
 	return cw_read_ac_descriptor(params->cfg,eh,params,data,len,allowed);
 
 }

src/mod/capwap/capwap_in_vendor_specific_payload.c

@@ -26,6 +26,9 @@ int capwap_in_vendor_specific_payload(struct cw_ElemHandler *handler,
 	
 	
 	if (!vhandler) {
+		cw_dbg_elem(params->dbg_level, NULL, params->msgdata->type, handler,
+                            data, len);
+
 		cw_dbg(DBG_WARN,
 		       "Can't handle Vendor Specific Payload %s/%d, in msg %d (%s) in %s state.",
 		       cw_strvendor(vendor_id), elem_id, params->msgdata->type,

src/mod/capwap/capwap_in_wtp_board_data.c

@@ -30,8 +30,8 @@
 #include "cw/keys.h"
 
 
-static void readsubelems_wtp_board_data(mavl_t cfg, uint8_t * msgelem,
+static void readsubelems_wtp_board_data(cw_Cfg_t * cfg, uint8_t * msgelem,
-					int len)
+					int len,const char *pkey)
 {
 	int i = 0;
 	uint32_t val;
@@ -56,12 +56,8 @@ static void readsubelems_wtp_board_data(mavl_t cfg, uint8_t * msgelem,
 			return;
 		}
 
-/*		cw_dbg(DBG_SUBELEM, "WTP board data sub-element, type=%d, len=%d",
-		       subtype, sublen);*/
-
 		switch (subtype) {
 			
-			
 			case CW_BOARDDATA_MODELNO:
 				key = "model-no";
 				break;
@@ -83,7 +79,7 @@ static void readsubelems_wtp_board_data(mavl_t cfg, uint8_t * msgelem,
 		}
 		if (key != NULL){
 			char add_key[CW_CFG_MAX_KEY_LEN];
-			sprintf(add_key,"wtp-board-data/%s",key);
+			sprintf(add_key,"%s/%s",pkey,key);
 			cw_cfg_set_val(cfg,add_key,CW_TYPE_BSTR16,NULL,msgelem+i,sublen);
 			
 		}
@@ -107,7 +103,7 @@ int capwap_in_wtp_board_data(struct cw_ElemHandler *eh, struct cw_ElemHandlerPar
 	sprintf(vendor_key,"%s/%s",eh->key,"vendor");
 	cw_cfg_set_val(params->cfg,vendor_key,CW_TYPE_DWORD,NULL,data,len);
 
-	readsubelems_wtp_board_data(params->cfg, data + 4, len - 4);
+	readsubelems_wtp_board_data(params->cfg, data + 4, len - 4,eh->key);
 	return 1;
 }
 

src/mod/capwap/capwap_out_ac_descriptor.c

@@ -3,74 +3,27 @@
 #include "cw/dbg.h"
 #include "cw/conn.h"
 
-
-
 #include "cw/capwap.h"
 #include "cw/cw.h"
-#include "cw/val.h"
 #include "cw/keys.h"
 
-
+#include "mod_capwap.h"
-
-static int put_ac_status(mavl_t global, mavl_t local, uint8_t *dst, const char * parent_key){
-
-	stop();
-
-	uint8_t *d = dst;
-	
-	char key[CW_CFG_MAX_KEY_LEN];
-	
-
-	d += cw_put_word(d,cw_ktv_get_word(global,"ac-descriptor/stations",0));
-	d += cw_put_word(d,cw_ktv_get_word(global,"ac-descriptor/station-limit",0));
-	d += cw_put_word(d,cw_ktv_get_word(global,"ac-descriptor/active-wtps",0));
-	d += cw_put_word(d,cw_ktv_get_word(global,"ac-descriptor/max-wtps",0));
-	
-	d += cw_put_byte(d,cw_ktv_get_byte(global,"ac-descriptor/security",0));
-/*	
-	security = 0;
-	if (cw_ktv_get(local,"dtls-cert-file",CW_TYPE_BSTR16))
-		security |= CAPWAP_FLAG_AC_SECURITY_X;
-		
-	if (cw_ktv_get(local,"dtls-psk",CW_TYPE_BSTR16))
-		security |= CAPWAP_FLAG_AC_SECURITY_S;
-
-	if (security == 0){
-		cw_log(LOG_WARNING,"No AC security selected");
-	}
-	d += cw_put_byte(dst,security);
-*/	
-	sprintf(key,"%s/%s",parent_key,CW_SKEY_RMAC_FIELD);
-	d += cw_put_byte(d,cw_ktv_get_byte(local,key,0));
-	
-	d += cw_put_byte(d,0);
-
-
-	sprintf(key,"%s/%s",parent_key,CW_SKEY_DTLS_POLICY);
-	d += cw_put_byte(d,cw_ktv_get_byte(local,key,0));
-
-	return d - dst;
-}
-
 
 int capwap_out_ac_descriptor(struct cw_ElemHandler * eh, 
 		struct cw_ElemHandlerParams * params, uint8_t * dst)
 {
-	stop();
+	int len,l;
-/*	int len,l;
 	uint8_t *d = dst+4;
 	char key[CW_CFG_MAX_KEY_LEN];
 
-	d+=put_ac_status(params->cfg,
+	d+=cw_put_ac_status(d, params->cfg_list, eh->key);
-				params->global_cfg,
-				d, eh->key);
 
 	sprintf(key,"%s/%s",eh->key,CW_SKEY_HARDWARE);
-	d+=cw_write_descriptor_subelem (d, params->cfg,
+	d+=cw_put_descriptor_subelem (d, params->cfg_list,
                                  CAPWAP_SUBELEM_AC_HARDWARE_VERSION, key);
  
 	sprintf(key,"%s/%s",eh->key,CW_SKEY_SOFTWARE);
-	d+=cw_write_descriptor_subelem (d, params->cfg,
+	d+=cw_put_descriptor_subelem (d, params->cfg_list,
                                  CAPWAP_SUBELEM_AC_SOFTWARE_VERSION, key);
 
 	len = d-dst-4;
@@ -78,6 +31,5 @@ int capwap_out_ac_descriptor(struct cw_ElemHandler * eh,
 	l = len + cw_put_elem_hdr(dst,eh->id,len);
 	cw_dbg_elem(DBG_ELEM_OUT,NULL,params->msgdata->type,eh,dst,l);
 	return l;
-*/
+
-	return 0;
 }

src/mod/capwap/capwap_out_wtp_descriptor.c

@@ -39,13 +39,12 @@ int capwap_out_wtp_descriptor(struct cw_ElemHandler * eh,
 	val = cw_cfg_get_byte_l(params->cfg_list,key, 0);
 	d+=cw_put_byte(d,val);
 	if (val<=0){
-		cw_dbg(DBG_WARN,"Cannot value for %s, setting to 0", CW_SKEY_MAX_RADIOS);
+		cw_dbg(DBG_WARN,"Cannot get value for %s, setting to 0", CW_SKEY_MAX_RADIOS);
 		d+=cw_put_byte(d,0);
 	}
 		
 	sprintf(key,"%s/%s",eh->key,CW_SKEY_RADIOS_IN_USE);
 	val = cw_cfg_get_byte_l(params->cfg_list,key, 0);
-cw_dbg("WTP-DESCRIPTOR: radios in use: %d",val);	
 	d+=cw_put_byte(d,val);	/*radios in use*/
 
 /* 	d+=cw_put_encryption_capabilities_7(d,1); */

src/mod/capwap/mod_capwap_ac.c

@@ -47,9 +47,11 @@ static int detect(struct cw_Conn *conn, const uint8_t * rawmsg, int rawlen, int
 int static setup_cfg(struct cw_Conn  * conn)
 {
 	int security;
-	
 	security = cw_setup_dtls(conn,conn->local_cfg,"capwap",CAPWAP_CIPHER);
-	cw_ktv_set_byte(conn->local_cfg,"ac-descriptor/security",security);
+
+
+//	stop();
+//	cw_ktv_set_byte(conn->local_cfg,"ac-descriptor/security",security);
 
 	return 0;
 }

src/mod/capwap80211/capwap80211_messages.c

@@ -15,6 +15,19 @@
 			uint8_t * data,	 int len);
 */
 
+
+char x[] = {'a','b'};
+
+static cw_ValStruct_t capwap80211_antenna_stru[]={
+	{CW_TYPE_BOOL,"diversity",1,-1},
+	{CW_TYPE_BYTE,"combiner",1,-1},
+	{CW_TYPE_BYTE,"antenna-count",1,-1},
+	{NULL,"xxx",1,-1,x},
+//	{NULL,"xxx",1,-1,"a",}
+	{NULL,NULL,0,0}
+};
+
+
 static struct cw_ElemHandler handlers[] = {
 	{
 		"IEEE 802.11 WTP Radio Information",		/* name */
@@ -22,7 +35,7 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		0, 0,						/* min/max length */
 		CW_TYPE_DWORD,					/* type */
-		"wtp-radio-information",			/* Key */
+		"capwap80211/wtp-radio-information",		/* Key */
 		cw_in_radio_generic,				/* get */
 		cw_out_radio_generic				/* put */
 	}
@@ -33,39 +46,55 @@ static struct cw_ElemHandler handlers[] = {
 		0, 0,						/* Vendor / Proto */
 		3, 0,						/* min/max length */
 		CW_TYPE_BSTR16,					/* type */
-		"rate_set",					/* Key */
+		"capwap80211/rate-set",				/* Key */
 		cw_in_radio_generic,				/* get */
 		cw_out_radio_generic				/* put */
 	}
 	,
-	{NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL}
+	{
+		"IEEE 802.11 Antenna",				/* name */
+		CAPWAP80211_ELEM_ANTENNA,				/* Element ID */
+		0, 0,						/* Vendor / Proto */
+		3, 0,						/* min/max length */
+		CW_TYPE_STRUCT,					/* type */
+		"capwap80211/antenna",				/* Key */
+		cw_in_radio_generic,				/* get */
+		cw_out_radio_generic,				/* put */
+		NULL,
+		NULL,
+		capwap80211_antenna_stru
 
+	}
+	,
+	{NULL, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL}
 
 };
 
-/*static int discovery_request_states[] = { CAPWAP_STATE_DISCOVERY, 0 };*/
 static struct cw_ElemDef discovery_request_elements[] = {
 	{0, 0, CAPWAP80211_ELEM_WTP_RADIO_INFORMATION, 1, 0},
 	{0, 0, 0, 0, 0}
 
 };
 
+static struct cw_ElemDef discovery_response_elements[] = {
+	{0, 0, CAPWAP80211_ELEM_WTP_RADIO_INFORMATION, 1, 0},
+	{0, 0, 0, 0, 0}
+
+};
+
 
-/*static int join_request_states[] = { CAPWAP_STATE_JOIN, 0 };*/
 static struct cw_ElemDef join_request_elements[] = {
 	{0, 0, CAPWAP80211_ELEM_WTP_RADIO_INFORMATION, 1, 0},
 	{0, 0, 0, 0, 0}
 
 };
 
-/*static int join_response_states[] = { CAPWAP_STATE_JOIN, 0 };*/
 static struct cw_ElemDef join_response_elements[] = {
 	{0, 0, CAPWAP80211_ELEM_WTP_RADIO_INFORMATION, 1, 0},
 	{0, 0, 0, 0, 0}
 
 };
 
-/*static int configuration_status_response_states[] = { CAPWAP_STATE_JOIN, 0 };*/
 static struct cw_ElemDef configuration_status_response_elements[] = {
 	{0, 0, CAPWAP80211_ELEM_RATE_SET		, 1, 0},
 	{0, 0, 0, 0, 0}
@@ -80,6 +109,14 @@ static struct cw_MsgDef messages[] = {
 		discovery_request_elements
 	}
 	,
+	{
+		NULL,
+		CAPWAP_MSG_DISCOVERY_RESPONSE,
+		CW_ROLE_WTP,
+		NULL,				/* states */
+		discovery_response_elements
+	}
+	,
 	{
 		NULL,				/* name */
 		CAPWAP_MSG_JOIN_REQUEST,	/* type */

src/mod/cisco/capwap_cisco.h

@@ -46,10 +46,11 @@
 
 #define CISCO_ELEM_TX_POWER			LW_ELEM_80211_TX_POWER			/* 12 */
 #define CISCO_ELEM_TX_POWER_LEVELS		LW_ELEM_80211_TX_POWER_LEVELS		/* 13 */
-#define CW_CISCO_DIRECT_SEQUENCE_CONTROL	LW_ELEM_DIRECT_SEQUENCE_CONTROL		/* 14 */
+#define CISCO_ELEM_DIRECT_SEQUENCE_CONTROL	LW_ELEM_DIRECT_SEQUENCE_CONTROL		/* 14 */
 #define CW_CISCO_SUPPORTED_RATES		LW_ELEM_80211_RATE_SET			/* 16 */
 
 #define CISCO_ELEM_15				15					/* 15 */
+#define CISCO_ELEM_16				16					/* 16 */
 #define CISCO_ELEM_19				19					/* 19 */
 #define CISCO_ELEM_22				22					/* 22 */
 #define CISCO_ELEM_24				24					/* 24 */
@@ -57,6 +58,9 @@
 #define CW_CISCO_80211_DELETE_WLAN		LW_ELEM_80211_DELETE_WLAN		/* 28 */
 
 #define CW_CISCO_MWAR_NAME			LW_ELEM_AC_NAME				/* 31 */
+#define CISCO_ELEM_33				33
+#define CISCO_ELEM_39				39
+
 
 #define CISCO_ELEM_LOCATION_DATA		LW_ELEM_LOCATION_DATA			/* 35 */
 #define CISCO_ELEM_STATISTICS_TIMER		LW_ELEM_STATISTICS_TIMER		/* 37 */
@@ -66,6 +70,8 @@
 #define CW_CISCO_CERTIFICATE			LW_ELEM_CERTIFICATE			/* 44 */
 
 #define CISCO_ELEM_47				47					/* 47 */
+#define CISCO_ELEM_48				48					/* 47 */
+
 
 #define CISCO_ELEM_WTP_BOARD_DATA		LW_ELEM_WTP_BOARD_DATA			/* 50 */
 #define CW_CISCO_BCAST_SSID_MODE		LW_BCAST_SSID_MODE
@@ -103,10 +109,22 @@
 #define CISCO_ELEM_AP_PRE_STD_SWITCH_CONFIG	137
 #define CISCO_ELEM_AP_POWER_INJECTOR_CONFIG	138
 
+#define CISCO_ELEM_145				145
+#define CISCO_ELEM_146				146
+
+
 #define CISCO_ELEM_AP_MIN_IOS_VERSION		149
 #define CISCO_ELEM_AP_TIMESYNC			151
-#define CW_CISCO_AP_DOMAIN			169
+
-#define CW_CISCO_AP_DNS				170
+#define CISCO_ELEM_153				153
+#define CISCO_ELEM_154				154
+#define CISCO_ELEM_156				156
+
+
+
+
+#define CISCO_ELEM_AP_DOMAIN			169
+#define CISCO_ELEM_AP_DNS			170
 
 #define CISCO_ELEM_AP_BACKUP_SOFTWARE_VERSION	183
 #define CW_CISCO_BOARD_DATA_OPTIONS		207