void cds_alloc_free(allocator_t *alloc,void *addr)
{
cds_slab_t *slab_list;
struct list_head *new_head;
struct list_head **free_slabs;
uint32_t size;
cds_alloc_t *alloc_p = &alloc->priv.cds_alloc;
dbg_str(DBG_ALLOC_DETAIL,"cds_alloc_free");
if(addr == NULL){
dbg_str(DBG_ALLOC_DETAIL,"release addr is NULL");
return;
}
slab_list = container_of(addr,cds_slab_t,data);
if(slab_list->stat_flag == 0){
dbg_str(DBG_WARNNING,"this addr has been released");
return;
}
dbg_str(DBG_ALLOC_DETAIL,"release slab_list:%p",slab_list);
dbg_str(DBG_ALLOC_DETAIL,"release mem_addr:%p,addr:%p",slab_list->mem_addr,addr);
new_head = &slab_list->list_head;
size = slab_list->size;
free_slabs = alloc_p->free_slabs;
slab_detach_list_from_used_slabs(alloc,
new_head,//struct list_head *del_head,
size);//uint32_t size);
slab_list->stat_flag = 0;
slab_attach_list_to_free_slabs(alloc,
new_head,//struct list_head *new_head,
size);//uint32_t size);
}
/* not del list,just detach it from one link list */
void mempool_detach_list(struct list_head *del_head,struct list_head *hl_head)
{
cds_mempool_head_list_t *head_list;
cds_mempool_t *mempool_list;
dbg_str(DBG_ALLOC_DETAIL,"mempool_detach_list");
head_list = container_of(hl_head,cds_mempool_head_list_t,list_head);
/*
*pthread_rwlock_wrlock(&head_list->head_lock);
*/
sync_lock(&head_list->head_lock,NULL);
/*
*dbg_str(DBG_ALLOC_DETAIL,"mempool del head:%p, hl_head:%p",del_head,hl_head);
*dbg_str(DBG_ALLOC_DETAIL,"mempool del heads next:%p, prev:%p",del_head->next,del_head->prev);
*/
list_del(del_head);
head_list->count--;
mempool_list = container_of(del_head,cds_mempool_t,list_head);
sync_unlock(&head_list->head_lock);
/*
*pthread_rwlock_unlock(&head_list->head_lock);
*/
dbg_str(DBG_ALLOC_DETAIL,"del_mempool list,list count =%d",head_list->count);
}
void *cds_alloc_alloc(allocator_t *alloc,uint32_t size)
{
cds_slab_t *slab_list;
uint32_t index;
index = slab_get_slab_index(alloc,size);
dbg_str(DBG_ALLOC_DETAIL,"size=%d,index=%d,slab_array_max_num=%d",
size,index,alloc->priv.cds_alloc.slab_array_max_num);
if(size > alloc->priv.cds_alloc.mempool_capacity){
dbg_str(DBG_ERROR,"apply szie excess mempool_capacity");
return NULL;
}
if(index >= alloc->priv.cds_alloc.slab_array_max_num){
dbg_str(DBG_ERROR,"apply size:%d too large,max size:%d,excess slab num,"
"please assignd by sys malloc,or reconfig cds_alloc",size,20*8);
return NULL;
}else{
dbg_str(DBG_ALLOC_DETAIL,"cds_alloc_alloc");
slab_list = slab_get_first_list_from_free_slabs(alloc,size);
if(slab_list == NULL){
slab_list = mempool_alloc_slab_list(alloc,size);
}
slab_attach_list_to_used_slabs(alloc,&slab_list->list_head,size);
return slab_list->mem_addr;
}
}
int hexstr2num(const char* const_str)
{
uint32_t ret=0;
uint32_t t;
char * str = (char *)const_str;
int len = strlen(str);
if(strncmp(str,"0x",2) && strncmp(str,"0X",2)) {
dbg_str(DBG_ERROR,"not hex data err");
return -1;
};
if(len > 10) {
dbg_str(DBG_ERROR,"str is too long");
return -1;
}
for (str += 2; *str; str++)
{
if (*str>='A' && *str <='F')
t = *str-55;//a-f之间的ascii与对应数值相差55如'A'为65,65-55即为A
else
t = *str-48;
ret <<= 4;
ret |= t;
}
return ret;
}
int vector_push_back(vector_t *vector,void *data)
{
uint32_t data_size = vector->data_size;
void *vector_head = vector->vector_head;
uint32_t step = vector->step;
uint32_t capacity = vector->capacity;
uint32_t push_pos = vector->end.vector_pos;
sync_lock(&vector->vector_lock,NULL);
if(push_pos < capacity){
memcpy(vector_head + (push_pos++)*step,data,data_size);
vector_pos_init(&vector->end,push_pos,vector);
}else{
dbg_str(DBG_CONTAINER_WARNNING,"realloc mem");
vector->vector_head = allocator_mem_alloc(
vector->allocator, 2*capacity * (vector->step));
if(vector->vector_head == NULL){
dbg_str(DBG_CONTAINER_ERROR,"vector_push_back,realloc mem");
}
vector->capacity = 2*capacity;
memcpy(vector->vector_head,vector_head,capacity*step);
memcpy(vector->vector_head + (push_pos++)*step,data,data_size);
vector_pos_init(&vector->end,push_pos,vector);
allocator_mem_free(vector->allocator,vector_head);
}
sync_unlock(&vector->vector_lock);
dbg_str(DBG_CONTAINER_DETAIL,"vector_push_back,push_pos=%d,capacity=%d",push_pos,vector->capacity);
return 0;
}
int pa_copy_protocol_format(struct protocol_analyzer_s *pa)
{
int ret = 0;
if(pa->pf_list_head_p == NULL){
dbg_str(PA_ERROR,"pa_copy_protocol_format,pf_list_head_p == NULL");
return -1;
}
proto_head_list_t *head_list,*head_list_copy;
proto_info_list_t *info_list,*info_list_copy;
struct list_head *hl_head = pa->pf_list_head_p;
struct list_head *pos,*n;
if(hl_head == NULL){
dbg_str(PA_ERROR,"a_copy_protocol_format err,hl_head is NULL");
return -1;
}
head_list = container_of(hl_head,proto_head_list_t,list_head);
head_list_copy = (proto_head_list_t *)allocator_mem_alloc(pa->allocator,sizeof(proto_head_list_t));
memcpy(head_list_copy,head_list,sizeof(proto_head_list_t));
head_list_copy->allocator = pa->allocator;
head_list_copy->list_count = 0;
INIT_LIST_HEAD(&head_list_copy->list_head);
list_for_each_safe(pos, n, hl_head) {
info_list = container_of(pos,proto_info_list_t,list_head);
info_list_copy = (proto_info_list_t *)allocator_mem_alloc(pa->allocator,sizeof(proto_info_list_t));
memcpy(info_list_copy,info_list,sizeof(proto_info_list_t));
pfs_add_list(&info_list_copy->list_head,&head_list_copy->list_head);
}
static int __init_window(Sdl_Graph *graph, void *window)
{
int ret;
Window *w = (Window *)window;
dbg_str(DBG_DETAIL,"Sdl_Graph create window");
dbg_str(DBG_DETAIL,"srceen width=%d, height=%d",w->screen_width,w->screen_height);
//Initialize SDL
if( SDL_Init( SDL_INIT_VIDEO ) < 0 ) {
dbg_str(DBG_ERROR,"SDL could not initialize! SDL_Error: %s", SDL_GetError() );
ret = -1;
} else {
//Create window
graph->window = SDL_CreateWindow("SDL Tutorial",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
w->screen_width,
w->screen_height,
SDL_WINDOW_SHOWN );
if( graph->window == NULL ) {
dbg_str(DBG_ERROR,"Window could not be created! SDL_Error: %s\n", SDL_GetError() );
ret = -1;
} else {
graph->screen_surface = SDL_GetWindowSurface(graph->window);
ret = 1;
}
}
return ret;
}
static void * __render_load_text(Sdl_Graph *graph,void *string,void *font,int r, int g, int b, int a)
{
allocator_t *allocator = ((Obj *)graph)->allocator;
Sdl_Text *text;
Sdl_Font *f = (Sdl_Font *)font;
SDL_Surface* surface = NULL;
SDL_Color textColor = {r, g, b, a };
String *content;
dbg_str(DBG_DETAIL,"Sdl_Text load text");
text = OBJECT_NEW(allocator, Sdl_Text,"");
content = ((Text *)text)->content;
content->assign(content,string);
surface = TTF_RenderText_Solid(f->ttf_font,
((Text *)text)->content->value,
textColor );
if(surface != NULL) {
text->texture = SDL_CreateTextureFromSurface(graph->render, surface);
text->width = surface->w;
text->height = surface->h;
dbg_str(DBG_DETAIL,"width =%d height=%d",text->width, text->height);
SDL_FreeSurface(surface);
}
return text;
}
static int __open_window(Window *window)
{
Graph *g = window->graph;
dbg_str(DBG_DETAIL,"sdl window open_window start");
if(g != NULL) {
g->init_window(g,window);
/*
*background->load_image(background);
*g->draw_image(g,background);
*/
} else {
dbg_str(DBG_ERROR,"window graph is NULL, please check");
return -1;
}
g->render_create(g);
g->render_set_color(g,0xff,0xff,0xff,0xff);
g->render_clear(g);
g->render_present(g);
dbg_str(DBG_DETAIL,"sdl window open_window end");
/*
*g->update_window(g);
*/
}
int
args_parse_args(args_processor_t *p,int argc, char *argv[])
{
int i = 0;
cmd_config_t *c;
uint8_t args_count;
for(i = 0; i < argc;){
c = args_find_entry(p,argv[i]);
if(c == NULL){
dbg_str(ARGS_WARNNING,"%s is not valid cmd,please check.We'll skip this cmd",argv[i]);
i++;
continue;
} else {
dbg_str(ARGS_DETAIL,"process cmd %s",argv[i]);
i++;
args_count = c->fn(p->base,argc - i,argv + i);
if(args_count != c->args_count){
dbg_str(ARGS_WARNNING,"the args funtion process args count is not equal the setting,"
"we'll compute by the default setting");
}
i+= c->args_count;
}
}
return 0;
}
int test_datastructure_rbtree_map(void)
{
int ret = 0;
rbtree_map_pos_t it,next,end;
rbtree_map_t *map;
allocator_t *allocator = allocator_get_default_alloc();
pair_t *pair;
struct rbtree_map_node *mnode;
int key_len = 2;
struct A t1 = {1,2};
struct A t2 = {2,2};
struct A t3 = {3,2};
struct A t4 = {4,2};
struct A t5 = {5,2};
dbg_str(DBG_DETAIL,"rbtree allocator addr:%p",allocator);
map = rbtree_map_create(allocator,0);
rbtree_map_init(map,key_len,sizeof(struct A) + key_len,NULL);
dbg_str(DBG_DETAIL,"create_pair");
pair = create_pair(key_len,sizeof(struct A));
make_pair(pair,"44",&t4);
rbtree_map_insert(map,pair->data);
make_pair(pair,"33",&t3);
rbtree_map_insert(map,pair->data);
make_pair(pair,"22",&t2);
rbtree_map_insert(map,pair->data);
make_pair(pair,"11",&t1);
rbtree_map_insert(map,pair->data);
dbg_str(DBG_DETAIL,"foreach ordinal print");
for( rbtree_map_begin(map,&it),rbtree_map_pos_next(&it,&next);
!rbtree_map_pos_equal(&it,rbtree_map_end(map,&end));
it = next,rbtree_map_pos_next(&it,&next))
{
mnode = rb_entry(it.rb_node_p,struct rbtree_map_node,node);
dbg_buf(DBG_DETAIL,"key:",mnode->key,mnode->value_pos);
print_A((struct A*)rbtree_map_pos_get_pointer(&it));
}
dbg_str(DBG_DETAIL,"search node key = 22");
rbtree_map_search(map, (void *)"22",&it);
print_A((struct A*)rbtree_map_pos_get_pointer(&it));
/*
*dbg_str(DBG_DETAIL,"delte node key = 11");
*container_delete(map,&it);
*/
rbtree_map_destroy(map);
allocator_destroy(allocator);
dbg_str(DBG_DETAIL,"map addr =%p",map);
return ret;
}
int lab()
{
if(check_endian()) {
dbg_str(DBG_DETAIL,"little endian");
} else {
dbg_str(DBG_DETAIL,"big endian");
}
}
int test_pdu_proto_analyzer()
{
protocol_format_set_t *pfs_p;
struct protocol_analyzer_s *pa;
uint32_t ret = 0;
proto_info_list_t *info_list = NULL;
struct proto_analyzer_admin_s *pa_admin = NULL;
allocator = allocator_creator(ALLOCATOR_TYPE_SYS_MALLOC,0);
pfs_p = pfs_create_proto_format_set(allocator);
init_proto_format_set(0x0,100,pfs_p);
pfs_set_pdu_format_ackd(pfs_p);
/*
*pfs_print_proto_link_lists(pfs_p);
*/
/*set and parse test*/
pa = pa_create_protocol_analyzer(allocator);
pa_init_protocol_analyzer(0x8, pfs_p, pa);
/*
*pa = proto_analyer_admin_get_pa(pa_admin,0x3008);
*/
pa_set_value("LB",1,pa);
pa_set_value("PF",1,pa);
pa_set_value("CSBKO",0x2f,pa);
pa_set_value("FID",0x8,pa);
pa_set_value("RI",1,pa);
pa_set_value("ARC",4,pa);
pa_set_value("RSVD",1,pa);
pa_set_value("TADDR",0xfffc001,pa);
pa_set_value("SADDR",0xfffc002,pa);
dbg_str(DBG_IMPORTANT,"print list for each,orinal data");
pfs_print_list_for_each(pa->pa_list_head_p);
pa_generate_protocol_data(pa);
dbg_str(DBG_DETAIL,"pa_parse_protocol_data\n");
pa_parse_protocol_data(pa);
dbg_str(DBG_IMPORTANT,"print list for each after parse");
pfs_print_list_for_each(pa->pa_list_head_p);
dbg_str(DBG_DETAIL,"pa_destroy_protocol_analyzer");
pa_destroy_protocol_analyzer(pa);
dbg_str(DBG_DETAIL,"pfs_destroy_protocol_format_set");
pfs_destroy_protocol_format_set(pfs_p);
return ret;
}
static int process_task_callback(client_task_t *task)
{
dbg_str(DBG_DETAIL,"process_task begin,client recv");
/*
*user_t *user = task->client;
*void *opaque = user->opaque;
*/
dbg_buf(DBG_VIP,"task buffer:",task->buffer,task->buffer_len);
dbg_str(DBG_DETAIL,"process_task end");
}
void lab5()
{
char *str = "a林能刚";
dbg_str(DBG_DETAIL,"strlen =%d",strlen(str));
dbg_str(DBG_DETAIL,"strlen =%s",str);
dbg_buf(DBG_DETAIL,"buff:",str, strlen(str));
}
static int __construct(Font *font,char *init_str)
{
Sdl_Font *f = (Sdl_Font *)font;
dbg_str(OBJ_DETAIL,"font construct, font addr:%p",font);
if(TTF_Init() == -1){
dbg_str(DBG_WARNNING,"TTF_Init error");
return -1;
}
return 0;
}
int test_miscellany_net()
{
unsigned char mac_addr[6];
char ip_addr[100];
#if 0
get_mac((char *)"eth0",mac_addr, sizeof(mac_addr));
print_mac(mac_addr);
get_local_ip((char *)"eth0",ip_addr);
print_ipaddr(ip_addr);
set_local_ip((char *)"eth0","192.168.20.182");
get_local_ip((char *)"eth0",ip_addr);
print_ipaddr(ip_addr);
dbg_str(DBG_DETAIL,"get local netmask");
get_local_netmask((char *)"eth0",ip_addr);
print_ipaddr(ip_addr);
dbg_str(DBG_DETAIL,"set local netmask");
set_local_netmask((char *)"eth0",(char *)"255.255.255.0");
get_local_netmask((char *)"eth0",ip_addr);
print_ipaddr(ip_addr);
dbg_str(DBG_DETAIL,"ip and str convert");
inet_str2num(AF_INET,(char *)"192.168.20.2");
inet_num2str(AF_INET,34908352,ip_addr);
#endif
#if 0
if(inet_is_in_same_subnet("192.168.2.32","eth0")) {
/*
*dbg_str(DBG_DETAIL,"this ip addr add local addr is in the same net");
*/
} else {
dbg_str(DBG_DETAIL,"this ip addr add local addr is not in the same net");
}
#endif
get_broadcast_addr("eth0", ip_addr);
print_ipaddr(ip_addr);
/*
*char ip_addr2[100];
*set_broadcast_addr("eth0", "192.168.20.255");
*print_ipaddr(ip_addr2);
*/
return 0;
}
int str2num(const char *const_str)
{
char * str = (char *)const_str;
int ret;
if(strncmp(str,"0x",2) && strncmp(str,"0X",2)) {
dbg_str(DBG_DETAIL,"str is dex data,convert func is atoi");
ret = atoi(const_str);
} else {
dbg_str(DBG_DETAIL,"str is hex data,convert func is hexstr2num");
ret = hexstr2num(const_str);
}
return ret;
}
int pa_check_protocol_num(struct protocol_analyzer_s *pa)
{
uint32_t protocol_num = pa->protocol_num;
uint32_t proto_base_addr = pa->pfs_p->proto_base_addr;
uint32_t proto_max_num = pa->pfs_p->proto_max_num;
dbg_str(PA_DETAIL,"proto_base_addr =%x,proto_max_num=%d",proto_base_addr,proto_max_num);
if(
(uint32_t)protocol_num > proto_base_addr + proto_max_num ||
(uint32_t)protocol_num < proto_base_addr)
{
dbg_str(PA_ERROR,"protocol num is err,please check");
return -1;
}
return 0;
}
void test_ui_sdl_grath()
{
Sdl_Graph *sdl_grath;
allocator_t *allocator = allocator_get_default_alloc();
char *set_str;
cjson_t *root, *e, *s;
char buf[2048];
root = cjson_create_object();{
cjson_add_item_to_object(root, "Sdl_Graph", e = cjson_create_object());{
cjson_add_string_to_object(e, "name", "alan");
}
}
set_str = cjson_print(root);
sdl_grath = OBJECT_NEW(allocator, Sdl_Graph,set_str);
object_dump(sdl_grath, "Sdl_Graph", buf, 2048);
dbg_str(DBG_DETAIL,"Sdl_Graph dump: %s",buf);
object_destroy(sdl_grath);
free(set_str);
}
static int __render_write_text(Sdl_Graph *graph,int x, int y, void *text)
{
dbg_str(DBG_DETAIL,"Sdl_Graph render_write_text");
Sdl_Text *t = (Sdl_Text *)text;
SDL_Rect render_quad = { x, y, t->width, t->height};
SDL_RenderCopy(graph->render, t->texture, NULL, &render_quad );
}
static int __set(Font *font, char *attrib, void *value)
{
Sdl_Font *f = (Sdl_Font *)font;
if(strcmp(attrib, "set") == 0) {
f->set = value;
} else if(strcmp(attrib, "get") == 0) {
f->get = value;
} else if(strcmp(attrib, "construct") == 0) {
f->construct = value;
} else if(strcmp(attrib, "deconstruct") == 0) {
f->deconstruct = value;
} else if(strcmp(attrib, "load_font") == 0) {
f->load_font = value;
} else if(strcmp(attrib, "load_ascii_character") == 0) {
f->load_ascii_character = value;
} else if(strcmp(attrib, "get_character_width") == 0) {
f->get_character_width = value;
} else if(strcmp(attrib, "get_character_height") == 0) {
f->get_character_height = value;
} else {
dbg_str(OBJ_WARNNING,"font set, \"%s\" setting is not support",attrib);
}
return 0;
}
static int __render_draw_image(Sdl_Graph *graph,int x, int y, void *image)
{
dbg_str(DBG_DETAIL,"Sdl_Graph render_draw_image");
Sdl_Image *i = (Sdl_Image *)image;
SDL_Rect render_quad = { x, y, i->width, i->height};
SDL_RenderCopy(graph->render, i->texture, NULL, &render_quad );
}
static int __render_set_font(Sdl_Graph *graph, void *font)
{
dbg_str(DBG_DETAIL,"Sdl_Graph set_font");
((Graph *)graph)->font = font;
return 0;
}
static int __load_font(Font *font)
{
Sdl_Font *f = (Sdl_Font *)font;
f->ttf_font = TTF_OpenFont( "./bin/Vera.ttf", 15 );
/*
*f->ttf_font = TTF_OpenFont( "./bin/TakaoPGothic.ttf", 18 );
*/
/*
*f->ttf_font = TTF_OpenFont( "./bin/Ubuntu-L.ttf", 18 );
*/
/*
*f->ttf_font = TTF_OpenFont( "./bin/Ubuntu-C.ttf", 18 );
*/
/*
*f->ttf_font = TTF_OpenFont( "./bin/UbuntuMono-R.ttf", 18 );
*/
/*
*f->ttf_font = TTF_OpenFont( "./bin/VLADIMIR.TTF", 40 );
*/
/*
*f->ttf_font = TTF_OpenFont( "./bin/TIMES.TTF", 20 );
*/
/*
*f->ttf_font = TTF_OpenFont( "./bin/ARIAL.TTF", 15 );
*/
if(f->ttf_font == NULL) {
} else {
dbg_str(DBG_DETAIL,"Sdl_Graph load font");
}
}
int vector_pop_back(vector_t *vector)
{
uint32_t pop_pos = vector->end.vector_pos;
dbg_str(DBG_CONTAINER_DETAIL,"pop back");
sync_lock(&vector->vector_lock,NULL);
if(!vector_pos_equal(&vector->begin,&vector->end)){
vector_pos_init(&vector->end,--pop_pos,vector);
} else{
dbg_str(DBG_CONTAINER_WARNNING,"vector is NULL");
}
sync_unlock(&vector->vector_lock);
return 0;
}
int get_broadcast_addr(char *ifname, char *ipaddr)
{
int sk;
struct sockaddr_in sin;
struct ifreq ifr;
sk = socket(AF_INET, SOCK_DGRAM, 0);
if (sk == -1)
{
dbg_str(DBG_ERROR,"get_broadcast_addr");
return -1;
}
memset(&ifr, 0, sizeof(ifr));
strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
if (!(ioctl(sk, SIOCGIFBRDADDR, &ifr)))
{
memcpy(&sin, &ifr.ifr_addr, sizeof(ifr.ifr_addr));
strcpy(ipaddr,inet_ntoa(sin.sin_addr));
}
close(sk);
return 1;
}
static int __draw_image(Sdl_Graph *graph, void *image)
{
Sdl_Image *i = (Sdl_Image *)image;
dbg_str(DBG_DETAIL,"Sdl_Graph draw_image");
SDL_BlitSurface(i->surface, NULL, graph->screen_surface, NULL );
}
static int __render_set_color(Sdl_Graph *graph,
uint8_t r, uint8_t g,
uint8_t b, uint8_t a)
{
dbg_str(DBG_DETAIL,"Sdl_Graph set_color");
SDL_SetRenderDrawColor(graph->render, r, g, b, a);
}
int container_hash_map_init(container_t *ct, uint32_t key_size,
uint32_t value_size, uint32_t bucket_size,
hash_func_fpt hash_func, key_cmp_fpt key_cmp_func)
{
hash_map_priv_t *hpi = &ct->priv.hash_map_priv;
dbg_str(DBG_CONTAINER_DETAIL,"container_hash_map_init");
hpi->key_size = key_size;
hpi->data_size = key_size + value_size;
hpi->hash_func = hash_func;
hpi->key_cmp_fpt = key_cmp_func;
hpi->bucket_size = bucket_size;
dbg_str(DBG_CONTAINER_DETAIL,"ct->c_ops_p->init(ct)");
return ct->c_ops_p->init(ct);
}
