#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include<malloc.h>
#include <arpa/inet.h>
 
 //链表头结构
 struct list_head
 {
     struct list_head *next,*prev;
 };
 
 //真正实现链表插入操作
 void _list_add(struct list_head *nnew,struct list_head *prev,struct list_head *next)
 {
     next->prev = nnew;
     nnew->next = next;
     nnew->prev = prev;
     prev->next = nnew;
 }


 void INIT_LIST_HEAD(struct list_head *list)
 {
     list->next = list;
     list->prev = list;
 }
 
 //向链表插入一个节点
 void list_add(struct list_head *nnew,struct list_head *head)
 {
     _list_add(nnew,head,head->next);
 }
 
 
 #define list_for_each(pos,head) \
     for(pos = (head)->next;pos != (head);pos = pos->next)
 
 #define list_for_each_safe(pos,n,head) \
     for(pos = (head)->next,n = pos->next;pos != (head);pos = n,n = pos->next)
 
 //根据节点中的一个成员在节点中的偏移量找到节点的起始地址
 #define list_entry(ptr,type,member) \
     ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 
 //真正实现链表删除操作
 void _list_del(struct list_head *prev,struct list_head *next)
 {
     next->prev = prev;
     prev->next = next;
 }
 

 //删除链表中的一个节点

删除节点后，内核原始操作会将两个指针指向自己，这个在实际运用的时候可能会出错，新分配的内存正好分陪到之前释放的节点的内存，会使得新的节点自己指向自己，导致死循环，

 void list_del(struct list_head *entry)
 {
     _list_del(entry->prev,entry->next);
     entry->next = NULL;
     entry->prev = NULL;
 }


#define SERVER_GROUP_NAME_SIZE 32
#define MAX_SERVER_GROUP_SIZE 128


typedef struct server_info {
    unsigned int status;
        union {
        struct in_addr addr;
        struct in6_addr addr6;
    };
}server_info_t;




typedef struct server_group 
{
struct list_head list;
char               name[SERVER_GROUP_NAME_SIZE];
    server_info_t       servers[MAX_SERVER_GROUP_SIZE];
    unsigned int           count;
}ser_group_t;

ser_group_t * g_ser_t;

void list_init()
{

g_ser_t = (ser_group_t *)malloc(sizeof(ser_group_t));
INIT_LIST_HEAD(&g_ser_t->list);
}

/*insert link*/
void add_list(ser_group_t* server_new_data)
{
ser_group_t *listnode = NULL;
listnode = (ser_group_t *)malloc(sizeof(ser_group_t));
memset(listnode,0,sizeof(listnode));
memcpy(listnode,server_new_data,sizeof(ser_group_t));
list_add(&listnode->list,&g_ser_t->list);
}
void node_find(ser_group_t* sernode_find)
{
struct ser_group_t *listnode;
struct list_head *pos ;
struct ser_group_t *p = NULL;
struct list_head *t;
int i;


//遍历链表
list_for_each(pos,&g_ser_t->list)
{
i--;
//找出一个节点
p = list_entry(pos,ser_group_t,list);
printf("Node %d's data: %d\n",i,p->count);
}
}
void node_delete(ser_group_t* sernode_del)
{
struct ser_group_t *listnode;
struct list_head *pos ;
struct ser_group_t *p;
struct list_head *t;

struct ser_group_t *tmp = NULL;

int i;

/*删除链表*/
#if 0
list_for_each_safe(pos,t,&g_ser_t.list)
{
//删除节点
list_del(pos);
p = list_entry(pos,struct ser_group_t,list);
//释放节点的内存
free(p);
}
#endif

/*删除一个节点*/
 list_for_each_safe(pos, t, &g_ser_t->list) 
      { 
        /*tmp = list_entry(pos, struct numlist, list); 
//节点相同，删除
 if(tmp == sernode_del) 
              { 
              printf("node %d delete\n",tmp->num);
                    list_del_init(pos); 
                    free(tmp); 
              } 
*/
       }
}

int main()
{
ser_group_t test = {0};
test.count = 1;


list_init();
add_list(&test);
node_find(&test);
return 0;
}