Removed libwifi dependencies

src/ac/Makefile

@@ -9,6 +9,7 @@ OBJS = \
 	discovery_cache.o\
 	rpc.o\
 	statemachine.o\
+	#hapd.o
 
 ACTOBJS = \
 	act.o 
@@ -26,8 +27,9 @@ LIBS+=-lnettle
 LIBS+=-lssl
 LIBS+=-lcrypto
 LIBS+=-ledit
+#LIBS+=-l:libhapd.a
 
-INCL_DIRS=-I../ -I/usr/local/include -I./ -I../../include
+INCL_DIRS=-I../ -I/usr/local/include -I./ -I../../include -I../../include/hostapd -I../../include/hostapd/utils
 #FLAGS=-DWITH_IPV6 -DWITH_OPENSSL -DSYS_ARCH="$(ARCH)" -DSYS_ARCH="XXX"
 FLAGS=-DWITH_IPV6 -DUSE_OPENSSL -DSYS_ARCH='"$(KERNEL)/$(ARCH)"'
 

src/ac/ac.h

@@ -20,6 +20,7 @@ enum {
 int start_rpc(cw_Cfg_t *global_cfg);
 int test_shell();
 
+void hapd_run();
 
 #endif
 

src/ac/ac_main.c

@@ -211,6 +211,7 @@ return 0;
 */
 
 static cw_Cfg_t * global_cfg = NULL;
+void process_wtp_packet (int index, struct sockaddr *addr, uint8_t * buffer, int len, int dta);
 
 
 int main (int argc, char *argv[])
@@ -236,6 +237,8 @@ int main (int argc, char *argv[])
 		goto errX;
 	};
 
+//hapd_run(); // init
+//stop();
 //const char *ttt = cw_cfg_get(global_cfg,"cisco/ssl-cipher",NULL);
 //printf("CFG: %s\n",ttt);
 //stop();
@@ -455,7 +458,7 @@ int ac_run(cw_Cfg_t * cfg)
 				                        (struct sockaddr *) &srcaddr,
 				                        &srcaddrlen);
 				                        
-				process_cw_data_packet (i, (struct sockaddr *) &srcaddr, buffer, len);
+				process_wtp_packet (i, (struct sockaddr *) &srcaddr, buffer, len,1);
 				
 			}
 			
@@ -468,7 +471,7 @@ int ac_run(cw_Cfg_t * cfg)
 				                        (struct sockaddr *) &srcaddr,
 				                        &srcaddrlen);
 				                        
-				process_ctrl_packet (i, (struct sockaddr *) &srcaddr, buffer, len);
+				process_wtp_packet (i, (struct sockaddr *) &srcaddr, buffer, len,0);
 			}
 			
 		}
@@ -482,14 +485,14 @@ int ac_run(cw_Cfg_t * cfg)
 void process_cw_data_packet (int index, struct sockaddr *addr, uint8_t * buffer, int len)
 {
 	char sock_buf[SOCK_ADDR_BUFSIZE];
-	cw_dbg (DBG_X, "There is a data packet now");
+//	cw_dbg (DBG_X, "There is a data packet now");
 	
 	dataman_list_lock();
-	cw_dbg (DBG_X, "Dataman list locked, now getting");
+//	cw_dbg (DBG_X, "Dataman list locked, now getting");
 	struct dataman * dm = dataman_list_get (socklist[index].data_sockfd, addr);
-	cw_dbg (DBG_X, "Dataman list locked, now gotted");
+//	cw_dbg (DBG_X, "Dataman list locked, now gotted");
 	
-	cw_dbg (DBG_INFO, "Packet for dataman %s,%d", sock_addr2str_p (addr, sock_buf), socklist[index].data_sockfd);
+//	cw_dbg (DBG_INFO, "Packet for dataman %s,%d", sock_addr2str_p (addr, sock_buf), socklist[index].data_sockfd);
 	
 	if (!dm) {
 		cw_dbg (DBG_INFO, "No dataman %s,%d", sock_addr2str_p (addr, sock_buf), socklist[index].data_sockfd);
@@ -501,15 +504,12 @@ void process_cw_data_packet (int index, struct sockaddr *addr, uint8_t * buffer,
 		}
 		
 		dataman_list_add (dm);
-		
 		dataman_start (dm);
-		
-		
 	}
 	
 	dataman_list_unlock();
 	
-	//dataman_add_packet (dm, buffer, len);
+	dataman_add_packet (dm, buffer, len);
 	
 	return;
 	
@@ -532,7 +532,7 @@ void process_cw_data_packet (int index, struct sockaddr *addr, uint8_t * buffer,
 }
 
 
-void process_cw_ctrl_packet (int index, struct sockaddr *addr, uint8_t * buffer, int len)
+void process_wtp_packet (int index, struct sockaddr *addr, uint8_t * buffer, int len, int dta)
 {
 	char sock_buf[SOCK_ADDR_BUFSIZE];
 	
@@ -552,6 +552,10 @@ void process_cw_ctrl_packet (int index, struct sockaddr *addr, uint8_t * buffer,
 
 
 	if (!wtpman) {
+		if (dta){
+			cw_dbg(DBG_PKT_ERR,"Data packet w/o wtpman received, ignoring");
+			return;
+		}
 	
 		wtpman = wtpman_create (index, addr, preamble & 0xf, global_cfg);
 		
@@ -573,9 +577,12 @@ void process_cw_ctrl_packet (int index, struct sockaddr *addr, uint8_t * buffer,
 		wtpman_start (wtpman, preamble & 0xf);
 	}
 	
-	//printf("Got Packet with len: %d\n",len);
-
+	if(!dta)
 		wtpman_addpacket (wtpman, buffer, len);
+	else{
+//		cw_dbg(DBG_X,"Data packet received");
+		wtpman_datapacket (wtpman, buffer, len);
+	}
 	wtplist_unlock();
 }
 
@@ -646,7 +653,7 @@ void process_ctrl_packet (int index, struct sockaddr *addr, uint8_t * buffer, in
 {
 	switch (socklist[index].ac_proto) {
 		case AC_PROTO_CAPWAP:
-			process_cw_ctrl_packet (index, addr, buffer, len);
+//			process_cw_ctrl_packet (index, addr, buffer, len);
 			return;
 			
 		/*case AC_PROTO_LWAPP:

src/ac/dataman.c

@@ -5,10 +5,12 @@
 #include "cw/timer.h"
 #include "cw/cw.h"
 #include "cw/format.h"
-#include "cw/netconn.h"
+#include "cw/conn.h"
 
 #include "cw/log.h"
 #include "cw/dbg.h"
+#include "cw/file.h"
+#include "cw/dot11.h"
 
 #include "wtplist.h"
 #include "dataman.h"
@@ -19,8 +21,8 @@ pthread_mutex_t dataman_list_mutex;
 
 static int cmp(const void *d1, const void *d2)
 {
-	struct netconn *nc1 = ((struct dataman *) d1)->nc;
-	struct netconn *nc2 = ((struct dataman *) d1)->nc;
+	struct cw_Conn *nc1 = ((struct dataman *) d1)->nc;
+	struct cw_Conn *nc2 = ((struct dataman *) d1)->nc;
 
 	int r = nc1->sock - nc2->sock;
 	if (r != 0)
@@ -52,7 +54,7 @@ void dataman_destroy(struct dataman *dm)
 {
 	if (!dm)
 		return;
-	netconn_destroy(dm->nc);
+	conn_destroy(dm->nc);
 }
 
 struct dataman *dataman_create(int sock, struct sockaddr *addr)
@@ -60,15 +62,15 @@ struct dataman *dataman_create(int sock, struct sockaddr *addr)
 	struct dataman *dm = malloc(sizeof(struct dataman));
 	if (!dm)
 		return NULL;
-
-	dm->nc = netconn_create(sock, addr, 100);
+	memset(dm,0,sizeof(struct dataman));
+	dm->nc = cw_conn_create(sock, addr, 100);
 	return dm;
 }
 
 
 struct dataman *dataman_list_get(int sock, struct sockaddr *addr)
 {
-	struct netconn search_nc;
+	struct cw_Conn search_nc;
 	struct dataman search_dm;
 
 	search_nc.sock = sock;
@@ -78,7 +80,7 @@ struct dataman *dataman_list_get(int sock, struct sockaddr *addr)
 
 	struct dataman *dm = mavl_get(dataman_list, &search_dm);
 
-	cw_dbg(DBG_X,"Getting dataman %p",dm); 
+//	cw_dbg(DBG_X,"Getting dataman %p",dm); 
 	return dm;
 }
 
@@ -91,7 +93,7 @@ struct dataman *dataman_list_add(struct dataman *dm)
 
 
 
-int dataman_process_keep_alive(struct netconn *nc, uint8_t *rawmsg, int len)
+int dataman_process_keep_alive(struct cw_Conn *nc, uint8_t *rawmsg, int len)
 {
 	struct dataman * dm = (struct dataman *)(nc->data);
 
@@ -133,7 +135,7 @@ int dataman_process_keep_alive(struct netconn *nc, uint8_t *rawmsg, int len)
 				printf("len len %d\n",l);
 				printf("Total len = %d\n",total_len);
 
-				netconn_send_capwap_msg(nc,buffer,total_len);
+				cw_send_msg(nc,buffer,total_len);
 				return len;
 					
 
@@ -167,26 +169,87 @@ int dataman_process_keep_alive(struct netconn *nc, uint8_t *rawmsg, int len)
 	return -1;	
 }
 
-int dataman_process_message0(struct netconn *nc, uint8_t * rawmsg, int len,
+
+int dataman_process_message0(struct cw_Conn *nc, uint8_t * rawmsg, int len,
 			struct sockaddr *from)
 {
+
+	static int c=0;
+	char fn[100];
+	sprintf(fn,"wificap-%03d",c++);
+///	cw_save_file(fn,(char*)rawmsg,len);
+///	cw_dbg(DBG_X,"saving %d bytes",len);
+	int offs =  cw_get_hdr_msg_offset(rawmsg);
+	int rc;
+	uint8_t * dot11frame = rawmsg + offs;
+	int dot11len = len-offs;
+
+//	cw_dbg(DBG_X,"802.11 - %s",dot11_get_frame_name(dot11frame));
+//	extern void ppacket(uint8_t * p, int len);
+
+	
+//	ppacket (dot11frame,len-cw_get_hdr_msg_offset(rawmsg));
+
+
+
+//	cw_dbg(DBG_X,"802.11 - %s",dot11_get_frame_name(dot11frame));
+//	cw_dbg(DBG_X,"802.11 - T&S: %d %d",dot11_get_type(dot11frame),dot11_get_subtype(dot11frame));
+
+
+//	cw_dbg(DBG_X,"Frame CTL:%d,%d",frame.frame_control.type, frame.frame_control.subtype);
+
+
+
+//	cw_dbg(DBG_X,"CMP???CTL:%d,%d (%d,%d)",frame.frame_control.type, frame.frame_control.subtype,
+//			TYPE_MANAGEMENT,SUBTYPE_ASSOC_REQ);
+	
+//	char ffr[1024];
+//	cw_format_dot11_hdr(ffr,dot11frame,dot11len);	
+//	cw_dbg(DBG_X,ffr);
+//
+//
+
+
+
+
+
+
+
+
+
+
+
+	
 	/* The very first data message MUST be a keep-alive message */
 	if (!cw_get_hdr_flag_k(rawmsg)){
+
+//		cw_dbg(DBG_X,"No K Flag founde");
 		errno = EAGAIN;
 		return -1;
 	}
 
+//	cw_dbg(DBG_X, "Goto Keep Alive Pack");
 	return dataman_process_keep_alive(nc,rawmsg,len);
 }
 
-int dataman_process_message(struct netconn *nc, uint8_t * rawmsg, int len,
+int dataman_process_message(struct cw_Conn *nc, uint8_t * rawmsg, int len,
 			struct sockaddr *from)
 {
 	if (cw_get_hdr_flag_k(rawmsg)){
 		return dataman_process_keep_alive(nc,rawmsg,len);
 	}
+	static int c=0;
+
+	char fn[100];
+	sprintf(fn,"wificap-%03d",c++);
+	cw_save_file(fn,(char*)rawmsg,len);
+
+	extern void ppacket(uint8_t * p, int len);
+
+//	ppacket (rawmsg,len);
 
 	cw_dbg(DBG_X,"There was someting else than dataman");
+
 	return 1;
 
 }
@@ -195,12 +258,22 @@ void dataman_run(struct dataman *dm)
 {
 	time_t timer = cw_timer_start(2);
 
-	dm->nc->process_packet=netconn_process_packet;
+	dm->nc->process_packet=conn_process_packet;
 	dm->nc->process_message=dataman_process_message0;
 	dm->nc->data = dm;
 
+
+	while (1){
+		time_t timer = cw_timer_start(2);
 		while (!cw_timer_timeout(timer)){
-		netconn_read_messages(dm->nc);
+			cw_read_messages(dm->nc);
+		}
+	}
+
+	
+
+	while (!cw_timer_timeout(timer)){
+		cw_read_messages(dm->nc);
 	}
 
 	if (!dm->wtpman){
@@ -215,7 +288,7 @@ void dataman_run(struct dataman *dm)
 	while (1){
 		time_t timer = cw_timer_start(2);
 		while (!cw_timer_timeout(timer)){
-			netconn_read_messages(dm->nc);
+			cw_read_messages(dm->nc);
 		}
 	}
 

src/ac/dataman.h

@@ -3,12 +3,11 @@
 
 #include <pthread.h>
 
-/*#include "cw/netconn.h"*/
 
 #include "wtpman.h"
 
 struct dataman {
-	struct netconn *nc;
+	struct cw_Conn *nc;
 	pthread_t thread;
 	struct wtpman * wtpman;
 
@@ -28,6 +27,6 @@ extern pthread_mutex_t dataman_list_mutex;
 #define dataman_list_lock() pthread_mutex_lock(&dataman_list_mutex)
 #define dataman_list_unlock() pthread_mutex_unlock(&dataman_list_mutex)
 
-#define dataman_add_packet(dm,data,len) (netconn_q_add_packet(dm->nc,data,len))
+#define dataman_add_packet(dm,data,len) (conn_q_add_packet(dm->nc,data,len))
 
 #endif

src/ac/wtpman.c

@@ -44,6 +44,8 @@
 
 #include "actube.h"
 
+#include "cw/dot11.h"
+
 
 static void wtpman_remove(struct wtpman *wtpman)
 {
@@ -310,6 +312,79 @@ int run_update(struct wtpman *wtpman)
 	return rc;
 }
 
+
+
+static int dataman_process_msg(struct cw_Conn *nc, uint8_t * rawmsg, int len,
+			struct sockaddr *from)
+{
+	char rframe[1000];
+	int offs =  cw_get_hdr_msg_offset(rawmsg);
+	uint8_t * frame = rawmsg + offs;
+	int frame_len = len-offs;
+	cw_dbg_dot11_frame(frame,frame_len);
+
+/*	dot11_init_assoc_resp(frame);
+
+	dot11_copy_mac(dot11_get_sa(dot11frame),dot11_get_da(frame));
+	dot11_copy_mac(dot11_get_bssid(dot11frame),dot11_get_bssid(frame));
+	dot11_copy_mac(dot11_get_da(dot11frame),dot11_get_sa(frame));
+	dot11_set_seq(frame,0);
+*/
+	if ( dot11_get_type_and_subtype(frame) == DOT11_ASSOC_REQ){
+		int l;
+		uint8_t rates[] = {
+			12,0x82,0x84,0x8b,0x96,0x0c,0x12,0x18,0x24,0x30,0x48,0x60,0x6c	
+		}; 
+		cw_dbg(DBG_X, "there is an assoc request!");
+
+		uint8_t  rframe[1000];
+		nc->mtu=800;
+
+
+        	dot11_init_assoc_resp(rframe);
+		dot11_set_duration(rframe,100);
+
+		dot11_copy_mac(dot11_get_sa(frame),dot11_get_da(rframe));
+		dot11_copy_mac(dot11_get_bssid(frame),dot11_get_bssid(rframe));
+		dot11_copy_mac(dot11_get_da(frame),dot11_get_sa(rframe));
+		dot11_set_seq(rframe,dot11_get_seq(frame));
+		dot11_assoc_resp_set_cap(rframe,dot11_assoc_req_get_cap(frame));
+		dot11_assoc_resp_set_status_code(rframe,0);
+		dot11_assoc_resp_set_assoc_id(rframe,17);
+		l=24+6;
+		l+=dot11_put_supported_rates(rframe+l,rates);
+		cw_dbg_dot11_frame(rframe,l);
+
+		uint8_t buf[1024];
+		int hlen;
+		hlen = cw_init_capwap_packet(buf,1,0,NULL,NULL);
+		cw_set_hdr_flags(buf, CAPWAP_FLAG_HDR_T, 1);
+		cw_send_capwap_packet(nc,buf,hlen,rframe,l);
+		
+	}
+	
+
+	return 0;
+}
+
+static void *wtpman_data_main(void *arg)
+{
+	struct wtpman * wtpman = arg;
+	struct cw_Conn * nc = wtpman->dconn;
+	nc->process_packet=conn_process_packet;
+	nc->process_message=dataman_process_msg;
+
+
+	while (1){
+		time_t timer = cw_timer_start(2);
+		while (!cw_timer_timeout(timer)){
+			cw_read_messages(nc);
+		}
+	}
+
+	
+}
+
 static void *wtpman_main(void *arg)
 {
 	//mavl_t r;
@@ -560,7 +635,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 {
 	struct sockaddr dbgaddr;
 	socklen_t dbgaddrl;
-	int sockfd, replyfd;
+	int sockfd, replyfd, data_sockfd,data_replyfd;
 	char sock_buf[SOCK_ADDR_BUFSIZE];
 
 	struct wtpman *wtpman;
@@ -574,6 +649,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 
 		int port = sock_getport(&socklist[socklistindex].addr);
 		replyfd = socklist_find_reply_socket(srcaddr, port);
+		data_replyfd=replyfd;
 
 		if (replyfd == -1) {
 			cw_log(LOG_ERR,
@@ -584,10 +660,11 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 		}
 	} else {
 		replyfd = socklist[socklistindex].sockfd;
+		data_replyfd = socklist[socklistindex].data_sockfd;
 	}
 
 	sockfd = replyfd;	/*//socklist[socklistindex].reply_sockfd; */
-
+	data_sockfd = data_replyfd;
 
 	dbgaddrl = sizeof(dbgaddr);
 	getsockname(sockfd, &dbgaddr, &dbgaddrl);
@@ -606,6 +683,15 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 		return NULL;
 	}
 
+	wtpman->dconn = cw_conn_create(data_sockfd, srcaddr, 100);
+	if (!wtpman->dconn) {
+		wtpman_destroy(wtpman);
+		return NULL;
+	}
+
+
+
+
 	cw_conn_register_msg_cb(wtpman->conn,
 		CAPWAP_MSG_DISCOVERY_REQUEST,
 		discovery_cb);
@@ -618,6 +704,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 
 	wtpman->conn->role = CW_ROLE_AC;
 	wtpman->conn->data=wtpman;
+	wtpman->dconn->data=wtpman;
 
 	wtpman->conn->cfg_list[0]=wtpman->conn->update_cfg;
 	wtpman->conn->cfg_list[1]=wtpman->conn->remote_cfg;
@@ -663,6 +750,8 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 			       cmod->name, bmod->name);
 			wtpman->conn->msgset =
 			    cw_mod_get_msg_set(wtpman->conn, cmod, bmod);
+
+			wtpman->dconn->msgset=wtpman->conn->msgset;
 			wtpman->conn->detected = 1;
 			cmod->setup_cfg(wtpman->conn);
 //	               if (wtpman->conn->setup_complete)
@@ -708,5 +797,14 @@ void wtpman_start(struct wtpman *wtpman, int dtlsmode)
 	cw_dbg(DBG_INFO, "Starting wtpman, DTLS mode = %d", dtlsmode);
 	wtpman->dtlsmode = dtlsmode;
 	pthread_create(&wtpman->thread, NULL, wtpman_main, (void *) wtpman);
+	pthread_create(&wtpman->thread, NULL, wtpman_data_main, (void *) wtpman);
 	return;
 }
+
+void wtpman_datapacket(struct wtpman *wtpman, uint8_t * packet, int len)
+{
+	conn_q_add_packet(wtpman->dconn, packet, len);
+}
+
+
+

src/ac/wtpman.h

@@ -17,6 +17,7 @@ struct wtpman {
 	pthread_t thread;
 
 	struct cw_Conn *conn;
+	struct cw_Conn *dconn;
 
 
 	/* wtp data */
@@ -67,6 +68,7 @@ struct wtpman *wtpman_create(int socklistindex, struct sockaddr *srcaddr,
 extern void wtpman_addpacket(struct wtpman *wtpman, uint8_t * packet, int len);
 extern void wtpman_destroy(struct wtpman *wtpman);
 extern void wtpman_start(struct wtpman *wtpman, int dtlsmode);
+void wtpman_datapacket(struct wtpman *wtpman, uint8_t * packet, int len);
 
 
 

src/contrib/install_hostapd.sh

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+wget https://w1.fi/releases/hostapd-2.10.tar.gz
+tar xzvf hostapd-2.10.tar.gz
+

src/cw/Makefile

@@ -6,7 +6,6 @@ CWSRC=\
 	cw.c\
 	cw_check_missing_mand.c\
 	cw_clock_lap.c\
-	cw_dbg_elem.c\
 	cw_filename.c\
 	cw_format_dump.c\
 	cw_format_pkt_hdr.c\
@@ -77,6 +76,7 @@ CWSRC=\
 	cw_in_radio_generic_struct.c\
 	cw_in_generic_struct.c\
 	cw_radio_set_admin_state.c\
+	cw_dbg_elem.c\
 
 KTVSRC=\
 	cfg.c\
@@ -171,7 +171,6 @@ MISCSRC=\
 	msgset.c\
 	send.c\
 	strheap.c\
-	netconn.c\
 	conn.c \
 	val.c \
 	discovery.c\
@@ -188,6 +187,7 @@ MISCSRC=\
 #	cw_put_msg.c\
 #	conn_process_packet.c\
 #	conn_destroy.c\
+	netconn.c\
 
 DTLSSRC+=\
 	dtls_bio.c\

src/cw/cfg.c

@@ -665,7 +665,13 @@ int cw_cfg_get_bool(cw_Cfg_t * cfg, const char * key, int def)
 	return v.val.boolean;
 }
 
+/*
+int cw_cfg_set_bool(cw_Cfg_t * cfg, const char * key, int val)
+{
+	return cw_cfg_set(cfg,key,val ? "true":"false");
+}
 
+*/
 uint8_t cw_cfg_get_byte(cw_Cfg_t * cfg, char *key, uint8_t def)
 {
 	struct cw_Val v;

src/cw/cfg.h

@@ -92,6 +92,8 @@ int cw_cfg_get_first_index_l(cw_Cfg_t ** cfgs, const char *key, int n);
 int cw_cfg_get_int(cw_Cfg_t * cfg, const char *key, int def);
 int cw_cfg_write_to_file(FILE *f, cw_Cfg_t * cfg);
 
+#define cw_cfg_set_bool(cfg,key,val) \
+		cw_cfg_set(cfg,key,(val) ? "true":"false")
 
 
 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

@@ -765,24 +765,22 @@ int conn_process_packet2(struct cw_Conn *conn, uint8_t * packet, int len,
 
 	if (cw_get_hdr_flag_f(packet)) {
 		/* fragmented, add the packet to fragman */
-		uint8_t *f;
+		uint8_t *f,*fp;
 		int rc;
 
-		f = fragman_add(conn->fragman, packet, offs, payloadlen);
-		if (f == NULL) {
+		fp = fragman_add(conn->fragman, packet, offs, payloadlen);
+		if (fp == NULL) {
 			errno = EAGAIN;
 			return -1;
 		}
 
+		f =fp+MAX_PKT_HDR_LEN;
 
-		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*/
+		cw_dbg_pkt(DBG_PKT_IN, conn, fp, *(uint32_t *) f+MAX_PKT_HDR_LEN, from);
 
 		rc = conn->process_message(conn, f + 4, *(uint32_t *) f, from);
 
-		free(f);
+		free(fp);
 		return rc;
 	}
 

src/cw/conn_send_msg.c

@@ -53,10 +53,10 @@ int conn_send_msg(struct cw_Conn * conn, uint8_t *rawmsg)
 
 
 
-	/* Zyxel doesn't count msg element length from
-	   behind seqnum */
+	//  Zyxel doesn't count msg element length from
+//	   behind seqnum * /
 //	if (conn->capwap_mode == CW_MODE_ZYXEL){
-/*		// XXX val-=3; */
+// *		// XXX val-=3; * /
 //	}
 
 
@@ -75,7 +75,7 @@ mtu = 9440;
 	 int offset = cw_get_hdr_msg_offset(rawmsg);
 	return cw_send_msg(conn,rawmsg+offset);
 
-
+/*
 	if (packetlen>mtu){
 		cw_set_hdr_flags(ptr,CAPWAP_FLAG_HDR_F,1);
 		cw_set_dword(ptr+4, conn->fragid<<16 | fragoffset<<3 );
@@ -122,6 +122,6 @@ mtu = 9440;
 
 	cw_dbg_pkt(DBG_PKT_OUT,conn,ptr,packetlen,(struct sockaddr*)&conn->addr);
 
-	return conn->write(conn,ptr,packetlen-0);
+	return conn->write(conn,ptr,packetlen-0); */
 }
 

src/cw/cw.h

@@ -146,8 +146,10 @@
 
 
 int cw_get_hdr_ws_len(uint8_t * th);
-uint8_t *cw_get_hdr_ws_data(uint8_t * th);
+int cw_get_hdr_ws_len_7(uint8_t * th);
 
+uint8_t *cw_get_hdr_ws_data(uint8_t * th);
+#define cw_get_hdr_ws_data_7(th) (cw_get_hdr_ws_data(th)+1)
 
 
 #define cw_get_hdr_msg_offset(th) (4*cw_get_hdr_hlen(th))
@@ -217,7 +219,7 @@ void cw_set_hdr_rid(uint8_t * th, int rid);
  * @see #cw_is_request
  */
 
-#define cw_is_response(msg_id) (!is_response(msg_id))
+#define cw_is_response(msg_id) (!cw_is_resquest(msg_id))
 
 
 uint8_t *cw_get_hdr_msg_elems_ptr(uint8_t * m);
@@ -563,6 +565,14 @@ int cw_out_generic_walk(struct cw_ElemHandler * handler, struct cw_ElemHandlerPa
 int cw_out_generic0(struct cw_ElemHandler * handler, struct cw_ElemHandlerParams * params
 			, uint8_t * dst,const char *key);
 
+
+
+
+int cw_init_capwap_packet( uint8_t * buf, int wbid ,int rid, bstr_t rmac, bstr_t wd);
+int cw_send_capwap_packet(struct cw_Conn * conn, uint8_t * buf, int hlen, uint8_t * data, int len);
+
+
+
 /**
  *@}
  */

src/cw/cw_80211.h

@@ -1,12 +0,0 @@
-#ifndef __CW_80211_H
-#define __CW_80211_H
-
-/*
-
-int cw_in_80211_mac_operation(struct conn *conn, struct cw_action_in *a, uint8_t * data,
-			 int len, struct sockaddr *from);
-
-int cw_read_80211_mac_operation(uint8_t *data,mbag_t r);
-*/
-
-#endif

src/cw/cw_format_pkt_hdr.c

@@ -3,105 +3,104 @@
 #include "conn.h"
 #include "cw.h"
 
-/**
- * @brief Format a packet header for debugging purposes
- * @param dst Destination buffer
- * @param incomming True if the packet is an incomming packet, otherweise 0
- * @param packet packet data
- * @param len length of packet data
- * @param from Address from where the packet was received
- * @return Number of bytes written
- */
-int cw_format_pkt_hdr(char *dst, int incomming, uint8_t * packet, int len,
-		      struct sockaddr *from)
+#include "dot11.h"
+
+int cw_format_dot11_fc_flags(char *dst, uint8_t *frame){
+	char *s = dst;
+	uint8_t f = frame[0];
+	s+=sprintf(s,"ToDS:%d ", f&1 ? 1:0);
+	s+=sprintf(s,"FromDS:%d ", f&2 ? 1:0);
+	s+=sprintf(s,"More Frgs:%d ", f&4 ? 1:0);
+	s+=sprintf(s,"Retry:%d ", f&8 ? 1:0);
+	s+=sprintf(s,"PwrMgmt:%d ", f&16 ? 1:0);
+	s+=sprintf(s,"More Dta:%d ", f&32 ? 1:0);
+	s+=sprintf(s,"Protec:%d ", f&64 ? 1:0);
+	s+=sprintf(s,"+HTC/:%d ", f&128 ? 1:0);
+	return s-dst;
+}
+
+
+int cw_format_dot11_rates(char *dst, const uint8_t *src, int len)
+{
+	int i;
+	char * k="";
+	char *s=dst;
+
+	for(i=0; i<len; i++){
+		int rate = src[i] &0x7f;
+		s+=sprintf(s,"%s%0.1f",k,dot11_rate2float(rate));
+		k=", ";
+	}
+	return s-dst;
+}
+
+
+int cw_format_dot11_elem(char *dst, uint8_t id, const uint8_t *src, int len)
+{
+	char *s = dst;
+	s += sprintf(s,"elem(id=%d) ",id);
+
+
+	switch(id){
+		case DOT11_ELEM_SSID:
+			s+=sprintf(s," ssid: %.*s",len,src);
+			break;
+		case DOT11_ELEM_SUPPORTED_RATES:
+			s+=sprintf(s," Supported Rates:");
+			s+=cw_format_dot11_rates(s,src,len);
+			break;
+		case DOT11_ELEM_EXTENDED_SUPPORTED_RATES:
+			s+=sprintf(s," Extended Supported Rates");
+			break;
+		case DOT11_ELEM_POWER_CAPABILITY:
+			s+=sprintf(s," Power Capability");
+			break;
+		case DOT11_ELEM_SUPPORTED_CHANNELS:
+			s+=sprintf(s," Supported Channels");
+			break;
+		case DOT11_ELEM_SUPPORTED_OPERATING_CLASSES:
+			s+=sprintf(s," Supported Operating Classes");
+			break;
+		case DOT11_ELEM_VENDOR_SPECIFIC:
+			s+=sprintf(s," Vendor Specific");
+			break;
+	default:
+			break;
+	}
+	s+=sprintf(s,", len=%d",len);
+	return s-dst;
+}
+
+
+int cw_format_dot11_hdr(char * dst, uint8_t * packet, int len)
 {
-	char sock_buf[SOCK_ADDR_BUFSIZE]; 
-	int preamble;
 	char *s;
-	int hlen, rid, wbid;
-	int frag_id,frag_offs;
+	int type = dot11_get_type_and_subtype(packet);
 
 	s=dst;
 
-	if (incomming){
-		if (cw_get_hdr_flag_f(packet)) {
-			s += sprintf(s, "Fragment from %s",
-				     sock_addr2str_p(from,sock_buf));
-		} else {
-			s += sprintf(s, "From %s", sock_addr2str_p(from,sock_buf));
-		}
-	}
-	else{
-		if (cw_get_hdr_flag_f(packet)) {
-			s += sprintf(s, "Fragment to %s", sock_addr2str(from,sock_buf));
-		} else {
-			s += sprintf(s, "To %s", sock_addr2str(from,sock_buf));
-		}
-	}
-	s += sprintf(s, " l=%d: ", len);
+	s+=sprintf(s,"IEEE 802.11 - %s",dot11_get_frame_name(packet));
+	s+=sprintf(s," da:");
+	s+=format_mac(s,dot11_get_da(packet),6);	
+	s+=sprintf(s," sa:");
+	s+=format_mac(s,dot11_get_sa(packet),6);	
+	s+=sprintf(s," bssid:");
+	s+=format_mac(s,dot11_get_bssid(packet),6);
+	s+=sprintf(s," seq: %d\n",dot11_get_seq(packet));
+	s+=cw_format_dot11_fc_flags(s,packet);
+	s+=sprintf(s,"\nDuration: %d",dot11_get_duration(packet));
+//
+/*	switch (type){
+		case DOT11_ASSOC_REQ:
+			s+=sprintf(s,"\n   ssid: %.*s",dot11_assoc_req_get_ssid_len(packet),
+					dot11_assoc_req_get_ssid(packet)
+			);
+			break;
 			
-	preamble = cw_get_hdr_preamble(packet);
-	if (preamble == 01) {
-		s += sprintf(s, " (encrypted)");
-		return s - dst;
-	}
-
-	if (len < 4)
-		goto abort;
-
-/*		
-	if (cw_get_hdr_flag_f(packet)){
-		s+=sprintf(s," (fragmented)");
-	}
-*/
-	hlen = cw_get_hdr_hlen(packet);
-	rid = cw_get_hdr_rid(packet);
-	wbid = cw_get_hdr_wbid(packet);
-	s += sprintf(s, " H:%d R:%02d W:%02d", hlen, rid, wbid);
-
-
-	s += sprintf(s, " Flgs:");
-	s += format_hdr_flags(s, packet);
-
-	if (len < 8)
-		goto abort;
-	frag_id = cw_get_hdr_fragid(packet);
-	frag_offs = cw_get_hdr_fragoffset(packet);
-	s += sprintf(s, " Frag/Offs:%d/%d", frag_id, frag_offs);
-
-
-	if (cw_get_hdr_flag_m(packet)) {
-		/* rmac is present, print the rmac */
-		int rmac_len = cw_get_hdr_rmac_len(packet);
-		int plen = rmac_len;
-		if (rmac_len + 8 > len)
-			plen = len - 8;
-		if (rmac_len > 10)
-			plen = 10;
-
-		s += sprintf(s, " R-MAC:");
-		s += format_mac(s, cw_get_hdr_rmac_data(packet), plen);
-		if (rmac_len > 10) {
-			s += sprintf(s, " ... (len=%d)", rmac_len);
-		}
-	}
-
-	if (cw_get_hdr_flag_w(packet)) {
-		/* print wireless specific info */
-		int ws_len = cw_get_hdr_ws_len(packet);
-		int plen = ws_len > 20 ? 20 : ws_len;
-		s += sprintf(s, " WS:");
-		s += format_hexu(s, cw_get_hdr_ws_data(packet), plen);
-		if (ws_len > 20) {
-			s += sprintf(s, " ... (len=%d)", ws_len);
-		}
-	}
-	return s - dst;
-
-
-
-      abort:
-	s += sprintf(s, " Incomplete...");
-	return s - dst;
+	}*/
 
 }
+
+
+
+

src/cw/cw_inline.c

@@ -15,6 +15,25 @@ int cw_get_hdr_ws_len(uint8_t * th)
 	return *(th + 9 + cw_get_hdr_rmac_len(th));
 }
 
+
+/** 
+ * Get length of wireless specific data for CAPWAP packet draft 7
+ * @param th Pointer to packet
+ * @return length of wireless specific data
+ *
+ * Call this function only if the W flag is set
+ */
+int cw_get_hdr_ws_len_7(uint8_t * th)
+{
+	if (!cw_get_hdr_flag_m(th)){
+		return *(th + 9);
+	}
+	return *(th + 10 + cw_get_hdr_rmac_len(th));
+}
+
+
+
+
 /** 
  * Get pointer to wireless specific data
  * @param th Pointer to packet
@@ -117,7 +136,7 @@ int cw_set_hdr_rmac(uint8_t * th, bstr_t rmac)
 		hlen++;
 	}
 	cw_set_hdr_hlen(th, hlen);
-	return 1;
+	return rmac_len;
 }
 
 

src/cw/cw_type_bits.c

@@ -1,4 +1,6 @@
 #include "val.h"
+#include "cfg.h"
+#include "dbg.h"
 
 static int get_len(const struct cw_ValBit *bits)
 {
@@ -16,15 +18,28 @@ static int get_bit(const uint8_t * src,int pos, int len)
 	return src[b]&m ? 1:0;
 }
 
+static void set_bit(uint8_t * dst,int pos, int len,int val)
+{
+	int b;
+	uint8_t m;
+	cw_dbg(DBG_X,"set bit val %d",val);
+	if (!val)
+		return;
+       	b = len-1-pos/8;
+	m = 1<<(pos%8);
+	dst[b]|=m;
+}
+
 static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, const void *param)
 {
+	char skey[CW_CFG_MAX_KEY_LEN];
 	const struct cw_ValBit * bits=param;
 	int l,i;
 	
 	l = get_len(bits);
 	for(i=0;bits[i].key!=NULL;i++){
-		int rc;
-		printf("%s: %d\n",bits[i].key,get_bit(src,bits[i].bit,l));
+		sprintf(skey,"%s/%s",key,bits[i].key);
+		cw_cfg_set_bool(cfg,skey,get_bit(src,bits[i].bit,l));
 	}
 	return 1;
 }
@@ -32,9 +47,24 @@ static int bread(cw_Cfg_t *cfg, const char * key, const uint8_t *src, int len, c
 
 static 	int bwrite(cw_Cfg_t ** cfgs, const char *key, uint8_t *dst, const void * param)
 {
-	return 0;
+	int l,i;
+	char skey[CW_CFG_MAX_KEY_LEN];
+	const struct cw_ValBit * bits=param;
+	l = get_len(bits);
+	memset(dst,0,l);
+	for(i=0;bits[i].key!=NULL;i++){
+		uint8_t val;
+		int rc;
+		val=0;
+		sprintf(skey,"%s/%s",key,bits[i].key);
+		rc = CW_TYPE_BOOL->write(cfgs, skey, &val, NULL);
+		if (rc<0)
+			val=0;
+		cw_dbg(DBG_X,"%s (rc: %d)",skey,rc);
+		set_bit(dst,bits[i].bit,l,val);
+	}
+	return l;
 }
-
 
 
 const struct cw_Type cw_type_bits = {

src/cw/dbg.c

@@ -31,25 +31,21 @@
 #include "format.h"
 #include "ansi_colors.h"
 
+#include "dot11.h"
 
 /**
  *@addtogroup DBG
  *@{
  */
 
- /*
-  * @defgroup DebugFunctions Debug Functions
-  * @{
-  */
-
 uint32_t cw_dbg_opt_display = DBG_DISP_COLORS;
 
 /**
- * Current debug level
+ * Contains all debuglevels currently set
  */
-//static uint32_t cw_dbg_opt_level = 0;
-//
 static struct mavl * cw_dbg_opt_level = NULL;
+
+
 static int dbg_cmp(const void *a, const void*b)
 {
 	return (*((int*)a)-*((int*)b));
@@ -80,19 +76,16 @@ static const char * dbg_level_elem_detail[] = {
 	"elem_detail_in", "elem_detail_out", NULL
 };
 
+static const char * dbg_level_elem_dmp[] = {
+	"elem_dmp_in", "elem_dmp_out", NULL
+};
+	
 static const char * dbg_level_elem_all[] = {
 	"elem", "elem_dmp", "elem_detail",NULL
 };
 
 static const char * dbg_level_std[] = {
 	"msg","elem","msg_err", "elem_err", "pkt_err", "rfc", "warn", "state", "info", NULL
-/*		
-	DBG_MSG_IN, DBG_MSG_OUT,
-	DBG_ELEM_IN, DBG_ELEM_OUT,
-	DBG_MSG_ERR, DBG_ELEM_ERR,
-	DBG_PKT_ERR, DBG_RFC, DBG_WARN,
-	DBG_STATE, DBG_INFO,
-	0*/
 };
 
 
@@ -105,6 +98,7 @@ struct cw_DbgStr cw_dbg_strings[] = {
 	{ 0,			"pkt", dbg_level_pkt, "packet headers" },
 	{ 0,			"elem", dbg_level_elem, "message elemenst" },
 	{ 0, 			"elem_detail", dbg_level_elem_detail, "details for message elements"},
+	{ 0, 			"elem_dmp", dbg_level_elem_dmp,"hexdump element"},
 	{ 0, 			"elem_all", dbg_level_elem_all,"all possible elem options"},
 
 	{ DBG_WARN,		"warn", NULL, "warnings" },
@@ -136,7 +130,8 @@ struct cw_DbgStr cw_dbg_strings[] = {
 	{ DBG_ELEM_OUT, 	"elem_out", NULL, "elements of outgoing messages"},
 	{ DBG_ELEM_DETAIL_IN, 	"elem_detail_in", NULL, "details of incomming message elements" },
 	{ DBG_ELEM_DETAIL_OUT, 	"elem_detail_out",NULL, "details of outgoing message elememnts" },
-	{ DBG_ELEM_DMP, 	"elem_dmp", NULL, "hex-dump of each message element"},
+	{ DBG_ELEM_DMP_IN, 	"elem_dmp_in", NULL, "hex-dump of incoming elements"},
+	{ DBG_ELEM_DMP_OUT, 	"elem_dmp_out", NULL, "hex-dump of outgoing elements"},
 	{ DBG_ELEM_VNDR,	"elem_vndr", NULL, "expand vendor specific payloads"},	
 	
 	{ DBG_DTLS, 		"dtls",NULL, "DTLS related stuff"},
@@ -152,14 +147,6 @@ struct cw_DbgStr cw_dbg_strings[] = {
 	{ 0, NULL } 
 };
 
-/**
- *@}
- */
-
-
-
-
-
 
 
 static struct cw_StrListElem theme0[] = {
@@ -210,7 +197,6 @@ static struct cw_StrListElem * color_on = theme0;
 
 struct cw_StrListElem color_ontext[] = {
 
-/*	{DBG_ELEM_DMP, "\x1b[37m"},*/
 	{DBG_ELEM_DMP_OUT, ANSI_BBLACK ANSI_ITALIC},
 	{DBG_ELEM_DMP_IN,  ANSI_BBLACK},
 
@@ -289,22 +275,36 @@ const char *get_dbg_color_ontext(int level)
  * @param level Level to check
  * @return 0 if leveln is not set, otherwise level is set
  */
-
 int cw_dbg_is_level(int level)
 {
 	if (cw_dbg_opt_level == NULL)
 		return 0;
 
 	return mavl_get(cw_dbg_opt_level,&level) == NULL ? 0:1;
+}
 
+/**
+  * Set debug level
+  * @param level debug level to set, allowed values are enumberated in #cw_dbg_levels structure.
+  * @param on 1: turns the specified debug level on, 0: turns the specified debug level off.
+  *
+  * To check if a specific debug level is set, call #cw_dbg_is_level.
+  */
+void cw_dbg_set_level (int level, int on)
+{
+	int exists;
 
-//	if (level > 1 && (level &1))
-		return 1;
+	if (cw_dbg_opt_level == NULL){
+		cw_dbg_opt_level = mavl_create(dbg_cmp,NULL,sizeof(int));
+		if (cw_dbg_opt_level == NULL)
+			return;
+	}
 
-/*	if (level >= DBG_ALL ){
-		return 1;
-	}*/
-//	return (cw_dbg_opt_level & (level));
+	if (on){
+		mavl_insert(cw_dbg_opt_level,&level,&exists);
+	}
+	else 
+		mavl_del(cw_dbg_opt_level,&level);
 }
 
 
@@ -324,63 +324,37 @@ static void cw_dbg_vlog_line(struct cw_LogWriter * writer,
 				
 	}
 	writer->write(LOG_DEBUG,fbuf,args,writer);
-
 }
 
 
 
 /**
- * Put a list of missing mandatory message elements to debug output
- */
-void cw_dbg_missing_mand(int level, struct cw_Conn *conn, int ** ml, int n,
-			 int  * a)
-{
-	/*
-//      if (!cw_dbg_is_level(DBG_MSG_ERR) || n == 0)
-//              return;
-*/
-
-
-	char buffer[2000];
-/*	char *p = buffer; */
-	int i;
-/*	char *delim = "";*/
-	
-	if (!cw_dbg_is_level(level) || n == 0)
-		return;
-	
-/*
-	// TODO XXXX
-*/
-	for (i = 0; i < n; i++) {
-/*		p += sprintf(p, "%s", delim);
-		delim = ", ";
-		p += sprintf(p, "%s", cw_strelemp(conn->actions, ml[i]->elem_id));
-*/
-	}
-	cw_dbg(level, "Missing mandatory elements: [%s]", buffer);
-}
-
-
-
-
-/**
- * Display a packet on for debugger
+ * Display a packet on debugger
  */
 void cw_dbg_pkt(int level, struct cw_Conn *conn, uint8_t * packet, int len,
 		struct sockaddr *from)
 {
 
-/*	int hlen;*/
 	char buf[1024];
+	int (*fmt_pkt_hdr)(char *dst, int incomming, uint8_t * packet, int len,
+		      struct sockaddr *from);
+	fmt_pkt_hdr = NULL;
+	if (conn){
+		if (conn->msgset)
+			fmt_pkt_hdr = conn->msgset->format_pkt_hdr;
+	}
+	if (fmt_pkt_hdr==NULL){
+		fmt_pkt_hdr = cw_format_pkt_hdr;
+	}
+
 
 	if (!cw_dbg_is_level(level))
 		return;
 	
 	if (level == DBG_PKT_IN)
-		cw_format_pkt_hdr(buf, 1,  packet, len, from);
+		fmt_pkt_hdr(buf, 1,  packet, len, from);
 	else
-		cw_format_pkt_hdr(buf, 0,  packet, len, from);
+		fmt_pkt_hdr(buf, 0,  packet, len, from);
 		
 /*	hlen = cw_get_hdr_msg_offset(packet);*/
 
@@ -527,7 +501,7 @@ void cw_dbg_elem(int level, struct cw_Conn *conn, int msg,
 	cw_dbg(level,"%s %d (%s), len=%d ",vendorname,handler->id,
 			handler->name,len);
 	
-	if (cw_dbg_is_level(DBG_ELEM_DMP)) {
+	if (cw_dbg_is_level(DBG_ELEM_DMP_OUT) || cw_dbg_is_level(DBG_ELEM_DMP_IN)) {
 		if (level == DBG_ELEM_OUT)
 			cw_dbg_dmp(DBG_ELEM_DMP_OUT,msgbuf,len,"");
 		else 
@@ -541,46 +515,6 @@ void cw_dbg_elem(int level, struct cw_Conn *conn, int msg,
 
 
 
-/**
-  * Set debug level
-  * @param level debug level to set, allowed values are enumberated in #cw_dbg_levels structure.
-  * @param on 1: turns the specified debug level on, 0: turns the specified debug level off.
-  */
-
-void cw_dbg_set_level (int level, int on)
-{
-	int exists;
-
-	if (cw_dbg_opt_level == NULL){
-		cw_dbg_opt_level = mavl_create(dbg_cmp,NULL,sizeof(int));
-		if (cw_dbg_opt_level == NULL)
-			return;
-	}
-
-	if (on){
-		mavl_insert(cw_dbg_opt_level,&level,&exists);
-	}
-	else 
-		mavl_del(cw_dbg_opt_level,&level);
-
-
-/*
-	switch (level) {
-		case DBG_ALL:
-			if (on)
-				cw_dbg_opt_level = 0xffffffff;
-			else
-				cw_dbg_opt_level = 0;
-			break;
-		default:
-			if (on)
-				cw_dbg_opt_level |= (level);
-			else 
-				cw_dbg_opt_level &= (0xffffffff) ^ (level);
-	}
-	*/
-}
-
 
 int cw_dbg_set_level_from_str0(const char *level,int on)
 {
@@ -638,6 +572,9 @@ int cw_dbg_set_level_from_str(const char *level)
 	return cw_dbg_set_level_from_str0(slevel,on);
 }
 
+
+
+
 void cw_dbg_print_help(FILE *out, const char * prefix)
 {
 	struct cw_DbgStr *s;
@@ -656,35 +593,55 @@ void cw_dbg_print_help(FILE *out, const char * prefix)
 		}
 		fprintf(out,"\n");
 	}
-
 }
 
-/*
-void dbg_istore_dmp(mbag_t s)
+
+
+void cw_dbg_dot11_elems(const uint8_t *src,int len)
 {
-	DEFINE_AVLITER(it,s);
-	avliter_foreach(&it) {
-
-		mbag_item_t *i = avliter_get(&it);
-
-		char buffer[1000];
-
-		struct cw_str * strings = cw_item_strings;
-		
-		const char * in = cw_strlist_get_str(strings,i->id);
-		
-		cw_format_item(buffer,i);
-		printf("Item ID %d-%s: %s\n",i->id,in,buffer);
+	uint8_t id,l;
+	int p;
+	char str[1024];
 
+	for(p=0; p<len; p+=l+2){
+		if (len-p<3){
+			cw_dbg(DBG_X,"Error in dot11 element");
+			return;
+		}
+		id=src[p];
+		l=src[p+1];
+		cw_format_dot11_elem(str,id,src+p+2,l);
+		cw_dbg_dmp(DBG_X,src+p+2,l,"");
+		cw_dbg(DBG_X,str);
+	}
 
 }
 
+void cw_dbg_dot11_frame(uint8_t * frame,int len)
+{
+	char hdr[1024];
+	cw_format_dot11_hdr(hdr, frame, len);
+	cw_dbg(DBG_X,"%s",hdr);
+
+	int type =dot11_get_type_and_subtype(frame);
+
+	switch (type){
+		case DOT11_ASSOC_REQ:
+			cw_dbg_dot11_elems(frame+28,len-28);
+			break;
+		case DOT11_ASSOC_RESP:
+			cw_dbg(DBG_X,"  Capapility info: %04X",dot11_assoc_resp_get_cap(frame)); 
+			cw_dbg(DBG_X,"  Status CodeCapapility info: %04X",dot11_assoc_resp_get_status_code(frame));
+			cw_dbg(DBG_X,"  Assoc ID: %04X",dot11_assoc_resp_get_assoc_id(frame)); 
+
+			cw_dbg_dot11_elems((frame+DOT11_BODY_POS+DOT11_ASSOC_RESP_BODY_LEN),
+					len-DOT11_BODY_POS-DOT11_ASSOC_RESP_BODY_LEN);
+			break;
 			
 	}
-*/
+}
 
 
 /**@}*/
 
 
-/**@}*/

src/cw/dbg.h

@@ -39,7 +39,7 @@
 
 
 /**
- *@addtogroup LOGDBG
+ *@addtogroup DBG
  *@{
  */
 
@@ -82,9 +82,6 @@ enum cw_dbg_levels{
 	/** Error in msg elements */
 	DBG_ELEM_ERR,
 
-	/** hex dump elements */	
-	DBG_ELEM_DMP,
-
 	/** General infos, like CAPWAP state */
 	DBG_INFO,	
 
@@ -116,11 +113,13 @@ enum cw_dbg_levels{
        	/**Debug State machine */
 	DBG_STATE,
 	
-	
+	/** Infos about nessage composing */	
 	DBG_MSG_COMPOSE,
 
+	/** Debug Configuration updates */
 	DBG_CFG_UPDATES,
 
+	/** Debug Vendor elements */
 	DBG_ELEM_VNDR,
 	
 	
@@ -130,11 +129,11 @@ enum cw_dbg_levels{
 
 	DBG_ALL,
 
-
+	/** Hexdump incoming msg elemenets */
 	DBG_ELEM_DMP_IN,
+	/** Hexdump outgoing msg elemenst */
 	DBG_ELEM_DMP_OUT,
 
-
 };
 
 #define DBG_MSG (DBG_MSG_IN | DBG_MSG_OUT)
@@ -220,8 +219,6 @@ void cw_dbg_msg(int level,struct cw_Conn *conn, uint8_t * packet, int len,struct
 char * cw_dbg_mkdmp(const uint8_t * data, int len);
 //void cw_dbg_version_subelem(int level, const char *context, int subtype, 
 //		uint32_t vendor_id, const uint8_t * vstr, int len);
-void cw_dbg_ktv_dump(mavl_t ktv, uint32_t dbglevel, 
-		const char *header, const char *prefix, const char *footer );
 
 /**
   * Set debug level
@@ -244,6 +241,8 @@ void cw_dbg_ktv_dump(mavl_t ktv, uint32_t dbglevel,
 int cw_dbg_is_level(int level);
 
 void cw_dbg_print_help(FILE *out, const char * prefix);
+void cw_dbg_dot11_frame(uint8_t * frame,int len);
+
 
 
 #define stop() printf("STOP IN %s:%d - %s\n", __FILE__, __LINE__, __FUNCTION__); exit(1)

src/cw/dbg_strings.c

@@ -1,135 +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 
- */
-
-
-
-#include "dbg.h"
-
-/**
- *@addtogroup DbgOptions 
- *@{
- */
-
-
-/**
- * Debug strings
- */
-struct cw_StrListElem cw_dbg_strings[] = {
-	{ DBG_INFO,		"info",  },
-	{ DBG_PKT_IN,		"pkt_in"  },
-	{ DBG_PKT_OUT,		"pkt_out" },
-	{ DBG_PKT_ERR,		"pkt_err" },
-	{ DBG_PKT_DMP_IN,	"pkt_dmp_in" },
-	{ DBG_PKT_DMP_OUT,	"pkt_dmp_out" },
-
-	{ DBG_MSG_IN,		"msg_in"  },
-	{ DBG_MSG_OUT,		"msg_out" },
-	{ DBG_MSG_DMP_IN,	"msg_dmp_in"  },
-	{ DBG_MSG_DMP_OUT,	"msg_dmp_out" },
-	
-	{ DBG_MSG_ERR,		"msg_err"},
-
-	{ DBG_RFC,		"rfc", 	 },
-
-	{ DBG_ELEM_IN,  	"elem_in"},
-	{ DBG_ELEM_OUT, 	"elem_out"},
-	{ DBG_ELEM_DMP, 	"elem_dmp"},
-	{ DBG_ELEM_ERR, 	"elem_err" },
-	{ DBG_ELEM_DETAIL_IN, 	"elem_detail_in" },
-	{ DBG_ELEM_DETAIL_OUT, 	"elem_detail_out" },
-	{ DBG_ELEM_VNDR,	"elem_vndr"},	
-	
-	{ DBG_DTLS, 		"dtls" },
-	{ DBG_DTLS_BIO,		"dtls_bio" },
-	{ DBG_DTLS_BIO_DMP,	"dtls_bio_dmp"},
-	{ DBG_DTLS_DETAIL, 	"dtls_detail"},
-
-	{ DBG_CFG_UPDATES, 	"cfg_updates" },
-	{ DBG_X,		"x" },
-
-	
-//	{DBG_CFG_DMP, "cfg_dmp" },
-	
-	{ DBG_WARN,		"warn" },
-		
-	{ DBG_MOD,		"mod"},
-	{ DBG_STATE,		"state" },
-	{ DBG_MSG_COMPOSE,	"msg_compose" },
-
-	{ (DBG_MSG_IN | DBG_MSG_OUT), "msg" },
-	{ (DBG_PKT_IN | DBG_PKT_OUT), "pkt" },
-	{ (DBG_ELEM_IN | DBG_ELEM_OUT), "elem" },
-	{ (DBG_ELEM_DETAIL_IN | DBG_ELEM_DETAIL_OUT), "elem_detail" },
-	{ (DBG_ELEM_IN | DBG_ELEM_OUT | DBG_ELEM_DMP | DBG_ELEM_DETAIL_IN | DBG_ELEM_DETAIL_OUT), "elem_all" },
-
-	{ (	DBG_MSG_IN | DBG_MSG_OUT | 
-		DBG_ELEM_IN | DBG_ELEM_OUT |
-		DBG_MSG_ERR | DBG_ELEM_ERR |
-		DBG_PKT_ERR | DBG_RFC | DBG_WARN
-		| DBG_STATE | DBG_INFO), 			"std" },
-
-	{ DBG_ALL, 		"all"},
-
-	
-	{ CW_STR_STOP, NULL } 
-};
-
-/**
- *@}
- */
-
-
-
-
-/*
-struct cw_dbg_cfgstrs cw_dbg_cfgstrs[] = {
-
-	{"info",DBG_CW_INFO},
-	{"msg",DBG_MSG},
-	{"elem",DBG_ELEM},
-	{"elem_dmp",DBG_ELEM_DMP},
-	{"rfc",DBG_CW_RFC},
-	{"pkt_in",DBG_CW_PKT_IN},
-	{"pkt_out",DBG_CW_PKT_OUT},
-	{"pkt_dtl",DBG_CW_PKT_DTL},
-	{"pkt",(DBG_CW_PKT_IN | DBG_CW_PKT_OUT)},
-	{"pkt_dmp",DBG_CW_PKT_DMP},
-	{"pkt_err",DBG_CW_PKT_ERR},
-	{"msg_err",DBG_MSG_ERR},
-	{"img_dtl",DBG_CW_IMG_DTL},
-	{"elem_err",DBG_ELEM_ERR},
-
-	{"dtls",DBG_DTLS},
-	{"dtls_detail",DBG_DTLS_DETAIL},
-	{"dtls_bio",DBG_DTLS_BIO},
-	{"dtls_bio_dmp",DBG_DTLS_BIO_DMP},
-
-
-	{"all",DBG_ALL},
-	{"err",DBG_ERR},
-	{0,0}
-
-};
-*/
-
-

src/cw/dot11.c

@@ -38,3 +38,28 @@ const char * dot11_type_strings[]=
 	"Probe Req",
 	"Probe Resp"
 };
+
+
+struct dot11_name{
+	uint8_t val;
+	const char * str;
+};
+
+struct cw_StrListElem dot11_names[]={
+	{DOT11_ASSOC_REQ, "Assoc Req"},
+	{DOT11_ASSOC_RESP, "Assoc Resp"},
+	{DOT11_REASSOC_REQ, "Reassoc Req"},
+	{DOT11_REASSOC_RESP, "Reassoc Resp"},
+	{DOT11_PROBE_REQ, "Probe Req"},	
+	{DOT11_PROBE_RESP, "Probe Resp"},
+	{DOT11_TIMING_ADV, "Timing Adv"},
+	{DOT11_MGM_RES111, "MGMRES111"},
+	{DOT11_BEACON, "Beacon"},
+	{CW_STR_STOP,"Unknown"},
+};
+
+
+int dot11_init_assoc_resp(uint8_t * dst)
+{
+	dot11_set_type_and_subtype(dst,DOT11_ASSOC_RESP);
+}

src/cw/dot11.h

@@ -20,6 +20,8 @@
 #include <endian.h>
 #endif
 
+#include "strlist.h"
+#include "bstr.h"
 
 /**
  * @defgroup DOT11_FRAME_TYPES Frame Types
@@ -47,17 +49,17 @@
  *
  * @{
  */
-#define DOT11_FC_ASSOC_REQ	dot11_fc_mgm(0b0000)
-#define DOT11_FC_ASSOC_RESP	dot11_fc_mgm(0b0001)
-#define DOT11_FC_REASSOC_REQ	dot11_fc_mgm(0b0010)
-#define DOT11_FC_REASSOC_RESP	dot11_fc_mgm(0b0011)
-#define DOT11_FC_PROBE_REQ	dot11_fc_mgm(0b0100)
-#define DOT11_FC_PROBE_RESP	dot11_fc_mgm(0b0101)
-#define DOT11_FC_TIMING_ADV	dot11_fc_mgm(0b0110)
-#define DOT11_FC_MGM_RES111	dot11_fc_mgm(0b0111)
-#define DOT11_FC_BEACON		dot11_fc_mgm(0b1000)
+#define DOT11_ASSOC_REQ		dot11_fc_mgm(0b0000)
+#define DOT11_ASSOC_RESP	dot11_fc_mgm(0b0001)
+#define DOT11_REASSOC_REQ	dot11_fc_mgm(0b0010)
+#define DOT11_REASSOC_RESP	dot11_fc_mgm(0b0011)
+#define DOT11_PROBE_REQ		dot11_fc_mgm(0b0100)
+#define DOT11_PROBE_RESP	dot11_fc_mgm(0b0101)
+#define DOT11_TIMING_ADV	dot11_fc_mgm(0b0110)
+#define DOT11_MGM_RES111	dot11_fc_mgm(0b0111)
+#define DOT11_BEACON		dot11_fc_mgm(0b1000)
 
-#define DOT11_FC_DATA		dot11_fc_dta(0b0000)
+#define DOT11_DATA		dot11_fc_dta(0b0000)
 
 /**
  * @}
@@ -114,6 +116,14 @@
 #define DOT11_ELEM_FH_PARAM_SET			2
 #define DOT11_ELEM_DSSS_PARAM_SET		3
 #define DOT11_ELEM_CF_PARAM_SET			4
+#define DOT11_ELEM_POWER_CAPABILITY		33
+#define DOT11_ELEM_SUPPORTED_CHANNELS		36
+#define DOT11_ELEM_EXTENDED_SUPPORTED_RATES	50
+#define DOT11_ELEM_AP_CHANNEL_REPORT		51
+#define DOT11_ELEM_SUPPORTED_OPERATING_CLASSES	59
+#define DOT11_ELEM_VENDOR_SPECIFIC		221
+
+
 /**
  * @}
  */
@@ -125,27 +135,32 @@ extern const uint8_t dot11_tab_br[256];
 
 #define dot11_get_byte(ptr) (*(ptr))
 
-#define dot11_put_byte(ptr,b) (*(ptr) = b)
+#define dot11_put_byte(ptr,b) (*(ptr) = b,1)
 #define dot11_put_word(dst,v) ((*((uint16_t*)(dst))=htobe16(v)),2)
-#define dot11_put_dword(dst,v) ((*((uint16_t*)(dst))=htobe16(v)),4)
+#define dot11_put_dword(dst,v) ((*((uint32_t*)(dst))=htobe32(v)),4)
 #define dot11_put_qword(dst,v) ((*((uint64_t*)(dst))=htobe64(v)),8)
 
+#define dot11_set_byte(ptr,b) (*(ptr) = b)
+#define dot11_set_word(dst,v) ((*((uint16_t*)(dst))=htobe16(v)))
+#define dot11_set_dword(dst,v) ((*((uint32_t*)(dst))=htobe32(v)))
+#define dot11_set_qword(dst,v) ((*((uint64_t*)(dst))=htobe64(v)))
+
+
+
+#define dot11_set_byte(ptr,b) (*(ptr) = b)
 
 uint16_t dot11_get_word(uint8_t * ptr);
 
 
 
-#define dot11_get_version(frame) ((frame[1])&0x03)
-#define dot11_get_type(frame) (((frame[1])&0x0c) >> 2)
-#define dot11_get_subtype(frame) (((frame[1])&0xf0) >> 4)
-/** 
- * Get Frame Control field 
- * @param frame
- * @return Frame Control field
- */
-#define dot11_get_fc(frame) dot11_get_word(frame)
+#define dot11_get_version(frame) ( (frame)[1] & 0x03)
+#define dot11_get_type(frame)    ( ((frame)[1] & 0x0c) >> 2)
+#define dot11_get_subtype(frame) ( (frame)[1] >> 4 )
+
+#define dot11_get_type_and_subtype(frame) ((frame)[1])
+#define dot11_set_type_and_subtype(frame,val) ((frame)[1]=val)
+
 
-#define dot11_get_duration(frame) dot11_get_word(frame+2)
 
 
 void dot11_get_address(uint8_t * dst, uint8_t * frame);
@@ -201,6 +216,9 @@ void dot11_timer_set(uint64_t val);
 #define dot11_put_address(dst,addr) (memcpy(dst,addr,6),6)
 #define dot11_put_sequence_control(dst,v) (dot11_put_word(dst,v))
 #define dot11_put_capability(dst,v) dot11_put_word(dst,v)
+
+
+
 int  dot11_put_ssid(uint8_t *dst,uint8_t * ssid,int len);
 
 
@@ -221,7 +239,9 @@ int  dot11_put_ssid(uint8_t *dst,uint8_t * ssid,int len);
  */
 #define dot11_rate2float(rate) (((float)(rate))/2.0)
 
-int dot11_put_supported_rates(uint8_t *dst, float *basic, float *rates);
+int dot11_put_supported_rates(uint8_t *dst, bstr_t src);
+
+//		float *basic, float *rates);
 int dot11_put_dsss_param_set(uint8_t *dst,int ch);
 
 
@@ -235,7 +255,81 @@ extern uint8_t dot11_broadcast_address[6];
 
 
 
+extern struct cw_StrListElem dot11_names[];
 
+#define dot11_get_frame_name(data) cw_strlist_get_str(dot11_names,(data)[1])
+
+/** 
+ * Get Frame Control field 
+ * @param frame uint8_t pointer to the frame
+ * @return uint16_t Frame Control field
+ */
+#define dot11_get_fc(frame) dot11_get_word(frame)
+ /** Get duration/aid field 
+  * @param frame uint8_t pointer to frame */
+#define dot11_get_duration(frame) dot11_get_word(frame+2)
+#define dot11_get_da(frame) ((frame)+4)
+#define dot11_get_sa(frame) ((frame)+10)
+#define dot11_get_bssid(frame) ((frame)+16)
+#define dot11_get_seq(frame) dot11_get_word((frame)+22)
+#define dot11_get_body(frame) ((frame)+24)
+
+#define DOT11_BODY_POS 24
+
+
+#define dot11_set_duration(frame,d) dot11_set_word(frame+2,d)
+#define dot11_set_seq(frame,s) dot11_set_word((frame)+22,s)
+
+
+#define DOT11_ASSOC_RESP_BODY_LEN 6
+
+#define dot11_assoc_req_get_cap(frame) \
+		dot11_get_word((frame)+24)
+#define dot11_assoc_req_get_listen_interval(frame) \
+			dot11_get_word((frame)+24+2)
+
+
+
+/*
+#define dot11_assoc_req_get_ssid_len(frame)\
+			((frame)[29])
+#define dot11_assoc_req_get_ssid(frame)\
+			(frame+30)
+*/
+#define dot11_assoc_resp_set_cap(frame,cap)\
+	dot11_set_word(dot11_get_body(frame),cap)
+#define dot11_assoc_resp_get_cap(frame)\
+	dot11_get_word(dot11_get_body(frame))
+
+
+#define dot11_assoc_resp_set_status_code(frame,code)\
+	dot11_set_word(dot11_get_body(frame)+2,code)
+#define dot11_assoc_resp_get_status_code(frame)\
+	dot11_get_word(dot11_get_body(frame)+2)
+
+
+#define dot11_assoc_resp_set_assoc_id(frame,id)\
+	dot11_set_word(dot11_get_body(frame)+4,id)
+#define dot11_assoc_resp_get_assoc_id(frame)\
+	dot11_get_word(dot11_get_body(frame)+4)
+
+
+
+//#define dot11_assoce_resp_get_var_body(frame) 
+//	(get_frame_body(frame)+6)
+
+
+
+#define dot11_copy_mac(src,dst)\
+	memcpy(dst,src,6);
+
+
+struct cw_Dot11Elemenst {
+
+	bstr_t supportet_rates;
+};
+
+int dot11_init_assoc_resp(uint8_t * dst);
 
 
 /**

src/cw/dot11_inline.c

@@ -31,8 +31,6 @@ uint64_t dot11_timer_get()
 	return 1000000 * tv.tv_sec + tv.tv_usec - dot11_timer_offset;
 }
 
-
-
 void dot11_timer_set(uint64_t val)
 {
 	struct timeval tv;
@@ -41,14 +39,15 @@ void dot11_timer_set(uint64_t val)
 }
 
 int  dot11_put_ssid(uint8_t *dst,uint8_t * ssid,int len){
-	dot11_put_byte(dst,DOT11_ELEM_SSID);
-	dot11_put_byte(dst+1,len);
+	dot11_set_byte(dst,DOT11_ELEM_SSID);
+	dot11_set_byte(dst+1,len);
 	memcpy(dst+2,ssid,len);
 	return len;
-
 }
 
-int dot11_put_supported_rates(uint8_t *dst, float *basic, float *rates){
+
+
+int dot11_convert_supported_rates(uint8_t *dst, float *basic, float *rates){
 	uint8_t *d = dst+2;
 	while(*basic != 0.0){
 		*d++ = 0x80 | dot11_float2rate(*basic);
@@ -65,12 +64,25 @@ int dot11_put_supported_rates(uint8_t *dst, float *basic, float *rates){
 }
 
 
+int dot11_put_supported_rates(uint8_t * dst, bstr_t src)
+{
+	int l = bstr_len(src);
+	dot11_set_byte(dst,DOT11_ELEM_SUPPORTED_RATES);
+	memcpy(dst+1, src,l+1);
+	return l+2;
+}
+
+
 int dot11_put_dsss_param_set(uint8_t *dst,int ch) {
 
-	dot11_put_byte(dst,DOT11_ELEM_DSSS_PARAM_SET);
-	dot11_put_byte(dst+1,1);
-	dot11_put_byte(dst+2,ch);
+	dot11_set_byte(dst,DOT11_ELEM_DSSS_PARAM_SET);
+	dot11_set_byte(dst+1,1);
+	dot11_set_byte(dst+2,ch);
 	return 3;
 }
 
 
+#define DOT11_INLINE 
+
+
+

src/cw/format.c

@@ -27,6 +27,8 @@
 
 #include "cw.h"
 
+#include "format.h"
+
 #include "capwap80211.h"
 
 /**
@@ -104,3 +106,130 @@ char * cw_format_radio_information(char * dst, int ri)
 	*d=0;
 	return dst;
 }
+
+
+static int cw_format_pkt_hdr0(char *dst, int incomming, uint8_t * packet, int len,
+		      struct sockaddr *from, int draft7)
+{
+	char sock_buf[SOCK_ADDR_BUFSIZE]; 
+	int preamble;
+	char *s;
+	int hlen, rid, wbid;
+	int frag_id,frag_offs;
+
+	s = dst;
+
+	if (incomming){
+		if (cw_get_hdr_flag_f(packet)) {
+			s += sprintf(s, "Fragment from %s",
+				     sock_addr2str_p(from,sock_buf));
+		} else {
+			s += sprintf(s, "From %s", sock_addr2str_p(from,sock_buf));
+		}
+	}
+	else{
+		if (cw_get_hdr_flag_f(packet)) {
+			s += sprintf(s, "Fragment to %s", sock_addr2str(from,sock_buf));
+		} else {
+			s += sprintf(s, "To %s", sock_addr2str(from,sock_buf));
+		}
+	}
+	s += sprintf(s, " l=%d: ", len);
+
+	preamble = cw_get_hdr_preamble(packet);
+	if (preamble == 01) {
+		s += sprintf(s, " (encrypted)");
+		return s - dst;
+	}
+
+	if (len < 4)
+		goto abort;
+
+	hlen = cw_get_hdr_hlen(packet);
+	rid = cw_get_hdr_rid(packet);
+	wbid = cw_get_hdr_wbid(packet);
+	s += sprintf(s, " H:%d R:%02d W:%02d", hlen, rid, wbid);
+
+
+	s += sprintf(s, " Flgs:");
+	s += format_hdr_flags(s, packet);
+
+	if (len < 8)
+		goto abort;
+	frag_id = cw_get_hdr_fragid(packet);
+	frag_offs = cw_get_hdr_fragoffset(packet);
+	s += sprintf(s, " Frag/Offs:%d/%d", frag_id, frag_offs);
+
+
+	if (cw_get_hdr_flag_m(packet)) {
+		/* rmac is present, print the rmac */
+		int rmac_len = cw_get_hdr_rmac_len(packet);
+		int plen = rmac_len;
+		if (rmac_len + 8 > len)
+			plen = len - 8;
+		if (rmac_len > 10)
+			plen = 10;
+
+		s += sprintf(s, " R-MAC:");
+		s += format_mac(s, cw_get_hdr_rmac_data(packet), plen);
+		if (rmac_len > 10) {
+			s += sprintf(s, " ... (len=%d)", rmac_len);
+		}
+	}
+
+	if (cw_get_hdr_flag_w(packet)) {
+		if (!draft7){
+			/* print wireless specific info */
+			int ws_len = cw_get_hdr_ws_len(packet);
+			int plen = ws_len > 20 ? 20 : ws_len;
+			s += sprintf(s, " WS:");
+			s += format_hexu(s, cw_get_hdr_ws_data(packet), plen);
+			if (ws_len > 20) {
+				s += sprintf(s, " ... (len=%d)", ws_len);
+			}
+		}
+		else {
+			int ws_len = cw_get_hdr_ws_len_7(packet);
+			int plen = ws_len > 20 ? 20 : ws_len;
+			s += sprintf(s, " WS:");
+			s += format_hexu(s, cw_get_hdr_ws_data_7(packet), plen);
+			if (ws_len > 20) {
+				s += sprintf(s, " ... (len=%d)", ws_len);
+			}
+
+		}
+	}
+	return s - dst;
+
+      abort:
+	s += sprintf(s, " Incomplete...");
+	return s - dst;
+
+}
+
+
+/**
+ * @brief Format a packet header for debugging purposes
+ * @param dst Destination buffer
+ * @param incomming True if the packet is an incomming packet, otherweise 0
+ * @param packet packet data
+ * @param len length of packet data
+ * @param from Address from where the packet was received
+ * @return Number of bytes written
+ */
+int cw_format_pkt_hdr(char *dst, int incomming, uint8_t * packet, int len,
+		      struct sockaddr *from)
+{
+	return cw_format_pkt_hdr0(dst, incomming, packet, len,
+	      from, 0);
+
+}
+
+int cw_format_pkt_hdr_7(char *dst, int incomming, uint8_t * packet, int len,
+		      struct sockaddr *from)
+{
+	return cw_format_pkt_hdr0(dst, incomming, packet, len,
+	      from, 1);
+
+}
+

src/cw/format.h

@@ -109,9 +109,14 @@ char *cw_format_dump(const uint8_t * data, int len,
 void cw_format_get_dump_defaults(struct cw_FormatDumpSettings * settings);
 int cw_format_pkt_hdr(char *dst, int incomming, uint8_t * packet, int len,
 		      struct sockaddr *from);
+int cw_format_pkt_hdr_7(char *dst, int incomming, uint8_t * packet, int len,
+		      struct sockaddr *from);
+
 int cw_format_version(char *s, const uint8_t * version, int len);
 
 char * cw_format_radio_information(char * dst, int ri);
+int cw_format_dot11_hdr(char * dst, uint8_t *packet, int len);
+int cw_format_dot11_elem(char *dst, uint8_t id, const uint8_t *src, int len);
 
 
 /**@}*/

src/cw/fragman.c

@@ -54,6 +54,7 @@
 
 
 #include "capwap.h"
+#include "cw.h"
 #include "fragman.h"
 
 /**
@@ -101,20 +102,6 @@ static struct frag * frag_new(struct frag * frags, int fragid)
 	return NULL;
 }
 
-/*
-void fragman_free(frag_t * frags,struct frag * f)
-{
-	int i;
-	for (i=0; i<FRAG_MAXIDS; i++){
-		if (frags[i]->fragid==f->fragid){
-			frags[i]=NULL;
-			break;
-		}
-	}
-	free(f);
-}
-*/
-
 /**
  * Add a fragment
  * @pram frags Fragman object
@@ -129,12 +116,10 @@ uint8_t * fragman_add(frag_t * frags, uint8_t *packet, int hlen, int payloadlen)
 	uint32_t val0,val1;
 	int fragid,fragoffset;
 	int dst;
-	int ti;
 	
 	/* read the transport header dword 0,
 	 * contains hlen*/	
 	val0 = ntohl(*((uint32_t*)packet));
-/*	int hlen = (val0 >> 19) & 0x1f;*/
 
 	/* read the transport header dword 1,
 	 * contains fragid and fragoffset */	
@@ -142,33 +127,30 @@ uint8_t * fragman_add(frag_t * frags, uint8_t *packet, int hlen, int payloadlen)
 	fragid = val1>>16;
 	fragoffset=(val1 >>3) & 0x1fff;
 
-/*//	printf("Fragid = %i, offset = %i\n",fragid,fragoffset);*/
-	
-	/* determine size of payload */
-/*	int payloadlen = len - hlen*4;
-	if (payloadlen<0){
-		errno = EINVAL;
-		return NULL;
-	}
-*/
 	/* find / create cfragment */
 	f = frag_get(frags,fragid);
 	if (!f){
 		f = frag_new(frags,fragid);
-	}
 		if (!f){
 			errno = ENOMEM;
 			/* out of fragmentation space */
 			return NULL;
 		}
-
+	}
 	errno = 0;
 
 	dst = fragoffset*8;
 
 	/* copy fragment*/
 	if (dst + payloadlen < FRAG_MAXSIZE) {
-		memcpy( f->buffer+4+dst,packet+hlen,payloadlen);
+		if (fragoffset==0){
+			/* preserve header of 1st fragment */
+			memset(f->buffer,0,MAX_PKT_HDR_LEN);
+			memcpy(f->buffer,packet,hlen);
+			cw_set_hdr_hlen(f->buffer,MAX_PKT_HDR_LEN/4);
+			cw_set_hdr_flags(f->buffer, CAPWAP_FLAG_HDR_F, 0);
+		}
+		memcpy( f->buffer+MAX_PKT_HDR_LEN+4+dst,packet+hlen,payloadlen);
 		f->bytesreceived+=payloadlen;
 	}
 
@@ -177,21 +159,13 @@ uint8_t * fragman_add(frag_t * frags, uint8_t *packet, int hlen, int payloadlen)
 	}
 
 
-	for (ti=0; ti<16; ti++){
-/*//		printf("%02X ",(f->buffer+4)[ti]);*/
-
-	}
-
-
 	if (f->bytesneeded>0 && f->bytesneeded<=f->bytesreceived){
 		uint8_t * r=f->buffer;
 		f->buffer=0;
-/*//		printf("last bytes need %i\n",f->bytesneeded);*/
-		*((uint32_t*)(r))=f->bytesneeded;
+		*((uint32_t*)(r+MAX_PKT_HDR_LEN))=f->bytesneeded;
 		return r; 
 	}
 
-/*//	printf("Fragman bytes needed: %i, received  %i\n",f->bytesneeded,f->bytesreceived);*/
 	return NULL;
 }
 

src/cw/fragman.h

@@ -19,9 +19,9 @@
 
 /**
  *@defgroup Fragman FRAGMAN
- *@breif Frgaman functions
+ *@brief Frgaman functions
  *
- * Detailed esription
+ * Detailed desription
  *@{
  */
 
@@ -33,18 +33,18 @@
 #include <time.h>
 #include <unistd.h>
 
-#ifndef FRAG_MAXSIZE
+
+#define MAX_PKT_HDR_LEN 64
+
 /** maximaum size of a fragment */
-	#define FRAG_MAXSIZE 65536+4
-#endif
+#define FRAG_MAXSIZE (65536+MAX_PKT_HDR_LEN)
 
-#ifndef FRAG_MAXIDS
 #define FRAG_MAXIDS 10
-#endif
 
-#ifndef FRAG_TTL
+/**
+ * TTL of received fragment in seconds
+ */
 #define FRAG_TTL 5 
-#endif
 
 
 struct frag {
@@ -57,7 +57,7 @@ struct frag {
 	int bytesreceived;
 	int bytesneeded;
 	struct timespec t;
-	uint8_t * header;
+//	uint8_t * header;
 };
 
 typedef struct frag frag_t; /*FRAGMAN;*/

src/cw/msgset.h

@@ -72,6 +72,9 @@ struct cw_MsgSet {
 	mavl_t statemachine_states;
 	int (*write_header)(struct cw_ElemHandler * handler, uint8_t * dst, int len);
 	int (*header_len)(struct cw_ElemHandler *handler);
+	int (*format_pkt_hdr)(char *dst, int incomming, uint8_t * packet, int len,
+		      struct sockaddr *from);
+	
 };
 
 

src/cw/send.c

@@ -90,10 +90,143 @@ int conn_send_data_msg(struct cw_Conn * conn, uint8_t *rawmsg,int len)
 	return 0;
 }
 
-
 #define MAX_MTU 9500
+
+
+/**
+ * Initialize a capwap header
+ *
+ * @param buf	Buffer to be initialized
+ * @param wbid  Wireless Binding ID 
+ * @param rid 	Radio ID
+ * @param rmac	Radio MAC, NULL if not present
+ * @param wd	Wireless Data, NULL if not present
+ *
+ * @return Length of the header that was initialized
+ */
+int 
+cw_init_capwap_packet( uint8_t * buf, int wbid ,int rid, bstr_t rmac, bstr_t wd)
+{
+	int len,hlen;
+
+	/* header len */
+	len = 8;
+
+	/* zero the first 8 bytes */
+	cw_set_dword(buf + 0, 0);
+	cw_set_dword(buf + 4, 0);
+
+	/* capwap version/unencrypted */
+	#if CAPWAP_VERSION != 0 
+		cw_set_hdr_preamble(buf, CAPWAP_VERSION << 4 | 0);
+	#endif
+
+	/* set wbid and rid */
+	cw_set_hdr_wbid(buf, wbid);
+	cw_set_hdr_rid(buf, rid);
+
+	/* add rmac if present */
+	if (rmac != NULL){
+		int rmac_len = bstr_len(rmac);
+		memcpy(cw_get_hdr_rmac(buf), rmac, rmac_len + 1);
+		cw_set_hdr_flags(buf, CAPWAP_FLAG_HDR_M, 1);
+		len+=rmac_len+1;
+	}
+
+	/* Add wireless data if present */
+	if (wd!=NULL){
+		int wd_len = bstr_len(wd);
+		memcpy(buf+len, wd, wd_len + 1);
+		cw_set_hdr_flags(buf, CAPWAP_FLAG_HDR_M, 1);
+		len+=wd_len;
+	}
+	
+	hlen = len / 4;
+	if (len % 4 != 0) {
+		hlen++;
+	}
+	cw_set_hdr_hlen(buf, hlen);
+
+	return hlen*4;
+}
+
+/**
+ * Send a CAPWAP packet and fragment it if nececerry
+ * @param conn connection where to send packet over
+ * @param buf pointer to a buffer initialized with #cw_init_capwap_packet
+ * @param hlen length of header, which is the value returned by #cw_init_capwap_packet
+ * @param data payload
+ * @param len length of payload 
+ */
+int cw_send_capwap_packet(struct cw_Conn * conn, uint8_t * buf, int hlen, uint8_t * data, int len)
+{
+	int fragoffset,mtu;
+	int fragid;
+
+	/* get mtu and align it to 8 */
+	mtu = conn->mtu;
+	mtu &= ~3;
+
+	/* initialize fragid and fragoffset */
+	fragoffset = 0;
+	if (len + hlen > mtu)
+		fragid = conn->fragid++;
+	else
+		fragid = 0;
+
+	/* create all fragments */
+	while (len + hlen > mtu){
+		memcpy(buf+hlen,data+(fragoffset*8),mtu-hlen);
+		len -= (mtu - hlen);
+
+		cw_set_hdr_flags(buf,CAPWAP_FLAG_HDR_F,1);
+		cw_set_dword(buf+4, fragid<<16 | fragoffset<<3 );
+
+		cw_dbg_pkt(DBG_PKT_OUT,conn,buf,mtu,(struct sockaddr*)&conn->addr);
+		if (conn->write(conn,buf,mtu)<0)
+			return -1;
+	
+		fragoffset+=(mtu-hlen)/8;
+
+		/* put rmac and wireless data only into the 1st fragment */
+		if (hlen!=8){
+			cw_set_hdr_flags(buf,CAPWAP_FLAG_HDR_M,0);
+			cw_set_hdr_flags(buf,CAPWAP_FLAG_HDR_W,0);
+			hlen = 8;
+			cw_set_hdr_hlen(buf,hlen/4);
+		}
+	}
+
+	if (fragoffset)
+		cw_set_hdr_flags(buf,CAPWAP_FLAG_HDR_F | CAPWAP_FLAG_HDR_L,1);
+	else
+		cw_set_hdr_flags(buf,CAPWAP_FLAG_HDR_F,0);
+
+	memcpy(buf+hlen,data+(fragoffset*8),len);
+
+	cw_set_dword(buf+4, fragid<<16 | fragoffset<<3 );
+
+	cw_dbg_pkt(DBG_PKT_OUT,conn,buf,len+hlen,(struct sockaddr*)&conn->addr);
+
+	return conn->write(conn,buf,len + hlen);
+}
+
 int 
 cw_send_msg( struct cw_Conn * conn, uint8_t *msg)
+{
+	uint8_t buf[MAX_MTU];
+	int hlen,msglen;
+	hlen = cw_init_capwap_packet(buf,1,0,NULL,NULL);
+	msglen = cw_get_msg_elems_len(msg) + 8;
+	return cw_send_capwap_packet(conn,buf,hlen,msg,msglen);
+}
+
+
+
+
+
+int 
+cw_send_msg_old( struct cw_Conn * conn, uint8_t *msg)
 {
 	uint8_t buf[MAX_MTU];
 	int fragoffset,hlen,mtu;

src/mod/capwap/capwap_actions.c

@@ -24,6 +24,7 @@
 
 #include "cw/msgset.h"
 #include "cw/keys.h"
+#include "cw/format.h"
 
 #include "mod_capwap.h"
 
@@ -85,7 +86,26 @@ static cw_ValValRange_t mac_types[]={
 	{0,0,NULL}
 };
 
-
+/*
+struct cw_ValBit xx[] = {
+                {0,"ess"},
+                {1,"ibss"},
+                {2,"cf-pollable"},
+                {3,"cf-poll-request"},
+                {4,"privacy"},
+                {5,"short-preamble"},
+                {2,"pbcc"},
+                {3,"cf-poll-request"},
+                {2,NULL}        
+        };
+*/
+struct cw_ValBit frame_tunnel_bits[] = {
+	{3,"native"},
+	{2,"802-3"},
+	{1,"local-bridging"},
+	{0,"reserved"},
+	{1, NULL}        
+};
 
 
 static cw_ValStruct_t radio_admin_state[] = {
@@ -151,10 +171,13 @@ static struct cw_ElemHandler handlers[] = {
 		CAPWAP_ELEM_WTP_FRAME_TUNNEL_MODE,	/* Element ID */
 		0,0,					/* Vendor / Proto */
 		1,1,					/* min/max length */
-		CW_TYPE_BYTE,				/* type */
+		CW_TYPE_BITS,				/* type */
 		"capwap/wtp-frame-tunnel-mode",		/* Key */
 		cw_in_generic,				/* get */
-		cw_out_generic				/* put */
+		cw_out_generic,				/* put */
+		NULL,
+		NULL,
+		frame_tunnel_bits
 	}
 	,
 	{ 
@@ -919,6 +942,7 @@ struct cw_MsgSet * capwap_register_msg_set(struct cw_MsgSet * set, int mode){
 	
 	set->write_header = write_header;
 	set->header_len = header_len;
+	set->format_pkt_hdr = cw_format_pkt_hdr;
 
 	cw_dbg(DBG_INFO,"CAPWAP: Done register messages");
 	return set;

src/mod/cisco/mod_cisco.c

@@ -48,6 +48,16 @@ int cisco_out_radio_info(struct cw_ElemHandler * handler, struct cw_ElemHandlerP
 			, uint8_t * dst);
 
 
+
+
+struct cw_ValBit frame_tunnel_bits_draft7[] = {
+	{2,"native"},
+	{1,"802-3"},
+	{0,"local-bridging"},
+	{1, NULL}        
+};
+
+
 static cw_ValValRange_t cfg_type[]={
 	{1,1,"1 - global"},
 	{2,2,"2 - custom"},
@@ -679,8 +689,19 @@ static cw_ValStruct_t cisco_ap_venue_settings[]={
 	
 };
 
+
+static cw_ValValRange_t cisco_ap_modes[]={
+	{0,0,"0 - local"},
+	{1,1,"1 - monitor"},
+	{2,2,"2 - FlexConnect"},
+	{3,3,"3 - Rouge Detector"},
+	{4,4,"4 - Sniffer"},
+	{5,5,"5 - Bridge"},
+	{0,0,NULL}
+};
+
 static cw_ValStruct_t cisco_ap_mode_and_type[]={
-	{CW_TYPE_BYTE,"mode",1,-1},
+	{CW_TYPE_BYTE,"mode",1,-1,cisco_ap_modes},
 	{CW_TYPE_BYTE,"type",1,-1},
 	{NULL,NULL,0,0}
 };
@@ -946,6 +967,20 @@ static int cisco_data(struct cw_ElemHandler *eh,
 */
 
 static struct cw_ElemHandler handlers70[] = {
+	{ 
+		"WTP Frame Tunnel Mode (Draft 7)",		/* name */
+		CAPWAP_ELEM_WTP_FRAME_TUNNEL_MODE,	/* Element ID */
+		0,0,					/* Vendor / Proto */
+		1,1,					/* min/max length */
+		CW_TYPE_BITS,				/* type */
+		"capwap/wtp-frame-tunnel-mode",		/* Key */
+		cw_in_generic,				/* get */
+		cw_out_generic,				/* put */
+		NULL,
+		NULL,
+		frame_tunnel_bits_draft7
+	}
+	,
 	
 	{ 
 		"AC Name - (zero-length allowed)",	/* name */
@@ -3327,6 +3362,7 @@ static struct cw_MsgSet * register_messages(struct cw_MsgSet *set, int mode)
 
 			set->write_header = write_header;
 		      	set->header_len = header_len;	
+			set->format_pkt_hdr = cw_format_pkt_hdr_7;
 			break;
 		}
 		case CW_MOD_MODE_BINDINGS:

src/wtp/Makefile

@@ -5,9 +5,9 @@ OBJDIR=./o
 LIBDIR		:= ../../lib
 LIBARCHDIR	:= $(LIBDIR)/$(KERNEL)/$(ARCH)
 
-CFLAGS+=-I../ -DUSE_OPENSSL -I../../include
+CFLAGS+=-I../ -DUSE_OPENSSL -I../../include -I/usr/include/libnl3
 LDFLAGS+=-L$(LIBARCHDIR) -L/usr/local/lib
-LIBS+=-lcw -lnettle -lssl -lcrypto -ldl -lpthread -lmavl
+LIBS+=-lcw -lnettle -lssl -lcrypto -ldl -lpthread -lmavl -lnl-3 -lnl-genl-3
 
 SOURCES=\
      	wtp_main.c\
@@ -15,6 +15,7 @@ SOURCES=\
 	join.c\
 	configure.c\
 	run.c\
-	changestate.c
+	changestate.c \
+	nlt.c
 
 include ../prog.mk

src/wtp/dot11.h

@@ -322,6 +322,9 @@ struct beacon_data{
 int dot11_get_beacon_data(struct apdata *ap,struct beacon_data *bd);
 
 
+#define cw_dot11_get_version(frame) ( (frame)[1] & 3)
+#define cw_dot11_get_type(frame) ( ( (frame)[1] & 0x0c) >> 2)
+#define cw_dot11_get_subtype(frame)  ( (frame)[1] >> 4)
 
 
 #endif

src/wtp/nlt.c

@@ -1,16 +1,17 @@
-#include "netlink/netlink.h"
-#include "netlink/genl/genl.h"
-#include "netlink/genl/ctrl.h"
+#include <netlink/netlink.h>
+#include <netlink/genl/genl.h>
+#include <netlink/genl/ctrl.h>
 #include <netlink/msg.h>
 
 #include "cw/log.h"
 #include "cw/dbg.h"
-#include "cw/avltree.h"
+
+#include <mavl.h>
 
 #include "nlt.h"
 
 
-/*
+
 
 static int error_handler(struct sockaddr_nl *nla, struct nlmsgerr *err, void *arg)
 {
@@ -32,21 +33,22 @@ static int wiphylist_cmp(const void * d1,const void *d2)
 }
 
 
-struct avltree * wiphylist_create()
+struct mavl * wiphylist_create()
 {
-	return avltree_create(wiphylist_cmp,0);
+	return mavl_create(wiphylist_cmp,0,sizeof(struct nlt_wiphyinfo));
 }
 
 
-struct nlt_wiphyinfo * wiphylist_get( struct avltree * l,int idx)
+struct nlt_wiphyinfo * wiphylist_get( struct mavl * l,int idx)
 {
 	//return avltree_get(l);
 }
 
 
-struct nlt_wiphyinfo * nlt_wiphylist_add(struct avltree * t, struct nlt_wiphyinfo * wi)
+struct nlt_wiphyinfo * nlt_wiphylist_add(struct mavl * t, struct nlt_wiphyinfo * wi)
 {
-	return avltree_add(t,wi);
+	int exists;
+	return mavl_insert(t,wi,exists);
 }
 
 
@@ -258,7 +260,7 @@ static int nlCallback(struct nl_msg *msg, void *arg)
 		       genlmsg_attrlen(ghdr, 0), NULL);
 
 	if (rc < 0) {
-		cw_dbg(DBG_DRV_ERR, "nla_parse failed: %d %d", rc, nl_geterror(rc));
+		cw_dbg(DBG_X, "nla_parse failed: %d %d", rc, nl_geterror(rc));
 		return NL_SKIP;
 	}
 
@@ -267,7 +269,7 @@ static int nlCallback(struct nl_msg *msg, void *arg)
 
 	switch (cmd) {
 		case NL80211_CMD_NEW_WIPHY:
-			add_wiphy_data(msgattribs, arg);
+			//add_wiphy_data(msgattribs, arg);
 			break;
 //              case NL80211_CMD_NEW_INTERFACE:
 //                      add_interface_data(msgattribs);
@@ -337,7 +339,6 @@ static int get_wiphy_info_cb(struct nl_msg * msg,void * arg)
 
 int nlt_get_wiphy_list(struct nl_sock *sk)
 {
-
 	struct nlt_wiphyinfo ** wi = malloc (sizeof(struct nlt_wiphyinfo *)*NLT_MAX_WIPHYINDEX);
 	if (wi==0)
 		return 0;
@@ -347,9 +348,9 @@ int nlt_get_wiphy_list(struct nl_sock *sk)
 	struct nl_msg * msg = nlt_nl_msg_new(sk,NL80211_CMD_GET_WIPHY,NLM_F_DUMP);
 	nl_send_auto(sk, msg);
 	struct nl_cb *nl_cb = get_nl_cb(get_wiphy_info_cb,wi);
-//	while(1){
+	while(1){
 		int nlr = nl_recvmsgs(sk, nl_cb);
-//	}
+	}
 
 
 	int i;
@@ -364,4 +365,15 @@ int nlt_get_wiphy_list(struct nl_sock *sk)
 }
 
 
-*/
+nlt_test()
+{
+	struct nl_sock *nl;
+	nl = nl_socket_alloc();
+	if (!nl) {
+		fprintf(stderr, "Failed to allocate netlink socket.\n");
+		return -ENOMEM;
+	}
+
+	nlt_get_wiphy_list(nl);
+
+}

src/wtp/wtp_main.c

@@ -3,7 +3,7 @@
 #include <errno.h>
 #include <stdlib.h>
 #include <unistd.h>
-\
+
 
 #include "cw/val.h"
 #include "cw/dbg.h"
@@ -88,6 +88,82 @@ static int parse_args (int argc, char *argv[], struct bootcfg * bootcfg)
 struct bootcfg bootcfg;
 
 
+#include "cw/file.h"
+
+#include "cw/dot11.h"
+
+int test()
+{
+	int rc;
+	uint8_t  *f,*frame;
+	size_t len;
+	f=(uint8_t*)cw_load_file("wificap-002",&len);
+	cw_dbg(DBG_X, "Loaded %d bytes",len);
+	int l;
+
+	uint8_t rates[] = {
+		12,0x82,0x84,0x8b,0x96,0x0c,0x12,0x18,0x24,0x30,0x48,0x60,0x6c	
+	}; 
+
+//	static int got_radiotap = 0;
+//	struct libwifi_frame frame = {0};
+///	rc = libwifi_get_wifi_frame(&frame, (unsigned char*)(f+16+1), len-16-1, 0);
+
+// struct libwifi_frame_ctrl *frame_control = (struct libwifi_frame_ctrl *) (f+16);
+// printf("SO: %d\n",frame_control->type);
+
+  //  	if (rc != 0) {
+   //     	printf("[!] Error getting libwifi_frame: %d\n", rc);
+   // 	}
+
+//	cw_dbg(DBG_X,"Frame CTL:%d,%d",frame.frame_control.type, frame.frame_control.subtype);
+
+//	cw_dbg(DBG_X,"MY RESULT: Type %d, SubType %d",cw_dot11_get_type(f+16), cw_dot11_get_subtype(f+16));
+//	cw_dbg(DBG_X,"FRAME: %s",dot11_get_frame_name(f+16+1));
+	
+
+	cw_dbg(DBG_X,"%04x",dot11_get_word((uint8_t*)(f)+16));
+
+	char dstr[2048];
+
+	cw_format_dot11_hdr(dstr,f+16,len-16);
+
+	cw_dbg(DBG_X,"R:\n%s",dstr);
+
+	
+
+	cw_dbg_dot11_frame(f+16,len-16);
+
+	frame = f+16;
+
+	uint8_t  rframe[1000];
+
+
+        dot11_init_assoc_resp(rframe);
+	dot11_set_duration(rframe,100);
+
+        dot11_copy_mac(dot11_get_sa(frame),dot11_get_da(rframe));
+        dot11_copy_mac(dot11_get_bssid(frame),dot11_get_bssid(rframe));
+        dot11_copy_mac(dot11_get_da(frame),dot11_get_sa(rframe));
+	dot11_set_seq(rframe,0);
+	dot11_assoc_resp_set_cap(rframe,dot11_assoc_req_get_cap(frame));
+	dot11_assoc_resp_set_status_code(rframe,0);
+	dot11_assoc_resp_set_assoc_id(rframe,17);
+	l=24+6;
+
+
+	l+=dot11_put_supported_rates(rframe+l,rates);
+
+	cw_dbg_dot11_frame(rframe,l);
+
+
+
+	free(f);
+	return 0;
+}
+
+
+
 int main (int argc, char **argv)
 {
 	struct cw_Mod * mod;
@@ -102,6 +178,7 @@ int main (int argc, char **argv)
 	const char *bind_addr, *disc_addr;
 
 
+
 /*	
 
 {
@@ -135,6 +212,11 @@ int main (int argc, char **argv)
 		bootcfg.nmods=2;
 	}
 
+	test();
+	nlt_test();
+	stop();
+
+
 	/* 
 	 * set ths for production
 	 * cw_dbg_set_level(DBG_X,0);