snsd_cache.h

Go to the documentation of this file.

/* This file is part of Netsukuku
 * (c) Copyright 2006 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 SNSD_H
#define SNSD_H

#include "inet.h"
#include "crypto.h"
#include "endianness.h"
#include "llist.c"

/*
 * SNSD definitions
 */

#define SNSD_MAX_RECORDS        256 /* Number of maximum SNSD records
                           which can be stored in an
                           andna_cache */
#define SNSD_MAX_QUEUE_RECORDS      1   /* There can be only one snsd 
                           record for the queued hnames */
#define SNSD_MAX_REC_SERV       16  /* Maximum records per service */

#define SNSD_ALL_SERVICE        (-1)    /* A service number equal to -1
                           refers to all the available
                           services */
#define SNSD_DEFAULT_SERVICE        0
#define SNSD_DEFAULT_PROTO      1   /* tcp */
#define SNSD_DEFAULT_PRIO       16
#define SNSD_DEFAULT_WEIGHT     1

#define SNSD_WEIGHT(x)          ((x) & 0x7f)    /* The snsd weight has to 
                               be <= 127 */

/* Fields used in the syntax for the `snsd_nodes' file:
 *  hostname:snsd_hostname:service:priority:weight[:pub_key_file]
 */
#define MAX_SNSD_LINE_SZ                (ANDNA_MAX_HNAME_LEN*4)
#define MAX_SNSD_FIELDS         6
#define MIN_SNSD_FIELDS         5

/* * snsd_node flags * */
#define SNSD_NODE_HNAME         1   /* A hname is associated in the 
                           snsd record */
#define SNSD_NODE_IP            (1<<1)  /* An IP is associated in the 
                           snsd record */
#define SNSD_NODE_MAIN_IP       (1<<2)  /* This is the first IP registered 
                           to the hname, it can't be
                           deleted */


/*
 * snsd_node, snsd_service, snsd_prio
 *
 * They are three linked list. They are all orthogonal to each other.
 * The snsd_node llist is inside each snsd_prio struct which is inside each
 * snsd_service struct:
 * || service X          <->   service Y          <->   service Z  <-> ... ||
 *        |                |                |
 *        V                V                V
 *    snsd_prio_1-->node       snsd_prio_1-->node          ...-->...
 *        |                |
 *        V                V
 *    snsd_prio_2-->node      ...-->node
 *        |
 *        V
 *       ...-->node
 *
 * Using this schema, we don't have to sort them, ever. The nodes are already
 * grouped by service and in each service by priority.
 * 
 * These llist are directly embedded in the andna_cache, lcl_cache and
 * rh_cache.
 * 
 * The andna_cache keeps all the SNSD nodes associated to the registered
 * hostname. The andna_cache doesn't need `snsd_node->pubkey'.
 *
 * The rh_cache stores only records which are of the SNSD_NODE_IP type.
 *
 * When the lcl_cache is saved, its snsd llist is discarded because it is
 * loaded each time from the /etc/netsukuku/snsd_nodes file.
 */
struct snsd_node
{ 
    LLIST_HDR   (struct snsd_node);
    
    u_int       record[MAX_IP_INT]; /* It can be the IP or the md5
                           hash of the hname of the 
                           SNSD node */
    RSA     *pubkey;        /* pubkey of the snsd_node */
    char        flags;          /* This will tell us what 
                           `record' is */
    
    u_char      weight;
};
typedef struct snsd_node snsd_node;
/* In the pack of a snsd_node we don't save the `pubkey' */
#define SNSD_NODE_PACK_SZ       (MAX_IP_SZ+sizeof(char)*2)

struct snsd_prio
{
    LLIST_HDR   (struct snsd_prio);
    
    u_char      prio;           /* Priority of the SNSD node */
    
    snsd_node   *node;
};
typedef struct snsd_prio snsd_prio;
#define SNSD_PRIO_PACK_SZ       (sizeof(char))

struct snsd_service
{
    LLIST_HDR   (struct snsd_service);

    u_short     service;        /* Service number */
    u_char      proto;          /* TCP/UDP, see the `proto_str'
                           static array below */
    
    snsd_prio   *prio;
};
typedef struct snsd_service snsd_service;
#define SNSD_SERVICE_PACK_SZ        (sizeof(u_short)+sizeof(u_char))


/*
 * 
 *  * * * snsd structs package * * *
 *  
 */

struct snsd_node_llist_hdr
{
    u_short     count;      /* # of snsd_node structs packed 
                       in the body */
}_PACKED_;
INT_INFO snsd_node_llist_hdr_iinfo = { 1, { INT_TYPE_16BIT }, { 0 }, { 1 } };
/*
 * the body of the pkt is:
 * 
 * struct snsd_node_pack {
 *  u_int           record[MAX_IP_INT];
 *  char            flags;
 *  u_char          weight;
 * } pack[hdr.nodes];
 */
#define SNSD_NODE_LLIST_PACK_SZ(head)   (list_count((head))*SNSD_NODE_PACK_SZ  \
                      + sizeof(struct snsd_node_llist_hdr))
        
struct snsd_prio_llist_hdr
{
    u_short     count;      /* number of structs packed in 
                       the body */
}_PACKED_;
INT_INFO snsd_prio_llist_hdr_iinfo = { 1, { INT_TYPE_16BIT }, { 0 }, { 1 } };
/*
 * the body is:
 *
 * snsd_prio_pack {
 *  u_char      prio;
 *  char        snsd_node_llist_pack[SNSD_NODE_LLIST_PACK_SZ];
 * } pack[hdr.count];
 */
#define SNSD_PRIO_LLIST_PACK_SZ(head)                   \
({                                  \
    snsd_prio *_p=(head);                       \
    int _priosz=0;                          \
                                    \
    list_for(_p) {                          \
        _priosz+=SNSD_NODE_LLIST_PACK_SZ(_p->node);     \
        _priosz+=SNSD_PRIO_PACK_SZ;             \
    }                               \
    _priosz+=sizeof(struct snsd_prio_llist_hdr);            \
    _priosz;                            \
})


struct snsd_service_llist_hdr
{
    u_short     count;
}_PACKED_;
INT_INFO snsd_service_llist_hdr_iinfo = { 1, { INT_TYPE_16BIT }, { 0 }, { 1 } };
/*
 * the body is:
 *  u_short     service;
 *  u_char      proto;
 *  char        snsd_prio_llist_pack[SNSD_PRIO_LLIST_PACK_SZ];
 */
#define SNSD_SERVICE_LLIST_PACK_SZ(head)                \
({                                  \
    snsd_service *_s=(head);                    \
    int _srvsz=0;                           \
    if(_s) {                            \
         list_for(_s) {                     \
             _srvsz+=SNSD_PRIO_LLIST_PACK_SZ(_s->prio); \
             _srvsz+=SNSD_SERVICE_PACK_SZ;          \
         }                          \
         _srvsz+=sizeof(struct snsd_service_llist_hdr);     \
     }                              \
    _srvsz;                             \
})

#define SNSD_SERVICE_SINGLE_PACK_SZ(head)               \
({  SNSD_SERVICE_PACK_SZ +                      \
        SNSD_PRIO_LLIST_PACK_SZ((head)->prio);          \
})
    
#define SNSD_SERVICE_MAX_PACK_SZ                    \
(   ( (SNSD_NODE_PACK_SZ + SNSD_PRIO_PACK_SZ) *             \
            (SNSD_MAX_REC_SERV)         ) +         \
    SNSD_SERVICE_PACK_SZ                  +     \
    sizeof(struct snsd_prio_llist_hdr)        +     \
    sizeof(struct snsd_service_llist_hdr)               \
)

#define SNSD_SERVICE_MAX_LLIST_PACK_SZ                  \
((  SNSD_NODE_PACK_SZ + SNSD_PRIO_PACK_SZ + SNSD_SERVICE_PACK_SZ +  \
        sizeof(struct snsd_prio_llist_hdr))*SNSD_MAX_RECORDS +  \
        sizeof(struct snsd_service_llist_hdr)               \
)


/*
 * This array is used to associate a 8bit number to a protocol name.
 * The number is the position of the protocol name in this array.
 * For example: "tcp" is in the first position so its associated number is 1,
 * while the number for "udp" is 2.
 *
 * Since we limit the proto number to an 8bit number, there can be only 255
 * protocols in this array.
 */
const static char proto_str[][5] =
{
    { "tcp" },
    { "udp" },
    { 0 },
};



/*
 * 
 * * * Functions' declaration * * *
 *
 */

void snsd_cache_init(int family);
u_char str_to_snsd_proto(char *proto_name);
const char *snsd_proto_to_str(u_char proto);
int str_to_snsd_service(char *str, int *service, u_char *proto);
struct servent *snsd_service_to_str(int service, u_char proto, 
                    char **service_str, char **proto_str);

snsd_service *snsd_find_service(snsd_service *sns, u_short service, u_char proto);
snsd_service *snsd_add_service(snsd_service **head, u_short service, u_char proto);
snsd_prio *snsd_find_prio(snsd_prio *snp, u_char prio);
snsd_prio *snsd_add_prio(snsd_prio **head, u_char prio);
snsd_node *snsd_find_node_by_record(snsd_node *snd, u_int record[MAX_IP_INT]);
snsd_node *snsd_add_node(snsd_node **head, u_short *counter, 
             u_short max_records, u_int record[MAX_IP_INT]);
snsd_node *snsd_add_mainip(snsd_service **head, u_short *counter,
                u_short max_records, u_int record[MAX_IP_INT]);
void snsd_service_llist_del(snsd_service **head);
void snsd_record_del_selected(snsd_service **head, u_short *snd_counter, 
            snsd_service *selected);

int snsd_pack_service(char *pack, size_t free_sz, snsd_service *service);
snsd_service *snsd_unpack_service(char *pack, size_t pack_sz, 
                  size_t *unpacked_sz, u_short *nodes_counter);
int snsd_pack_all_services(char *pack, size_t pack_sz, snsd_service *head);
snsd_service *snsd_unpack_all_service(char *pack, size_t pack_sz, 
                        size_t *unpacked_sz, u_short *nodes_counter);

snsd_node *snsd_choose_wrand(snsd_node *head);
snsd_prio *snsd_highest_prio(snsd_prio *head);
snsd_node *snsd_find_mainip(snsd_service *sns);
void snsd_unset_all_flags(snsd_service *sns, u_char flag);
snsd_service *snsd_service_llist_copy(snsd_service *sns, int service, 
                    u_char proto);

void snsd_merge_node(snsd_node **head, u_short *snsd_counter, snsd_node *new);
void snsd_node_llist_merge(snsd_node **dst, u_short *snsd_counter, snsd_node *src);
void snsd_merge_prio(snsd_prio **head, u_short *snsd_counter, snsd_prio *new);
void snsd_prio_llist_merge(snsd_prio **dst, u_short *snsd_counter, snsd_prio *src);
void snsd_merge_service(snsd_service **head, u_short *snsd_counter, 
            snsd_service *new);
void snsd_service_llist_merge(snsd_service **dst, u_short *snsd_counter,
                  snsd_service *src);

int snsd_count_nodes(snsd_node *head);
int snsd_count_prio_nodes(snsd_prio *head);
int snsd_count_service_nodes(snsd_service *head);
#endif /*SNSD_H*/