pkts.h

Go to the documentation of this file.

/* 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*/