link.c

采用UDP协议实现的UNIX/Linux环境下的聊天服务器和客户端程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "link.h"
#include "utils.h"

//link_node_t *global_link_head = NULL;
static void release_node(link_node_t * p);
static inline void set_node_type(link_node_t * p, node_type_t t);
inline node_type_t get_node_type(link_node_t * p);
static void dump_node(link_node_t * p);

//////////////////////////////////////////////////////////////////////
// Link related functions
//////////////////////////////////////////////////////////////////////
link_node_t *link_init(void (*destroy_data_callback) (void *), void (*dump_self_callback) (void *))
{
  link_node_t *head;

  head = create_node(NODE_TYPE_HEAD);

  head->destroy_data = destroy_data_callback;
  head->dump_self = dump_self_callback;

  //global_link_head->type = NODE_TYPE_HEAD;
  //set_node_type(head, NODE_TYPE_HEAD);

  return head;
}

void link_destroy(link_node_t * head)
{
  link_node_t *p = NULL;
  link_node_t *current = NULL;

  p = head;
  current = p;

  while (p && p->next)
  {
    current = p;
    p = p->next;
    release_node(current);
  }

  release_node(p);
  head = NULL;
}

int link_insert_normal_node(link_node_t * head, link_node_t * ref, link_node_t * p, insert_method_t method)
{
  set_node_type(p, NODE_TYPE_NORMAL);
  link_insert_node(head, ref, p, method);

  return 0;
}

int link_insert_node(link_node_t * head, link_node_t * ref, link_node_t * p, insert_method_t method)
{
  if (p == NULL)
    return -1;

  if (ref == NULL)
  {
    return -1;
  }

  p->destroy_data = head->destroy_data;
  p->dump_self = head->dump_self;

  switch (method)
  {
    case INSERT_METHOD_BEFORE:
      // XXX: if the reference node is the head, the operation is forbidden
      if (get_node_type(ref) == NODE_TYPE_HEAD)
      {
#ifdef _DEBUG_
	fprintf(stderr, "ERROR: Cannot insert a node before head.\n");
#endif
	return -2;
      }
      else
      {
	// before
	p->next = ref;
	p->prev = ref->prev;

	if (ref->prev)
	{
	  ref->prev->next = p;
	}
	ref->prev = p;
      }
      break;
    case INSERT_METHOD_AFTER:
      // XXX: if the reference node is the tail node, the operation is forbidden
      if (get_node_type(ref) == NODE_TYPE_TAIL)
      {
#ifdef _DEBUG_
	fprintf(stderr, "ERROR: Cannot insert a node after tail.\n");
#endif
	return -2;
      }
      else
      {
	// after
	p->prev = ref;
	p->next = ref->next;

	if (ref->next)
	{
	  ref->next->prev = p;
	}
	ref->next = p;
      }
      break;
    default:
      return -1;
      break;
  }

  return 0;
}

int link_delete_node(link_node_t * head, link_node_t * p)
{
  if (p && (get_node_type(p) != NODE_TYPE_HEAD) && (get_node_type(p) != NODE_TYPE_TAIL))
  {
    if (p->prev)
    {
      p->prev->next = p->next;
    }

    if (p->next)
    {
      p->next->prev = p->prev;
    }

    release_node(p);
  }
  else
  {
    return -1;
  }

  return 0;
}

link_node_t *link_locate_node(link_node_t * head, void *condition)
{
  //TODO: according condition to locate the corrent node.
  return NULL;
}

int link_update_node(link_node_t * head, link_node_t * p)
{
  //TODO: update the fields
  return 0;
}

void link_dump_nodes(link_node_t * head)
{
  link_node_t *p;
  link_node_t *current;

  p = head;

  while (p && p->next)
  {
    current = p;
    p = current->next;

    if (current->dump_self)
    {
      current->dump_self(current);
    }
    else
    {
      fprintf(stderr, "Undefined dump node function.\n");
    }
  }

  if (p->dump_self)
  {
    p->dump_self(p);
  }
  else
  {
    fprintf(stderr, "Undefined dump node function.\n");
  }
}

//////////////////////////////////////////////////////////////////////
// Node related functions
//////////////////////////////////////////////////////////////////////
//static link_node_t *create_node(node_type_t t, void (*destroy_data_callback) (void *))
link_node_t *create_node(node_type_t t)
{
  link_node_t *p = NULL;

  p = malloc(sizeof(link_node_t));
  memset(p, 0, sizeof(link_node_t));

  p->data = NULL;
  p->next = NULL;
  p->prev = NULL;
  p->destroy_data = NULL;

  set_node_type(p, t);

  return p;
}

static void release_node(link_node_t * p)
{
  if (p)
  {
    if (p->data)
    {
      // FIXME: release data object
      if (p->destroy_data)
      {
	p->destroy_data(p->data);
      }
      else
      {
	fprintf(stderr, "Undefined destroy data function.\n");
      }
    }

    safe_free(p);
  }
}

static inline void set_node_type(link_node_t * p, node_type_t t)
{
  p->type = t;
}

inline node_type_t get_node_type(link_node_t * p)
{
  return p->type;
}

static void dump_node(link_node_t * p)
{
  // TODO: dump all feilds
}