double send_reset race, free_ack_conns on reset, lock both conn sides on reset, skip...

[cor_2_6_31.git] / net / cor / cor.h

/**
 *      Connection oriented routing
 *      Copyright (C) 2007-2011 Michael Blizek
 *
 *      This program 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 program 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.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 *      02110-1301, USA.
 */

#include <asm/atomic.h>

#include <linux/types.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/kref.h>
#include <linux/ktime.h>

#include "settings.h"


#define S64_MAX 9223372036854775807LL
#define S64_MIN (1LL << 63)


#define ETH_P_COR 0x1022
#define AF_COR 37
#define PF_COR AF_COR

#define SOCKADDRTYPE_PORT 1
struct cor_sockaddr {
        int type;

        union {
                __be64 port;
        } addr;
};

#define MAX_CONN_CMD_LEN 4096


#define PACKET_TYPE_ANNOUNCE 1
#define PACKET_TYPE_DATA 2

/*
 * Kernel packet data - these commands are sent by the neighbor
 * The end nodes may cause these commands to be sent, but they see them beyond
 * the first hop.
 */

/* KP_PADDING[1] */
#define KP_PADDING 1

/*
 * KP_PING[1] cookie[4]
 * KP_PONG[1] cookie[4] respdelay[4]
 *
 * This is needed to find out whether the other node is reachable. After a new
 * neighbor is seen, ping requests are sent and the neighbor is only reachable
 * after a few pongs are received. These requests are also used to find out
 * whether a neighber is gone.
 *
 * respdelay:
 * The receiver of a ping may delay the sending of the pong e.g. to create
 * bigger kernel packets. The respdelay is the time in microseconds the packet
 * was delayed.
 */
#define KP_PING 2
#define KP_PONG 3

/* KP_ACK[1] seqno[4] */
#define KP_ACK 4

/*
 * KP_ACK_CONN[1] conn_id[4] flags[1] seqno[4] window[1] seqno_ooo[4]
 *   length[1-4] credits[2]
 *
 * conn_id is the conn_id we use if we sent something through this conn and
 *   *not* the conn_id that the neighbor used to send us the data
 *
 * flags defines which of the following fields are sent
 *
 * seqno = the seqno which is expected in the next non-out-of-order packet
 *
 * window = amount of data which can be sent without receiving the next ack
 *   packets with lower seqno do not overwrite the last window size
 *   note: the other side may also reduce the window size
 *   decode:
 *     0 = 0
 *     1...255 = 64*2^((value-1)/11) end result is rounded down to an integer
 *
 * todo 32* 2 ^ ((value-1)/8)
 *
 * seqno_ooo, length = This packet was received out of order. Maybe a previous
 *   packet has been lost. Out of order data should not be retransmitted.
 *   Multiple ooo packets may be merged into a single ack. Ooo packets may be
 *   partially accepted, so that the length does not cover the full packet and/
 *   or the seqno starts in the middle of a packet
 *
 * credits = decaytime+seqno
 */
#define KP_ACK_CONN 5

#define KP_ACK_CONN_FLAGS_SEQNO 1
#define KP_ACK_CONN_FLAGS_WINDOW 2
#define KP_ACK_CONN_FLAGS_OOO 12 /* 4+8 */
#define KP_ACK_CONN_FLAGS_CREDITS 16

static inline __u8 ooolen_to_flags(__u32 len)
{
        if (len == 0)
                return 0;
        if (len < 256)
                return 4;
        if (len < 65536)
                return 8;
        return 12;
}

static inline int ooolen(__u8 flags)
{
        int len = ((flags & KP_ACK_CONN_FLAGS_OOO) >> 2);
        if (unlikely(len == 3))
                return 4;
        return len;
}

static inline int ack_conn_len(__u8 flags)
{
        int len = 0;
        if ((flags & KP_ACK_CONN_FLAGS_SEQNO) != 0) {
                len += 4;
                if ((flags & KP_ACK_CONN_FLAGS_WINDOW) != 0)
                        len++;
        }

        if (ooolen(flags) != 0) {
                len += 4;
                len += ooolen(flags);
        }

        if (flags & KP_ACK_CONN_FLAGS_CREDITS)
                len += 2;

        return len;
}

/*
 * NOTE on connection ids:
 * connection ids + init seqnos we send are used for the receive channel
 * connection ids + init seqnos we receive are used for the send channel
 *
 * ATTENTION: the credit seqno are reversed:
 * decaytime seqnos we send are used when we send updates
 * decaytime seqnos we received are used when we receive updates
 */

/*
 * incoming connection
 * credits = decaytime+seqno
 * KP_CONNECT[1] conn_id[4] init_seqno[4] window[1] credits[2]
 */
#define KP_CONNECT 6

/*
 * incoming connection successful,
 * the first conn_id is the same as previously sent/received in KP_CONNECT
 * the second conn_id is generated by us and used for the other direction
 * KP_CONNECT_SUCCESS[1] conn_id[4] conn_id[4] init_seqno[4] window[1]
 *   credits[2]
 */
#define KP_CONNECT_SUCCESS 7

/* KP_CONN_DATA[1] conn_id[4] seqno[4] length[2] data[length] */
#define KP_CONN_DATA 8

/*
 * { KP_RESET_CONN[1] conn_id[4] }
 * We send this, if there is an established connection we want to close.
 */
#define KP_RESET_CONN 9

/*
 * KP_CONNID_UNKNOWN[1] sent_conn_id[4]
 * We send this, if we receive an invalid conn_id
 */
#define KP_CONNID_UNKNOWN 10

/*
 * KP_SET_MAX_CMSG_DELAY[1] delay[4]
 * Sent after connecting and at any change
 * delay in specifies in microsecs
 */
#define KP_SET_MAX_CMSG_DELAY 11


/*
 * Connection data which in interpreted when connection has no target yet
 * These commands are sent by the end node.
 *
 * Format:
 * cmd[2] length[1-4] parameter[length]
 * unrecogniced commands are ignored
 * parameters which are longer than expected are ignored as well
 */

/* outgoing connection: CD_CONNECT_NB[2] length[1-4]
 * addrtypelen[1-4] addrlen[1-4] addrtype[addrtypelen] addr[addrlen] */
#define CD_CONNECT_NB 1

/* connection to local open part: CD_CONNECT_PORT[2] length[1-4] port[8] */
#define CD_CONNECT_PORT 2

/*
 * CD_LIST_NEIGH sends CDR_BINDATA if the command was successful. The response
 * format is:
 *
 * totalneighs[1-4] response_rows[1-4]
 * numfields[1-4] (field[2] fieldlen[1-4])[numfields]
 * rows[responserows]:
 *   fieldlen[1-4], only if fieldlen in the header was "0"
 *   fielddata[fieldlen]
 *
 * Neighbors have to be sorted by uptime, new neighbors first. This is so that
 * the routing daemon can easily find out whether there are new neighbors. It
 * only needs to send a query with offset 0. If the totalneighs stays the same
 * while new were added, a connection to another neighbor was lost.
 *
 * Future versions may append data to field definition. Therefore clients must
 * silently discard data at the end they do not expect.
 */

/* list connected neighbors: CD_LIST_NEIGH[2] length[1-4] limit[1-4]
 * offset[1-4] */
#define CD_LIST_NEIGH 3

/*
 * numaddr[1-4] (addrtypelen[1-4] addrlen[1-4] addrtype[addrtypelen]
 * addr[addrlen])[numaddr]
 */
#define LIST_NEIGH_FIELD_ADDR 1

/*
 * latency_in_microsecs[4]
 * Only raw network latency in measured. Delays caused by the credit system are
 * *not* included.
 */
#define LIST_NEIGH_FIELD_LATENCY 2


/*
 * CD_SET_TOS[2] length[1-4] forward_tos[1] backward_tos[1]
 * Only 2 bits of the tos flags are used, the highers 6 bits are ignored.
 */
#define CD_SET_TOS 4

#define TOS_NORMAL 0
#define TOS_LATENCY 1
#define TOS_THROUGHPUT 2
#define TOS_PRIVACY 3



/*
 * Connection data response
 * Format is the same as with connection data
 */

/*
 * CDR_EXECOK[1]
 */
#define CDR_EXECOK 1

/*
 * CDR_EXECFAILED[1] reasoncode[2]
 * reasontextlength[1-4] reasontext[reasontextlength]
 * reasontextlength may be 0
 */
#define CDR_EXECFAILED 2
        #define CDR_EXECFAILED_UNKNOWN_COMMAND 1
        #define CDR_EXECFAILED_PERMISSION_DENIED 2
        #define CDR_EXECFAILED_TEMPORARILY_OUT_OF_RESSOURCES 3
        #define CDR_EXECFAILED_CMD_TOO_SHORT 4
        #define CDR_EXECFAILED_CMD_TOO_LONG 5
        #define CDR_EXECFAILED_TARGETADDRTYPE_UNKNOWN 6
        #define CDR_EXECFAILED_TARGETADDR_DOESNTEXIST 7
        #define CDR_EXECFAILED_TARGETADDR_PORTCLOSED 8
        #define CDR_EXECFAILED_LISTENERQUEUE_FULL 9
        #define CDR_EXECFAILED_ILLEGAL_COMMAND 10

/*
 * must be sent after CDR_EXEC{OK|FAILED}
 * CDR_EXEOK_BINDATA[1] bindatalen[1-4] bindata[bindatalen] */
#define CDR_BINDATA 3

/**
 * sending 2^32 credits per millisec means that credits the neighbor owns
 * should be halfed after 1 minute
 *
 * ((x - 4294967295)/x) ^ 60000 = 0.5
 * (x-4294967295)/x = 0.5**(1/60000)
 * x/x - 4294967295/x = 0.5**(1/60000)
 * 1 - 0.5**(1/60000) = 4294967295/x
 * x = 4294967295 / (1 - 0.5**(1/60000))
 */
#define CREDITS_TOTAL (1LL << 63)



/* result codes for rcv.c/proc_packet */
#define RC_DROP 0
#define RC_FINISHED 1

#define RC_RCV1_ANNOUNCE 2
#define RC_RCV1_KERNEL 3
#define RC_RCV1_CONN 4

struct htab_entry{
        /* start of next element, *not* next htab_entry */
        void *next;
};

struct htable{
        struct htab_entry **htable;
        __u32 htable_size;
        __u32 cell_size;
        __u32 num_elements;

        int (*matches)(void *htentry, void *searcheditem);
        __u32 key_offset;
        __u32 entry_offset;
        __u32 kref_offset;
};

struct resume_block{
        struct list_head lh;
        int in_queue;
};

struct announce_data{
        struct kref ref;

        struct list_head lh;
        struct net_device *dev;
        struct delayed_work announce_work;
        struct announce *ann;
        struct resume_block rb;

        __u32 curr_announce_msg_offset;
        __u64 scheduled_announce_timer;
};

struct ping_cookie{
        ktime_t time;
        __u32 cookie;
        __u8 pongs; /* count of pongs for pings sent after this one */
};

#define NEIGHBOR_STATE_INITIAL 0
#define NEIGHBOR_STATE_ACTIVE 1
#define NEIGHBOR_STATE_STALLED 2
#define NEIGHBOR_STATE_KILLED 3

struct neighbor{
        struct list_head nb_list;

        struct kref ref;

        struct net_device *dev;
        char mac[MAX_ADDR_LEN];

        char *addr;
        __u16 addrlen;

        struct timer_list cmsg_timer;
        struct work_struct cmsg_work;
        atomic_t cmsg_work_scheduled;
        atomic_t cmsg_timer_running;
        struct mutex cmsg_lock;
        struct mutex send_cmsg_lock;
        struct list_head control_msgs_out;
        /**
         * urgent messages; These are sent even if the neighbor state is not
         * active. If the queue gets full, the oldest ones are dropped. It thus
         * may only contain messages which are allowed to be dropped.
         */
        struct list_head ucontrol_msgs_out;
        unsigned long timeout;
        __u32 cmlength;
        __u32 ucmlength;

        atomic_t cmcnt; /* size of queue + retransmits */
        atomic_t ucmcnt; /* size of queue only */

        unsigned long jiffies_last_cmsg;
        __u32 cmsg_interval; /* microsecs */

        __u8 max_cmsg_delay_sent;

        /* procected by queues_lock */
        struct resume_block rb_kp;
        struct resume_block rb_cr;

        spinlock_t busytill_lock;
        unsigned long busy_till;

        struct mutex pingcookie_lock;
        unsigned long last_ping_time;
        __u32 ping_intransit;
        struct ping_cookie cookies[PING_COOKIES_PER_NEIGH];
        __u32 lastcookie;
        atomic_t latency; /* microsecs */
        atomic_t max_remote_cmsg_delay; /* microsecs */

        spinlock_t state_lock;
        union {
                __u64 last_state_change;/* initial state */
                /**
                 * last_roundtrip:
                 * time of the last sent packet which has been acked or
                 * otherwise responded to (e.g. pong)
                 */
                ktime_t last_roundtrip;/* active/stalled state */
        }state_time;
        __u8 state;
        __u16 ping_success;

        struct delayed_work stalltimeout_timer;
        __u8 str_timer_pending;


        atomic_t kpacket_seqno;
        atomic_t ooo_packets;

        spinlock_t credits_lock;
        unsigned long jiffies_credit_update;
        unsigned long jiffies_credit_decay;

        /* we only keep track on how much the other side may spend */
        __u64 credits;
        __u32 credits_fract;
        /* credit rates are in credits/sec */
        __u32 creditrate_initial;
        __u64 creditrate_earning;
        __u64 creditrate_spending;

        /*
         * connecions which receive data from/send data to this node
         * used when terminating all connections of a neighbor
         */
        spinlock_t conn_list_lock;
        struct list_head rcv_conn_list;

        /*
         * the timer has to be inited when adding the neighbor
         * init_timer(struct timer_list * timer);
         * add_timer(struct timer_list * timer);
         */
        spinlock_t retrans_lock;
        struct delayed_work retrans_timer_conn;
        struct delayed_work retrans_timer;
        __u8 retrans_timer_conn_running;
        __u8 retrans_timer_running;

        struct list_head retrans_list;
        struct list_head retrans_list_conn;

        struct conn *firstboundconn;
};

struct cor_sched_data{
        spinlock_t lock;
        struct list_head conn_list;
        struct sk_buff_head requeue_queue;
};

#define TYPE_BUF 0
#define TYPE_SKB 1

struct data_buf_item{
        struct list_head buf_list;

        union {
                struct {
                        char *buf;
                        __u16 datalen;
                        __u16 buflen;

                }buf;

                struct sk_buff *skb;
        }data;

        __u8 type;
};

struct connlistener;

struct bindnode{
        struct list_head lh;
        struct connlistener *owner;
        __be64 port;
};

#define SOCKSTATE_LISTENER 1
#define SOCKSTATE_CONN 2

struct sock_hdr {
        /* The first member of connlistener/conn (see sock.c) */
        __u8 sockstate;
};

struct connlistener {
        /* The first member has to be the same as in conn (see sock.c) */
        __u8 sockstate;
        struct bindnode *bn;
        struct mutex lock;
        int queue_maxlen;
        int queue_len;
        struct list_head conn_queue;
        wait_queue_head_t wait;

};

struct speedtracker{
        __u64 speed;/* bytes*65536/jiffie */
        unsigned long jiffies_last_update;
        __u32 bytes_curr;
};

/**
 * There are 2 conn objects per bi-directional connection. They refer to each
 * other with in the reversedir field.
 *
 *
 *
 * Naming:
 * cn: conn we have no clue what is inside
 *
 * src_in, trgt_unconn, trgt_out, ...: A conn with the specified source or
 * targettype. In the unlocked case the types are actually just a guess,
 * because they could have changed since the last access. After locking the
 * source/destination parameters have to be checked whether they still are
 * what we expect. This includes source/targettype, neighbor, conn_id,
 *
 *
 * Naming suffixes:
 * no suffix: unlocked
 *
 * _l: this direction is locked
 *
 * _ll: both directions are locked
 *
 * _lc: locked for credits: If source/targettype is in/out and connid is set on
 * the target.out, only this direction is locked. Otherwise both directions are
 * locked.
 *
 * _o: unlocked, but source or target is known for sure, because an outside
 * lock is taken; For variables on the heap this means that an outside lock must
 * be taken before accessing the struct which points to the conn can be
 * accessed.
 *
 *
 *
 * Locking:
 * The following fields are immutable after the conn has been allocated:
 * is_client, reversedir
 *
 * Most fields are protected by rcv_lock. Fields which which control
 * source and destination of the data flow require both directions to
 * to be locked and external references to be cleared before the change can
 * happen . This includes fields like sourcetype, targettype, connid,
 * list_heads, htab_entries, ???. In this case the side with is_client == 1
 * needs to be locked first. Changes to conn_id and neighbor also require
 * removing the conn from the htables first.
 *
 * Some other fields like htab_entry, some list_head need are locked
 * outside (e.g. at struct neighbor).
 */
struct conn{
        /* The first member has to be the same as in connlistener (see sock.c)*/
        __u8 sockstate;

#define SOURCE_NONE 0
#define SOURCE_IN 1
#define SOURCE_SOCK 2

#define TARGET_UNCONNECTED 0
#define TARGET_OUT 1
#define TARGET_SOCK 2

        __u8    sourcetype:4,
                targettype:4;

        __u8    tos;

        __u8    last_bufferstate:1,
                in_credit_list:1;

        __u8    is_client;

        /*
         * isreset values:
         * 0... connection active
         * 1... connection is about to be reset, target does not need to be
         *      notified
         * 2... connection is reset
         * 3... connection is reset + no pointers to "struct conn *reversedir"
         *      remaining except from this conn
         */
        __u8    isreset;

        struct list_head queue_list;

        struct kref ref;

        struct mutex rcv_lock;

        unsigned long jiffies_credit_update;
        struct list_head credit_list;
        /* state */
        __u64 credits;
        /* credit rates per second, locked by credit_lock (in credit.c) */
        __u64 crate_in;
        __u32 crate_out;
        /*
         * This is how much we *want* to forward, not how much we actually do.
         * 2^31 == 100%
         */
        __u32 crate_forward;

        union{
                struct{
                        struct neighbor *nb;
                        /* list of all connections from this neighbor */
                        struct list_head nb_list;

                        struct sk_buff_head reorder_queue;

                        struct htab_entry htab_entry;
                        __u32 conn_id;
                        __u32 next_seqno;
                        __u32 ooo_packets;

                        /* number of ack sent, not data seqno */
                        __u32 ack_seqno;

                        /* credit rate */
                        __u16 decaytime;
                        __u8 decaytime_seqno;
                        __u8 inorder_ack_needed;

                        __u32 window_seqnolimit;
                        __u32 window_seqnolimit_remote;

                        /* protected by nb->cmsg_lock */
                        struct list_head acks_pending;

                        struct list_head buffer_list;

                        __u32 buffer_init;
                        __u32 buffer_speed;
                        __u32 buffer_ata;

                        __u32 usage_init;
                        __u32 usage_speed;
                        __u32 usage_ata;
                        __u32 usage_reserve;

                        struct speedtracker st;

                        unsigned long jiffies_last_window_set;

                        unsigned long jiffies_last_act;
                }in;

                struct{
                        struct list_head cl_list;
                        wait_queue_head_t wait;
                        struct socket *sock;
                        int flags;

                        __u32 crate;

                        __u32 wait_len;

                        /**
                         * alloclimit, delflush_list, alwait_list,
                         * in_alwait_list are protected by
                         * sock_bufferlimits_lock
                         *
                         * sbt may not change unless both sock_bufferlimits_lock
                         * and rcv_lock is held
                         *
                         * delay_flush is protocted by rcv_lock
                         */
                        __u32 alloclimit;
                        struct sock_buffertracker *sbt;
                        struct list_head delflush_list;
                        struct list_head alwait_list;
                        __u8 in_alwait_list;
                        __u8 delay_flush;
                }sock;
        }source;

        union{
                struct{
                        __u32 paramlen;
                        __u32 cmdread;
                        __u16 cmd;
                        __u8 paramlen_read;
                        __u8 *cmdparams;
                        char paramlen_buf[4];

                        __u8 in_buffer_wait_list;
                        struct list_head buffer_wait_list;
                }unconnected;

                struct{
                        struct neighbor *nb;
                        /* protected by nb->retrans_lock, sorted by seqno */
                        struct list_head retrans_list;

                        /* reverse conn_id lookup */
                        struct htab_entry htab_entry;

                        __u32 conn_id;
                        __u32 seqno_nextsend;
                        __u32 seqno_acked;
                        __u32 seqno_windowlimit;

                        struct resume_block rb;

                        __u16 decaytime_last;
                        __u8 decaytime_seqno;
                        __u8 decaytime_send_allowed;
                }out;

                struct{
                        wait_queue_head_t wait;

                        __u8 credituser;
                }sock;
        }target;

        struct{
                struct list_head items;
                struct data_buf_item *lastread;
                __u32 first_offset;

                __u32 totalsize;
                __u32 overhead;
                __u32 read_remaining;

                __u16 last_read_offset;

                __u16 cpacket_buffer;/* including overhead */
        }data_buf;

        struct conn *reversedir;
};

/* inside skb->cb */
struct skb_procstate{
        union{
                struct{
                        struct work_struct work;
                }rcv;

                struct{
                        __u32 offset;
                }announce;

                struct{
                        __u32 seqno;
                }rcv2;
        }funcstate;
};

struct sock_buffertracker {
        struct list_head lh;

        uid_t uid;
        __u64 usage;

        struct list_head delflush_conns;
        struct list_head waiting_conns;

        struct kref ref;
};


/* common.c */
extern atomic_t num_conns;

extern __u8 __attribute__((const)) enc_log_64_11(__u32 window_bytes);

extern __u32 __attribute__((const)) dec_log_64_11(__u8 window);

extern __u16 __attribute__((const)) enc_log_300_24(__u64 value);

extern __u64 __attribute__((const)) dec_log_300_24(__u16 value);

extern __u64 __attribute__((const)) multiply_div(__u64 a, __u64 b, __u64 c);

extern char *htable_get(struct htable *ht, __u32 key, void *searcheditem);

extern int htable_delete(struct htable *ht, __u32 key, void *searcheditem,
                void (*free) (struct kref *ref));

extern void htable_insert(struct htable *ht, char *newelement, __u32 key);

extern void htable_init(struct htable *ht, int (*matches)(void *htentry,
                void *searcheditem), __u32 entry_offset,
                __u32 kref_offset);

extern struct conn *get_conn_reverse(struct neighbor *nb, __u32 conn_id);

extern void insert_reverse_connid(struct conn *trgt_out_ll);

extern struct conn *get_conn(__u32 conn_id);

extern void _set_last_act(struct conn *src_in_l);

extern void free_conn(struct kref *ref);

extern int conn_init_out(struct conn *trgt_unconn_ll, struct neighbor *nb);

extern void conn_init_sock_source(struct conn *cn);

extern void conn_init_sock_target(struct conn *cn);

extern void close_port(struct connlistener *listener);

extern struct connlistener *open_port(__be64 port);

extern int connect_port(struct conn *trtg_unconn_l, __be64 port);

extern int connect_neigh(struct conn *trtg_unconn_l,
                __u16 addrtypelen, __u8 *addrtype,
                __u16 addrlen, __u8 *addr);

extern struct conn* alloc_conn(gfp_t allocflags);

extern void reset_conn(struct conn *cn);

/* credits.c */
extern __u32 creditrate_initial(void);

extern int refresh_conn_credits(struct conn *conn, int fromperiodic,
                int locked);

extern void set_creditrate_initial(struct neighbor *nb, __u32 debitrate);

extern void set_conn_in_decaytime(struct neighbor *nb, __u32 conn_id,
                struct conn *src_in, __u8 decaytime_seqno, __u16 decaytime);

extern void connreset_credits(struct conn *cn);

extern void __init credits_init(void);

/* neighbor.c */
extern void neighbor_free(struct kref *ref);

extern int is_from_nb(struct sk_buff *skb, struct neighbor *nb);

extern struct neighbor *get_neigh_by_mac(struct sk_buff *skb);

extern struct neighbor *find_neigh(__u16 addrtypelen, __u8 *addrtype,
                __u16 addrlen, __u8 *addr);

extern __u32 generate_neigh_list(char *buf, __u32 buflen, __u32 limit,
                __u32 offset);

extern int get_neigh_state(struct neighbor *nb);

extern void ping_resp(struct neighbor *nb, __u32 cookie, __u32 respdelay);

extern __u32 add_ping_req(struct neighbor *nb, unsigned long *last_ping_time);

extern void unadd_ping_req(struct neighbor *nb, __u32 cookie,
                unsigned long last_ping_time);

extern void set_busy_till(struct neighbor *nb, int initial);

extern int time_to_send_ping(struct neighbor *nb);

extern int get_next_ping_time(struct neighbor *nb);

extern int force_ping(struct neighbor *nb);

extern void rcv_announce(struct sk_buff *skb);

extern int send_announce_qos(struct announce_data *ann);

extern void announce_data_free(struct kref *ref);

extern int __init cor_neighbor_init(void);

/* rcv.c */
extern __u8 get_window(struct conn *cn, struct neighbor *expectedsender,
                __u32 expected_connid, int from_acksend);

extern void reset_bufferusage(struct conn *cn);

extern void refresh_speedstat(struct conn *l_src_in, __u32 written);

extern void drain_ooo_queue(struct conn *l_src_in);

extern void conn_rcv_buildskb(struct neighbor *nb, char *data, __u32 datalen,
                __u32 conn_id, __u32 seqno);

extern int __init cor_rcv_init(void);

/* kpacket_parse.c */
extern void kernel_packet(struct neighbor *nb, struct sk_buff *skb,
                __u32 seqno);

/* kpacket_gen.c */
extern void controlmsg_workfunc(struct work_struct *work);

struct control_msg_out;

#define ACM_PRIORITY_LOW 1 /* oom recovery easy */
#define ACM_PRIORITY_MED 2 /* oom may require recovery on layer 4 */
#define ACM_PRIORITY_HIGH 3 /* oom may cause timeouts on layer 3 */

extern int may_alloc_control_msg(struct neighbor *nb, int priority);

extern struct control_msg_out *alloc_control_msg(struct neighbor *nb,
                int priority);

extern void free_control_msg(struct control_msg_out *cm);

extern void retransmit_timerfunc(struct work_struct *work);

extern void kern_ack_rcvd(struct neighbor *nb, __u32 seqno);

extern int send_messages(struct neighbor *nb, int resume);

extern void controlmsg_workfunc(struct work_struct *work);

extern void controlmsg_timerfunc(unsigned long arg);

extern void schedule_controlmsg_timer(struct neighbor *nb);

extern void send_pong(struct neighbor *nb,
                __u32 cookie);

extern int send_reset_conn(struct neighbor *nb, __u32 conn_id_reset,
                __u32 conn_id_unknown, int lowprio);

extern void send_ack(struct neighbor *nb,
                __u32 seqno);

extern void send_ack_conn_ifneeded(struct conn *src_in_l);

extern void send_ack_conn_ooo(struct control_msg_out *cm, struct conn *src_in_l,
                __u32 conn_id, __u32 seqno_ooo, __u32 length);

extern void send_decaytime(struct conn *trgt_out_l, int force, __u16 decaytime);

extern void free_ack_conns(struct conn *src_in_l);

extern void send_connect_success(struct control_msg_out *cm, __u32 rcvd_conn_id,
                __u32 gen_conn_id, __u32 init_seqno,  struct conn *src_in);

extern void send_connect_nb(struct control_msg_out *cm, __u32 conn_id,
                __u32 init_seqno, struct conn *src_in);

extern void send_conndata(struct control_msg_out *cm, __u32 conn_id,
                __u32 seqno, char *data_orig, char *data, __u32 datalen);

extern void send_connid_unknown(struct neighbor *nb, __u32 conn_id);

extern void __init cor_kgen_init(void);

/* cpacket_parse.c */
extern void free_cpacket_buffer(__s32 amount);

extern void connreset_cpacket_buffer(struct conn *trtg_unconn_l);

extern int encode_len(char *buf, int buflen, __u32 len);

extern int decode_len(char *buf, int buflen, __u32 *len);

extern void parse(struct conn *trtg_unconn, int fromresume);

extern int __init cor_cpacket_init(void);

/* snd.c */
extern int destroy_queue(struct net_device *dev);

extern int create_queue(struct net_device *dev);

#define QOS_CALLER_KPACKET 0
#define QOS_CALLER_CONN_RETRANS 1
#define QOS_CALLER_ANNOUNCE 2
#define QOS_CALLER_CONN 3

extern void qos_enqueue(struct net_device *dev, struct resume_block *rb,
                int caller);

extern void qos_remove_conn(struct conn *cn);

extern struct sk_buff *create_packet(struct neighbor *nb, int size,
                gfp_t alloc_flags, __u32 conn_id, __u32 seqno);

extern void cancel_retrans(struct conn *trgt_out_l);

extern void retransmit_conn_timerfunc(struct work_struct *work);

extern void conn_ack_ooo_rcvd(struct neighbor *nb, __u32 conn_id,
                struct conn *trgt_out, __u32 seqno_ooo, __u32 length);

extern void conn_ack_rcvd(struct neighbor *nb, __u32 conn_id,
                struct conn *trgt_out, __u32 seqno, int setwindow, __u8 window);

#define RC_FLUSH_CONN_OUT_OK 0
#define RC_FLUSH_CONN_OUT_OK_SENT 1
#define RC_FLUSH_CONN_OUT_CONG 2
#define RC_FLUSH_CONN_OUT_CREDITS 3
#define RC_FLUSH_CONN_OUT_OOM 4
extern int flush_out(struct conn *trgt_out_l, int fromqos, __u32 creditsperbyte);

extern int __init cor_snd_init(void);

/* forward.c */
extern void databuf_init(struct conn *cn_init);

extern void databuf_free(struct conn *cn_l);

extern void reset_seqno(struct conn *cn_l, __u32 initseqno);

extern void databuf_pull(struct conn *cn_l, char *dst, int len);

extern size_t databuf_pulluser(struct conn *trgt_sock_l, struct msghdr *msg);

extern void databuf_unpull(struct conn *trgt_out_l, __u32 bytes);

extern void databuf_pullold(struct conn *trgt_out_l, __u32 startpos, char *dst,
                int len);

extern void databuf_ack(struct conn *trgt_out_l, __u32 pos);

extern void databuf_ackread(struct conn *cn_l);

__s64 receive_userbuf(struct conn *src_sock_l, struct msghdr *msg, __u32 maxcpy,
                __u32 maxusage);

extern void receive_cpacketresp(struct conn *trtg_unconn_l, char *buf, int len);

extern int receive_skb(struct conn *src_in_l, struct sk_buff *skb);

extern void wake_sender(struct conn *cn);

extern void flush_buf(struct conn *cn);

extern void __init forward_init(void);

/* sock.c */
extern struct mutex sock_bufferlimits_lock;

extern void connreset_sbt(struct conn *cn);

extern void unreserve_sock_buffer(struct conn *cn);


static inline struct skb_procstate *skb_pstate(struct sk_buff *skb)
{
        return (struct skb_procstate *) &(skb->cb[0]);
}

static inline struct sk_buff *skb_from_pstate(struct skb_procstate *ps)
{
        return (struct sk_buff *) (((char *)ps) - offsetof(struct sk_buff,cb));
}


static inline __u32 mss(struct neighbor *nb)
{
        return nb->dev->mtu - LL_RESERVED_SPACE(nb->dev) - 9;
}


static inline void put_u64(char *dst, __u64 value, int convbo)
{
        char *p_value = (char *) &value;

        if (convbo)
                value = cpu_to_be64(value);

        dst[0] = p_value[0];
        dst[1] = p_value[1];
        dst[2] = p_value[2];
        dst[3] = p_value[3];
        dst[4] = p_value[4];
        dst[5] = p_value[5];
        dst[6] = p_value[6];
        dst[7] = p_value[7];
}

static inline void put_u32(char *dst, __u32 value, int convbo)
{
        char *p_value = (char *) &value;

        if (convbo)
                value = cpu_to_be32(value);

        dst[0] = p_value[0];
        dst[1] = p_value[1];
        dst[2] = p_value[2];
        dst[3] = p_value[3];
}

static inline void put_u16(char *dst, __u16 value, int convbo)
{
        char *p_value = (char *) &value;

        if (convbo)
                value = cpu_to_be16(value);

        dst[0] = p_value[0];
        dst[1] = p_value[1];
}

static inline char *cor_pull_skb(struct sk_buff *skb, unsigned int len)
{
        char *ptr = skb_pull(skb, len);

        if(unlikely(ptr == 0))
                return 0;

        return ptr - len;
}

static inline int is_conn_in(struct conn *cn_l, struct neighbor *nb,
                __u32 conn_id)
{
        if (unlikely(unlikely(cn_l->sourcetype != SOURCE_IN) ||
                        unlikely(cn_l->source.in.nb != nb) ||
                        unlikely(cn_l->source.in.conn_id != conn_id) ||
                        unlikely(cn_l->isreset != 0)))
                return 0;
        return 1;
}

static inline void set_last_act(struct conn *src_in_l)
{
        unsigned long jiffies_tmp = jiffies;

        BUG_ON(src_in_l->sourcetype != SOURCE_IN);

        if (unlikely(time_after(src_in_l->source.in.jiffies_last_act +
                        HZ * CONN_ACTIVITY_UPDATEINTERVAL_SEC,
                        jiffies_tmp)))
                _set_last_act(src_in_l);
}


static inline int seqno_before(__u32 seqno1, __u32 seqno2)
{
        return (seqno1 - seqno2) >= (1 << 31);
}

static inline int seqno_before_eq(__u32 seqno1, __u32 seqno2)
{
        return (seqno1 == seqno2) || ((seqno1 - seqno2) >= (1 << 31));
}

static inline int seqno_after(__u32 seqno1, __u32 seqno2)
{
        return (seqno1 - seqno2) < (1 << 31);
}

static inline int seqno_after_eq(__u32 seqno1, __u32 seqno2)
{
        return (seqno1 == seqno2) || ((seqno1 - seqno2) < (1 << 31));
}

static inline int ktime_before(ktime_t time1, ktime_t time2)
{
        return ktime_to_ns(time1) - ktime_to_ns(time2) < 0;
}

static inline int ktime_before_eq(ktime_t time1, ktime_t time2)
{
        return ktime_to_ns(time1) - ktime_to_ns(time2) <= 0;
}

static inline int ktime_after(ktime_t time1, ktime_t time2)
{
        return ktime_to_ns(time1) - ktime_to_ns(time2) > 0;
}

static inline int ktime_after_eq(ktime_t time1, ktime_t time2)
{
        return ktime_to_ns(time1) - ktime_to_ns(time2) >= 0;
}

static inline __s64 ktime_to_ms(ktime_t time)
{
        return (ktime_to_ns(time) + 500000) / 1000000;
}