netsukuku/src/pkts.h

/* This file is part of Netsukuku system
 * (c) Copyright 2005 Andrea Lo Pumo aka AlpT <alpt@freaknet.org>
 *
 * This source code 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 2 of the License,
 * or (at your option) any later version.
 *
 * This source code 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.
 * Please refer to the GNU Public License for more details.
 *
 * You should have received a copy of the GNU Public License along with
 * this source code; if not, write to:
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#ifndef PKTS_H
#define PKTS_H

#include "if.h"
#include "request.h"
#include "llist.c"

#define NETSUKUKU_ID		"ntk"
#define MAXMSGSZ		65536

/*\
 *
 * Pkt's op definitions
 * (The requests and replies are in request.h)
 *
\*/

/* Pkt.sk_type */
#define SKT_TCP 		1
#define SKT_UDP			2
#define SKT_BCAST		3

/* 
 * Pkt.pkt_flags flags 
 */
#define PKT_BIND_DEV		1	/* Bind the pkt.sk socket to pkt.dev */
#define PKT_RECV_TIMEOUT	(1<<1)
#define PKT_SEND_TIMEOUT	(1<<2)
#define PKT_SET_LOWDELAY	(1<<3)
#define PKT_COMPRESSED		(1<<4)	/* If set the packet will be Z 
					   compressed before being sent */
#define PKT_KEEPALIVE		(1<<5)  /* Let the pkt.sk socket be alive */
#define PKT_NONBLOCK		(1<<6)	/* Socket must not block */

/* 
 * Pkt.hdr flags 
 */
#define SEND_ACK		1
#define BCAST_PKT		(1<<1)	/* In this pkt there is encapsulated a 
					 * broadcast/flood pkt. Woa */
#define HOOK_PKT		(1<<2)  /* All the pkts sent while hooking have
					 * this flag set      */
#define ASYNC_REPLY		(1<<3)	/* Tells the receiver to reply with a new 
					   connection. The reply pkt will be
					   handled by the pkt_queue. */
#define ASYNC_REPLIED		(1<<4)
#define LOOPBACK_PKT		(1<<5)  /* This is a packet destinated to me */
#define RESTRICTED_PKT		(1<<6)	/* Packet sent from a node in restricted 
					   mode */
#define COMPRESSED_PKT		(1<<7)  /* The whole packet is Z compressed */


/*
 * Broacast ptk's flags
 */
#define BCAST_TRACER_PKT	1	/*When a bcast is marked with this, it 
					  acts as a tracer_pkt ;)*/
#define BCAST_TRACER_BBLOCK	(1<<1)  /*When set, the tracer pkt carries also
					  bnodes blocks.*/
#define BCAST_TRACER_STARTERS	(1<<2)  /*Tracer pkt bound to the qspn starter 
					  continual group*/
#define QSPN_BNODE_CLOSED	(1<<3)	/*The last bnode, who forwarded this 
					  qspn pkt has all its links closed.*/
#define QSPN_BNODE_OPENED	(1<<4)

/* General defines */
#define PKT_MAX_MSG_SZ		1048576	/* bytes */
#define PKT_COMPRESS_LEVEL	Z_DEFAULT_COMPRESSION
#define PKT_COMPRESS_THRESHOLD	1024	/* If the flag PKT_COMPRESSED is set 
					   and hdr.sz > PKT_COMPRESS_THRESHOLD,
					   then compress the packet */

/*
 * pkt_hdr: the pkt_hdr is always put at the very beginning of any netsukuku
 * packets
 */
typedef struct
{
	char		ntk_id[3];
	int 		id;
	u_char		flags; 
	u_char 		op;
	size_t 		sz;		/* The size of the message */
	size_t		uncompress_sz;	/* The size of the decompressed packet. */
}_PACKED_  pkt_hdr;
INT_INFO pkt_hdr_iinfo = { 3, 
			   { INT_TYPE_32BIT, INT_TYPE_32BIT, INT_TYPE_32BIT },
			   { sizeof(char)*3, sizeof(char)*5+sizeof(int), 
			     sizeof(char)*5+sizeof(int)+sizeof(size_t) },
			   { 1, 1, 1 }
			 };
#define PACKET_SZ(sz) (sizeof(pkt_hdr)+(sz))

/*
 * PACKET
 *
 * this struct is used only to represent internally a packet, which
 * will be sent or received.
 */
typedef struct
{
	/* General informations of the packet */
	
	inet_prefix 	from;		/* The sender ip of this packet */
	inet_prefix 	to;		/* Where to send this packet */

	interface	*dev;		/* Device used to send/receive the 
					   packet. `sk' will be bound to it
					   if `dev' is not null and if the 
					   PKT_BIND_DEV flag is set in
					   `pkt_flags'. `dev' is a pointer
					   to a struct contained in the 
					   me.cur_ifs array. */
	
	int		family;
	int 		sk;
	char 		sk_type;
	u_short 	port;

	u_char		pkt_flags;	/*Flags for this PACKET*/
	int 		flags;		/*Flags used by send/recv*/

	u_int		timeout;	/*After `timeout' seconds give up the
					  send/recv of the packet. 
					  The PKT_[RECV/SEND]_TIMEOUT flags are
					  used to determine its scope (send, 
					  recv or both).*/

	/* Body of the packet */
	pkt_hdr 	hdr;
	char 		*msg;
} PACKET;
	
/*Broadcast packet*/
typedef struct
{
	u_char		g_node;		/*The gnode the brdcast_pkt is restricted to*/
	u_char 		level;		/*The level of the g_node*/
	u_char	 	gttl;		/*Gnode ttl: How many gnodes the packet
					  can traverse*/
	u_char	 	sub_id;		/*The sub_id is the node who sent the pkt,
					  but is only used by the qspn_open*/
	size_t 		sz;		/*Sizeof(the pkt)*/
	char 		flags;		/*Various flags*/
}_PACKED_ brdcast_hdr;

INT_INFO brdcast_hdr_iinfo = { 1, { INT_TYPE_32BIT }, { sizeof(char)*4 }, { 1 } };
#define BRDCAST_SZ(pkt_sz) 	(sizeof(brdcast_hdr)+(pkt_sz))
#define BRDCAST_HDR_PTR(msg)	((brdcast_hdr *)(msg))


/* 
 * In this stable, each op (request or reply) is associated with a
 * `pkt_exec_func', which pkt_exec() will use to handle the incoming packets of
 * the same op.
 * Each op is also associated with its specific socket type (udp, tcp, bcast)
 * with `sk_type', and the `port' where the pkt will be sent or received.
 * Each element in the table is equivalent to a request or reply, ie the
 * function to handle the x request is at pkt_op_table[x].exec_func;
 */
struct pkt_op_table {
	char 		sk_type;
	u_short 	port;
	void 		*exec_func;
} pkt_op_tbl[TOTAL_OPS];

/* pkt_queue's flags */
#define PKT_Q_MTX_LOCKED	1		/* We are waiting the reply */
#define PKT_Q_PKT_RECEIVED	(1<<1)		/* The reply was received */
#define PKT_Q_TIMEOUT		(1<<2)		/* None replied ._, */
#define PKT_Q_CHECK_FROM	(1<<3)		/* Check the from ip while
						   receiving the async pkt */

/*
 * The pkt_queue is used when a reply will be received with a completely new 
 * connection. This is how it works:
 * The pkt.hdr.flags is ORed with ASYNC_REPLY, a new struct is added in the
 * pkt_q linked list, pkt_q->pkt.hdr.id is set to the id of the outgoing pkt
 * and pkt_q->pkt.hdr.op is set to the waited reply op.
 * The function x() it's started as a new thread and the request is sent; to 
 * receive the reply, x() locks twice `mtx'. The thread is now freezed.
 * The reply is received by pkt_exec() which passes the pkt to the function
 * y(). y() searches in the pkt_q a struct which has the same pkt.hdr.id of
 * the received pkt. The reply pkt is copied in the found struct and `mtx' is
 * unlocked. x() can now continue to read the reply and unlocks `mtx'.
 * Note that the reply pkt must have the ASYNC_REPLIED flag set in pkt.hdr.flags.
 */
struct pkt_queue{
	LLIST_HDR	(struct pkt_queue);

	PACKET 		pkt;
	pthread_mutex_t mtx;

	char 		flags;
};
typedef  struct pkt_queue pkt_queue;

pkt_queue *pkt_q;
int pkt_q_counter;

/*Functions' declarations*/
void pkts_init(interface *ifs, int ifs_n, int queue_init);
	
void pkt_addfrom(PACKET *pkt, inet_prefix *from);
void pkt_addto(PACKET *pkt, inet_prefix *to);
void pkt_add_dev(PACKET *pkt, interface *dev, int bind_the_socket);
void pkt_addsk(PACKET *pkt, int family, int sk, int sk_type);
void pkt_addport(PACKET *pkt, u_short port);
void pkt_addflags(PACKET *pkt, int flags);
void pkt_addtimeout(PACKET *pkt, u_int timeout, int recv, int send);
void pkt_addcompress(PACKET *pkt);
void pkt_addlowdelay(PACKET *pkt);
void pkt_addnonblock(PACKET *pkt);
void pkt_addhdr(PACKET *pkt, pkt_hdr *hdr);
void pkt_addmsg(PACKET *pkt, char *msg);
void pkt_copy(PACKET *dst, PACKET *src);
void pkt_clear(PACKET *pkt);

void pkt_free(PACKET *pkt, int close_socket);
char *pkt_pack(PACKET *pkt);

int pkt_verify_hdr(PACKET pkt);
ssize_t pkt_send(PACKET *pkt);
ssize_t pkt_recv(PACKET *pkt);
int pkt_tcp_connect(inet_prefix *host, short port, interface *dev);

void pkt_fill_hdr(pkt_hdr *hdr, u_char flags, int id, u_char op, size_t sz);

#define SEND_RQ_ERR		-1
#define SEND_RQ_ERR_RQ		-2
#define SEND_RQ_ERR_RE		-3
#define SEND_RQ_ERR_PORT	-4
#define SEND_RQ_ERR_TO		-5
#define SEND_RQ_ERR_CONNECT	-6
#define SEND_RQ_ERR_SEND	-7
#define SEND_RQ_ERR_RECV	-8
#define SEND_RQ_ERR_RECVOP	-9
#define SEND_RQ_ERR_RECVID	-10
#define SEND_RQ_ERR_REPLY	-11
int send_rq(PACKET *pkt, int pkt_flags, u_char rq, int rq_id, u_char re, 
		int check_ack, PACKET *rpkt);

int forward_pkt(PACKET rpkt, inet_prefix to);
int pkt_err(PACKET pkt, u_char err, int free_pkt);

void add_pkt_op(u_char op, char sk_type, u_short port, int (*exec_f)(PACKET pkt));
int pkt_exec(PACKET pkt, int acpt_idx);

void pkt_queue_init(void);
void pkt_queue_close(void);
int pkt_q_wait_recv(int id, inet_prefix *from, PACKET *rpkt, pkt_queue **ret_pq);
int pkt_q_add_pkt(PACKET pkt);
void pkt_q_del(pkt_queue *pq, int close_socket);

#endif /*PKTS_H*/