path: root/libglouglou/libggnet.c

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

#include "libglouglou.h"
#include "libggnet.h"

struct ggnet *
ggnet_new(int manage_connid)
{
  struct ggnet *net;
  int i;

  net = xcalloc(1, sizeof(struct ggnet));
  net->manage_connid = manage_connid;
	for (i=0; i<GGNET_CONN_FREEIDS_COUNT-1; i++)
		net->conn_freeids[i] = i;

  return net;
}

void
ggnet_free(struct ggnet *net)
{
  struct ggnet_conn *c, *ctmp;
  struct ggnet_node *n, *ntmp;

  LIST_FOREACH_SAFE(c, &net->conn_list, entry, ctmp)
    ggnet_conn_del(net, c);
  LIST_FOREACH_SAFE(n, &net->node_list, entry, ntmp)
    ggnet_node_del(net, n);
  free(net);
}

struct ggnet_node *
ggnet_node_add(struct ggnet *net, struct in_addr *addr)
{
	struct ggnet_node *n;

	gg_log_debug("ggnet_node_add");

	n = xcalloc(1, sizeof(struct ggnet_node));
	n->addr.s_addr = addr->s_addr;
	n->namelen = GGNET_NODENAME_WAITING;
	n->lastseen = net->time;
	LIST_INSERT_HEAD(&net->node_list, n, entry);
	net->node_count++;

	return n;
}

void
ggnet_node_del(struct ggnet *net, struct ggnet_node *n)
{
	if (n->used)
		gg_log_fatal("ggnet_node_del: trying to remove a used node !");
	gg_log_debug("ggnet_node_del: ggnet_node_del");

	LIST_REMOVE(n, entry);
	free(n);
	net->node_count--;
}

struct ggnet_node *
ggnet_node_find(struct ggnet *net, struct in_addr *remote)
{
	struct ggnet_node *n;

	LIST_FOREACH(n, &net->node_list, entry)
		if (n->addr.s_addr == remote->s_addr)
			return n;
	return NULL;
}

void
ggnet_node_update_name(struct ggnet *net, struct ggnet_node *n,
                       char *name, int len)
{
  if (!name) {
    snprintf(n->name, sizeof(n->name), "%x", n->addr.s_addr);
    n->namelen = sizeof(n->addr.s_addr);
  } else {
    if (len > sizeof(n->name))
      len = sizeof(n->name);
    strncpy(n->name, name, len);
    n->namelen = len;
  }
}

void *
ggnet_node_usrdata_get(struct ggnet_node *n)
{
  return n->usrdata;
}

void
ggnet_node_usrdata_set(struct ggnet_node *n, void *usrdata)
{
  n->usrdata = usrdata;
}

struct ggnet_conn *
ggnet_conn_add(struct ggnet *net, struct in_addr *src, int src_port,
               struct in_addr *dst, int dst_port, int proto, int size,
               int given_id)
{
	struct ggnet_conn *c;
	struct ggnet_node *srcnode;
	struct ggnet_node *dstnode;
	int id;

	gg_log_debug("ggnet_conn_add, %x:%d->%x:%d %d [%d]",
		src->s_addr, src_port, dst->s_addr, dst_port, proto, size);

  if (net->manage_connid) {
    if (net->conn_freeids_ptr == GGNET_CONN_FREEIDS_COUNT) {
      gg_log_warn("ggnet_conn_add: out of connection identifiers !");
      return NULL;
    }
    id = net->conn_freeids[net->conn_freeids_ptr];
    net->conn_freeids_ptr++;
  } else {
    id = given_id;
  }

	srcnode = ggnet_node_find(net, src);
	if (!srcnode)
		srcnode = ggnet_node_add(net, src);
	srcnode->used++;
	dstnode = ggnet_node_find(net, dst);
	if (!dstnode)
		dstnode = ggnet_node_add(net, dst);
	dstnode->used++;

	c = xmalloc(sizeof(struct ggnet_conn));
	c->id = id;
	c->state = CONNSTATE_ESTABLISHED;
	c->src = srcnode;
	c->src_port = src_port;
	c->dst = dstnode;
	c->dst_port = dst_port;
	c->proto = proto;
	c->size = size;
	c->size_response = 0;
	c->lastseen = net->time;
	c->usrdata = NULL;
	LIST_INSERT_HEAD(&net->conn_list, c, entry);

	return c;
}

void
ggnet_conn_data(struct ggnet *net, struct ggnet_conn *c, int size, int response)
{
	gg_log_debug("ggnet_conn_data");

  if (!response)
    c->size = c->size + size;
  else
    c->size_response = c->size_response + size;
	c->lastseen = net->time;
}

void
ggnet_conn_del(struct ggnet *net, struct ggnet_conn *c)
{
	gg_log_debug("ggnet_conn_del");

	if (c->proto == IPPROTO_TCP) {
		switch (c->state) {
		case CONNSTATE_ESTABLISHED:
			c->state = CONNSTATE_TCPFIN;
			return;
		case CONNSTATE_TCPFIN:
			c->state = CONNSTATE_TCPFIN2;
			return;
		case CONNSTATE_TCPFIN2:
			break;
		}
	}

  if (net->manage_connid) {
    if (net->conn_freeids_ptr == 0)
      gg_log_fatal("net->conn_freeids_ptr == 0");
    net->conn_freeids_ptr--;
    net->conn_freeids[net->conn_freeids_ptr] = c->id;
  }

	c->src->used--;
	c->dst->used--;

	LIST_REMOVE(c, entry);
	free(c);
}

struct ggnet_conn *
ggnet_conn_find(struct ggnet *net, struct in_addr *src, int src_port,
                struct in_addr *dst, int dst_port, int proto, int *response)
{
  struct ggnet_conn *c;

	LIST_FOREACH(c, &net->conn_list, entry) {
		if (((c->src->addr.s_addr == src->s_addr &&
				c->src_port == src_port &&
				c->dst->addr.s_addr == dst->s_addr &&
				c->dst_port == dst_port) ||
			(c->src->addr.s_addr == dst->s_addr &&
				 c->src_port == dst_port &&
				 c->dst->addr.s_addr == src->s_addr &&
				 c->dst_port == src_port)) &&
			c->proto == proto) {
			if (c->src->addr.s_addr == src->s_addr)
				*response = 0;
			else
				*response = 1;
			return c;
		}
	}
	return NULL;
}

struct ggnet_conn *
ggnet_conn_find_by_id(struct ggnet *net, int id)
{
  struct ggnet_conn *c;

	LIST_FOREACH(c, &net->conn_list, entry)
	  if (c->id == id)
	    return c;
  return NULL;
}

struct ggnet_conn *
ggnet_conn_find_by_node(struct ggnet *net,
                        struct ggnet_node *a, struct ggnet_node *b)
{
  struct ggnet_conn *c;

	LIST_FOREACH(c, &net->conn_list, entry)
	  if ((c->src == a && c->dst == b) ||
	      (c->src == b && c->dst == a))
	    return c;
  return NULL;
}

void *
ggnet_conn_usrdata_get(struct ggnet_conn *c)
{
  return c->usrdata;
}

void
ggnet_conn_usrdata_set(struct ggnet_conn *c, void *usrdata)
{
  c->usrdata = usrdata;
}

void *
ggnet_conn_src_get(struct ggnet_conn *c)
{
  return c->src;
}

void *
ggnet_conn_dst_get(struct ggnet_conn *c)
{
  return c->dst;
}

void
ggnet_time_update(struct ggnet *net, time_t time)
{
  net->time = time;
}