Added some instructions to run AC

INSTALL

@@ -1,40 +1,57 @@
 pre-requisites to build actube
 ==============================
 
+Compile 
+=======
 
-
-
-
-On FreeBSD 10.2
+FreeBSD 
 ----------------
 
-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-get install libsqlite3-dev
-
-
-
-pre-requisites to build wtp
-===========================
-
-Ubuntu 14.04
-------------
-
-apt-get install cmake
-apt-get install libnl-genl-3-dev
+apt install libedit-dev
+apt install bmake
 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 $(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/mavltypes.h"
-
+#include "cw/cfg.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,27 +207,10 @@ int main (int argc, char *argv[])
 	int rc = 0;
 	struct bootcfg bootcfg;
 
-
-
-/*
-	cw_Cfg_t * tcfg = cw_cfg_create();
-	cw_cfg_set(tcfg,"tube.0","hallo");
-	cw_cfg_set(tcfg,"tube.1","welt");
-	cw_cfg_set(tcfg,"tube.2","der guten laune");
-	cw_cfg_dump(tcfg);
-
-	printf("Next Index: %d\n",cw_cfg_get_next_index(tcfg,"kinder"));
-
-
-	exit(0);
-*/
-
-
 	/* 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));
@@ -211,11 +225,39 @@ int main (int argc, char *argv[])
 		goto errX;
 	};
 
-
 	cw_log_name = "AC-Tube";
+
+/*
+
+	{
+	int rc;
+	cw_Cfg_t * cfg = global_cfg;
+	struct cw_Cfg_entry e, *result;
+
+	e.key="hi";
+
+	rc = cw_cfg_base_exists(cfg,"ac-descriptor");
+        if (!rc ){
+		printf("No!\n");
+                return 0;
+        }
+
+	printf("RESULT: %d\n",rc);
+
+	cw_cfg_set(tcfg,"tube.0","hallo");
+	cw_cfg_set(tcfg,"tube.1","welt");
+	cw_cfg_set(tcfg,"tube.2","der guten laune");
+	cw_cfg_dump(tcfg);
+
+	printf("Next Index: %d\n",cw_cfg_get_next_index(tcfg,"kinder"));
+
+
+	exit(0);
+	}
+
+*/
 	
 		
-	start_shell();
 
 	/* Init DTLS library */
 	dtls_init();
@@ -231,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);
@@ -263,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;
 
 
@@ -273,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/ipv6","true")
+				cw_cfg_get_bool(cfg,"actube/ipv4",1),
+				cw_cfg_get_bool(cfg,"actube/ipv6",1)
 				);
         }
 	if (!i) {
@@ -318,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 <sys/param.h>
-     #include <sys/time.h>
-     #include <sys/socket.h>
-     #include <net/if.h>
-
+#include "cw/dbg.h"
+#include "cw/cw.h"
+#include "cw/cfg.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_bsalist_len = 0;
+//int conf_salist_len = 0;
+//int conf_bsalist_len = 0;
 
-struct sockaddr *conf_ac_ips;
-int conf_ac_ips_len;
+//struct sockaddr *conf_ac_ips;
+//int conf_ac_ips_len;
 
-char *conf_sslcertfilename = NULL;
-char *conf_sslkeyfilename = NULL;
-char *conf_sslkeypass = NULL;
-char *conf_dtls_psk = NULL;
+//char *conf_sslcertfilename = NULL;
+//char *conf_sslkeyfilename = NULL;
+//char *conf_sslkeypass = 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; (modname = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
-
-		printf("init mod name: %s\n",modname);
-
+        for (i=0; (e = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++) {
+		modname = e->val;
 		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,11 +6,14 @@
 #
 #capwap/ac-name
 #
+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"
@@ -37,20 +40,36 @@ actube/mod.0: cisco
 actube/mod.1: capwap
 actube/mod.2: capwap80211
 
-
-ac-descriptor/dtls-policy:  1
-ac-descriptor/hardware/vendor: 4232704
-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
+#actube/rpc/listen: unix:/tmp/actube
+actube/rpc/listen: tcp:127.0.0.1:5000
+actube/rpc/enable: true
+
+
+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/data-check-timer: Word: 10
+capwap/timers/echo-interval :Byte: 30
+capwap/timers/max-discovery-interval :Byte: 10
 
 
-capwap-control-ip-address/address.0: 192.168.0.14
 

src/ac/dataman.c

@@ -114,8 +114,10 @@ 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

@@ -4,6 +4,7 @@
 #include "cw/mlist.h"
 #include "mavl.h"
 #include "cw/mod.h"
+#include "cw/dbg.h"
 
 #include "discovery_cache.h"
 struct cw_DiscoveryCacheElem{
@@ -108,15 +109,24 @@ errX:
 void discovery_cache_add(struct cw_DiscoveryCache *cache, 
 	struct sockaddr * addr, struct cw_Mod  * mod_capwap, struct cw_Mod * mod_bindings)
 {
+
+	{
+		cw_dbg(DBG_X,"//////////////////////////   ADDD CAHCE ///////////////////////");
+		char str[128];
+	sock_addrtostr(addr,str,128,1);
+	}
+
 	struct cw_DiscoveryCacheElem * cur = cache->queue+cache->qpos;
 	if (cur->cmod!=NULL){
 		/* delete here */
+
+		cw_dbg(DBG_X,"DOIN MAVL DEL ----- ///////////");
+
 		void * ptr = &cur;
 		mavl_del(cache->byaddr,ptr);
-		mavl_del(cache->byaddr,ptr);
-
+		mavl_del(cache->byaddrp,ptr);
 	}
-	
+
 	cur->cmod=mod_capwap;
 	cur->bmod=mod_bindings;
 	sock_copyaddr(&cur->addr,addr);
@@ -144,9 +154,22 @@ int discovery_cache_get(struct cw_DiscoveryCache * cache,struct sockaddr *addr,
 	sock_copyaddr(&search.addr,addr);
 	search.ctrhi=search.ctrlo=0;
 	
+	{
+	cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- GET ENTER");
+	char str[128];
+	sock_addrtostr(addr,str,128,1);
+	}
+
 	search_ptr = &search;
 	result = mavl_get(cache->byaddrp ,&search_ptr);
 	if (result != NULL){
+		{
+		cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- FOUND 1 with Port");
+		char str[128];
+		sock_addrtostr(addr,str,128,1);
+		}
+
+
 		elem = *result;
 		if (elem != NULL){
 			mavl_del(cache->byaddr,result);
@@ -166,14 +189,36 @@ int discovery_cache_get(struct cw_DiscoveryCache * cache,struct sockaddr *addr,
 	result = mavl_get_first(cache->byaddr, &search_ptr);
 	if (result == NULL)
 		return 0;
+	{
+	cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- DOUND BY ADDR");
+	char str[128];
+	sock_addrtostr(addr,str,128,1);
+	}
+
 
 	elem = *result;
 	if (elem != NULL){
+		cw_dbg(DBG_X,"elem != NULL");
+		
+	{
+	cw_dbg(DBG_X,"DISCOVERY CACHE ---------------------------- DOUND BY ADDR");
+	char str[128];
+	sock_addrtostr((struct sockaddr*)&elem->addr,str,128,1);
+	printf("ELEM addr: %s\n",str);
+	}
+
+
+		
+
+
 		if (sock_cmpaddr((struct sockaddr*)&elem->addr,addr,0)!=0)
 			return 0;
 			
-		mavl_del(cache->byaddr,result);
-		mavl_del(cache->byaddrp,result);
+		cw_dbg(DBG_X,"DOIN MAVL DEL HERO ----- ///////////");
+		mavl_del(cache->byaddr,&elem);
+		cw_dbg(DBG_X,"DOIN MAVL DEL HERXXXXXXO ----- ///////////");
+		mavl_del(cache->byaddrp,&elem);
+		cw_dbg(DBG_X,"DOIN MAVL DEL HERO 0000 ----- ///////////");
 		
 		*modcapwap=elem->cmod;
 		*modbindings=elem->bmod;

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,491 +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)
-{
-	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_KTV_MAX_KEY_LEN];
-	char type[CW_KTV_MAX_KEY_LEN];
-	char val[2048];
-	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_KTV_MAX_KEY_LEN];
-	sscanf(str,"%s",key);
-	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_KTV_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

@@ -37,7 +37,6 @@
 
 #include "ac.h"
 #include "conf.h"
-#include "db.h"
 #include "socklist.h"
 #include "wtpman.h"
 #include "wtplist.h"
@@ -65,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;
 
@@ -86,7 +87,6 @@ static void wtpman_run_discovery(void *arg)
 
 		}
 	}
-
 	return;
 }
 
@@ -166,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;
@@ -300,18 +300,18 @@ 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;
 	conn = wtpman->conn;
 
-	wtpman->conn->remote_cfg = cw_cfg_create();
+//	wtpman->conn->remote_cfg = cw_cfg_create();
 
 
 	if (!wtpman->dtlsmode) {
@@ -346,8 +346,8 @@ static void *wtpman_main(void *arg)
 
 	while (1) {
 
-		int wait_join;
-		int wait_change_state;
+		//int wait_join;
+		//int wait_change_state;
 
 
 
@@ -359,32 +359,6 @@ static void *wtpman_main(void *arg)
 
 
 		while (!cw_timer_timeout(timer)) {
-			if (conn->update_cfg != NULL) {
-				mavl_t tmp;
-
-
-				tmp = conn->local_cfg;
-
-				mavl_merge(conn->default_cfg, conn->local_cfg);
-/*				mavl_merge(conn->default_cfg, conn->remote_cfg);*/
-
-				conn->local_cfg = conn->update_cfg;
-
-
-
-
-
-				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->remote_cfg, conn->update_cfg);
-
-				conn->update_cfg = NULL;
-				conn->local_cfg = tmp;
-			}
-
 
 			rc = cw_read_messages(wtpman->conn);
 			if (rc < 0) {
@@ -423,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);
@@ -436,223 +410,112 @@ 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);
-}
-
-
 
 void wtpman_destroy(struct wtpman *wtpman)
 {
 	if (wtpman->conn)
 		conn_destroy(wtpman->conn);
+	
+	if (wtpman->wtp_cfg)
+		cw_cfg_destroy(wtpman->wtp_cfg);
+
 	free(wtpman);
 }
 
-static void discovery_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
+
+static void copy(struct cw_ElemHandlerParams * params)
 {
-	cw_dbg(DBG_X,"Discovery->Callback");
+//	struct wtpman * wtpman;
+	//struct cw_Conn * conn;
+	//wtpman = (struct wtpman*)params->conn->data;
+	//conn = (struct cw_Conn*)params->conn;
+
+
+//	cw_dbg(DBG_X,"-------------  Here is the config we ve got from WTP ---------------- ");
+//	cw_cfg_dump(params->cfg);
+//	cw_dbg(DBG_X,"-------------  This was the config we ve got from WTP ---------------- ");
+//	cw_dbg(DBG_X,"Now copying:");
+//	cw_cfg_copy(params->cfg,conn->local_cfg,0,"");
+        cw_cfg_copy(params->cfg, params->conn->remote_cfg,DBG_CFG_UPDATES,"GlobalCfg");
+
+//	cw_dbg(DBG_X,"Copying done.");
 }
 
-static void join_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
+static int discovery_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
 {
-	struct wtpman * wtpman = (struct wtpman *)params->conn->data;
-	cw_dbg(DBG_X,"JOIN->Callback");
-	wtpman->pjoin(params,elems_ptr,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;
 }
 
-static void update_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
+static int join_cb(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len)
 {
-	struct wtpman * wtpman = (struct wtpman *)params->conn->data;
-	cw_dbg(DBG_X,"UPDATE->Callback");
-	if ( wtpman->pupdate )
-		wtpman->pupdate(params,elems_ptr,elems_len);
+	struct cw_Conn * conn = (struct cw_Conn*)params->conn;
+	char filename[200];
+
+	cw_dbg(DBG_X,"JOIN Callback");
+	copy(params);
+	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,NULL);
+	cw_cfg_clear(params->cfg);
+	return 0;
+}
+
+static int update_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,"UPDATE Callback");
+	copy(params);
+
+	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,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)
@@ -697,17 +560,26 @@ 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;
 	}
 	wtpman->conn->global_cfg = global_cfg;
 	wtpman->conn->local_cfg = cw_cfg_create();
+	wtpman->wtp_cfg = cw_cfg_create();
+
 
 	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);
@@ -716,12 +588,27 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 			CAPWAP_MSG_DISCOVERY_REQUEST,
 			discovery_cb);
 
+	cw_conn_set_msg_cb(wtpman->conn,
+			CAPWAP_MSG_JOIN_REQUEST,
+			join_cb);
+
+	cw_conn_set_msg_cb(wtpman->conn,
+			CAPWAP_MSG_CONFIGURATION_STATUS_REQUEST,
+			update_cb);
+
+	cw_conn_set_msg_cb(wtpman->conn,
+			CAPWAP_MSG_WTP_EVENT_REQUEST,
+			event_cb);
+
+
+
+
 //	wtpman->conn->mods = conf_mods;
 
 	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();
@@ -749,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)
-        	                wtpman->conn->setup_complete(wtpman->conn);
+//	               if (wtpman->conn->setup_complete)
+//        	                wtpman->conn->setup_complete(wtpman->conn);
 
 
 		}
@@ -764,7 +651,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 
 void wtpman_addpacket(struct wtpman *wtpman, uint8_t * packet, int len)
 {
-	cw_dbg(DBG_X,"ADD PACKET DETECTED %d",wtpman->conn->detected);
+//	cw_dbg(DBG_X,"ADD PACKET DETECTED %d",wtpman->conn->detected);
 	conn_q_add_packet(wtpman->conn, packet, len);
 }
 

src/ac/wtpman.h

@@ -38,12 +38,9 @@ struct wtpman {
 				 from a .ckv file on startup.
 				 */
 
+	cw_Cfg_t * wtp_cfg;
 
-	cw_MsgCallbackFun pdiscovery;
-	cw_MsgCallbackFun pjoin;
-	cw_MsgCallbackFun pupdate;
-
-
+	
 
 };
 

src/contrib/install_libmavl.sh

@@ -1,6 +1,6 @@
 #!/bin/sh
 
-VERSION="1.1.0a"
+VERSION="1.2.0"
 
 wget -O libmavl-${VERSION}.tgz ftp://ftp.planix.org/pub/planix/libmavl-${VERSION}.tgz
 tar xzvf libmavl-${VERSION}.tgz

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

@@ -3,6 +3,7 @@ MFDEPS=../Defs.mak
 
 
 CWSRC=\
+	cw.c\
 	cw_check_missing_mand.c\
 	cw_clock_lap.c\
 	cw_dbg_elem.c\
@@ -16,14 +17,7 @@ CWSRC=\
 	cw_in_ac_name_with_priority.c\
 	cw_in_capwap_local_ipv4_address.c\
 	cw_in_capwap_local_ipv6_address.c\
-	cw_in_check_disc_req.c\
-	cw_in_check_img_data_req_ac.c\
-	cw_in_check_img_data_req_wtp.c\
-	cw_in_check_join_req.c\
-	cw_in_check_join_resp.c\
-	cw_in_generic.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\
@@ -37,10 +31,8 @@ CWSRC=\
 	cw_in_wtp_reboot_statistics.c\
 	cw_is_printable.c\
 	cw_load_file.c\
-	cw_out_generic.c\
 	cw_out_generic_with_index.c\
 	cw_out_radio_administrative_states.c\
-	cw_process_element.c\
 	cw_put_elem_radio_administrative_state.c\
 	cw_put_elem_radio_operational_state.c\
 	cw_put_image_data.c\
@@ -74,37 +66,55 @@ 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\
+#	cw_in_check_img_data_req_wtp.c\
+#	cw_in_check_join_req.c\
+#	cw_in_check_join_resp.c\
+#	cw_in_generic.c\
+#	cw_out_generic.c\
+#	
+#	cw_process_element.c\
 
 KTVSRC=\
-	cw_ktv_add.c\
-	cw_ktv_cast.c\
-	cw_ktv_replace.c\
+	cfg.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_base_exists.c\
-	cw_ktv_save.c\
-	cw_ktv_del_sub.c\
-	cw_ktv_parser.c\
-	cfg.c\
+
+#	cw_ktv_cast.c\
+	cw_ktv_replace.c\
+	cw_ktv_get.c\
 
 
 LWSRC=\
@@ -176,11 +186,8 @@ MISCSRC=\
 	capwap_strings_state.c\
 	capwap_strings_vendor.c\
 	conn_create_noq.c\
-	conn_destroy.c\
 	connlist.c\
 	conn_prepare_image_data_request.c\
-	conn_process_packet.c\
-	cw_decode_msg.c \
 	conn_q_add_packet.c\
 	conn_q_get_packet.c\
 	conn_q_recv_packet.c\
@@ -193,20 +200,28 @@ MISCSRC=\
 	format.c\
 	format_is_utf8.c\
 	fragman.c\
-	intavltree.c\
 	md5sum.c\
 	mod.c\
 	msgset.c\
 	send.c\
 	strheap.c\
 	netconn.c\
-	conn.c
+	conn.c \
+	val.c \
+	discovery.c\
+	message.c\
+	cw_out_radio_generic_struct.c\
+
+
+#	intavltree.c\
 
 #	conn_q_wait_packet.c\
 #	conn_init.c\
 #	conn_create.c\
 #	conn_send_request.c\
 #	cw_put_msg.c\
+#	conn_process_packet.c\
+#	conn_destroy.c\
 
 DTLSSRC+=\
 	dtls_bio.c\
@@ -214,9 +229,9 @@ DTLSSRC+=\
 
 
 RADIOSRC=\
-	cw_out_radio_generic.c\
-	cw_out_radio_generic_struct.c\
-	cw_read_radio_generic.c\
+	
+#	cw_in_radio_generic.c\
+#	cw_out_radio_generic.c\
 
 MAVLSRC=\
 	mavl_get_ptr.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,12 +126,27 @@ 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;
 }
 
+const char *cw_cfg_get_l(cw_Cfg_t ** cfg, const char * key, const char *def)
+{
+	int i;
+	struct cw_Cfg_entry e, *r;
+	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]->cfg, &e);
+		if (r!=NULL)
+			return r->val;
+	}
+	return def;
+}
+
+
 const char *cw_cfg_get2(cw_Cfg_t *cfg1, cw_Cfg_t *cfg2, const char *key, const char *def)
 {
 	return cw_cfg_get(cfg1, key, cw_cfg_get(cfg2,key,def));
@@ -152,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);
@@ -161,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;
@@ -442,7 +481,6 @@ int cw_cfg_read_from_file(FILE * f, cw_Cfg_t * cfg)
 	return errs;
 }
 
-
 int cw_cfg_load(const char *filename, cw_Cfg_t * cfg)
 {
 	int errs;
@@ -457,19 +495,76 @@ 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->cfg);
+	mavliter_foreach(&it) {
+		int n;
+		e = mavliter_get(&it);
+		n=strlen(e->val);
+		if (n>0) 
+			n-=1;
+
+//printf("Write %s: \"%s\"   - %d %d (%02x)\n",e->key,e->val,n,isspace(e->val[n]),e->val[n]);
+		if(isspace(e->val[0]) || isspace(e->val[n]))
+			fprintf(f,"%s: \"%s\"\n", e->key, e->val);
+		else
+			fprintf(f,"%s: %s\n", e->key, e->val);
+
+		//cw_dbg(dbglevel,"%s%s :%s: %s",prefix,data->key,type->get_type_name(data), value);
+	}
+	return 0;
+}
+
+
+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);
+
+	return rc;
+}
+
 
 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;
@@ -491,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;
 		}
 
 	}
@@ -506,14 +601,16 @@ 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;
 }
 
 
-int cw_cfg_get_bool(cw_Cfg_t * cfg, const char * key, const char *def)
+int cw_cfg_get_bool(cw_Cfg_t * cfg, const char * key, int def)
 {
 	struct cw_Val v;
-	const char *s = cw_cfg_get(cfg,key,def);
+	const char *s = cw_cfg_get(cfg,key,NULL);
+	if (s==NULL)
+		return def;
 	CW_TYPE_BOOL->from_str(&v,s);
 	return v.val.boolean;
 }
@@ -527,12 +624,23 @@ uint8_t cw_cfg_get_byte(cw_Cfg_t * cfg, char *key, uint8_t def)
 	if (s==NULL)
 		return def;
 	CW_TYPE_BYTE->from_str(&v,s);
-	return v.val.word;
+	return v.val.byte;
+}
+
+uint8_t cw_cfg_get_byte_l(cw_Cfg_t ** cfgs, char *key, uint8_t def)
+{
+	struct cw_Val v;
+	memset(&v,0,sizeof(struct cw_Val));
+	const char *s = cw_cfg_get_l(cfgs,key,NULL);
+	if (s==NULL)
+		return def;
+	CW_TYPE_BYTE->from_str(&v,s);
+	return v.val.byte;
 }
 
 
 
-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);
@@ -542,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)
 {
@@ -573,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;
 	}
@@ -596,7 +717,6 @@ int cw_cfg_set_val(cw_Cfg_t * cfg, const char *key, const struct cw_Type *type,
 	memset(&mdata,0,sizeof(cw_Val_t));
 	mdata.type=type;
 	mdata.valguard=valguard;
-cw_dbg(DBG_X,"SETVAL FOR TYPE: %s",type->name);	
 	mresult = type->get(&mdata,data,len);
 	if (!mresult){
 		cw_log(LOG_ERR, "Can't create cfg element for key %s of type %s: %s",
@@ -611,3 +731,125 @@ cw_dbg(DBG_X,"SETVAL FOR TYPE: %s",type->name);
 		type->del(&mdata);
 	return 1;
 }
+
+//int cw_cfg_put(cw_Cfg_t *cfg, const char *key, const struct cw_Type *type,const void
+
+
+
+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->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);
+
+/*		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_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_level, "%s: %s -> %s",new_elem.key,old_elem->val,new_elem.val);
+//		cw_dbg(DBG_X, "Replace: %s: %s (old: %s)",new_elem.key, new_elem.val, old_elem->val);
+		if(dst->cfg->del){
+			dst->cfg->del(old_elem);
+		}
+		memcpy(old_elem,&new_elem,dst->cfg->data_size);
+	}
+
+}
+
+
+void cw_cfg_destroy(cw_Cfg_t *cfg)
+{
+	if (cfg->cfg)
+		mavl_destroy(cfg->cfg);
+	free(cfg);
+}
+
+
+void cw_cfg_clear(cw_Cfg_t *cfg)
+{
+	mavl_del_all(cfg->cfg);
+}
+
+
+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->cfg,&e);
+        if (result == NULL)
+                return 0;
+//cw_dbg(DBG_X,"BASEXXX: %s",result->key);
+
+	if (strlen(result->key)<strlen(key))
+		return 0;		
+//cw_dbg(DBG_X,"BASEXXX1: %d",strlen(key));
+	if (result->key[strlen(key)]!='/' && result->key[strlen(key)]!='.')
+		return 0;
+//cw_dbg(DBG_X,"BASEXXX2: ");
+	if (strncmp(result->key,key,strlen(key))==0)
+		return 1;
+cw_dbg(DBG_X,"BASEXXX3: ");
+
+	return 0;
+}
+
+int cw_cfg_base_exists_l(cw_Cfg_t ** cfgs, const char *key)
+{
+	int i;
+	for(i=0; cfgs[i]; i++){
+		if (cw_cfg_base_exists(cfgs[i],key))
+			return 1;
+	}
+//	cw_dbg(DBG_X,"NOX EXISIS: %s in %d",key,i);
+	return 0;
+}
+
+
+
+cw_Val_t * cw_cfg_get_val_l(cw_Cfg_t ** cfgs, const char *key, const struct cw_Type *type)
+{
+	const char *s;
+	cw_Val_t * val;
+	s = cw_cfg_get_l(cfgs,key,NULL);
+	val = malloc(sizeof(cw_Val_t));
+	if (val==NULL)
+		return NULL;
+	val->type=type;
+	val->type->from_str(val,s);
+	return val;
+}

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,16 +35,32 @@ 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, const char *def);
-uint16_t cw_cfg_get_word(cw_Cfg_t * cfg, char *key, uint16_t def);
+int cw_cfg_get_bool(cw_Cfg_t * cfg, const char * key, int 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,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, 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);
+
+
+
 
 
 int cw_cfg_set_val(cw_Cfg_t * cfg, const char *key, const struct cw_Type *t, const void * valguard, const uint8_t * data, int len);

src/cw/conn.c

@@ -22,142 +22,7 @@
 #include "msgset.h"
 #include "mavltypes.h"
 
-
-
-
-/**
- * Put a message to a buffer
- * This functions assumes, that a message header is
- * alread initilaized in buffer 
- * Message alements are taken fom actiondef in #conn->action
- */
-int cw_assemble_message(struct cw_Conn *conn, uint8_t * rawout)
-{
-	char details[1024];
-	uint8_t *msgptr,*dst;
-	int type;
-	struct cw_MsgData * msg;
-	struct mlistelem * elem;
-	int len,l;
-
-	//cw_dbg(DBG_INFO, "Number of elements in ktv: %d",conn->local_cfg->count);
-/*	cw_dbg_ktv_dump(conn->local_cfg,DBG_CFG_DMP,"Local CFG","LOCAL:","End Local CFG");*/
-
-	/* rawout is already initialized, so we can get 
-	 * 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_ASSEMBLY,"*** Assembling message of type %d (%s) ***", 
-			msg->type, msg->name);
-	
-	dst = msgptr+8;
-	len =0;
-	mlist_foreach(elem,msg->elements_list){
-		struct cw_ElemData * data;
-		struct cw_ElemHandler * handler;
-		struct cw_ElemHandlerParams params;
-		
-		data =  mlistelem_dataptr(elem);
-		handler = cw_msgset_get_elemhandler(conn->msgset,data->proto,data->vendor,data->id);
-//		cw_dbg(DBG_X,"Elem: %d %d %d %s\n", data->proto, data->vendor, data->id, handler->name);
-		if (handler==NULL){
-			cw_log(LOG_ERR,"Can't put message element %d %d %d, no handler defined.",
-					data->proto,data->vendor,data->id);
-			continue;
-		}
-
-
-		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;
-		}
-
-		params.conn=conn;
-		params.cfg=conn->remote_cfg;
-		params.default_cfg=conn->default_cfg;
-
-		params.msgset=conn->msgset;
-
-
-
-		params.elemdata = data;
-		params.msgdata=msg;
-		params.debug_details=details;
-		*details=0;
-
-/*		if (strcmp(handler->key,"cisco/ap-led-flash-config")==0){
-			printf("flash config\n");
-			 cisco/ap-led-flash-config/flash-enable 
-		}*/
-
-
-		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_ASSEMBLY,"*** 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);
-	mavl_t * cfg = cw_cfg_create();
-
-	struct cw_ElemHandlerParams params;
-
-	params.cfg=cfg;
-	params.default_cfg=NULL;
-	params.msgset=conn->msgset;
-	params.msgdata=msg;
-
-
-	cw_decode_elements( &params, elems_ptr,elems_len);
-
-	printf ("----------------------------------- end redecode -----------------------------\n");
-
-	}
-
-	return CAPWAP_RESULT_SUCCESS;
-
-
-}
+#include "dtls.h"
 
 
 
@@ -192,6 +57,11 @@ void cw_conn_init(struct cw_Conn * conn)
 	conn->process_message=process_message;
 
 	conn->msg_callbacks = mavl_create(msg_callback_cmp,NULL,sizeof(struct msg_callback));
+
+	conn->update_cfg = cw_cfg_create();
+	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)
@@ -202,6 +72,7 @@ int cw_conn_set_msg_cb(struct cw_Conn *conn, int type, cw_MsgCallbackFun fun)
 	cb.type = type;
 	cb.fun = fun;
 	mavl_insert(conn->msg_callbacks,&cb,&exists);
+	return 1;
 }
 
 cw_MsgCallbackFun cw_conn_get_msg_cb(struct cw_Conn *conn, int type)
@@ -269,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;
@@ -279,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;
 
 
 
@@ -288,3 +159,668 @@ struct cw_Conn * cw_conn_create(int sock, struct sockaddr * addr, int qsize)
 }
 
 
+
+
+
+/**
+ * Init response message header
+ */
+void cw_init_response(struct cw_Conn *conn, uint8_t * req)
+{
+	uint8_t *buffer;
+	int shbytes, dhbytes;
+	uint8_t *msgptr, *dmsgptr;
+
+	buffer = conn->resp_buffer;
+	shbytes = cw_get_hdr_msg_offset(req);
+
+	memcpy(buffer, req, shbytes);
+
+	cw_set_hdr_rmac(buffer, conn->base_rmac);
+/*
+//      cw_set_hdr_hlen(buffer, 2);
+//      cw_set_hdr_flags(buffer, CW_FLAG_HDR_M, 1);
+*/
+
+	dhbytes = cw_get_hdr_msg_offset(buffer);
+
+	msgptr = req + shbytes;
+	dmsgptr = buffer + dhbytes;
+
+	cw_set_msg_type(dmsgptr, cw_get_msg_type(msgptr) + 1);
+	cw_set_msg_seqnum(dmsgptr, cw_get_msg_seqnum(msgptr));
+	cw_set_msg_flags(dmsgptr, 0);
+}
+
+void cw_init_request(struct cw_Conn *conn, int msg_id)
+{
+	uint8_t *buffer = conn->req_buffer;
+	uint8_t *msgptr;
+
+	/* zero the first 8 bytes */
+	cw_set_dword(buffer + 0, 0);
+	cw_set_dword(buffer + 4, 0);
+
+	/* unencrypted */
+	cw_set_hdr_preamble(buffer, CAPWAP_VERSION << 4 | 0);
+
+	cw_set_hdr_rmac(buffer, conn->base_rmac);
+/*
+	//cw_set_hdr_hlen(buffer, 2);
+*/
+
+
+	cw_set_hdr_wbid(buffer, conn->wbid);
+	cw_set_hdr_rid(buffer, 0);
+
+
+	msgptr = cw_get_hdr_msg_offset(buffer) + buffer;
+	cw_set_msg_type(msgptr, msg_id);
+	cw_set_msg_flags(msgptr, 0);
+	cw_set_msg_elems_len(msgptr, 0);
+}
+
+void cw_init_data_msg(struct cw_Conn *conn)
+{
+	uint8_t *buffer = conn->req_buffer;
+	cw_set_dword(buffer + 0, 0);
+	cw_set_dword(buffer + 4, 0);
+
+	/* unencrypted */
+	cw_set_hdr_preamble(buffer, CAPWAP_VERSION << 4 | 0);
+
+
+
+}
+
+
+/**
+ * send a response 
+ */
+int cw_send_response(struct cw_Conn *conn, uint8_t * rawmsg, int len)
+{
+	int rc;
+	cw_init_response(conn, rawmsg);
+	rc = cw_compose_message(conn, conn->resp_buffer);
+	if (!cw_result_is_ok(rc))
+		return 0;
+	conn_send_msg(conn, conn->resp_buffer);
+	return 1;
+}
+
+
+
+/**
+ * Special case error message, which is sent when an unexpected messages 
+ * was received or something else happened.
+ * @param conn conection
+ * @param rawmsg the received request message, which the response belongs to
+ * @param result_code result code to send
+ * @return 1
+ */
+int cw_send_error_response(struct cw_Conn *conn, uint8_t * rawmsg,
+			   uint32_t result_code)
+{
+	uint8_t *out, *dst;
+	int l;
+
+	cw_init_response(conn, rawmsg);
+
+	out = conn->resp_buffer;
+
+	dst = cw_get_hdr_msg_elems_ptr(out);
+	l = cw_put_elem_result_code(dst, result_code);
+
+	cw_set_msg_elems_len(out + cw_get_hdr_msg_offset(out), l);
+
+	conn_send_msg(conn, conn->resp_buffer);
+
+	return 1;
+}
+
+
+static struct cw_MsgSet *load_msg_set(struct cw_Conn *conn, uint8_t * rawmsg,
+				      int len, int elems_len,
+				      struct sockaddr *from)
+{
+	char sock_buf[SOCK_ADDR_BUFSIZE];
+	struct cw_Mod *cmod, *bmod;
+
+	cmod =
+	    cw_mod_detect(conn, rawmsg, len, elems_len, from,
+			  CW_MOD_MODE_CAPWAP);
+	if (cmod == MOD_NULL) {
+		cw_dbg(DBG_MSG_ERR,
+		       "Can't find mod to handle connection from %s, discarding message",
+		       sock_addr2str_p(from, sock_buf));
+		return NULL;
+	}
+
+	bmod =
+	    cw_mod_detect(conn, rawmsg, len, elems_len, from,
+			  CW_MOD_MODE_BINDINGS);
+
+
+	cw_dbg(DBG_INFO, "Mods deteced: %s,%s", cmod->name, bmod->name);
+
+	conn->cmod = cmod;
+	conn->bmod = bmod;
+
+	return cw_mod_get_msg_set(conn, cmod, bmod);
+
+}
+
+/*
+int cw_in_check_generic(struct cw_Conn *conn, struct cw_action_in *a, uint8_t * data,
+			 int len,struct sockaddr *from)
+{
+//	if (cw_is_request(a->msg_id)){
+//		return cw_in_check_generic_req(conn,a,data,len,from);
+//	}
+//	return cw_in_check_generic_resp(conn,a,data,len,from);
+
+	
+}
+*/
+
+
+static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
+			    struct sockaddr *from)
+{
+	struct cw_MsgData search;
+	struct cw_MsgData *message;
+	int result_code;
+	cw_State_t *ui;
+
+	uint8_t *elems_ptr;
+	struct cw_ElemHandlerParams params;
+
+	char sock_buf[SOCK_ADDR_BUFSIZE]; /**< to hold str from sockaddr2str */
+
+	/*struct cw_action_in as, *af, *afm; */
+
+	int offset = cw_get_hdr_msg_offset(rawmsg);
+
+	uint8_t *msg_ptr = rawmsg + offset;
+
+	int elems_len = cw_get_msg_elems_len(msg_ptr);
+
+	int payloadlen = len - offset;
+
+
+	/* 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) ",
+			       sock_addr2str(&conn->addr, sock_buf), elems_len,
+			       payloadlen - 8);
+			errno = EAGAIN;
+			return -1;
+		}
+
+
+		if (elems_len < payloadlen - 8) {
+			cw_dbg(DBG_RFC,
+			       "Packet from from %s has %d bytes of extra data, ignoring.",
+			       sock_addr2str(&conn->addr, sock_buf),
+			       payloadlen - 8 - elems_len);
+			//elems_len = len - 8;
+		}
+
+		if (elems_len > payloadlen - 8) {
+
+			cw_dbg(DBG_RFC,
+			       "Packet from from %s has msgelems len of %d bytes, but has only %d bytes of data, truncating.",
+			       sock_addr2str(&conn->addr, sock_buf), elems_len,
+			       payloadlen - 8);
+			elems_len = payloadlen - 8;
+		}
+	}
+
+
+	/* Detect the connecting WTP type */
+	if (!conn->detected) {
+
+		struct cw_MsgSet *set =
+		    load_msg_set(conn, rawmsg, len, elems_len, from);
+		if (!set) {
+/*
+			//cw_log(LOG_ERR, "Error");
+*/
+			errno = EAGAIN;
+			return -1;
+		}
+		conn->cmod->setup_cfg(conn);
+		conn->msgset = set;
+		conn->detected = 1;
+
+		if (conn->setup_complete)
+			conn->setup_complete(conn);
+
+	}
+
+	/** debug the received message */
+	cw_dbg_msg(DBG_MSG_IN, conn, rawmsg, len, from);
+
+	/* prepare struct for search operation */
+	search.type = cw_get_msg_id(msg_ptr);
+
+	/* Search message */
+
+	message = mavl_get(conn->msgset->msgdata, &search);
+
+	result_code = 0;
+
+	if (!message) {
+		/* Message is unknown */
+		if (search.type & 1) {
+			cw_dbg(DBG_MSG_ERR,
+			       "Message type %d [%s] unrecognized, sending response.",
+			       search.type, cw_strmsg(search.type),
+			       cw_strstate(conn->capwap_state));
+
+			result_code = CAPWAP_RESULT_MSG_UNRECOGNIZED;
+			cw_send_error_response(conn, rawmsg, result_code);
+			errno = EAGAIN;
+			return -1;
+		}
+		cw_dbg(DBG_MSG_ERR,
+		       "Message type %d [%s] unrecognized, discarding.",
+		       search.type, cw_strmsg(search.type),
+		       cw_strstate(conn->capwap_state));
+		errno = EAGAIN;
+		return -1;
+
+	}
+
+	/* Throw away unexpected messages */
+	/* maybe we have to check this too: if (!(message->type & 1)) 
+	 * means unexpected response message
+	 * */
+	if (!(message->receiver & conn->role)) {
+		cw_dbg(DBG_MSG_ERR,
+		       "Message type %d (%s) unexpected/illegal in %s State, discarding.",
+		       search.type, cw_strmsg(search.type),
+		       cw_strstate(conn->capwap_state));
+		errno = EAGAIN;
+		return -1;
+	}
+
+	/* Check if current state is in state of message */
+	ui = message->states;
+
+	for (ui = message->states; ui->state; ui++) {
+/*		printf("Comparing %d and %d\n", conn->capwap_state, ui->state);*/
+		if (ui->state == conn->capwap_state) {
+			break;
+		}
+	}
+
+	if (!ui->state) {
+		/* Message found, but it was in wrong state */
+		cw_dbg(DBG_MSG_ERR,
+		       "Message type %d (%s) not allowed in %s State, sending response.",
+		       search.type, cw_strmsg(search.type),
+		       cw_strstate(conn->capwap_state));
+		result_code = CAPWAP_RESULT_MSG_INVALID_IN_CURRENT_STATE;
+		cw_send_error_response(conn, rawmsg, result_code);
+		errno = EAGAIN;
+		return -1;
+	}
+
+
+
+
+	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)",
+		       message->type, message->name);
+	}*/
+
+	memset(&params,0,sizeof(struct cw_ElemHandlerParams));
+	
+	params.mand_found = mavl_create_conststr();
+	params.unrecognized = mlist_create(NULL, NULL, sizeof(uint8_t *));
+
+	params.cfg = cw_cfg_create();
+	params.cfg->dbg_level = DBG_ELEM_DETAIL_IN;
+	params.cfg->dbg_prefix = "    ";
+
+	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);
+
+	/* all message elements are processed, do now after processing
+	   by calling the "end" function for the message */
+
+	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) ***",
+//	       message->type, message->name);
+
+	if (params.mand_found)
+		mavl_destroy(params.mand_found);
+
+	if (message->postprocess) {
+		message->postprocess(&params,elems_ptr, elems_len);
+	}
+
+	cw_MsgCallbackFun cb_fun = cw_conn_get_msg_cb(conn,message->type);
+	if (cb_fun != NULL){
+		result_code = cb_fun(&params,elems_ptr, elems_len);
+	}
+	else{
+		cw_cfg_clear(conn->update_cfg);
+	}
+
+//	conn->remote_cfg=params.cfg;
+
+	/* if we've got a request message, we always have to send a response message */
+	if (message->type & 1) {
+		if (result_code > 0) {
+			/* the end method gave us an result code>0, so
+			   send an error message */
+
+			cw_send_error_response(conn, rawmsg, result_code);
+		} else if (result_code == 0) {
+			cw_cfg_set_int(conn->update_cfg, "capwap/result-code",
+					 result_code);
+			if (ui->next) {
+				conn->capwap_prevstate = conn->capwap_state;
+				conn->capwap_state = ui->next;
+			}
+
+			/* All is ok, send regular response message */
+			cw_send_response(conn, rawmsg, len);
+		} else {
+			/* the request message is ignored, no response
+			   will be sent */
+			errno = EAGAIN;
+		}
+	} else {
+		/* 
+		 * Whe have got a response message.
+		 * Put further actions here, if needed.
+		 */
+	}
+
+	if (params.unrecognized)
+		mlist_destroy(params.unrecognized);
+	cw_cfg_destroy(params.cfg);
+//	conn->remote_cfg=NULL;
+
+	return result_code;
+
+}
+
+
+
+
+
+
+int process_message(struct cw_Conn *conn, uint8_t * rawmsg, int rawlen,
+		    struct sockaddr *from)
+{
+	char sock_buf[SOCK_ADDR_BUFSIZE];
+	uint8_t seqnum;
+	int s1, s2, sd;
+
+	uint8_t *msgptr = rawmsg + cw_get_hdr_msg_offset(rawmsg);
+
+
+	uint32_t type = cw_get_msg_type(msgptr);
+
+	if (!(type & 0x1)) {
+		/* It's a response  message, no further examination required. */
+		return process_elements(conn, rawmsg, rawlen, from);
+	}
+
+	/* It's a request message, check if seqnum is right and if
+	 * we have already sent a response message*/
+
+	seqnum = cw_get_msg_seqnum(msgptr);
+
+	s1 = conn->last_seqnum_received;
+	s2 = seqnum;
+	sd = s2 - s1;
+
+	if ((sd > 0 && sd < 128) || (sd < 0 && sd < -128) || s1 < 0) {
+		/* seqnum is ok, normal message processing */
+		conn->last_seqnum_received = seqnum;
+
+		return process_elements(conn, rawmsg, rawlen, from);
+	}
+
+	if (sd != 0) {
+		cw_dbg(DBG_MSG_ERR,
+		       "Discarding message from %s, old seqnum, seqnum = %d, last seqnum=%d",
+		       sock_addr2str(&conn->addr, sock_buf), s2, s1);
+		errno = EAGAIN;
+		return -1;
+	}
+
+	/* the received request message was retransmittet by our peer,
+	 * let's retransmit our response message if we have one*/
+
+
+	cw_dbg(DBG_MSG_ERR,
+	       "Retransmitted request message from %s detected, seqnum=%d, type=%d",
+	       sock_addr2str(&conn->addr, sock_buf), s2, type);
+
+
+	if (cw_get_hdr_msg_type(conn->resp_buffer) - 1 != type) {
+/*		cw_dbg(DBG_MSG_ERR,
+		       "No cached response for retransmission, request seqnum=%d,in cache=%d",
+		       s2, conn->resp_msg.type);*/
+		errno = EAGAIN;
+		return -1;
+	}
+
+	cw_dbg(DBG_MSG_ERR, "Retransmitting response message to %s, seqnum=%d",
+	       sock_addr2str(&conn->addr, sock_buf), s2);
+
+	/*// XXX untested */
+	conn_send_msg(conn, conn->resp_buffer);
+	errno = EAGAIN;
+	return -1;
+}
+
+
+/*
+ * Process an incomming CAPWAP packet, assuming the packet is already decrypted
+ * @param conn conection object 
+ * @param packet pointer to packet data
+ * @param len lenght of packet data
+ */
+int conn_process_packet2(struct cw_Conn *conn, uint8_t * packet, int len,
+			 struct sockaddr *from)
+{
+	char sock_buf[SOCK_ADDR_BUFSIZE];
+	int preamble;
+	int offs;
+	int payloadlen;
+
+	if (len < 8) {
+		/* packet too short */
+		cw_dbg(DBG_PKT_ERR,
+		       "Discarding packet from %s, packet too short, len=%d,  at least 8 expected.",
+		       sock_addr2str(&conn->addr, sock_buf), len);
+		errno = EAGAIN;
+		return -1;
+	}
+
+	preamble = cw_get_hdr_preamble(packet);
+
+	if ((preamble & 0xf0) != (CAPWAP_VERSION << 4)) {
+		/* wrong version */
+		cw_dbg(DBG_PKT_ERR,
+		       "Discarding packet from %s, wrong version, version=%d, version %d expected.",
+		       sock_addr2str(&conn->addr, sock_buf),
+		       (preamble & 0xf0) >> 4, CAPWAP_VERSION);
+		errno = EAGAIN;
+		return -1;
+	}
+
+	if (preamble & 0xf) {
+		/* Encrypted data, this shuold never happen here */
+		cw_dbg(DBG_PKT_ERR,
+		       "Discarding packet from %s, encrypted data after decryption ...",
+		       sock_addr2str(&conn->addr, sock_buf));
+		errno = EAGAIN;
+		return -1;
+	}
+
+
+	offs = cw_get_hdr_msg_offset(packet);
+
+
+	payloadlen = len - offs;
+	if (payloadlen < 0) {
+		/* Eleminate messages with wrong header size */
+		cw_dbg(DBG_PKT_ERR,
+		       "Discarding packet from %s, header length (%d) greater than packet len (%d).",
+		       sock_addr2str(&conn->addr, sock_buf), offs, len);
+		errno = EAGAIN;
+		return -1;
+	}
+
+	/* Check if Radio MAC is present */
+	if (cw_get_hdr_flag_m(packet)) {
+
+		if (cw_get_hdr_rmac_len(packet) + 8 > offs) {
+			/* wrong rmac size */
+			cw_dbg(DBG_PKT_ERR,
+			       "Discarding packet from %s, wrong R-MAC size, size=%d",
+			       sock_addr2str(&conn->addr, sock_buf),
+			       *(packet + 8));
+			errno = EAGAIN;
+			return -1;
+		}
+
+	}
+
+
+	if (cw_get_hdr_flag_f(packet)) {
+		/* fragmented, add the packet to fragman */
+		uint8_t *f;
+		int rc;
+
+		f = fragman_add(conn->fragman, packet, offs, payloadlen);
+		if (f == NULL) {
+			errno = EAGAIN;
+			return -1;
+		}
+
+
+		cw_dbg_pkt(DBG_PKT_IN, conn, f + 4, *(uint32_t *) f, from);
+/*//		cw_dbg_msg(DBG_MSG_IN, conn, f + 4, *(uint32_t *) f, from);*/
+
+/*		// XXX: Modify fragman to not throw away CAPWAP headers*/
+
+		rc = conn->process_message(conn, f + 4, *(uint32_t *) f, from);
+
+		free(f);
+		return rc;
+	}
+
+	/* not fragmented, we have a complete message */
+/*//	cw_dbg_msg(DBG_MSG_IN, conn, packet, len, from);*/
+	return conn->process_message(conn, packet, len, from);
+}
+
+int conn_process_packet(struct cw_Conn *conn, uint8_t * packet, int len,
+			struct sockaddr *from)
+{
+
+	/* show this packet in debug output */
+	cw_dbg_pkt(DBG_PKT_IN, conn, packet, len, from);
+
+	return conn_process_packet2(conn, packet, len, from);
+}
+
+
+int conn_process_data_packet(struct cw_Conn *conn, uint8_t * packet, int len,
+			     struct sockaddr *from)
+{
+
+	/* show this packet in debug output */
+	cw_dbg_pkt(DBG_PKT_IN, conn, packet, len, from);
+
+	return conn_process_packet2(conn, packet, len, from);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Used as main message loop
+ */
+int cw_read_messages(struct cw_Conn *conn)
+{
+	uint8_t buf[2024];
+	int len = 2024;
+
+	int n = conn->read(conn, buf, len);
+	if (n < 0)
+		return n;
+
+	if (n > 0) {
+		return conn->process_packet(conn, buf, n,
+					    (struct sockaddr *) &conn->addr);
+	}
+	errno = EAGAIN;
+	return -1;
+}
+
+
+
+/**
+ * Destroy a conn object
+ * @param object to destroy
+ */
+void conn_destroy(struct cw_Conn * conn)
+{
+	dtls_shutdown(conn);
+	if (conn->fragman)
+		fragman_destroy(conn->fragman);
+	if (conn->q)
+		free (conn->q);
+
+	if (conn->msg_callbacks)
+		mavl_destroy(conn->msg_callbacks);
+
+	if (conn->base_rmac)
+		free(conn->base_rmac);
+
+	if (conn->remote_cfg)
+		cw_cfg_destroy(conn->remote_cfg);
+
+	if (conn->local_cfg)
+		cw_cfg_destroy(conn->local_cfg);
+
+	if (conn->update_cfg)
+		cw_cfg_destroy(conn->update_cfg);
+	free(conn);
+}
+
+

src/cw/conn.h

@@ -38,7 +38,6 @@
 
 /*#include "mbag.h"*/
 
-#include "intavltree.h"
 #include "bstr.h"
 #include "msgset.h"
 
@@ -70,13 +69,25 @@ struct cw_Conn {
 
 
 	int recv_timeout;
+
+
+	cw_Cfg_t * global_cfg;	/**< This should set the global cfg of the program
+				     which is using this conn object.
+				     Teh global_cfg has to be treated read-only. */
+
+	cw_Cfg_t * local_cfg;	/**< local_cfg contains overrides for global_cfg 
+				     wich are related to this conn object. */
 	
-	
-	mavl_t remote_cfg;
-	mavl_t default_cfg;
-	mavl_t update_cfg;
-	mavl_t local_cfg;
-	mavl_t global_cfg;
+	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.  */
+
+	cw_Cfg_t * update_cfg;
+
+	cw_Cfg_t * cfg_list[10];
 	
 	bstr16_t session_id;
 
@@ -90,9 +101,6 @@ struct cw_Conn {
 	uint8_t wbid;
 
 
-	/** Counter for mandatory message elements */
-/*	struct avltree *mand;*/
-
 
 	/** Actionsdefs - this defines the possible actions for
 	    this conn object, so in the end this is the specification
@@ -119,10 +127,6 @@ struct cw_Conn {
 	int last_seqnum_received;
 	int last_message_id_received;
 
-
-//	struct cwmsg req_msg;
-//	struct cwmsg resp_msg;
-
 	/** Buffer for outgoing request messages */
 	uint8_t req_buffer[CONN_MAX_MSG_LENGTH];
 
@@ -141,17 +145,10 @@ struct cw_Conn {
 	int (*recv_packet) (struct cw_Conn*, uint8_t *, int);
 	int (*recv_packet_peek) (struct cw_Conn*, uint8_t *, int);
 	int (*send_packet) (struct cw_Conn*, const uint8_t *, int);
-/*
-//	int (*recv_data_packet) (struct cw_Conn*, uint8_t *,int);
-//	int (*send_data_packet) (struct cw_Conn*, const uint8_t *, int);
-*/	
-
 	int (*readfrom) (struct cw_Conn*, uint8_t *, int, struct sockaddr_storage *);
 	int (*read) (struct cw_Conn*, uint8_t *, int);
 	int (*write) (struct cw_Conn*, const uint8_t *, int);
-/*
-//	int (*write_data) (struct cw_Conn*, const uint8_t *, int);
-*/
+
 	/* optional packet queue */
 	uint8_t **q;
 	int qsize;
@@ -174,12 +171,12 @@ struct cw_Conn {
 
 	struct cw_Mod *cmod, *bmod;
 
-	char *dtls_cert_file;
-	char *dtls_key_file;
-	char *dtls_key_pass;
+	const char *dtls_cert_file;
+	const char *dtls_key_file;
+	const char *dtls_key_pass;
 
 	void *dtls_data;
-	char *dtls_cipher;
+	const char *dtls_cipher;
 	int dtls_error;
 
 	uint8_t dtls_cookie[8];
@@ -317,5 +314,10 @@ void conn_clear_upd(struct cw_Conn*conn, int merge);
 int cw_conn_set_msg_cb(struct cw_Conn *conn, int type, cw_MsgCallbackFun fun);
 cw_MsgCallbackFun cw_conn_get_msg_cb(struct cw_Conn *conn, int type);
 
+int cw_decode_element(struct cw_ElemHandlerParams *params, int proto,
+		      int vendor, int elem_id, uint8_t * data, int len);
+
+int cw_decode_elements(struct cw_ElemHandlerParams * params, uint8_t * elems_ptr, int elems_len);
+
 
 #endif	/* __CONN_H */

src/cw/conn_destroy.c

@@ -1,44 +0,0 @@
-/*
-    This file is part of actube.
-
-    actube is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    libcapwap is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-/**
- * @file
- * @brief Implements conn_destroy
- */
-
-#include <stdlib.h>
-
-#include "conn.h"
-
-/**
- * Destroy a conn object
- * @param object to destroy
- */
-void conn_destroy(struct cw_Conn * conn)
-{
-	if (conn->fragman)
-		fragman_destroy(conn->fragman);
-	if (conn->q)
-		free (conn->q);
-
-	if (conn->msg_callbacks)
-		mavl_destroy(conn->msg_callbacks);
-
-	free(conn);
-}
-
-

src/cw/conn_init.c

@@ -1,74 +0,0 @@
-/*
-    This file is part of libcapwap.
-
-    libcapwap is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    libcapwap is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-
-
-/**
- * @file
- * @brief conn_init
- */ 
-
-#include <string.h>
-
-
-#include "conn.h"
-#include "capwap.h"
-#include "cw.h"
-
-/*
-static int write_header(struct cw_ElemHandler * handler, uint8_t * dst, int len)
-{
-	if (handler->vendor)
-		return len + cw_put_elem_vendor_hdr(dst, handler->vendor, handler->id, len);
-
-	return  len + cw_put_elem_hdr(dst, handler->id, len);
-}
-
-static int header_len(struct cw_ElemHandler * handler)
-{
-	return handler->vendor ? 10 : 4;
-}
-
-*/
-
-/**
- * Basic initialization of a conn object 
- * @param conn conn object to initialize
- */ 
-void conn_init(struct cw_Conn * conn)
-{
-	memset(conn,0,sizeof(struct cw_Conn ));
-	conn->retransmit_interval=CAPWAP_RETRANSMIT_INTERVAL;
-	conn->max_retransmit=CAPWAP_MAX_RETRANSMIT;
-	conn->wait_dtls=CAPWAP_WAIT_DTLS;
-	conn->wait_join=CAPWAP_WAIT_JOIN;
-	conn->mtu_discovery=1;
-//	conn->capwap_mode = 0;
-	conn->strict_capwap=1;
-
-
-
-	conn->process_packet=conn_process_packet;
-	conn->process_message=process_message;
-/*
-	conn->write_header = write_header;
-	conn->header_len = header_len;
-*/
-
-}
-
-

src/cw/conn_process_packet.c

@@ -1,680 +0,0 @@
-/*
-    This file is part of libcapwap.
-
-    libcapwap is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    libcapwap is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
-
-*/
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-
-#include "cw.h"
-#include "dbg.h"
-
-#include "log.h"
-#include "cw_util.h"
-
-#include "conn.h"
-#include "sock.h"
-
-/*#include "stravltree.h"*/
-#include "mod.h"
-#include "msgset.h"
-
-#include "val.h"
-
-
-
-
-
-
-/**
- * Init response message header
- */
-void cw_init_response(struct cw_Conn *conn, uint8_t * req)
-{
-	uint8_t *buffer;
-	int shbytes, dhbytes;
-	uint8_t *msgptr, *dmsgptr;
-
-	buffer = conn->resp_buffer;
-	shbytes = cw_get_hdr_msg_offset(req);
-
-	memcpy(buffer, req, shbytes);
-
-	cw_set_hdr_rmac(buffer, conn->base_rmac);
-/*
-//      cw_set_hdr_hlen(buffer, 2);
-//      cw_set_hdr_flags(buffer, CW_FLAG_HDR_M, 1);
-*/
-
-	dhbytes = cw_get_hdr_msg_offset(buffer);
-
-	msgptr = req + shbytes;
-	dmsgptr = buffer + dhbytes;
-
-	cw_set_msg_type(dmsgptr, cw_get_msg_type(msgptr) + 1);
-	cw_set_msg_seqnum(dmsgptr, cw_get_msg_seqnum(msgptr));
-	cw_set_msg_flags(dmsgptr, 0);
-}
-
-void cw_init_request(struct cw_Conn *conn, int msg_id)
-{
-	uint8_t *buffer = conn->req_buffer;
-	uint8_t *msgptr;
-
-	/* zero the first 8 bytes */
-	cw_set_dword(buffer + 0, 0);
-	cw_set_dword(buffer + 4, 0);
-
-	/* unencrypted */
-	cw_set_hdr_preamble(buffer, CAPWAP_VERSION << 4 | 0);
-
-	cw_set_hdr_rmac(buffer, conn->base_rmac);
-/*
-	//cw_set_hdr_hlen(buffer, 2);
-*/
-
-
-	cw_set_hdr_wbid(buffer, conn->wbid);
-	cw_set_hdr_rid(buffer, 0);
-
-
-	msgptr = cw_get_hdr_msg_offset(buffer) + buffer;
-	cw_set_msg_type(msgptr, msg_id);
-	cw_set_msg_flags(msgptr, 0);
-	cw_set_msg_elems_len(msgptr, 0);
-}
-
-void cw_init_data_msg(struct cw_Conn *conn)
-{
-	uint8_t *buffer = conn->req_buffer;
-	cw_set_dword(buffer + 0, 0);
-	cw_set_dword(buffer + 4, 0);
-
-	/* unencrypted */
-	cw_set_hdr_preamble(buffer, CAPWAP_VERSION << 4 | 0);
-
-
-
-}
-
-
-/**
- * send a response 
- */
-int cw_send_response(struct cw_Conn *conn, uint8_t * rawmsg, int len)
-{
-	int rc;
-	cw_init_response(conn, rawmsg);
-	rc = cw_assemble_message(conn, conn->resp_buffer);
-	if (!cw_result_is_ok(rc))
-		return 0;
-	conn_send_msg(conn, conn->resp_buffer);
-	return 1;
-}
-
-
-
-/**
- * Special case error message, which is sent when an unexpected messages 
- * was received or something else happened.
- * @param conn conection
- * @param rawmsg the received request message, which the response belongs to
- * @param result_code result code to send
- * @return 1
- */
-int cw_send_error_response(struct cw_Conn *conn, uint8_t * rawmsg,
-			   uint32_t result_code)
-{
-	uint8_t *out, *dst;
-	int l;
-
-	cw_init_response(conn, rawmsg);
-
-	out = conn->resp_buffer;
-
-	dst = cw_get_hdr_msg_elems_ptr(out);
-	l = cw_put_elem_result_code(dst, result_code);
-
-	cw_set_msg_elems_len(out + cw_get_hdr_msg_offset(out), l);
-
-	conn_send_msg(conn, conn->resp_buffer);
-
-	return 1;
-}
-
-
-static struct cw_MsgSet *load_msg_set(struct cw_Conn *conn, uint8_t * rawmsg,
-				      int len, int elems_len,
-				      struct sockaddr *from)
-{
-	char sock_buf[SOCK_ADDR_BUFSIZE];
-	struct cw_Mod *cmod, *bmod;
-
-	cmod =
-	    cw_mod_detect(conn, rawmsg, len, elems_len, from,
-			  CW_MOD_MODE_CAPWAP);
-	if (cmod == MOD_NULL) {
-		cw_dbg(DBG_MSG_ERR,
-		       "Can't find mod to handle connection from %s, discarding message",
-		       sock_addr2str_p(from, sock_buf));
-		return NULL;
-	}
-
-	bmod =
-	    cw_mod_detect(conn, rawmsg, len, elems_len, from,
-			  CW_MOD_MODE_BINDINGS);
-
-
-	cw_dbg(DBG_INFO, "Mods deteced: %s,%s", cmod->name, bmod->name);
-
-	conn->cmod = cmod;
-	conn->bmod = bmod;
-
-	return cw_mod_get_msg_set(conn, cmod, bmod);
-
-}
-
-/*
-int cw_in_check_generic(struct cw_Conn *conn, struct cw_action_in *a, uint8_t * data,
-			 int len,struct sockaddr *from)
-{
-//	if (cw_is_request(a->msg_id)){
-//		return cw_in_check_generic_req(conn,a,data,len,from);
-//	}
-//	return cw_in_check_generic_resp(conn,a,data,len,from);
-
-	
-}
-*/
-
-/*
-void cw_read_elem(struct cw_ElemHandler * handler, struct cw_Conn * conn, 
-		uint8_t * elem_data, int elem_len, struct sockaddr * from){
-	mavldata_t data, *result;
-	char str[30];
-		
-	result = handler->type->get(&data,elem_data,elem_len);
-	
-	handler->type->to_str(result,str,30);
-	printf("Read %d-%s: %s %s\n", handler->id, handler->name, handler->key, str);
-	//mavl_insert(conn->remote_cfg
-}
-*/
-
-
-static int process_elements(struct cw_Conn *conn, uint8_t * rawmsg, int len,
-			    struct sockaddr *from)
-{
-	mavl_t mand_found;
-	mlist_t unrecognized;
-	struct cw_MsgData search;
-	struct cw_MsgData *message;
-	int result_code;
-	cw_State_t *ui;
-
-	uint8_t *elems_ptr;
-	uint8_t *elem;
-	struct cw_ElemHandlerParams params;
-
-	char sock_buf[SOCK_ADDR_BUFSIZE]; /**< to hold str from sockaddr2str */
-
-	/*struct cw_action_in as, *af, *afm; */
-
-	int offset = cw_get_hdr_msg_offset(rawmsg);
-
-	uint8_t *msg_ptr = rawmsg + offset;
-
-	int elems_len = cw_get_msg_elems_len(msg_ptr);
-
-	int payloadlen = len - offset;
-
-
-	/* pre-check message */
-	if (payloadlen - 8 != elems_len) {
-
-		if (conn->strict_hdr) {
-			cw_dbg(DBG_MSG_ERR,
-			       "Discarding message from %s, msgelems len=%d, payload len=%d, (Strict CAPWAP) ",
-			       sock_addr2str(&conn->addr, sock_buf), elems_len,
-			       payloadlen - 8);
-			errno = EAGAIN;
-			return -1;
-		}
-
-
-		if (elems_len < payloadlen - 8) {
-			cw_dbg(DBG_RFC,
-			       "Packet from from %s has %d bytes of extra data, ignoring.",
-			       sock_addr2str(&conn->addr, sock_buf),
-			       payloadlen - 8 - elems_len);
-			elems_len = len - 8;
-		}
-
-		if (elems_len > payloadlen - 8) {
-
-			cw_dbg(DBG_RFC,
-			       "Packet from from %s has msgelems len of %d bytes, but has only %d bytes of data, truncating.",
-			       sock_addr2str(&conn->addr, sock_buf), elems_len,
-			       payloadlen - 8);
-			elems_len = payloadlen - 8;
-		}
-	}
-
-
-	/* Detect the connecting WTP type */
-	if (!conn->detected) {
-
-		struct cw_MsgSet *set =
-		    load_msg_set(conn, rawmsg, len, elems_len, from);
-		if (!set) {
-/*
-			//cw_log(LOG_ERR, "Error");
-*/
-			errno = EAGAIN;
-			return -1;
-		}
-		conn->cmod->setup_cfg(conn);
-		conn->msgset = set;
-		conn->detected = 1;
-
-		if (conn->setup_complete)
-			conn->setup_complete(conn);
-
-	}
-
-	/** debug the received message */
-	cw_dbg_msg(DBG_MSG_IN, conn, rawmsg, len, from);
-
-	/* prepare struct for search operation */
-	search.type = cw_get_msg_id(msg_ptr);
-
-	/* Search message */
-
-	message = mavl_get(conn->msgset->msgdata, &search);
-
-	result_code = 0;
-
-	if (!message) {
-		/* Message is unknown */
-		if (search.type & 1) {
-			cw_dbg(DBG_MSG_ERR,
-			       "Message type %d [%s] unrecognized, sending response.",
-			       search.type, cw_strmsg(search.type),
-			       cw_strstate(conn->capwap_state));
-
-			result_code = CAPWAP_RESULT_MSG_UNRECOGNIZED;
-			cw_send_error_response(conn, rawmsg, result_code);
-			errno = EAGAIN;
-			return -1;
-		}
-		cw_dbg(DBG_MSG_ERR,
-		       "Message type %d [%s] unrecognized, discarding.",
-		       search.type, cw_strmsg(search.type),
-		       cw_strstate(conn->capwap_state));
-		errno = EAGAIN;
-		return -1;
-
-	}
-
-	/* Throw away unexpected messages */
-	/* maybe we have to check this too: if (!(message->type & 1)) 
-	 * means unexpected response message
-	 * */
-	if (!(message->receiver & conn->role)) {
-		cw_dbg(DBG_MSG_ERR,
-		       "Message type %d (%s) unexpected/illegal in %s State, discarding.",
-		       search.type, cw_strmsg(search.type),
-		       cw_strstate(conn->capwap_state));
-		errno = EAGAIN;
-		return -1;
-	}
-
-	/* Check if current state is in state of message */
-	ui = message->states;
-
-	for (ui = message->states; ui->state; ui++) {
-/*		printf("Comparing %d and %d\n", conn->capwap_state, ui->state);*/
-		if (ui->state == conn->capwap_state) {
-			break;
-		}
-	}
-
-	if (!ui->state) {
-		/* Message found, but it was in wrong state */
-		cw_dbg(DBG_MSG_ERR,
-		       "Message type %d (%s) not allowed in %s State, sending response.",
-		       search.type, cw_strmsg(search.type),
-		       cw_strstate(conn->capwap_state));
-		result_code = CAPWAP_RESULT_MSG_INVALID_IN_CURRENT_STATE;
-		cw_send_error_response(conn, rawmsg, result_code);
-		errno = EAGAIN;
-		return -1;
-	}
-
-
-
-
-	elems_ptr = cw_get_msg_elems_ptr(msg_ptr);
-
-
-
-	mand_found = mavl_create_conststr();
-	unrecognized = mlist_create(NULL, NULL, sizeof(uint8_t *));
-	
-
-
-
-	cw_dbg(DBG_MSG_PARSING, "*** Parsing message of type %d - (%s) ***",
-	       message->type, message->name);
-
-	params.cfg = cw_cfg_create(); //conn->remote_cfg;
-	params.default_cfg = NULL;
-	params.from = from;
-	params.msgdata = message;
-	params.mand_found = mand_found;
-	params.msgset=conn->msgset;
-	params.conn = conn;
-
-	cw_decode_elements(&params,elems_ptr, elems_len);
-
-	/* all message elements are processed, do now after processing
-	   by calling the "end" function for the message */
-
-	cw_check_missing_mand(message, mand_found);
-
-	cw_dbg(DBG_MSG_PARSING, " *** End parsing message of type %d (%s) ***",
-	       message->type, message->name);
-
-
-	mavl_destroy(mand_found);
-
-/*	cw_dbg_ktv_dump(conn->remote_cfg,DBG_CFG_DMP,
-		" *** Remote CFG dump ***", "CFG:", " *** End of remote CFG dump");
-*/
-
-	cw_MsgCallbackFun cb_fun = cw_conn_get_msg_cb(conn,message->type);
-	if (cb_fun != NULL){
-		cb_fun(&params,elems_ptr, elems_len);
-	}
-
-
-	if (message->postprocess) {
-//		message->postprocess(conn);
-		message->postprocess(&params,elems_ptr, elems_len);
-	}
-
-
-	/* if we've got a request message, we always have to send a response message */
-	if (message->type & 1) {
-		if (result_code > 0) {
-			/* the end method gave us an result code>0, so
-			   send an error message */
-
-			cw_send_error_response(conn, rawmsg, result_code);
-		} else if (result_code == 0) {
-			cw_ktv_set_dword(conn->local_cfg, "result-code",
-					 result_code);
-			if (ui->next) {
-				conn->capwap_prevstate = conn->capwap_state;
-				conn->capwap_state = ui->next;
-			}
-
-			/* All is ok, send regular response message */
-			cw_send_response(conn, rawmsg, len);
-		} else {
-			/* the request message is ignored, no response
-			   will be sent */
-			errno = EAGAIN;
-		}
-	} else {
-		/* 
-		 * Whe have got a response message.
-		 * Put further actions here, if needed.
-		 */
-	}
-
-
-	return result_code;
-
-}
-
-
-
-
-
-
-int process_message(struct cw_Conn *conn, uint8_t * rawmsg, int rawlen,
-		    struct sockaddr *from)
-{
-	char sock_buf[SOCK_ADDR_BUFSIZE];
-	uint8_t seqnum;
-	int s1, s2, sd;
-
-	uint8_t *msgptr = rawmsg + cw_get_hdr_msg_offset(rawmsg);
-
-
-	uint32_t type = cw_get_msg_type(msgptr);
-
-	if (!(type & 0x1)) {
-		/* It's a response  message, no further examination required. */
-		return process_elements(conn, rawmsg, rawlen, from);
-	}
-
-	/* It's a request message, check if seqnum is right and if
-	 * we have already sent a response message*/
-
-	seqnum = cw_get_msg_seqnum(msgptr);
-
-	s1 = conn->last_seqnum_received;
-	s2 = seqnum;
-	sd = s2 - s1;
-
-	if ((sd > 0 && sd < 128) || (sd < 0 && sd < -128) || s1 < 0) {
-		/* seqnum is ok, normal message processing */
-		conn->last_seqnum_received = seqnum;
-
-		return process_elements(conn, rawmsg, rawlen, from);
-	}
-
-	if (sd != 0) {
-		cw_dbg(DBG_MSG_ERR,
-		       "Discarding message from %s, old seqnum, seqnum = %d, last seqnum=%d",
-		       sock_addr2str(&conn->addr, sock_buf), s2, s1);
-		errno = EAGAIN;
-		return -1;
-	}
-
-	/* the received request message was retransmittet by our peer,
-	 * let's retransmit our response message if we have one*/
-
-
-	cw_dbg(DBG_MSG_ERR,
-	       "Retransmitted request message from %s detected, seqnum=%d, type=%d",
-	       sock_addr2str(&conn->addr, sock_buf), s2, type);
-
-
-	if (cw_get_hdr_msg_type(conn->resp_buffer) - 1 != type) {
-/*		cw_dbg(DBG_MSG_ERR,
-		       "No cached response for retransmission, request seqnum=%d,in cache=%d",
-		       s2, conn->resp_msg.type);*/
-		errno = EAGAIN;
-		return -1;
-	}
-
-	cw_dbg(DBG_MSG_ERR, "Retransmitting response message to %s, seqnum=%d",
-	       sock_addr2str(&conn->addr, sock_buf), s2);
-
-	/*// XXX untested */
-	conn_send_msg(conn, conn->resp_buffer);
-	errno = EAGAIN;
-	return -1;
-}
-
-
-/*
- * Process an incomming CAPWAP packet, assuming the packet is already decrypted
- * @param conn conection object 
- * @param packet pointer to packet data
- * @param len lenght of packet data
- */
-int conn_process_packet2(struct cw_Conn *conn, uint8_t * packet, int len,
-			 struct sockaddr *from)
-{
-	char sock_buf[SOCK_ADDR_BUFSIZE];
-	int preamble;
-	int offs;
-	int payloadlen;
-
-	if (len < 8) {
-		/* packet too short */
-		cw_dbg(DBG_PKT_ERR,
-		       "Discarding packet from %s, packet too short, len=%d,  at least 8 expected.",
-		       sock_addr2str(&conn->addr, sock_buf), len);
-		errno = EAGAIN;
-		return -1;
-	}
-
-	preamble = cw_get_hdr_preamble(packet);
-
-	if ((preamble & 0xf0) != (CAPWAP_VERSION << 4)) {
-		/* wrong version */
-		cw_dbg(DBG_PKT_ERR,
-		       "Discarding packet from %s, wrong version, version=%d, version %d expected.",
-		       sock_addr2str(&conn->addr, sock_buf),
-		       (preamble & 0xf0) >> 4, CAPWAP_VERSION);
-		errno = EAGAIN;
-		return -1;
-	}
-
-	if (preamble & 0xf) {
-		/* Encrypted data, this shuold never happen here */
-		cw_dbg(DBG_PKT_ERR,
-		       "Discarding packet from %s, encrypted data after decryption ...",
-		       sock_addr2str(&conn->addr, sock_buf));
-		errno = EAGAIN;
-		return -1;
-	}
-
-
-	offs = cw_get_hdr_msg_offset(packet);
-
-
-	payloadlen = len - offs;
-	if (payloadlen < 0) {
-		/* Eleminate messages with wrong header size */
-		cw_dbg(DBG_PKT_ERR,
-		       "Discarding packet from %s, header length (%d) greater than packet len (%d).",
-		       sock_addr2str(&conn->addr, sock_buf), offs, len);
-		errno = EAGAIN;
-		return -1;
-	}
-
-	/* Check if Radio MAC is present */
-	if (cw_get_hdr_flag_m(packet)) {
-
-		if (cw_get_hdr_rmac_len(packet) + 8 > offs) {
-			/* wrong rmac size */
-			cw_dbg(DBG_PKT_ERR,
-			       "Discarding packet from %s, wrong R-MAC size, size=%d",
-			       sock_addr2str(&conn->addr, sock_buf),
-			       *(packet + 8));
-			errno = EAGAIN;
-			return -1;
-		}
-
-	}
-
-
-	if (cw_get_hdr_flag_f(packet)) {
-		/* fragmented, add the packet to fragman */
-		uint8_t *f;
-		int rc;
-
-		f = fragman_add(conn->fragman, packet, offs, payloadlen);
-		if (f == NULL) {
-			errno = EAGAIN;
-			return -1;
-		}
-
-
-		cw_dbg_pkt(DBG_PKT_IN, conn, f + 4, *(uint32_t *) f, from);
-/*//		cw_dbg_msg(DBG_MSG_IN, conn, f + 4, *(uint32_t *) f, from);*/
-
-/*		// XXX: Modify fragman to not throw away CAPWAP headers*/
-
-		rc = conn->process_message(conn, f + 4, *(uint32_t *) f, from);
-
-		free(f);
-		return rc;
-	}
-
-	/* not fragmented, we have a complete message */
-/*//	cw_dbg_msg(DBG_MSG_IN, conn, packet, len, from);*/
-	return conn->process_message(conn, packet, len, from);
-}
-
-int conn_process_packet(struct cw_Conn *conn, uint8_t * packet, int len,
-			struct sockaddr *from)
-{
-
-	/* show this packet in debug output */
-	cw_dbg_pkt(DBG_PKT_IN, conn, packet, len, from);
-
-	return conn_process_packet2(conn, packet, len, from);
-}
-
-
-int conn_process_data_packet(struct cw_Conn *conn, uint8_t * packet, int len,
-			     struct sockaddr *from)
-{
-
-	/* show this packet in debug output */
-	cw_dbg_pkt(DBG_PKT_IN, conn, packet, len, from);
-
-	return conn_process_packet2(conn, packet, len, from);
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-/**
- * Used as main message loop
- */
-int cw_read_messages(struct cw_Conn *conn)
-{
-	uint8_t buf[2024];
-	int len = 2024;
-
-	int n = conn->read(conn, buf, len);
-	if (n < 0)
-		return n;
-
-	if (n > 0) {
-		return conn->process_packet(conn, buf, n,
-					    (struct sockaddr *) &conn->addr);
-	}
-	errno = EAGAIN;
-	return -1;
-}

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

@@ -3,7 +3,7 @@
 #include "dbg.h"
 
 #define CW_MODE_ZYXEL 7
-extern cw_send_msg(struct cw_Conn * conn,uint8_t * msg);
+extern int cw_send_msg(struct cw_Conn * conn,uint8_t * msg);
 
 int conn_send_msg(struct cw_Conn * conn, uint8_t *rawmsg)
 {
@@ -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
@@ -34,7 +71,7 @@ mtu = 9440;
 	mtu = mtu >> 3;
 	mtu = mtu << 3;
 	
-	printf("packetlenX = %d (%d)\n",packetlen,hlen);
+//	printf("packetlenX = %d (%d)\n",packetlen,hlen);
 	 int offset = cw_get_hdr_msg_offset(rawmsg);
 	return cw_send_msg(conn,rawmsg+offset);
 

src/cw/cw.c

@@ -0,0 +1,272 @@
+#include "cw.h"
+#include "log.h"
+#include "dbg.h"
+#include "keys.h"
+
+int cw_in_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
+		uint8_t * elem_data, int elem_len)
+{
+	cw_Type_t * type;
+	type = (cw_Type_t*)handler->type;
+	char mkey[CW_CFG_MAX_KEY_LEN];
+	const char *key;
+
+
+
+	if (!type){
+		cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
+		return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
+	}
+
+	if (handler->mkkey != NULL){
+		handler->mkkey(handler->key,elem_data,elem_len, mkey);
+		key = mkey;
+	}
+	else{
+		key = handler->key;
+	}
+
+
+	
+
+/*	cw_dbg(DBG_X, "READ: %s / %s",type->name,key);*/
+	type->read(params->cfg, key,elem_data,elem_len,handler->param);
+	return CAPWAP_RESULT_SUCCESS;
+}
+
+
+
+int cw_out_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
+			, uint8_t * dst)
+{
+
+	int start, len, l;
+	
+//	cw_dbg(DBG_X,"cw_out_generic (%s)%s",((struct cw_Type*)handler->type)->name,handler->key);
+
+//	cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
+//	cw_cfg_dump(params->cfg);
+//	cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!! ENDDUMP");
+
+	start = params->msgset->header_len(handler);
+	len = ((const cw_Type_t*)(handler->type))->
+		write(params->cfg_list,handler->key,dst+start,handler->param);
+//	cw_dbg(DBG_X, "Type result is %d",len);
+
+	if (len == -1) {
+		const char *vendor="";
+		if ( handler->vendor ) {
+			vendor=cw_strvendor(handler->vendor);
+		}
+		if ( params->elemdata->mand) {
+			cw_log(LOG_ERR,
+			       "Can't put mandatory element %s %d-(%s) into %s. No value for '%s' found.",
+				vendor, handler->id, handler->name, params->msgdata->name
+			       , handler->key
+			    );
+		}
+		else{
+/*			cw_dbg(DBG_WARN,"No output for element %s%d -(%s) in %s. Item %s not found.",
+				vendor,
+			       a->elem_id, cw_strelemp(conn->actions, a->elem_id)
+			       , cw_strmsg(a->msg_id),a->item_id);
+*/
+		}
+
+		return 0;
+	} 
+
+	l = params->msgset->write_header(handler,dst,len);
+
+	return l;
+}
+
+
+
+int cw_in_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
+		uint8_t * elem_data, int elem_len)
+{
+	char key[CW_CFG_MAX_KEY_LEN];
+	int radio;
+	struct cw_Type *type;
+	type = (struct cw_Type*)handler->type;
+
+	if (!type){
+		cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
+		return CAPWAP_RESULT_UNRECOGNIZED_MESSAGE_ELEMENT;
+	}
+
+	
+	
+	radio=cw_get_byte(elem_data);
+	sprintf(key,"radio.%d/%s",radio,handler->key);
+	
+	/*cw_cfg_set_val(params->cfg, key, 
+				handler->type, handler->param, elem_data+1,elem_len-1);*/
+	
+	type->read(params->cfg, key,elem_data+1,elem_len-1,handler->param);
+	return CAPWAP_RESULT_SUCCESS;	
+}
+
+int cw_out_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
+			, uint8_t * dst)
+{
+	char key[CW_CFG_MAX_KEY_LEN];
+	struct cw_Type * type;
+
+	int len,i,l,start;
+	int radios;
+	len =0;
+	
+	radios = cw_cfg_get_byte_l(params->cfg_list,"capwap/wtp-descriptor/max-radios",0);
+	for(i=0;i<radios;i++){
+
+		type = (struct cw_Type*)handler->type;
+		start = params->msgset->header_len(handler)+len;
+
+		sprintf(key,"radio.%d/%s",i,handler->key);
+//printf("RADIO KEY: %s\n",key);
+		
+//		cw_dbg(DBG_X,"KEY: %s",key);
+
+		l = type->write(params->cfg_list, key,dst+start+1,handler->param);
+		if (l==-1)
+			continue;
+
+		l += cw_put_byte(dst+start,i);
+
+		l = params->msgset->write_header(handler,dst+len,l);
+		len+=l;
+
+	}
+	return len;
+}
+
+
+int cw_write_header(struct cw_ElemHandler * handler, uint8_t * dst, int len)
+{
+	if (handler->vendor)
+		return len + cw_put_elem_vendor_hdr(dst, handler->vendor, handler->id, len);
+
+	return  len + cw_put_elem_hdr(dst, handler->id, len);
+}
+
+
+
+int cw_header_len(struct cw_ElemHandler * handler)
+{
+	return handler->vendor ? 10 : 4;
+}
+
+
+
+/**
+ * Put the "status part" of an an AC Descriptor to memory
+ * @param cfg_list Cfg list to read status from
+ * @param dst Where to put the status to
+ * @param parent_key prefix to each key
+ */
+int 
+cw_put_ac_status(uint8_t *dst, cw_Cfg_t ** cfg_list, const char * parent_key){
+
+	uint8_t *d = dst;
+	
+	char key[CW_CFG_MAX_KEY_LEN];
+	
+	/* put statiosn */
+	sprintf(key,"%s/%s",parent_key,"stations");
+	d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
+
+	/* put station limit */
+	sprintf(key,"%s/%s",parent_key,"station-limit");
+	d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
+
+	/* Put number of active WTPs */
+	sprintf(key,"%s/%s",parent_key,"active-wtps");
+	d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
+
+	/* Put max WTPs */
+	sprintf(key,"%s/%s",parent_key,"max-wtps");
+	d += cw_put_word(d,cw_cfg_get_word_l(cfg_list,key,0));
+
+	/* Put security flags */	
+	sprintf(key,"%s/%s",parent_key,"security");
+	d += cw_put_byte(d,cw_cfg_get_byte_l(cfg_list,key,0));
+
+	/* Put rmac-filed */
+	sprintf(key,"%s/%s",parent_key,"rmac-field");
+	d += cw_put_byte(d,cw_cfg_get_byte_l(cfg_list,key,0));
+	
+	/* reserved field, must be zero - RFC5415 */
+	d += cw_put_byte(d,0); 
+
+	sprintf(key,"%s/%s",parent_key,"dtls-policy");
+	d += cw_put_byte(d,cw_cfg_get_byte_l(cfg_list,key,0));
+
+	return d - dst;
+}
+
+/** 
+ * Put a descripter sub element like harware vendor/version etc.
+ * Used when putting AC Descriptors or WTP Descriptors
+ * @param dst Where to write to
+ * @param cfg_list list of cfgs
+ * @subelem_id Id of subelement
+ * @parent_key parent key
+ */
+int 
+cw_put_descriptor_subelem (uint8_t *dst, cw_Cfg_t ** cfg_list,
+                                 int subelem_id, const char * parent_key )
+{
+	char key[256];
+	uint32_t vendor;
+	//bstr16_t version;
+	const char *vendor_s;
+
+	uint8_t *d;
+
+
+	/*        d += cw_put_dword(d, bstrv_get_vendor_id(v));
+	d += cw_put_dword(d, (subelem_id << 16) | bstrv_len(v));
+	d += cw_put_data(d, bstrv_data(v), bstrv_len(v));
+	*/
+	sprintf (key, "%s/%s", parent_key, CW_SKEY_VENDOR);
+	vendor_s = cw_cfg_get_l (cfg_list, key, NULL);
+	
+	if (vendor_s == NULL) {
+		cw_log (LOG_ERR, "Can't put subelem %s, no value of type Dword found.", key);
+		return 0;
+	}
+
+	vendor = atoi(vendor_s);	
+
+
+
+	sprintf (key, "%s/%s", parent_key, CW_SKEY_VERSION);
+	cw_Val_t * val = cw_cfg_get_val_l(cfg_list, key, CW_TYPE_BSTR16);
+
+	//version = cw_cfg_get_bstr16 (cfg, key, NULL);
+
+
+	if (val == NULL) {
+		cw_log (LOG_ERR, "Can't put subelem %s, no value of type Bstr16 found.", key);
+		return 0;
+	}
+	
+	d = dst;
+	
+	/* put vendor */
+	d += cw_put_dword(d, vendor); //->type->put (vendor, d);
+	
+	/* put version */
+	
+	d += cw_put_dword (d, (subelem_id << 16) | val->type->len(val));
+//	d += cw_put_bstr16(d, version);
+	d += val->type->put(val,d);
+
+	cw_val_destroy(val);
+
+//	free(version);
+	
+	return d-dst;
+}

src/cw/cw.h

@@ -348,11 +348,12 @@ struct cw_DescriptorSubelemDef {
 
 
 
-int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys );
+//int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys );
+int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys, mavl_t handlers_by_key );
 
 
 
-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);
 
 /*
@@ -361,30 +362,30 @@ 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);
 
-int cw_write_descriptor_subelem (uint8_t *dst, mavl_t ktvstore,
+int cw_write_descriptor_subelem (uint8_t *dst, cw_Cfg_t ** cfg_list,
                                  int subelem_id, const char * parent_key);
 
 int cw_write_radio_element(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params, int idx,
 			 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);
 
 
 
@@ -550,6 +551,14 @@ int cw_stricmp(char const *a, char const *b);
 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

@@ -3,12 +3,15 @@
 #include "dbg.h"
 #include "log.h"
 
-int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys )
+int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys, mavl_t handlers_by_key )
 {
 	mlistelem_t * elem;
 	char *mandkey, *result;
 	mlist_t missing;
 	int count;
+
+	if (msgdata==NULL)
+		return 0;
 	
 	missing = mlist_create_conststr();
 	if (missing==NULL){
@@ -26,7 +29,22 @@ int cw_check_missing_mand(struct cw_MsgData *msgdata, mavl_t keys )
 	}
 	
 	mlist_foreach(elem,missing){
-		cw_dbg(DBG_RFC,"     Missing mandatory message element: %s", mlistelem_get_str(elem));
+		const char * str;
+		struct cw_ElemHandler search, *result;
+
+		str = mlistelem_get_str(elem);
+
+		search.key = str;
+		result = mavl_get(handlers_by_key,&search);
+		if (result == NULL){
+			cw_log(LOG_ERR,"Can't find handler for for key %s",str);
+		} 
+		else {
+			cw_dbg(DBG_RFC,"Missing mandatory message element: %s: %d - %s", 
+					str,result->id, result->name);
+		}
+
+
 	}
 
 	count = missing->count;

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_decode_msg.c

@@ -1,127 +0,0 @@
-#include "cw.h"
-#include "dbg.h"
-#include "log.h"
-#include "msgset.h"
-
-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;
-	elem_data = mavl_get(params->msgdata->elements_tree, &elem_data_search);
-	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) {
-		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;
-	}
-
-	cw_dbg_elem(DBG_ELEM_IN, 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){
-			mlist_append(unrecognized,&elem);
-			continue;
-		}
-		
-		if (rc < 0 ){
-			continue;
-		}
-
-	}
-
-	mavl_destroy(mand_found);
-	mlist_destroy(unrecognized);
-	return 0;
-}

src/cw/cw_in_check_disc_req.c

@@ -1,43 +0,0 @@
-
-#include "capwap.h"
-
-
-#include "intavltree.h"
-#include "log.h"
-#include "dbg.h"
-#include "sock.h"
-
-int cw_in_check_disc_req(struct conn *conn, struct cw_action_in *a, uint8_t * data,
-			 int len,struct sockaddr *from)
-{
-/*	
-	char sock_buf[SOCK_ADDR_BUFSIZE];
-
-	cw_action_in_t *mlist[120];
-	int n = cw_check_missing_mand(mlist, conn, a);
-
-	conn->capwap_state = CW_STATE_NONE;
-
-
-	if (n && conn->strict_capwap) {
-		cw_dbg_missing_mand(DBG_MSG_ERR, conn, mlist, n, a);
-		// if mandatory elements are missing, in strict 
-		   // mode send no discovery response 
-		cw_dbg(DBG_MSG_ERR,
-		       "Ignoring Discovery Request from %s - missing mandatory elements.",
-		       sock_addr2str(from,sock_buf));
-		return -1;
-	}
-
-	if ( n ) {
-		// put a warning here 
-		cw_dbg_missing_mand(DBG_RFC, conn, mlist, n, a);
-	}
-
-		
-
-	// ok, send response 
-	conn->capwap_state = CAPWAP_STATE_JOIN;
-*/
-	return 0;
-}

src/cw/cw_in_check_join_req.c

@@ -1,44 +0,0 @@
-
-#include "capwap.h"
-#include "intavltree.h"
-#include "dbg.h"
-#include "log.h"
-
-#include "format.h"
-#include "connlist.h"
-
-int cw_in_check_join_req(struct conn *conn, struct cw_action_in *a, uint8_t * data,
-			 int len,struct sockaddr *from)
-{
-/*
-	cw_action_in_t * mlist[60];
-
-	//Check for mandatory elements 
-	int n = cw_check_missing_mand(mlist,conn,a);
-	if (n) {
-		if ( conn->strict_capwap ){
-			cw_dbg_missing_mand(DBG_MSG_ERR,conn,mlist,n,a);
-			conn->capwap_state=CAPWAP_STATE_JOIN;
-			return CW_RESULT_MISSING_MAND_ELEM;
-		}
-		cw_dbg_missing_mand(DBG_RFC,conn,mlist,n,a);
-	}
-
-	connlist_lock(conn->connlist);
-	struct conn *cc = connlist_get_by_session_id(conn->connlist,conn);
-	if (!cc){
-		connlist_add_by_session_id(conn->connlist,conn);
-	}
-	connlist_unlock(conn->connlist);
-	if (cc){
-		cw_dbg(DBG_ELEM_ERR,"Session already in use %s",format_bin2hex(conn->session_id,16));
-		conn->capwap_state=CAPWAP_STATE_JOIN;
-		return CW_RESULT_JOIN_FAILURE_SESSION_ALREADY_IN_USE;
-	}
-	
-	// set result code to ok and change to configure state 
-	mbag_set_dword(conn->outgoing,CW_ITEM_RESULT_CODE,0);
-	conn->capwap_state = CW_STATE_CONFIGURE;
-*/
-	return 0;
-}

src/cw/cw_in_check_join_resp.c

@@ -1,47 +0,0 @@
-
-#include <errno.h>
-
-#include "capwap.h"
-#include "intavltree.h"
-#include "dbg.h"
-#include "log.h"
-
-
-int cw_in_check_join_resp(struct conn *conn, struct cw_action_in *a, uint8_t * data,
-			 int len,struct sockaddr *from)
-{
-/*
-	cw_action_in_t * mlist[60];
-
-	mbag_item_t * jresult = mbag_get(conn->incomming,CW_ITEM_RESULT_CODE);
-	if  (jresult ) {
-		if (!cw_result_is_ok(jresult->u2.dword)){
-			return jresult->u2.dword;
-		}
-	}
-
-
-	// Check for mandatory elements 
-	int n = cw_check_missing_mand(mlist,conn,a);
-	if (n && conn->strict_capwap) {
-		cw_dbg_missing_mand(DBG_MSG_ERR,conn,mlist,n,a);
-		conn->capwap_state=CAPWAP_STATE_JOIN;
-		errno=EAGAIN;
-		return -1; //CW_RESULT_MISSING_MAND_ELEM;
-	}
-	if (n){
-		cw_dbg_missing_mand(DBG_RFC,conn,mlist,n,a);
-	}
-
-	
-
-
-	if ( jresult ) {
-		return jresult->u2.dword;
-	}
-
-	// set result code to ok and change to configure state 
-//	mbag_set_dword(conn->outgoing,CW_ITEM_RESULT_CODE,0);
-*/
-	return 0;
-}

src/cw/cw_in_generic.c

@@ -10,7 +10,7 @@ int cw_in_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams *
 {
 	cw_Type_t * type;
 	type = (cw_Type_t*)handler->type;
-	char mkey[CW_KTV_MAX_KEY_LEN];
+	char mkey[CW_CFG_MAX_KEY_LEN];
 	const char *key;
 
 

src/cw/cw_in_generic_enum.c

@@ -17,7 +17,7 @@ int cw_in_generic_enum(struct cw_ElemHandler * handler, struct cw_ElemHandlerPar
 {
 	int val;
 	const cw_ValEnum_t * e;
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	struct cw_ElemHandler thandler;
 	
 	val = cw_get_byte(elem_data+1);

src/cw/cw_in_generic_struct.c

@@ -10,8 +10,8 @@ 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;
-	char tmpkey[CW_KTV_MAX_KEY_LEN];
+/*	const char * key;
+	char tmpkey[CW_CFG_MAX_KEY_LEN];
 
 	
 	if (handler->mkkey != NULL){
@@ -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

@@ -5,14 +5,13 @@ int cw_in_generic_with_index(struct cw_ElemHandler *eh,
 		struct cw_ElemHandlerParams *params, 
 			uint8_t * data,	 int len)
 {
-	char key[CW_KTV_MAX_KEY_LEN];
+	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_in_idx_generic_struct.c

@@ -10,12 +10,12 @@
 int cw_in_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params,
 		uint8_t * elem_data, int elem_len)
 {
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	int idx;
 
 
 	cw_dbg(DBG_X,"Fix cw_in_idx_generic_struct");
-	exit(1);
+	stop();
 	
 	if (!handler->type){
 		cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);

src/cw/cw_in_radio_generic_struct.c

@@ -13,7 +13,7 @@ int cw_in_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHa
 
 	stop();
 
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	int radio;
 	
 	if (!handler->type){

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_del_sub.c

@@ -1,22 +0,0 @@
-
-
-#include "val.h"
-
-void cw_ktv_del_sub(mavl_t ktvstore, const char *basekey)
-{
-	cw_Val_t * result, search;
-
-	
-	while (1){
-		search.key=(char*)basekey;
-		result = mavl_get_first(ktvstore,&search);
-	
-		if (result == NULL)
-			return;
-	
-		if (strncmp(result->key,basekey,strlen(basekey))!=0)
-			break;
-		search.key = result->key;
-		mavl_del(ktvstore,&search);
-	}
-}

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,125 +0,0 @@
-#include "val.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_KTV_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_KTV_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"
-
-
-int cw_ktv_read_file(FILE * file, mavl_t ktv, mavl_t types)
-{
-	char key[CW_KTV_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,61 +0,0 @@
-#include "val.h"
-#include "dbg.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_KTV_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,304 +0,0 @@
-#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 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_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;
-}

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,76 +0,0 @@
-#include "val.h"
-#include "dbg.h"
-#include "log.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_KTV_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.c

@@ -1,55 +0,0 @@
-
-#include "cw.h"
-
-
-#include "dbg.h"
-#include "log.h"
-#include "msgset.h"
-#include "val.h"
-
-
-int cw_out_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
-			, uint8_t * dst)
-{
-
-	int start, len, l;
-
-//	cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
-//	cw_cfg_dump(params->cfg);
-//	cw_dbg(DBG_X,"Generic out!!!!!!!!!!!!!!!!!!!!!!!!!!!! ENDDUMP");
-
-	start = params->msgset->header_len(handler);
-	len = ((const cw_Type_t*)(handler->type))->
-		write(params->cfg,handler->key,dst+start,handler->param);
-
-
-	if (len == -1) {
-		const char *vendor="";
-		if ( handler->vendor ) {
-			vendor=cw_strvendor(handler->vendor);
-		}
-		if ( params->elemdata->mand) {
-			cw_log(LOG_ERR,
-			       "Can't put mandatory element %s %d-(%s) into %s. No value for '%s' found.",
-				vendor, handler->id, handler->name, params->msgdata->name
-			       , handler->key
-			    );
-		}
-		else{
-/*			cw_dbg(DBG_WARN,"No output for element %s%d -(%s) in %s. Item %s not found.",
-				vendor,
-			       a->elem_id, cw_strelemp(conn->actions, a->elem_id)
-			       , cw_strmsg(a->msg_id),a->item_id);
-*/
-		}
-		return 0;
-	} 
-
-	l = params->msgset->write_header(handler,dst,len);
-
-	return l;
-}
-
-
-
-

src/cw/cw_out_generic_indexed_enum.c

@@ -1,17 +1,18 @@
 #include "cw.h"
 #include"dbg.h"
+#include "cfg.h"
 
 
 int cw_out_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
 			, uint8_t * dst)
 {
-	cw_dbg(DBG_X,"Fix: cw_out_generic_indexed_enum");
-	exit(1);
+//	cw_dbg(DBG_X,"Fix: cw_out_generic_indexed_enum %s",handler->key);
+//	stop();
 
 
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	int i;
-	cw_Val_t * result;
+//	cw_Val_t * result;
 	int len,start;
 	uint8_t * ob;
 	const cw_ValIndexed_t *ie;
@@ -26,32 +27,42 @@ int cw_out_generic_indexed_enum(struct cw_ElemHandler * handler, struct cw_ElemH
 	e = ie->type;
 	
 	for(i=0; e[i].name!=NULL; i++) {
+		int b;
 		sprintf(key,"%s/%s",handler->key,e[i].name);
 
-//printf("Her is the Key: %s - %s\n",key, );
+cw_dbg(DBG_X,"Her is the Key: %s %s\n",key,e[i].name);
 
-		result = cw_ktv_base_exists(params->cfg,key);
-		if (result==NULL)
+		b = cw_cfg_base_exists_l(params->cfg_list,handler->key);
+		if (!b){
+			stop();
 			continue;
+		}
 		start = params->msgset->header_len(handler);
 		len = 0;
 		if (ie->idxpos==0)
 			len = 1;
 	
-		if (e[i].fun_out==NULL)
-			len += result->type->put(result,ob+start+len);
-		else
-			len += cw_ktv_write_struct(params->cfg,
-			NULL,e[i].type,key,ob+start+len);
+		if (e[i].fun_out==NULL){
+			stop();
+//			result = 			
+//			len += result->type->put(result,ob+start+len);
+		}
+		else{
+			len += ((cw_Type_t*)e[i].type)->write(params->cfg_list,key,ob+start+len,e[i].param);
+//			len += cw_ktv_write_struct(params->cfg,
+//			NULL,e[i].type,key,ob+start+len);
+		}
 			
 		cw_set_byte(ob+start+ie->idxpos,e[i].value);
 		if (ie->idxpos==len)
 			len++;
 
 		ob += params->msgset->write_header(handler,ob,len);
-		
+	//	cw_val_destroy(result);
 	}
 
 	return ob-dst;
+	
+	return 0;
 
 }

src/cw/cw_out_generic_struct.c

@@ -10,6 +10,7 @@
 int cw_out_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
 			, uint8_t * dst)
 {
+	cw_dbg(DBG_X,"Key: %s",handler->key);
 	stop();
 
 
@@ -39,7 +40,7 @@ int cw_out_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandler
 	start = params->msgset->header_len(handler);
 
 	len = cw_ktv_write_struct(params->cfg,
-		params->default_cfg,
+		params->cfg,
 		handler->type,handler->key,dst+start);
 	
 	return params->msgset->write_header(handler,dst,len);

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_KTV_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 {
-		sprintf(key,"%s.%d",eh->key,idx);
-		search.key=key;
-		result = mavl_get_first(params->cfg,&search);
-		if (result==NULL)
-			break;
-		if (strncmp(result->key,key,strlen(key))!=0)
-			break;
-	
+	cw_cfg_iter_init(params->cfg_list[0], &cfi, eh->key);
+	for (i=0; (e = cw_cfg_iter_next(&cfi, NULL)) != NULL; i++){
 		start = params->msgset->header_len(eh);
-		len = cw_put_byte(ob+start,idx);
-		
-		len += result->type->put(result,ob+start+len);
+		len = cw_put_byte(ob+start,i);
+
+		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;
+	
 }
 

src/cw/cw_out_idx_generic_struct.c

@@ -8,7 +8,7 @@ int cw_out_idx_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHan
 
 	stop();
 
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	struct cw_Val * elem, search;
 	int i;
 	int idx, sr;

src/cw/cw_out_radio_generic.c

@@ -1,34 +0,0 @@
-
-#include "cw.h"
-#include "dbg.h"
-
-int cw_ktv_idx_get_next(mavl_t ktv, const char *key, int n);
-
-int cw_out_radio_generic(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
-			, uint8_t * dst)
-{
-	stop();
-
-	int len,i,l;
-	int radios;
-	len =0;
-	
-/*	int idx=0;*/
-	
-/*	while(1){
-		char key[CW_KTV_MAX_KEY_LEN];
-		sprintf(key,"radio.%d",idx);
-		idx = cw_ktv_idx_get_next(params->conn->local_cfg,key,idx);
-		idx++;
-	}
-*/	
-	radios = cw_ktv_get_byte(params->cfg,"wtp-descriptor/max-radios",0);
-
-	for(i=0;i<radios;i++){
-		l = cw_write_radio_element(handler,params,i,dst+len);
-		cw_dbg_elem(DBG_ELEM_OUT,NULL,params->msgdata->type,handler,dst,l);
-		len+=l;
-	}
-	return len;
-}
-

src/cw/cw_out_radio_generic_struct.c

@@ -7,8 +7,9 @@ int cw_ktv_idx_get_next(mavl_t ktv, const char *key, int n);
 int cw_out_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
 			, uint8_t * dst)
 {
+	cw_dbg(DBG_X,"KEY: %s",handler->key);
 	stop();
-
+/*
 	int i,l, offset;
 
 	uint8_t * cdst;
@@ -20,7 +21,7 @@ int cw_out_radio_generic_struct(struct cw_ElemHandler * handler, struct cw_ElemH
 
 	i=-1;
 	while(1){
-		char basekey[CW_KTV_MAX_KEY_LEN];
+		char basekey[CW_CFG_MAX_KEY_LEN];
 		cw_Val_t * result;
 		
 		i = cw_ktv_idx_get_next(params->cfg,"radio",i+1);
@@ -51,7 +52,7 @@ int cw_out_traverse0(struct cw_ElemHandler * handler, struct cw_ElemHandlerParam
 {
 	char *sl;
 	int l;
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	int len;
 	len = 0;
 
@@ -70,7 +71,7 @@ printf("Next: %s\n", next);
 			for (i=0;i<stack[0];i++){
 				printf("I=%i\n",stack[i+1]);
 			}
-			l= cw_ktv_write_struct(params->cfg,params->default_cfg, 
+			l= cw_ktv_write_struct(params->cfg,params->cfg, 
 				handler->type,key,dst+offset);
 			
 			printf("Write struct len %i\n",l);
@@ -101,7 +102,7 @@ printf("current is %s\n", current);
 	cw_dbg_ktv_dump(params->cfg,DBG_INFO,"start"," ", "end" );
 	i=-1;
 	while(1){
-		char basekey[CW_KTV_MAX_KEY_LEN];
+		char basekey[CW_CFG_MAX_KEY_LEN];
 		cw_Val_t * result;
 		
 		i = cw_ktv_idx_get_next(params->cfg,key,i+1);
@@ -123,6 +124,8 @@ printf("current is %s\n", current);
 
 
 	return len;
+	*/
+	return 0;
 }
 
 int cw_out_traverse(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
@@ -130,14 +133,15 @@ int cw_out_traverse(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams
 
 {
 
-	char current[CW_KTV_MAX_KEY_LEN];
-	int stack[10];
-	stack[0]=0;
-
-	current[0]=0;
+	//char current[CW_CFG_MAX_KEY_LEN];
+	//int stack[10];
+	//stack[0]=0;
 
+	//current[0]=0;
 
+	stop();
+	return 0;
 	
-	return cw_out_traverse0(handler,params,dst,-1,current,handler->key, stack);
+//	return cw_out_traverse0(handler,params,dst,-1,current,handler->key, stack);
 }
 

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, 
@@ -33,7 +33,6 @@ int cw_read_ac_descriptor(mavl_t store,
 {
 
 	CW_TYPE_STRUCT->read(params->cfg,eh->key,data,len,acstatus);
-//	cw_ktv_read_struct(params->remote_cfg,acstatus,eh->key,data,len);
 
 	if (!allowed)
 		allowed=allowed_default;

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_radio_generic.c

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

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)
 {
@@ -38,11 +38,13 @@ int cw_read_wtp_descriptor(mavl_t cfg, struct cw_Conn *conn,
 		       "Non standard conform WTP Descriptor, number of encryptoin elements is 0.");
 	}
 
-	sprintf(key,"%s/%s",eh->key, CW_SKEY_MAX_RADIOS);
-	cw_ktv_add(cfg,key,CW_TYPE_BYTE,NULL,data,1);
+	sprintf(key,"%s/%s",eh->key, "max-radios");
+//	cw_ktv_add(cfg,key,CW_TYPE_BYTE,NULL,data,1);
+	CW_TYPE_BYTE->read(cfg,key,data,1,eh->param);
 
 	sprintf(key,"%s/%s",eh->key, CW_SKEY_RADIOS_IN_USE);
-	cw_ktv_add(cfg,key,CW_TYPE_BYTE,NULL,data+1,1);
+//	cw_ktv_add(cfg,key,CW_TYPE_BYTE,NULL,data+1,1);
+	CW_TYPE_BYTE->read(cfg,key,data,1,eh->param);
 
 
 

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)
 {
@@ -29,7 +29,7 @@ int cw_read_wtp_descriptor_7(mavl_t cfg, struct cw_Conn *conn,
 	int pos;
 	char key[64];
 
-	sprintf(key,"%s/%s",eh->key, CW_SKEY_MAX_RADIOS);
+	sprintf(key,"%s/%s",eh->key, "max-radios");
 	cw_cfg_set_int(cfg,key,cw_get_byte(data));
 
 	sprintf(key,"%s/%s",eh->key, CW_SKEY_RADIOS_IN_USE);

src/cw/cw_setup_dtls.c

@@ -7,10 +7,11 @@
 static int get_psk(struct cw_Conn *conn, const char *username, uint8_t ** psk,
 		   unsigned int *len)
 {
-	char key[CW_KTV_MAX_KEY_LEN];
+	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);
@@ -36,11 +37,11 @@ static int get_psk(struct cw_Conn *conn, const char *username, uint8_t ** psk,
  * @param default_cipher
  * @return 
  */
-int cw_setup_dtls(struct cw_Conn *conn, mavl_t cfg, const char *prefix,
+int cw_setup_dtls(struct cw_Conn *conn, cw_Cfg_t * cfg, const char *prefix,
 		  char *default_cipher)
 {
-	char key[CW_KTV_MAX_KEY_LEN];
-	char *ssl_cert, *ssl_key;
+	char key[CW_CFG_MAX_KEY_LEN];
+	const char *ssl_cert, *ssl_key;
 	uint8_t security;
 
 	security = 0;
@@ -49,10 +50,10 @@ int cw_setup_dtls(struct cw_Conn *conn, mavl_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_type_bool.c

@@ -101,6 +101,11 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
 	return l;
 }
 
+static 	int bwrite(cw_Cfg_t ** cfgs, const char *key, uint8_t *dst, const void * param)
+{
+	return cw_generic_write_l(cfgs,CW_TYPE_BOOL,key,dst,param);
+}
+
 
 
 const struct cw_Type cw_type_bool = {
@@ -114,5 +119,6 @@ const struct cw_Type cw_type_bool = {
 	data,			/* data */ 
 	get_type_name,		/* get_type_name */
 	NULL,
-	bread
+	bread,
+	bwrite
 };

src/cw/cw_type_bstr16.c

@@ -21,6 +21,7 @@
 #include "format.h"
 #include "cw.h"
 #include "val.h"
+#include "dbg.h"
 
 
 static void del ( struct cw_Val * data )
@@ -163,11 +164,11 @@ static int xput(uint8_t * dst,const char *s)
 
 
 
-static 	int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param)
+static 	int bwrite(cw_Cfg_t **cfg, const char *key, uint8_t *dst, const void * param)
 {
 	const char *s;
 
-	s = cw_cfg_get(cfg,key,NULL);
+	s = cw_cfg_get_l(cfg,key,NULL);
 	if (s==NULL)
 		return -1;
 	return xput(dst,s);

src/cw/cw_type_byte.c

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

src/cw/cw_type_dword.c

@@ -68,6 +68,8 @@ static int cast(cw_Val_t * data)
 
 static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
 {
+
+
 	uint32_t val;
 	//cw_ValValRange_t * valrange = (cw_ValValRange_t *) param;
 	//const char *str;
@@ -83,10 +85,11 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
 }
 
 
-static 	int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * param)
+static 	int bwrite(cw_Cfg_t **cfgs, const char *key, uint8_t *dst, const void * param)
 {
+	return cw_generic_write_l(cfgs,CW_TYPE_DWORD,key,dst,param);
 
-	cw_Val_t val;
+/*	cw_Val_t val;
 	int l;
 	const char *s;
 	memset(&val,0,sizeof(cw_Val_t));
@@ -98,7 +101,7 @@ static 	int bwrite(cw_Cfg_t *cfg, const char *key, uint8_t *dst, const void * pa
 	l = put(&val,dst);
 	if(val.type->del)
 		val.type->del(&val);
-	return l;
+	return l;*/
 }
 
 

src/cw/cw_type_ipaddress.c

@@ -127,6 +127,11 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
 	return rc;
 }
 
+static 	int bwrite(cw_Cfg_t ** cfgs, const char *key, uint8_t *dst, const void * param)
+{
+	return cw_generic_write_l(cfgs,CW_TYPE_IPADDRESS,key,dst,param);
+}
+
 
 
 const struct cw_Type cw_type_ipaddress = {
@@ -141,6 +146,7 @@ const struct cw_Type cw_type_ipaddress = {
 	get_type_name,
 	NULL,
 	bread,
+	bwrite,
 	
 };
 

src/cw/cw_type_str.c

@@ -105,6 +105,10 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
 	return l;
 }
 
+static 	int bwrite(cw_Cfg_t ** cfgs, const char *key, uint8_t *dst, const void * param)
+{
+	return cw_generic_write_l(cfgs,CW_TYPE_STR,key,dst,param);
+}
 
 
 const struct cw_Type cw_type_str = {
@@ -119,6 +123,8 @@ const struct cw_Type cw_type_str = {
 	get_type_name,	/* get_type_name */
 	NULL,
 	bread,
+	bwrite,
+
 
 
 };

src/cw/cw_type_struct.c

@@ -1,11 +1,13 @@
 #include "cw.h"
 #include "val.h"
+#include "dbg.h"
+#include "log.h"
 
 
 static int read_struct(cw_Cfg_t * cfg,const cw_ValStruct_t * stru, const char *pkey, 
 	const uint8_t * data, int len)
 {
-	char key[CW_KTV_MAX_KEY_LEN];
+	char key[CW_CFG_MAX_KEY_LEN];
 	int pos, i,l;
 	
 	
@@ -43,10 +45,7 @@ static int read_struct(cw_Cfg_t * cfg,const cw_ValStruct_t * stru, const char *p
 
 		l=stru[i].type->read(cfg,key,data+pos,l,stru[i].valguard);
 
-//		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){
@@ -75,6 +74,112 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
 }
 
 
+static int write_struct(cw_Cfg_t ** cfgs,  const cw_ValStruct_t * stru, const char *pkey, 
+	uint8_t * dst)
+{
+	char key[CW_CFG_MAX_KEY_LEN];
+	int pos, i;
+	const char * result;
+	int wrlen;
+
+	cw_Val_t val;
+	memset(&val,0,sizeof(cw_Val_t));
+	
+	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);
+
+		result = cw_cfg_get_l(cfgs,key,NULL);
+		if(result) {
+//			char s[2048];
+//			result->type->to_str(result,s,2048);
+//			printf("Content: '%s'\n",s);
+		}	
+
+		
+		if (result == NULL){
+			cw_log(LOG_ERR,"Can't put %s, no value found, filling wth zeros.",key);
+			memset(dst+pos,0,stru[i].len);
+		}
+		else{
+			struct cw_Type * type;
+			type = (struct cw_Type *)stru[i].type;
+			wrlen = type->write(cfgs,key,dst+pos,stru[i].valguard);
+
+
+/*			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);
+			}
+		
+			result->type->put(result,dst+pos);*/
+		}
+		if (stru[i].len!=-1)
+			pos+=stru[i].len;
+		else	
+			pos+=wrlen; //result->type->len(result);
+
+	}
+
+	return pos;
+}
+
+
+
+
+static 	int bwrite(cw_Cfg_t **cfgs, const char *key, uint8_t *dst, const void * param)
+{
+	return write_struct(cfgs,param,key,dst);
+
+	stop();
+
+/*
+	int start;
+	int len;
+	cw_Val_t search;
+	const char *result;
+
+	if (!handler->type){
+		cw_log(LOG_ERR,"Can't handle element: %s, no type defined",handler->name);
+		return 0;
+	}
+	
+	search.key = (char*)handler->key;
+	result = mavl_get_first(params->cfg,&search);
+	if (result == NULL ){
+		if (params->elemdata->mand)
+			cw_log(LOG_ERR,"Can't put mandatory message element %s, no data available",handler->name);
+		return 0;
+	}
+	
+	if (strncmp(result->key,handler->key, strlen(handler->key))!=0){
+		if (params->elemdata->mand)
+			cw_log(LOG_ERR,"Can't put mandatory message element %s, no data available",handler->name);
+		return 0;
+	}
+
+	start = params->msgset->header_len(handler);
+
+	len = cw_ktv_write_struct(params->cfg,
+		params->cfg,
+		handler->type,handler->key,dst+start);
+	
+	return params->msgset->write_header(handler,dst,len);
+*/
+	
+}
+
 
 
 
@@ -90,6 +195,6 @@ const struct cw_Type cw_type_struct = {
 	NULL,			/* get_type_name */
 	NULL,
 	bread,
-	NULL
+	bwrite
 
 };