2015-04-10 17:14:55 +02:00
|
|
|
/*
|
|
|
|
This file is part of libcapwap.
|
2015-04-07 07:46:55 +02:00
|
|
|
|
2015-04-10 17:14:55 +02:00
|
|
|
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/>.
|
|
|
|
|
|
|
|
*/
|
2015-04-07 07:46:55 +02:00
|
|
|
|
2015-10-18 09:07:30 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
2015-04-12 23:28:55 +02:00
|
|
|
/**
|
2015-04-13 14:55:03 +02:00
|
|
|
* @file Debugging Functions
|
2015-04-12 23:28:55 +02:00
|
|
|
* @brief Various debug functions.
|
2015-10-18 09:07:30 +02:00
|
|
|
*/
|
2018-03-02 00:12:38 +01:00
|
|
|
#include <stdarg.h>
|
2018-03-18 21:48:34 +01:00
|
|
|
#include <stdint.h>
|
2015-04-12 23:28:55 +02:00
|
|
|
|
2015-04-07 07:46:55 +02:00
|
|
|
#include "dbg.h"
|
2015-04-10 17:52:01 +02:00
|
|
|
#include "log.h"
|
2015-04-11 19:00:51 +02:00
|
|
|
#include "format.h"
|
2018-03-18 23:51:59 +01:00
|
|
|
#include "ansi_colors.h"
|
2018-03-02 00:12:38 +01:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
#include "dot11.h"
|
2018-03-02 00:12:38 +01:00
|
|
|
|
2015-10-18 09:07:30 +02:00
|
|
|
/**
|
|
|
|
*@addtogroup DBG
|
|
|
|
*@{
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
2018-02-23 09:06:04 +01:00
|
|
|
* @defgroup DebugFunctions Debug Functions
|
|
|
|
* @{
|
|
|
|
*/
|
2015-10-18 09:07:30 +02:00
|
|
|
|
2018-03-17 19:32:44 +01:00
|
|
|
uint32_t cw_dbg_opt_display = DBG_DISP_COLORS;
|
2015-10-17 22:43:49 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Current debug level
|
2018-02-23 09:06:04 +01:00
|
|
|
*/
|
2022-09-04 11:13:12 +02:00
|
|
|
//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));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
struct cw_DbgStr {
|
|
|
|
int level;
|
|
|
|
const char *str;
|
|
|
|
const char ** str_list;
|
|
|
|
const char *descr;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static const char * dbg_level_msg[] = {
|
|
|
|
"msg_in", "msg_out", NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char * dbg_level_pkt[] = {
|
|
|
|
"pkt_in", "pkt_out", NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char * dbg_level_elem[]={
|
|
|
|
"elem_in","elem_out",NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static const char * dbg_level_elem_detail[] = {
|
|
|
|
"elem_detail_in", "elem_detail_out", NULL
|
|
|
|
};
|
2022-09-04 12:30:08 +02:00
|
|
|
|
|
|
|
static const char * dbg_level_elem_all[] = {
|
|
|
|
"elem", "elem_dmp", "elem_detail",NULL
|
|
|
|
};
|
2022-09-04 11:13:12 +02:00
|
|
|
|
|
|
|
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*/
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Debug strings
|
|
|
|
*/
|
|
|
|
struct cw_DbgStr cw_dbg_strings[] = {
|
2022-09-04 12:30:08 +02:00
|
|
|
{ 0, "std", dbg_level_std, "some useful standard options to debug CAPWAP"},
|
|
|
|
{ 0, "msg", dbg_level_msg, "messages headers" },
|
|
|
|
{ 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_all", dbg_level_elem_all,"all possible elem options"},
|
|
|
|
|
|
|
|
{ DBG_WARN, "warn", NULL, "warnings" },
|
|
|
|
|
|
|
|
{ DBG_ELEM_ERR, "elem_err", NULL, "errors in elements" },
|
|
|
|
{ DBG_PKT_ERR, "pkt_err", NULL, "packets with errors which are usually would be discard" },
|
|
|
|
{ DBG_MSG_ERR, "msg_err", NULL, "message errors"},
|
|
|
|
{ DBG_RFC, "rfc", NULL, "errors related to RFC5415/RFC5416 viloations" },
|
|
|
|
{ DBG_CFG_UPDATES, "cfg_updates",NULL, "show configuration aupdates" },
|
|
|
|
{ DBG_MOD, "mod",NULL, "module related"},
|
|
|
|
{ DBG_MOD_DETAIL, "mod_detail",NULL, "module related details"},
|
|
|
|
{ DBG_STATE, "state",NULL, "CAWPAP states" },
|
|
|
|
{ DBG_MSG_COMPOSE, "msg_compose",NULL,"message composing details" },
|
|
|
|
|
|
|
|
|
|
|
|
{ DBG_INFO, "info", NULL, "several infos are displayed" },
|
|
|
|
{ DBG_PKT_IN, "pkt_in",NULL, "headers of incomming packets." },
|
|
|
|
{ DBG_PKT_OUT, "pkt_out",NULL, "headers out outgoing packets." },
|
|
|
|
{ DBG_PKT_DMP_IN, "pkt_dmp_in",NULL, "hex-dump incomming packets" },
|
|
|
|
{ DBG_PKT_DMP_OUT, "pkt_dmp_out",NULL, "hex-dump outgoing packets" },
|
|
|
|
|
|
|
|
{ DBG_MSG_IN, "msg_in", NULL, "incomming messages" },
|
|
|
|
{ DBG_MSG_OUT, "msg_out", NULL, "outgoing messages" },
|
|
|
|
{ DBG_MSG_DMP_IN, "msg_dmp_in", NULL, "hex-dump incomming messages" },
|
|
|
|
{ DBG_MSG_DMP_OUT, "msg_dmp_out", NULL,"hex-dump of outgong messages" },
|
2022-09-04 11:13:12 +02:00
|
|
|
|
|
|
|
|
2022-09-04 12:30:08 +02:00
|
|
|
{ DBG_ELEM_IN, "elem_in", NULL, "elements of incomming messages"},
|
|
|
|
{ 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_VNDR, "elem_vndr", NULL, "expand vendor specific payloads"},
|
2022-09-04 11:13:12 +02:00
|
|
|
|
2022-09-04 12:30:08 +02:00
|
|
|
{ DBG_DTLS, "dtls",NULL, "DTLS related stuff"},
|
|
|
|
{ DBG_DTLS_BIO, "dtls_bio",NULL, "DTLS BIO releated" },
|
|
|
|
{ DBG_DTLS_BIO_DMP, "dtls_bio_dmp",NULL, "hex-dump dtls packets" },
|
|
|
|
{ DBG_DTLS_DETAIL, "dtls_detail",NULL, "DTLS detailed messages"},
|
2022-09-04 11:13:12 +02:00
|
|
|
|
2022-09-04 12:30:08 +02:00
|
|
|
{ DBG_X, "x", NULL, "only for developers" },
|
2022-09-04 11:13:12 +02:00
|
|
|
|
2022-09-04 12:30:08 +02:00
|
|
|
{ DBG_ALL, "all", NULL, "all debug levels at once"},
|
2022-09-04 11:13:12 +02:00
|
|
|
|
|
|
|
|
2022-09-04 12:30:08 +02:00
|
|
|
{ 0, NULL }
|
2022-09-04 11:13:12 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
*@}
|
|
|
|
*/
|
2015-04-11 19:00:51 +02:00
|
|
|
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
2016-03-09 18:39:57 +01:00
|
|
|
|
|
|
|
|
2022-08-11 00:21:01 +02:00
|
|
|
static struct cw_StrListElem theme0[] = {
|
2018-03-18 23:51:59 +01:00
|
|
|
{DBG_PKT_IN, ANSI_YELLOW},
|
|
|
|
{DBG_PKT_OUT, ANSI_YELLOW ANSI_ITALIC},
|
|
|
|
|
|
|
|
{DBG_PKT_DMP_IN, ANSI_BYELLOW},
|
|
|
|
{DBG_PKT_DMP_OUT, ANSI_BYELLOW ANSI_ITALIC},
|
|
|
|
|
|
|
|
{DBG_MSG_IN, ANSI_BLUE ANSI_BOLD},
|
|
|
|
|
|
|
|
{DBG_MSG_OUT, ANSI_BLUE ANSI_BOLD ANSI_ITALIC},
|
2022-08-21 00:53:41 +02:00
|
|
|
{DBG_MSG_COMPOSE, ANSI_BLUE ANSI_ITALIC},
|
2018-03-18 23:51:59 +01:00
|
|
|
|
|
|
|
|
2022-08-21 00:53:41 +02:00
|
|
|
{DBG_MSG_DMP_IN, ANSI_BBLUE },
|
|
|
|
{DBG_MSG_DMP_OUT, ANSI_BBLUE ANSI_ITALIC},
|
2018-03-18 23:51:59 +01:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
{DBG_ELEM_IN, ANSI_DEFAULT},
|
|
|
|
{DBG_ELEM_OUT, ANSI_DEFAULT ANSI_ITALIC},
|
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
{DBG_MSG_ERR, ANSI_RED},
|
|
|
|
{DBG_PKT_ERR, ANSI_RED},
|
|
|
|
{DBG_ELEM_ERR, ANSI_RED},
|
2018-03-18 21:48:34 +01:00
|
|
|
|
2022-08-20 21:00:46 +02:00
|
|
|
// {DBG_SUBELEM, ANSI_BBLACK},
|
2018-03-18 23:51:59 +01:00
|
|
|
{DBG_DTLS, ANSI_MAGENTA ANSI_BOLD},
|
|
|
|
{DBG_DTLS_DETAIL, ANSI_MAGENTA},
|
|
|
|
{DBG_DTLS_BIO, ANSI_BMAGENTA},
|
2018-02-23 09:06:04 +01:00
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
{DBG_INFO, ANSI_DEFAULT},
|
2018-02-23 09:06:04 +01:00
|
|
|
|
2022-08-11 00:21:01 +02:00
|
|
|
{DBG_STATE, ANSI_GREEN ANSI_BOLD},
|
2018-05-07 10:57:12 +02:00
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
{DBG_RFC, ANSI_BRED},
|
2018-02-23 09:06:04 +01:00
|
|
|
{DBG_X, "\x1b[31m"},
|
2018-03-18 23:51:59 +01:00
|
|
|
{DBG_WARN, ANSI_CYAN},
|
2022-08-28 09:06:15 +02:00
|
|
|
{DBG_MOD_DETAIL, ANSI_WHITE},
|
|
|
|
{DBG_MOD, ANSI_BBLACK ANSI_BOLD },
|
2022-08-21 00:53:41 +02:00
|
|
|
// {DBG_CFG_DMP, ANSI_BCYAN },
|
2022-08-22 01:59:23 +02:00
|
|
|
{DBG_CFG_UPDATES,ANSI_GREEN},
|
2022-08-20 21:00:46 +02:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
{CW_STR_STOP, ""}
|
2015-04-12 10:19:02 +02:00
|
|
|
};
|
2018-02-23 09:06:04 +01:00
|
|
|
|
2022-08-11 00:21:01 +02:00
|
|
|
static struct cw_StrListElem * color_on = theme0;
|
|
|
|
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
struct cw_StrListElem color_ontext[] = {
|
2015-04-12 10:19:02 +02:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
/* {DBG_ELEM_DMP, "\x1b[37m"},*/
|
2022-08-20 22:03:06 +02:00
|
|
|
{DBG_ELEM_DMP_OUT, ANSI_BBLACK ANSI_ITALIC},
|
|
|
|
{DBG_ELEM_DMP_IN, ANSI_BBLACK},
|
2018-03-18 23:51:59 +01:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
{CW_STR_STOP, ""}
|
2015-04-12 10:19:02 +02:00
|
|
|
};
|
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
/*
|
2018-03-17 19:32:44 +01:00
|
|
|
static struct cw_StrListElem color_off[] = {
|
2015-04-12 10:19:02 +02:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
{CW_STR_STOP, "\x1b[22;39m\x1b[23m"}
|
2015-04-12 10:19:02 +02:00
|
|
|
};
|
2018-03-18 23:51:59 +01:00
|
|
|
*/
|
2015-04-12 10:19:02 +02:00
|
|
|
|
2018-03-17 19:32:44 +01:00
|
|
|
static struct cw_StrListElem prefix[] = {
|
2022-08-28 09:06:15 +02:00
|
|
|
{DBG_INFO, "Info - "},
|
|
|
|
{DBG_PKT_IN, "Pkt In - "},
|
|
|
|
{DBG_PKT_OUT, "Pkt Out - "},
|
2022-08-21 00:53:41 +02:00
|
|
|
{DBG_MSG_IN, "Msg In - "},
|
|
|
|
{DBG_MSG_OUT, "Msg Out - "},
|
|
|
|
|
2022-08-28 09:06:15 +02:00
|
|
|
{DBG_ELEM_IN, " Msg Element - "},
|
|
|
|
{DBG_ELEM_OUT, " Msg Element - "},
|
2018-03-18 21:48:34 +01:00
|
|
|
|
2022-08-28 09:06:15 +02:00
|
|
|
{DBG_MSG_ERR, " Msg Error - "},
|
|
|
|
{DBG_PKT_ERR, " Pkt Error - "},
|
|
|
|
{DBG_ELEM_ERR, " Elem Error - "},
|
|
|
|
{DBG_RFC, " RFC - "},
|
2022-08-21 00:53:41 +02:00
|
|
|
{DBG_DTLS, "DTLS - "},
|
|
|
|
{DBG_DTLS_DETAIL, "DTLS - "},
|
2022-09-01 10:24:40 +02:00
|
|
|
{DBG_WARN, "Warning - "},
|
2022-08-21 00:53:41 +02:00
|
|
|
{DBG_MOD, "Mod - "},
|
2022-08-28 09:06:15 +02:00
|
|
|
{DBG_MOD_DETAIL, "Mod - "},
|
2022-08-21 00:53:41 +02:00
|
|
|
{DBG_STATE, "STATEMACHINE - "},
|
|
|
|
{DBG_CFG_UPDATES, "Cfg - "},
|
2022-08-09 21:51:49 +02:00
|
|
|
|
|
|
|
|
2018-03-19 17:26:01 +01:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
{DBG_X, "XXXXX - "},
|
|
|
|
|
2022-08-20 21:00:46 +02:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
{CW_STR_STOP, ""}
|
2015-04-12 10:19:02 +02:00
|
|
|
};
|
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
static const char *get_dbg_color_on(int level)
|
|
|
|
{
|
|
|
|
if (!(cw_dbg_opt_display & DBG_DISP_COLORS))
|
2015-04-12 10:19:02 +02:00
|
|
|
return "";
|
2018-02-23 09:06:04 +01:00
|
|
|
return cw_strlist_get_str(color_on, level);
|
2015-04-12 10:19:02 +02:00
|
|
|
}
|
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
/*
|
2018-02-23 09:06:04 +01:00
|
|
|
static const char *get_dbg_color_off(int level)
|
|
|
|
{
|
|
|
|
if (!(cw_dbg_opt_display & DBG_DISP_COLORS))
|
2015-04-12 10:19:02 +02:00
|
|
|
return "";
|
2018-02-23 09:06:04 +01:00
|
|
|
return cw_strlist_get_str(color_off, level);
|
2015-04-12 10:19:02 +02:00
|
|
|
}
|
2018-03-18 23:51:59 +01:00
|
|
|
*/
|
2015-04-12 10:19:02 +02:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
static const char *get_dbg_prefix(int level)
|
|
|
|
{
|
|
|
|
return cw_strlist_get_str(prefix, level);
|
2015-04-12 10:19:02 +02:00
|
|
|
}
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
const char *get_dbg_color_ontext(int level)
|
2018-02-23 09:06:04 +01:00
|
|
|
{
|
|
|
|
if (!(cw_dbg_opt_display & DBG_DISP_COLORS))
|
2015-04-12 10:19:02 +02:00
|
|
|
return "";
|
2018-02-23 09:06:04 +01:00
|
|
|
return cw_strlist_get_str(color_ontext, level);
|
2015-04-12 10:19:02 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
/**
|
|
|
|
* Check if a specific debug level is set.
|
|
|
|
* @param level Level to check
|
|
|
|
* @return 0 if leveln is not set, otherwise level is set
|
|
|
|
*/
|
2015-04-12 10:19:02 +02:00
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
int cw_dbg_is_level(int level)
|
|
|
|
{
|
2022-09-04 11:13:12 +02:00
|
|
|
if (cw_dbg_opt_level == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return mavl_get(cw_dbg_opt_level,&level) == NULL ? 0:1;
|
|
|
|
|
|
|
|
|
|
|
|
// if (level > 1 && (level &1))
|
2018-03-18 23:51:59 +01:00
|
|
|
return 1;
|
2022-08-20 21:00:46 +02:00
|
|
|
|
|
|
|
/* if (level >= DBG_ALL ){
|
|
|
|
return 1;
|
|
|
|
}*/
|
2022-09-04 11:13:12 +02:00
|
|
|
// return (cw_dbg_opt_level & (level));
|
2018-03-18 23:51:59 +01:00
|
|
|
}
|
2015-04-12 10:19:02 +02:00
|
|
|
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
static void cw_dbg_vlog_line(struct cw_LogWriter * writer,
|
|
|
|
const char * prefix, const char * prefix_color,
|
|
|
|
const char *textcolor,const char * format, va_list args)
|
|
|
|
{
|
|
|
|
char fbuf[512];
|
|
|
|
|
|
|
|
if ( writer->colored){
|
2022-08-20 21:00:46 +02:00
|
|
|
sprintf(fbuf,"DBG: %s%s%s%s%s",
|
2018-03-18 21:48:34 +01:00
|
|
|
prefix_color,prefix,textcolor,format,DBG_CLR_OFF);
|
|
|
|
}
|
|
|
|
else{
|
2022-08-20 21:00:46 +02:00
|
|
|
sprintf(fbuf,"DBG: %s%s",
|
2018-03-18 21:48:34 +01:00
|
|
|
prefix,format);
|
|
|
|
|
|
|
|
}
|
|
|
|
writer->write(LOG_DEBUG,fbuf,args,writer);
|
2015-04-12 10:19:02 +02:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
}
|
2015-04-12 10:19:02 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
2015-04-10 17:14:55 +02:00
|
|
|
/**
|
|
|
|
* Put a list of missing mandatory message elements to debug output
|
|
|
|
*/
|
2022-08-09 22:35:47 +02:00
|
|
|
void cw_dbg_missing_mand(int level, struct cw_Conn *conn, int ** ml, int n,
|
2018-03-17 17:29:09 +01:00
|
|
|
int * a)
|
2015-04-07 07:46:55 +02:00
|
|
|
{
|
2018-03-05 20:39:15 +01:00
|
|
|
/*
|
2018-02-23 09:06:04 +01:00
|
|
|
// if (!cw_dbg_is_level(DBG_MSG_ERR) || n == 0)
|
|
|
|
// return;
|
2018-03-05 20:39:15 +01:00
|
|
|
*/
|
2015-04-12 19:19:29 +02:00
|
|
|
|
2015-04-07 07:46:55 +02:00
|
|
|
|
|
|
|
char buffer[2000];
|
2018-03-05 20:39:15 +01:00
|
|
|
/* char *p = buffer; */
|
2015-04-07 07:46:55 +02:00
|
|
|
int i;
|
2018-03-05 20:39:15 +01:00
|
|
|
/* char *delim = "";*/
|
|
|
|
|
|
|
|
if (!cw_dbg_is_level(level) || n == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
2018-02-26 18:28:12 +01:00
|
|
|
// TODO XXXX
|
2018-03-05 20:39:15 +01:00
|
|
|
*/
|
2015-04-11 19:00:51 +02:00
|
|
|
for (i = 0; i < n; i++) {
|
2018-02-26 18:28:12 +01:00
|
|
|
/* p += sprintf(p, "%s", delim);
|
2015-04-11 19:00:51 +02:00
|
|
|
delim = ", ";
|
|
|
|
p += sprintf(p, "%s", cw_strelemp(conn->actions, ml[i]->elem_id));
|
2018-02-26 18:28:12 +01:00
|
|
|
*/
|
2015-04-11 19:00:51 +02:00
|
|
|
}
|
2015-04-12 19:19:29 +02:00
|
|
|
cw_dbg(level, "Missing mandatory elements: [%s]", buffer);
|
2015-04-11 19:00:51 +02:00
|
|
|
}
|
|
|
|
|
2015-04-12 10:19:02 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
2015-04-13 14:55:03 +02:00
|
|
|
/**
|
|
|
|
* Display a packet on for debugger
|
2018-02-23 09:06:04 +01:00
|
|
|
*/
|
2022-08-09 22:35:47 +02:00
|
|
|
void cw_dbg_pkt(int level, struct cw_Conn *conn, uint8_t * packet, int len,
|
2018-02-23 09:06:04 +01:00
|
|
|
struct sockaddr *from)
|
2015-04-11 19:00:51 +02:00
|
|
|
{
|
|
|
|
|
|
|
|
char buf[1024];
|
2022-09-12 00:28:58 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-04-12 15:15:40 +02:00
|
|
|
|
2018-03-05 20:39:15 +01:00
|
|
|
if (!cw_dbg_is_level(level))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (level == DBG_PKT_IN)
|
2022-09-12 00:28:58 +02:00
|
|
|
fmt_pkt_hdr(buf, 1, packet, len, from);
|
2018-03-05 20:39:15 +01:00
|
|
|
else
|
2022-09-12 00:28:58 +02:00
|
|
|
fmt_pkt_hdr(buf, 0, packet, len, from);
|
2018-03-05 20:39:15 +01:00
|
|
|
|
2018-03-25 10:35:53 +02:00
|
|
|
/* hlen = cw_get_hdr_msg_offset(packet);*/
|
2016-03-21 23:35:08 +01:00
|
|
|
|
2018-03-18 23:51:59 +01:00
|
|
|
cw_dbg(level, "%s", buf);
|
2018-03-05 20:39:15 +01:00
|
|
|
|
2022-08-20 22:03:06 +02:00
|
|
|
// if (cw_dbg_is_level(DBG_PKT_DMP)) {
|
2018-03-18 23:51:59 +01:00
|
|
|
int dlevel;
|
|
|
|
if (level == DBG_PKT_IN){
|
|
|
|
dlevel=DBG_PKT_DMP_IN;
|
|
|
|
}
|
|
|
|
else{
|
|
|
|
dlevel=DBG_PKT_DMP_OUT;
|
|
|
|
}
|
|
|
|
cw_dbg_dmp(dlevel,packet,len,"");
|
2022-08-20 22:03:06 +02:00
|
|
|
// }
|
2018-03-18 23:51:59 +01:00
|
|
|
|
2015-04-11 19:00:51 +02:00
|
|
|
}
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
|
|
|
|
void cw_dbg_dmp(int level, const uint8_t * data, int len, const char *format, ...)
|
2016-04-10 15:58:10 +02:00
|
|
|
{
|
2018-03-18 21:48:34 +01:00
|
|
|
char *dmp,*s,*c;
|
|
|
|
struct cw_FormatDumpSettings settings;
|
|
|
|
|
2016-04-10 15:58:10 +02:00
|
|
|
if (!cw_dbg_is_level(level))
|
|
|
|
return;
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
cw_format_get_dump_defaults(&settings);
|
|
|
|
|
|
|
|
settings.dump_prefix=" ";
|
|
|
|
settings.newline="\n ";
|
|
|
|
settings.dump_suffix="\n";
|
|
|
|
|
2015-04-11 19:00:51 +02:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
dmp = cw_format_dump(data, len, &settings);
|
2016-03-12 16:12:36 +01:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
/* wrtie the dump line by line to the log file */
|
|
|
|
c=dmp;
|
|
|
|
while ((s=strchr(c,'\n'))!=NULL){
|
|
|
|
*s=0;
|
|
|
|
cw_dbg(level," %s",c);
|
|
|
|
c=s+1;
|
|
|
|
}
|
2016-03-12 16:12:36 +01:00
|
|
|
|
|
|
|
free(dmp);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-08-09 22:35:47 +02:00
|
|
|
void cw_dbg_msg(int level, struct cw_Conn *conn, uint8_t * packet, int len,
|
2018-02-23 09:06:04 +01:00
|
|
|
struct sockaddr *from)
|
2015-04-11 19:00:51 +02:00
|
|
|
{
|
2018-03-05 20:39:15 +01:00
|
|
|
|
2018-03-05 12:23:16 +01:00
|
|
|
char sock_buf[SOCK_ADDR_BUFSIZE];
|
2015-04-11 19:00:51 +02:00
|
|
|
char buf[1024];
|
2018-03-05 20:39:15 +01:00
|
|
|
char *s;
|
|
|
|
struct cw_MsgData search;
|
|
|
|
struct cw_MsgData * message;
|
|
|
|
const char * msname;
|
|
|
|
uint8_t *msgptr;
|
|
|
|
int msg_id;
|
|
|
|
|
|
|
|
if (!cw_dbg_is_level(level))
|
|
|
|
return;
|
|
|
|
|
|
|
|
s = buf;
|
2015-04-11 19:00:51 +02:00
|
|
|
|
2018-03-05 20:39:15 +01:00
|
|
|
msgptr = cw_get_hdr_msg_ptr(packet);
|
|
|
|
msg_id = cw_get_msg_id(msgptr);
|
|
|
|
|
2018-02-26 20:18:53 +01:00
|
|
|
search.type = msg_id;
|
2018-03-11 00:56:41 +01:00
|
|
|
message = mavl_get(conn->msgset->msgdata,&search);
|
2018-03-05 20:39:15 +01:00
|
|
|
|
2018-02-26 23:14:32 +01:00
|
|
|
if (!message)
|
2018-03-18 21:48:34 +01:00
|
|
|
msname=cw_strmsg(msg_id);
|
2018-02-26 23:14:32 +01:00
|
|
|
else
|
|
|
|
msname = message->name;
|
2018-02-26 20:18:53 +01:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
s += sprintf(s, "%s Message (type=%d) ", msname , msg_id);
|
2018-02-23 09:06:04 +01:00
|
|
|
if (level == DBG_MSG_IN)
|
2018-03-05 12:23:16 +01:00
|
|
|
s += sprintf(s, "from %s ", sock_addr2str(from,sock_buf));
|
2015-04-13 11:00:46 +02:00
|
|
|
else
|
2018-03-05 12:23:16 +01:00
|
|
|
s += sprintf(s, "to %s ", sock_addr2str(from,sock_buf));
|
2015-04-13 11:00:46 +02:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
s += sprintf(s, ", Seqnum: %d ElemLen: %d", cw_get_msg_seqnum(msgptr),
|
|
|
|
cw_get_msg_elems_len(msgptr));
|
2018-03-18 21:48:34 +01:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
cw_dbg(level, "%s", buf);
|
2018-03-18 23:51:59 +01:00
|
|
|
|
|
|
|
|
2022-08-21 00:53:41 +02:00
|
|
|
// if (cw_dbg_is_level(DBG_MSG_DMP)){
|
2018-03-18 23:51:59 +01:00
|
|
|
int dlevel;
|
|
|
|
if(level==DBG_MSG_IN){
|
2022-08-21 00:53:41 +02:00
|
|
|
dlevel = DBG_MSG_DMP_IN;
|
2018-03-18 23:51:59 +01:00
|
|
|
}
|
|
|
|
else{
|
2022-08-21 00:53:41 +02:00
|
|
|
dlevel = DBG_MSG_DMP_OUT;
|
2018-03-18 23:51:59 +01:00
|
|
|
}
|
|
|
|
cw_dbg_dmp(dlevel,packet,len,"");
|
2022-08-21 00:53:41 +02:00
|
|
|
// }
|
2018-03-18 23:51:59 +01:00
|
|
|
|
|
|
|
|
2015-04-07 07:46:55 +02:00
|
|
|
}
|
2015-04-10 17:14:55 +02:00
|
|
|
|
2015-04-11 19:00:51 +02:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
void cw_dbg(int level, const char *format, ...){
|
|
|
|
int i;
|
|
|
|
va_list args;
|
2018-03-05 20:39:15 +01:00
|
|
|
|
2015-04-12 10:19:02 +02:00
|
|
|
if (!(cw_dbg_is_level(level)))
|
2015-04-11 19:00:51 +02:00
|
|
|
return;
|
2018-03-18 21:48:34 +01:00
|
|
|
|
|
|
|
for (i=0; cw_log_writers[i]; i++){
|
|
|
|
va_start(args, format);
|
|
|
|
cw_dbg_vlog_line(cw_log_writers[i],
|
|
|
|
get_dbg_prefix(level),get_dbg_color_on(level),
|
|
|
|
get_dbg_color_ontext(level),
|
|
|
|
format, args);
|
|
|
|
va_end(args);
|
|
|
|
}
|
|
|
|
}
|
2015-04-11 19:00:51 +02:00
|
|
|
|
2018-02-23 09:06:04 +01:00
|
|
|
|
2018-03-17 19:32:44 +01:00
|
|
|
|
2022-08-09 22:35:47 +02:00
|
|
|
void cw_dbg_elem(int level, struct cw_Conn *conn, int msg,
|
2018-03-19 17:26:01 +01:00
|
|
|
struct cw_ElemHandler * handler, const uint8_t * msgbuf, int len)
|
2018-03-18 21:48:34 +01:00
|
|
|
{
|
|
|
|
char vendorname[256];
|
|
|
|
char vendor_details[265];
|
2018-03-18 23:51:59 +01:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
|
|
|
|
if (!cw_dbg_is_level(level))
|
|
|
|
return;
|
|
|
|
|
|
|
|
*vendor_details = 0;
|
2018-03-17 19:32:44 +01:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
if (handler->vendor){
|
|
|
|
sprintf(vendorname,"Vendor %s",cw_strvendor(handler->vendor));
|
|
|
|
}
|
|
|
|
else{
|
2018-03-25 10:35:53 +02:00
|
|
|
sprintf(vendorname,"%s","");
|
2018-03-18 21:48:34 +01:00
|
|
|
}
|
2015-04-11 19:00:51 +02:00
|
|
|
|
2018-03-19 17:26:01 +01:00
|
|
|
|
|
|
|
cw_dbg(level,"%s %d (%s), len=%d ",vendorname,handler->id,
|
2018-03-18 21:48:34 +01:00
|
|
|
handler->name,len);
|
2018-03-19 08:31:50 +01:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
if (cw_dbg_is_level(DBG_ELEM_DMP)) {
|
2022-08-20 22:03:06 +02:00
|
|
|
if (level == DBG_ELEM_OUT)
|
|
|
|
cw_dbg_dmp(DBG_ELEM_DMP_OUT,msgbuf,len,"");
|
|
|
|
else
|
|
|
|
cw_dbg_dmp(DBG_ELEM_DMP_IN,msgbuf,len,"");
|
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
}
|
2015-04-19 16:44:20 +02:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
return;
|
2015-04-19 16:44:20 +02:00
|
|
|
|
2018-03-18 21:48:34 +01:00
|
|
|
}
|
2018-03-03 17:42:28 +01:00
|
|
|
|
|
|
|
|
|
|
|
|
2022-09-04 11:13:12 +02:00
|
|
|
/**
|
|
|
|
* 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;
|
|
|
|
}
|
2018-03-03 17:42:28 +01:00
|
|
|
|
2022-09-04 11:13:12 +02:00
|
|
|
if (on){
|
|
|
|
mavl_insert(cw_dbg_opt_level,&level,&exists);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
mavl_del(cw_dbg_opt_level,&level);
|
2018-03-03 17:42:28 +01:00
|
|
|
|
|
|
|
|
2022-09-04 11:13:12 +02:00
|
|
|
/*
|
|
|
|
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)
|
|
|
|
{
|
2022-09-04 12:30:08 +02:00
|
|
|
int i,all;
|
|
|
|
all = strcmp(level,"all")==0 ? 1: 0;
|
2022-09-04 11:13:12 +02:00
|
|
|
|
|
|
|
for(i=0; cw_dbg_strings[i].str != NULL; i++){
|
2022-09-04 12:30:08 +02:00
|
|
|
if (strcmp(cw_dbg_strings[i].str,level)==0 || all){
|
2022-09-04 11:13:12 +02:00
|
|
|
if (cw_dbg_strings[i].str_list==NULL)
|
|
|
|
cw_dbg_set_level(cw_dbg_strings[i].level,on);
|
|
|
|
else {
|
|
|
|
const char **l;
|
|
|
|
for (l=cw_dbg_strings[i].str_list; *l; l++){
|
|
|
|
if (!cw_dbg_set_level_from_str0(*l,on)){
|
|
|
|
stop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-09-04 12:30:08 +02:00
|
|
|
if (!all)
|
|
|
|
return 1;
|
2022-09-04 11:13:12 +02:00
|
|
|
}
|
|
|
|
}
|
2022-09-04 12:30:08 +02:00
|
|
|
if (all)
|
|
|
|
return 1;
|
2022-09-04 11:13:12 +02:00
|
|
|
/* blevel = cw_strlist_get_id(cw_dbg_strings, slevel);
|
|
|
|
if (blevel==-1)
|
|
|
|
return 0;
|
|
|
|
*/
|
|
|
|
// cw_dbg_set_level(blevel,on);
|
|
|
|
// return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int cw_dbg_set_level_from_str(const char *level)
|
|
|
|
{
|
|
|
|
int on;
|
|
|
|
const char *slevel;
|
|
|
|
|
|
|
|
switch(*level){
|
|
|
|
case '-':
|
|
|
|
case '!':
|
|
|
|
case '~':
|
|
|
|
on =0;
|
|
|
|
slevel=level+1;
|
|
|
|
break;
|
|
|
|
case '+':
|
|
|
|
slevel=level+1;
|
|
|
|
on=1;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
slevel=level;
|
|
|
|
on=1;
|
|
|
|
}
|
|
|
|
return cw_dbg_set_level_from_str0(slevel,on);
|
|
|
|
}
|
2018-03-03 17:42:28 +01:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
2022-09-04 12:30:08 +02:00
|
|
|
void cw_dbg_print_help(FILE *out, const char * prefix)
|
|
|
|
{
|
|
|
|
struct cw_DbgStr *s;
|
|
|
|
for (s=cw_dbg_strings; s->str != NULL; s++){
|
|
|
|
const char * descr = s->descr!=NULL ? s->descr : "";
|
|
|
|
fprintf(out,"%s%s: %s",prefix,s->str,descr);
|
|
|
|
if (s->str_list != NULL){
|
|
|
|
const char **l;
|
|
|
|
char *sp="";
|
|
|
|
fprintf(out," (");
|
|
|
|
for(l = s->str_list; *l!=NULL; l++){
|
|
|
|
fprintf(out,"%s%s",sp,*l);
|
|
|
|
sp=" ";
|
|
|
|
}
|
|
|
|
fprintf(out,")");
|
|
|
|
}
|
|
|
|
fprintf(out,"\n");
|
|
|
|
}
|
|
|
|
}
|
2018-03-03 17:42:28 +01:00
|
|
|
|
2015-04-19 16:44:20 +02:00
|
|
|
|
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
void cw_dbg_dot11_elems(const uint8_t *src,int len)
|
|
|
|
{
|
|
|
|
uint8_t id,l;
|
|
|
|
int p;
|
|
|
|
char str[1024];
|
2022-09-18 08:04:49 +02:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
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);
|
|
|
|
}
|
2015-04-19 16:44:20 +02:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
}
|
2015-04-19 16:44:20 +02:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
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);
|
2015-04-19 16:44:20 +02:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
int type =dot11_get_type_and_subtype(frame);
|
2015-04-19 16:44:20 +02:00
|
|
|
|
2022-09-12 00:28:58 +02:00
|
|
|
switch (type){
|
|
|
|
case DOT11_ASSOC_REQ:
|
|
|
|
cw_dbg_dot11_elems(frame+28,len-28);
|
|
|
|
break;
|
2022-09-15 07:47:41 +02:00
|
|
|
case DOT11_ASSOC_RESP:
|
2022-09-18 08:04:49 +02:00
|
|
|
|
|
|
|
cw_dbg_dot11_elems((frame+DOT11_BODY_POS+DOT11_ASSOC_RESP_BODY_LEN),
|
|
|
|
len-DOT11_BODY_POS-DOT11_ASSOC_RESP_BODY_LEN);
|
2022-09-15 07:47:41 +02:00
|
|
|
break;
|
2022-09-12 00:28:58 +02:00
|
|
|
|
|
|
|
}
|
2015-04-19 16:44:20 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-04-13 14:55:03 +02:00
|
|
|
/**@}*/
|
2015-04-11 19:00:51 +02:00
|
|
|
|
2015-10-18 09:07:30 +02:00
|
|
|
|
|
|
|
/**@}*/
|