diff options
Diffstat (limited to 'pfinet/linux-src/include/net')
64 files changed, 8548 insertions, 0 deletions
diff --git a/pfinet/linux-src/include/net/addrconf.h b/pfinet/linux-src/include/net/addrconf.h new file mode 100644 index 00000000..d711d0d5 --- /dev/null +++ b/pfinet/linux-src/include/net/addrconf.h @@ -0,0 +1,158 @@ +#ifndef _ADDRCONF_H +#define _ADDRCONF_H + +#define RETRANS_TIMER HZ + +#define MAX_RTR_SOLICITATIONS 3 +#define RTR_SOLICITATION_INTERVAL (4*HZ) + +#define ADDR_CHECK_FREQUENCY (120*HZ) + +struct prefix_info { + __u8 type; + __u8 length; + __u8 prefix_len; + +#if defined(__BIG_ENDIAN_BITFIELD) + __u8 onlink : 1, + autoconf : 1, + reserved : 6; +#elif defined(__LITTLE_ENDIAN_BITFIELD) + __u8 reserved : 6, + autoconf : 1, + onlink : 1; +#else +#error "Please fix <asm/byteorder.h>" +#endif + __u32 valid; + __u32 prefered; + __u32 reserved2; + + struct in6_addr prefix; +}; + + +#ifdef __KERNEL__ + +#include <linux/in6.h> +#include <linux/netdevice.h> +#include <net/if_inet6.h> + +#define IN6_ADDR_HSIZE 16 + +extern void addrconf_init(void); +extern void addrconf_cleanup(void); + +extern int addrconf_notify(struct notifier_block *this, + unsigned long event, + void * data); + +extern int addrconf_add_ifaddr(void *arg); +extern int addrconf_del_ifaddr(void *arg); +extern int addrconf_set_dstaddr(void *arg); + +extern struct inet6_ifaddr * ipv6_chk_addr(struct in6_addr *addr, + struct device *dev, int nd); +extern int ipv6_get_saddr(struct dst_entry *dst, + struct in6_addr *daddr, + struct in6_addr *saddr); +extern struct inet6_ifaddr * ipv6_get_lladdr(struct device *dev); + +/* + * multicast prototypes (mcast.c) + */ +extern int ipv6_sock_mc_join(struct sock *sk, + int ifindex, + struct in6_addr *addr); +extern int ipv6_sock_mc_drop(struct sock *sk, + int ifindex, + struct in6_addr *addr); +extern void ipv6_sock_mc_close(struct sock *sk); + +extern int ipv6_dev_mc_inc(struct device *dev, + struct in6_addr *addr); +extern int ipv6_dev_mc_dec(struct device *dev, + struct in6_addr *addr); +extern void ipv6_mc_up(struct inet6_dev *idev); +extern void ipv6_mc_down(struct inet6_dev *idev); +extern void ipv6_mc_destroy_dev(struct inet6_dev *idev); +extern void addrconf_dad_failure(struct inet6_ifaddr *ifp); + +extern int ipv6_chk_mcast_addr(struct device *dev, + struct in6_addr *addr); + +extern void addrconf_prefix_rcv(struct device *dev, + u8 *opt, int len); + +extern struct inet6_dev * ipv6_get_idev(struct device *dev); + +extern void addrconf_forwarding_on(void); +/* + * Hash function taken from net_alias.c + */ + +static __inline__ u8 ipv6_addr_hash(struct in6_addr *addr) +{ + __u32 word; + unsigned tmp; + + /* + * We perform the hash function over the last 64 bits of the address + * This will include the IEEE address token on links that support it. + */ + + word = addr->s6_addr[2] ^ addr->s6_addr32[3]; + tmp = word ^ (word>>16); + tmp ^= (tmp >> 8); + + return ((tmp ^ (tmp >> 4)) & 0x0f); +} + +static __inline__ int ipv6_devindex_hash(int ifindex) +{ + return ifindex & (IN6_ADDR_HSIZE - 1); +} + +/* + * compute link-local solicited-node multicast address + */ + +extern __inline__ void addrconf_addr_solict_mult_old(struct in6_addr *addr, + struct in6_addr *solicited) +{ + ipv6_addr_set(solicited, + __constant_htonl(0xFF020000), 0, + __constant_htonl(0x1), addr->s6_addr32[3]); +} + +extern __inline__ void addrconf_addr_solict_mult_new(struct in6_addr *addr, + struct in6_addr *solicited) +{ + ipv6_addr_set(solicited, + __constant_htonl(0xFF020000), 0, + __constant_htonl(0x1), + __constant_htonl(0xFF000000) | addr->s6_addr32[3]); +} + + +extern __inline__ void ipv6_addr_all_nodes(struct in6_addr *addr) +{ + ipv6_addr_set(addr, + __constant_htonl(0xFF020000), 0, 0, + __constant_htonl(0x1)); +} + +extern __inline__ void ipv6_addr_all_routers(struct in6_addr *addr) +{ + ipv6_addr_set(addr, + __constant_htonl(0xFF020000), 0, 0, + __constant_htonl(0x2)); +} + +extern __inline__ int ipv6_addr_is_multicast(struct in6_addr *addr) +{ + return (addr->s6_addr32[0] & __constant_htonl(0xFF000000)) == __constant_htonl(0xFF000000); +} + +#endif +#endif diff --git a/pfinet/linux-src/include/net/af_unix.h b/pfinet/linux-src/include/net/af_unix.h new file mode 100644 index 00000000..06970ac6 --- /dev/null +++ b/pfinet/linux-src/include/net/af_unix.h @@ -0,0 +1,35 @@ +#ifndef __LINUX_NET_AFUNIX_H +#define __LINUX_NET_AFUNIX_H +extern void unix_proto_init(struct net_proto *pro); +extern struct proto_ops unix_proto_ops; +extern void unix_inflight(struct file *fp); +extern void unix_notinflight(struct file *fp); +typedef struct sock unix_socket; +extern void unix_gc(void); + +#define UNIX_HASH_SIZE 16 + +extern unix_socket *unix_socket_table[UNIX_HASH_SIZE+1]; + +#define forall_unix_sockets(i, s) for (i=0; i<=UNIX_HASH_SIZE; i++) \ + for (s=unix_socket_table[i]; s; s=s->next) + +struct unix_address +{ + atomic_t refcnt; + int len; + unsigned hash; + struct sockaddr_un name[0]; +}; + +struct unix_skb_parms +{ + struct ucred creds; /* Skb credentials */ + struct scm_fp_list *fp; /* Passed files */ + unsigned attr; /* Special attributes */ +}; + +#define UNIXCB(skb) (*(struct unix_skb_parms*)&((skb)->cb)) +#define UNIXCREDS(skb) (&UNIXCB((skb)).creds) + +#endif diff --git a/pfinet/linux-src/include/net/arp.h b/pfinet/linux-src/include/net/arp.h new file mode 100644 index 00000000..b672bacb --- /dev/null +++ b/pfinet/linux-src/include/net/arp.h @@ -0,0 +1,24 @@ +/* linux/net/inet/arp.h */ +#ifndef _ARP_H +#define _ARP_H + +#include <linux/if_arp.h> +#include <net/neighbour.h> + +extern struct neigh_table arp_tbl; + +extern void arp_init(void); +extern int arp_rcv(struct sk_buff *skb, struct device *dev, + struct packet_type *pt); +extern int arp_find(unsigned char *haddr, struct sk_buff *skb); +extern int arp_ioctl(unsigned int cmd, void *arg); +extern void arp_send(int type, int ptype, u32 dest_ip, + struct device *dev, u32 src_ip, + unsigned char *dest_hw, unsigned char *src_hw, unsigned char *th); +extern int arp_bind_neighbour(struct dst_entry *dst); +extern int arp_mc_map(u32 addr, u8 *haddr, struct device *dev, int dir); +extern void arp_ifdown(struct device *dev); + +extern struct neigh_ops arp_broken_ops; + +#endif /* _ARP_H */ diff --git a/pfinet/linux-src/include/net/atalkcall.h b/pfinet/linux-src/include/net/atalkcall.h new file mode 100644 index 00000000..726e33cd --- /dev/null +++ b/pfinet/linux-src/include/net/atalkcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void atalk_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/ax25.h b/pfinet/linux-src/include/net/ax25.h new file mode 100644 index 00000000..2c8d20a6 --- /dev/null +++ b/pfinet/linux-src/include/net/ax25.h @@ -0,0 +1,349 @@ +/* + * Declarations of AX.25 type objects. + * + * Alan Cox (GW4PTS) 10/11/93 + */ + +#ifndef _AX25_H +#define _AX25_H +#include <linux/config.h> +#include <linux/ax25.h> + +#define AX25_T1CLAMPLO 1 +#define AX25_T1CLAMPHI (30 * HZ) + +#define AX25_BPQ_HEADER_LEN 16 +#define AX25_KISS_HEADER_LEN 1 + +#define AX25_HEADER_LEN 17 +#define AX25_ADDR_LEN 7 +#define AX25_DIGI_HEADER_LEN (AX25_MAX_DIGIS * AX25_ADDR_LEN) +#define AX25_MAX_HEADER_LEN (AX25_HEADER_LEN + AX25_DIGI_HEADER_LEN) + +/* AX.25 Protocol IDs */ +#define AX25_P_ROSE 0x01 +#define AX25_P_IP 0xCC +#define AX25_P_ARP 0xCD +#define AX25_P_TEXT 0xF0 +#define AX25_P_NETROM 0xCF +#define AX25_P_SEGMENT 0x08 + +/* AX.25 Segment control values */ +#define AX25_SEG_REM 0x7F +#define AX25_SEG_FIRST 0x80 + +#define AX25_CBIT 0x80 /* Command/Response bit */ +#define AX25_EBIT 0x01 /* HDLC Address Extension bit */ +#define AX25_HBIT 0x80 /* Has been repeated bit */ + +#define AX25_SSSID_SPARE 0x60 /* Unused bits in SSID for standard AX.25 */ +#define AX25_ESSID_SPARE 0x20 /* Unused bits in SSID for extended AX.25 */ +#define AX25_DAMA_FLAG 0x20 /* Well, it is *NOT* unused! (dl1bke 951121 */ + +#define AX25_COND_ACK_PENDING 0x01 +#define AX25_COND_REJECT 0x02 +#define AX25_COND_PEER_RX_BUSY 0x04 +#define AX25_COND_OWN_RX_BUSY 0x08 +#define AX25_COND_DAMA_MODE 0x10 + +#ifndef _LINUX_NETDEVICE_H +#include <linux/netdevice.h> +#endif + +/* Upper sub-layer (LAPB) definitions */ + +/* Control field templates */ +#define AX25_I 0x00 /* Information frames */ +#define AX25_S 0x01 /* Supervisory frames */ +#define AX25_RR 0x01 /* Receiver ready */ +#define AX25_RNR 0x05 /* Receiver not ready */ +#define AX25_REJ 0x09 /* Reject */ +#define AX25_U 0x03 /* Unnumbered frames */ +#define AX25_SABM 0x2f /* Set Asynchronous Balanced Mode */ +#define AX25_SABME 0x6f /* Set Asynchronous Balanced Mode Extended */ +#define AX25_DISC 0x43 /* Disconnect */ +#define AX25_DM 0x0f /* Disconnected mode */ +#define AX25_UA 0x63 /* Unnumbered acknowledge */ +#define AX25_FRMR 0x87 /* Frame reject */ +#define AX25_UI 0x03 /* Unnumbered information */ + +#define AX25_PF 0x10 /* Poll/final bit for standard AX.25 */ +#define AX25_EPF 0x01 /* Poll/final bit for extended AX.25 */ + +#define AX25_ILLEGAL 0x100 /* Impossible to be a real frame type */ + +#define AX25_POLLOFF 0 +#define AX25_POLLON 1 + +/* AX25 L2 C-bit */ +#define AX25_COMMAND 1 +#define AX25_RESPONSE 2 + +/* Define Link State constants. */ + +enum { + AX25_STATE_0, + AX25_STATE_1, + AX25_STATE_2, + AX25_STATE_3, + AX25_STATE_4 +}; + +#define AX25_MODULUS 8 /* Standard AX.25 modulus */ +#define AX25_EMODULUS 128 /* Extended AX.25 modulus */ + +enum { + AX25_PROTO_STD_SIMPLEX, + AX25_PROTO_STD_DUPLEX, + AX25_PROTO_DAMA_SLAVE, + AX25_PROTO_DAMA_MASTER +}; + +enum { + AX25_VALUES_IPDEFMODE, /* 0=DG 1=VC */ + AX25_VALUES_AXDEFMODE, /* 0=Normal 1=Extended Seq Nos */ + AX25_VALUES_BACKOFF, /* 0=None 1=Linear 2=Exponential */ + AX25_VALUES_CONMODE, /* Allow connected modes - 0=No 1=no "PID text" 2=all PIDs */ + AX25_VALUES_WINDOW, /* Default window size for standard AX.25 */ + AX25_VALUES_EWINDOW, /* Default window size for extended AX.25 */ + AX25_VALUES_T1, /* Default T1 timeout value */ + AX25_VALUES_T2, /* Default T2 timeout value */ + AX25_VALUES_T3, /* Default T3 timeout value */ + AX25_VALUES_IDLE, /* Connected mode idle timer */ + AX25_VALUES_N2, /* Default N2 value */ + AX25_VALUES_PACLEN, /* AX.25 MTU */ + AX25_VALUES_PROTOCOL, /* Std AX.25, DAMA Slave, DAMA Master */ + AX25_VALUES_DS_TIMEOUT, /* DAMA Slave timeout */ + AX25_MAX_VALUES /* THIS MUST REMAIN THE LAST ENTRY OF THIS LIST */ +}; + +#define AX25_DEF_IPDEFMODE 0 /* Datagram */ +#define AX25_DEF_AXDEFMODE 0 /* Normal */ +#define AX25_DEF_BACKOFF 1 /* Linear backoff */ +#define AX25_DEF_CONMODE 2 /* Connected mode allowed */ +#define AX25_DEF_WINDOW 2 /* Window=2 */ +#define AX25_DEF_EWINDOW 32 /* Module-128 Window=32 */ +#define AX25_DEF_T1 (10 * HZ) /* T1=10s */ +#define AX25_DEF_T2 (3 * HZ) /* T2=3s */ +#define AX25_DEF_T3 (300 * HZ) /* T3=300s */ +#define AX25_DEF_N2 10 /* N2=10 */ +#define AX25_DEF_IDLE (0 * 60 * HZ) /* Idle=None */ +#define AX25_DEF_PACLEN 256 /* Paclen=256 */ +#define AX25_DEF_PROTOCOL AX25_PROTO_STD_SIMPLEX /* Standard AX.25 */ +#define AX25_DEF_DS_TIMEOUT (3 * 60 * HZ) /* DAMA timeout 3 minutes */ + +typedef struct ax25_uid_assoc { + struct ax25_uid_assoc *next; + uid_t uid; + ax25_address call; +} ax25_uid_assoc; + +typedef struct { + ax25_address calls[AX25_MAX_DIGIS]; + unsigned char repeated[AX25_MAX_DIGIS]; + unsigned char ndigi; + char lastrepeat; +} ax25_digi; + +typedef struct ax25_route { + struct ax25_route *next; + ax25_address callsign; + struct device *dev; + ax25_digi *digipeat; + char ip_mode; +} ax25_route; + +typedef struct { + char slave; /* slave_mode? */ + struct timer_list slave_timer; /* timeout timer */ + unsigned short slave_timeout; /* when? */ +} ax25_dama_info; + +#ifndef _LINUX_SYSCTL_H +#include <linux/sysctl.h> +#endif + +typedef struct ax25_dev { + struct ax25_dev *next; + struct device *dev; + struct device *forward; + struct ctl_table systable[AX25_MAX_VALUES+1]; + int values[AX25_MAX_VALUES]; +#if defined(CONFIG_AX25_DAMA_SLAVE) || defined(CONFIG_AX25_DAMA_MASTER) + ax25_dama_info dama; +#endif +} ax25_dev; + +typedef struct ax25_cb { + struct ax25_cb *next; + ax25_address source_addr, dest_addr; + ax25_digi *digipeat; + ax25_dev *ax25_dev; + unsigned char iamdigi; + unsigned char state, modulus, pidincl; + unsigned short vs, vr, va; + unsigned char condition, backoff; + unsigned char n2, n2count; + struct timer_list t1timer, t2timer, t3timer, idletimer; + unsigned long t1, t2, t3, idle, rtt; + unsigned short paclen, fragno, fraglen; + struct sk_buff_head write_queue; + struct sk_buff_head reseq_queue; + struct sk_buff_head ack_queue; + struct sk_buff_head frag_queue; + unsigned char window; + struct timer_list timer; + struct sock *sk; /* Backlink to socket */ +} ax25_cb; + +/* af_ax25.c */ +extern ax25_cb *volatile ax25_list; +extern void ax25_free_cb(ax25_cb *); +extern void ax25_insert_socket(ax25_cb *); +struct sock *ax25_find_listener(ax25_address *, int, struct device *, int); +struct sock *ax25_find_socket(ax25_address *, ax25_address *, int); +extern ax25_cb *ax25_find_cb(ax25_address *, ax25_address *, ax25_digi *, struct device *); +extern struct sock *ax25_addr_match(ax25_address *); +extern void ax25_send_to_raw(struct sock *, struct sk_buff *, int); +extern void ax25_destroy_socket(ax25_cb *); +extern ax25_cb *ax25_create_cb(void); +extern void ax25_fillin_cb(ax25_cb *, ax25_dev *); +extern int ax25_create(struct socket *, int); +extern struct sock *ax25_make_new(struct sock *, struct ax25_dev *); + +/* ax25_addr.c */ +extern ax25_address null_ax25_address; +extern char *ax2asc(ax25_address *); +extern ax25_address *asc2ax(char *); +extern int ax25cmp(ax25_address *, ax25_address *); +extern int ax25digicmp(ax25_digi *, ax25_digi *); +extern unsigned char *ax25_addr_parse(unsigned char *, int, ax25_address *, ax25_address *, ax25_digi *, int *, int *); +extern int ax25_addr_build(unsigned char *, ax25_address *, ax25_address *, ax25_digi *, int, int); +extern int ax25_addr_size(ax25_digi *); +extern void ax25_digi_invert(ax25_digi *, ax25_digi *); + +/* ax25_dev.c */ +extern ax25_dev *ax25_dev_list; +extern ax25_dev *ax25_dev_ax25dev(struct device *); +extern ax25_dev *ax25_addr_ax25dev(ax25_address *); +extern void ax25_dev_device_up(struct device *); +extern void ax25_dev_device_down(struct device *); +extern int ax25_fwd_ioctl(unsigned int, struct ax25_fwd_struct *); +extern struct device *ax25_fwd_dev(struct device *); +extern void ax25_dev_free(void); + +/* ax25_ds_in.c */ +extern int ax25_ds_frame_in(ax25_cb *, struct sk_buff *, int); + +/* ax25_ds_subr.c */ +extern void ax25_ds_nr_error_recovery(ax25_cb *); +extern void ax25_ds_enquiry_response(ax25_cb *); +extern void ax25_ds_establish_data_link(ax25_cb *); +extern void ax25_dev_dama_on(ax25_dev *); +extern void ax25_dev_dama_off(ax25_dev *); +extern void ax25_dama_on(ax25_cb *); +extern void ax25_dama_off(ax25_cb *); + +/* ax25_ds_timer.c */ +extern void ax25_ds_set_timer(ax25_dev *); +extern void ax25_ds_del_timer(ax25_dev *); +extern void ax25_ds_timer(ax25_cb *); +extern void ax25_ds_t1_timeout(ax25_cb *); +extern void ax25_ds_heartbeat_expiry(ax25_cb *); +extern void ax25_ds_t3timer_expiry(ax25_cb *); +extern void ax25_ds_idletimer_expiry(ax25_cb *); + +#include <net/ax25call.h> + +/* ax25_iface.c */ +extern int ax25_protocol_register(unsigned int, int (*)(struct sk_buff *, ax25_cb *)); +extern void ax25_protocol_release(unsigned int); +extern int ax25_linkfail_register(void (*)(ax25_cb *, int)); +extern void ax25_linkfail_release(void (*)(ax25_cb *, int)); +extern int ax25_listen_register(ax25_address *, struct device *); +extern void ax25_listen_release(ax25_address *, struct device *); +extern int (*ax25_protocol_function(unsigned int))(struct sk_buff *, ax25_cb *); +extern int ax25_listen_mine(ax25_address *, struct device *); +extern void ax25_link_failed(ax25_cb *, int); +extern int ax25_protocol_is_registered(unsigned int); + +/* ax25_in.c */ +extern int ax25_rx_iframe(ax25_cb *, struct sk_buff *); +extern int ax25_kiss_rcv(struct sk_buff *, struct device *, struct packet_type *); + +/* ax25_ip.c */ +extern int ax25_encapsulate(struct sk_buff *, struct device *, unsigned short, void *, void *, unsigned int); +extern int ax25_rebuild_header(struct sk_buff *); + +/* ax25_out.c */ +extern ax25_cb *ax25_send_frame(struct sk_buff *, int, ax25_address *, ax25_address *, ax25_digi *, struct device *); +extern void ax25_output(ax25_cb *, int, struct sk_buff *); +extern void ax25_kick(ax25_cb *); +extern void ax25_transmit_buffer(ax25_cb *, struct sk_buff *, int); +extern void ax25_queue_xmit(struct sk_buff *); +extern int ax25_check_iframes_acked(ax25_cb *, unsigned short); + +/* ax25_route.c */ +extern void ax25_rt_device_down(struct device *); +extern int ax25_rt_ioctl(unsigned int, void *); +extern int ax25_rt_get_info(char *, char **, off_t, int, int); +extern int ax25_rt_autobind(ax25_cb *, ax25_address *); +extern ax25_route *ax25_rt_find_route(ax25_address *, struct device *); +extern struct sk_buff *ax25_rt_build_path(struct sk_buff *, ax25_address *, ax25_address *, ax25_digi *); +extern void ax25_rt_free(void); + +/* ax25_std_in.c */ +extern int ax25_std_frame_in(ax25_cb *, struct sk_buff *, int); + +/* ax25_std_subr.c */ +extern void ax25_std_nr_error_recovery(ax25_cb *); +extern void ax25_std_establish_data_link(ax25_cb *); +extern void ax25_std_transmit_enquiry(ax25_cb *); +extern void ax25_std_enquiry_response(ax25_cb *); +extern void ax25_std_timeout_response(ax25_cb *); + +/* ax25_std_timer.c */ +extern void ax25_std_heartbeat_expiry(ax25_cb *); +extern void ax25_std_t1timer_expiry(ax25_cb *); +extern void ax25_std_t2timer_expiry(ax25_cb *); +extern void ax25_std_t3timer_expiry(ax25_cb *); +extern void ax25_std_idletimer_expiry(ax25_cb *); + +/* ax25_subr.c */ +extern void ax25_clear_queues(ax25_cb *); +extern void ax25_frames_acked(ax25_cb *, unsigned short); +extern void ax25_requeue_frames(ax25_cb *); +extern int ax25_validate_nr(ax25_cb *, unsigned short); +extern int ax25_decode(ax25_cb *, struct sk_buff *, int *, int *, int *); +extern void ax25_send_control(ax25_cb *, int, int, int); +extern void ax25_return_dm(struct device *, ax25_address *, ax25_address *, ax25_digi *); +extern void ax25_calculate_t1(ax25_cb *); +extern void ax25_calculate_rtt(ax25_cb *); +extern void ax25_disconnect(ax25_cb *, int); + +/* ax25_timer.c */ +extern void ax25_start_heartbeat(ax25_cb *); +extern void ax25_start_t1timer(ax25_cb *); +extern void ax25_start_t2timer(ax25_cb *); +extern void ax25_start_t3timer(ax25_cb *); +extern void ax25_start_idletimer(ax25_cb *); +extern void ax25_stop_heartbeat(ax25_cb *); +extern void ax25_stop_t1timer(ax25_cb *); +extern void ax25_stop_t2timer(ax25_cb *); +extern void ax25_stop_t3timer(ax25_cb *); +extern void ax25_stop_idletimer(ax25_cb *); +extern int ax25_t1timer_running(ax25_cb *); +extern unsigned long ax25_display_timer(struct timer_list *); + +/* ax25_uid.c */ +extern int ax25_uid_policy; +extern ax25_address *ax25_findbyuid(uid_t); +extern int ax25_uid_ioctl(int, struct sockaddr_ax25 *); +extern int ax25_uid_get_info(char *, char **, off_t, int, int); +extern void ax25_uid_free(void); + +/* sysctl_net_ax25.c */ +extern void ax25_register_sysctl(void); +extern void ax25_unregister_sysctl(void); + +#endif diff --git a/pfinet/linux-src/include/net/ax25call.h b/pfinet/linux-src/include/net/ax25call.h new file mode 100644 index 00000000..68b8a70c --- /dev/null +++ b/pfinet/linux-src/include/net/ax25call.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void ax25_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/br.h b/pfinet/linux-src/include/net/br.h new file mode 100644 index 00000000..4d79fc62 --- /dev/null +++ b/pfinet/linux-src/include/net/br.h @@ -0,0 +1,305 @@ +/* + * Constants and structure definitions for the bridging code + */ + +#if !defined(One) +#define Zero 0 +#define One 1 +#endif /* !defined(One) */ + +#if !defined(TRUE) +#define FALSE 0 +#define TRUE 1 +#endif /* !defined(TRUE) */ + +/** port states. **/ +#define Disabled 0 /* (4.4 5) */ +#define Listening 1 /* (4.4.2) */ +#define Learning 2 /* (4.4.3) */ +#define Forwarding 3 /* (4 4 4) */ +#define Blocking 4 /* (4.4.1) */ + +#define No_of_ports 8 +/* arbitrary choice, to allow the code below to compile */ + +#define All_ports (No_of_ports + 1) + +/* + * We time out our entries in the FDB after this many seconds. + */ +#define FDB_TIMEOUT 20 /* JRP: 20s as NSC bridge code, was 300 for Linux */ + +/* + * the following defines are the initial values used when the + * bridge is booted. These may be overridden when this bridge is + * not the root bridge. These are the recommended default values + * from the 802.1d specification. + */ +#define BRIDGE_MAX_AGE 20 +#define BRIDGE_HELLO_TIME 2 +#define BRIDGE_FORWARD_DELAY 15 +#define HOLD_TIME 1 + +/* broacast/multicast storm limitation. This per source. */ +#define MAX_MCAST_PER_PERIOD 4 +#define MCAST_HOLD_TIME (10*HZ/100) + +#define Default_path_cost 10 + +/* + * minimum increment possible to avoid underestimating age, allows for BPDU + * transmission time + */ +#define Message_age_increment 1 + +#define No_port 0 +/* + * reserved value for Bridge's root port parameter indicating no root port, + * used when Bridge is the root - also used to indicate the source when + * a frame is being generated by a higher layer protocol on this host + */ + +/** Configuration BPDU Parameters (4.5.1) **/ + +typedef struct { + union { + struct { + unsigned short priority; + unsigned char ula[6]; + } p_u; + unsigned int id[2]; + } bi; +} bridge_id_t; + +#define BRIDGE_PRIORITY bi.p_u.priority +#define BRIDGE_ID_ULA bi.p_u.ula +#define BRIDGE_ID bi.id + +/* JRP: on the network the flags field is between "type" and "root_id" + * this is unfortunated! To make the code portable to a RISC machine + * the pdus are now massaged a little bit for processing + */ +#define TOPOLOGY_CHANGE 0x01 +#define TOPOLOGY_CHANGE_ACK 0x80 +#define BRIDGE_BPDU_8021_CONFIG_SIZE 35 /* real size */ +#define BRIDGE_BPDU_8021_CONFIG_FLAG_OFFSET 4 +#define BRIDGE_BPDU_8021_PROTOCOL_ID 0 +#define BRIDGE_BPDU_8021_PROTOCOL_VERSION_ID 0 +#define BRIDGE_LLC1_HS 3 +#define BRIDGE_LLC1_DSAP 0x42 +#define BRIDGE_LLC1_SSAP 0x42 +#define BRIDGE_LLC1_CTRL 0x03 + +typedef struct { + unsigned short protocol_id; + unsigned char protocol_version_id; + unsigned char type; + bridge_id_t root_id; /* (4.5.1.1) */ + unsigned int root_path_cost; /* (4.5.1.2) */ + bridge_id_t bridge_id; /* (4.5.1.3) */ + unsigned short port_id; /* (4.5.1.4) */ + unsigned short message_age; /* (4.5.1.5) */ + unsigned short max_age; /* (4.5.1.6) */ + unsigned short hello_time; /* (4.5.1.7) */ + unsigned short forward_delay; /* (4.5.1.8) */ + unsigned char top_change_ack; + unsigned char top_change; +} Config_bpdu; + +#ifdef __LITTLE_ENDIAN +#define config_bpdu_hton(config_bpdu) \ + (config_bpdu)->root_path_cost = htonl((config_bpdu)->root_path_cost); \ + (config_bpdu)->port_id = htons((config_bpdu)->port_id); \ + (config_bpdu)->message_age = htons((config_bpdu)->message_age); \ + (config_bpdu)->max_age = htons((config_bpdu)->max_age); \ + (config_bpdu)->hello_time = htons((config_bpdu)->hello_time); \ + (config_bpdu)->forward_delay = htons((config_bpdu)->forward_delay); +#else +#define config_bpdu_hton(config_bpdu) +#endif +#define config_bpdu_ntoh config_bpdu_hton + + +/** Topology Change Notification BPDU Parameters (4.5.2) **/ + +typedef struct { + unsigned short protocol_id; + unsigned char protocol_version_id; + unsigned char type; +} Tcn_bpdu; + +#define BPDU_TYPE_CONFIG 0 +#define BPDU_TYPE_TOPO_CHANGE 128 + +/** Bridge Parameters (4.5.3) **/ +typedef struct { + bridge_id_t designated_root; /* (4.5.3.1) */ + unsigned int root_path_cost; /* (4.5.3.2) */ + unsigned int root_port; /* (4.5.3.3) */ + unsigned short max_age; /* (4.5.3.4) */ + unsigned short hello_time; /* (4.5.3.5) */ + unsigned short forward_delay; /* (4.5.3.6) */ + bridge_id_t bridge_id; /* (4.5.3.7) */ + unsigned short bridge_max_age; /* (4.5.3.8) */ + unsigned short bridge_hello_time; /* (4.5.3.9) */ + unsigned short bridge_forward_delay; /* (4.5.3.10) */ + unsigned int top_change_detected; /* (4.5.3.11) */ + unsigned int top_change; /* (4.5.3.12) */ + unsigned short topology_change_time; /* (4.5.3.13) */ + unsigned short hold_time; /* (4.5.3.14) */ +} Bridge_data; + +/** Port Parameters (4.5.5) **/ +typedef struct { + unsigned short port_id; /* (4.5.5.1) */ + unsigned int state; /* (4.5.5.2) */ + unsigned int path_cost; /* (4.5.5.3) */ + bridge_id_t designated_root; /* (4.5.5.4) */ + unsigned int designated_cost; /* (4.5.5.5) */ + bridge_id_t designated_bridge; /* (4.5.5.6) */ + unsigned short designated_port; /* (4.5.5.7) */ + unsigned int top_change_ack; /* (4.5.5.8) */ + unsigned int config_pending; /* (4.5.5.9) */ + struct device *dev; + struct fdb *fdb; /* head of per port fdb chain */ +} Port_data; + + + +/** types to support timers for this pseudo-implementation. **/ +typedef struct { + unsigned int active; /* timer in use. */ + unsigned int value; /* current value of timer, + * counting up. */ +} Timer; + +struct fdb { + unsigned char ula[6]; + unsigned char pad[2]; + unsigned short port; + unsigned int timer; + unsigned short flags; +#define FDB_ENT_VALID 0x01 + unsigned short mcast_count; + unsigned int mcast_timer; /* oldest xxxxxcast */ + +/* AVL tree of all addresses, sorted by address */ + short fdb_avl_height; + struct fdb *fdb_avl_left; + struct fdb *fdb_avl_right; +/* linked list of addresses for each port */ + struct fdb *fdb_next; +}; + +/* data returned on BRCMD_DISPLAY_FDB */ +struct fdb_info { + unsigned char ula[6]; + unsigned char port; + unsigned char flags; + unsigned int timer; +}; +struct fdb_info_hdr { + int copied; /* nb of entries copied to user */ + int not_copied; /* when user buffer is too small */ + int cmd_time; +}; + +#define IS_BRIDGED 0x2e + + +#define BR_MAX_PROTOCOLS 32 +#define BR_MAX_PROT_STATS BR_MAX_PROTOCOLS + +/* policy values for policy field */ +#define BR_ACCEPT 1 +#define BR_REJECT 0 + +/* JRP: extra statistics for debug */ +typedef struct { + /* br_receive_frame counters */ + int port_disable_up_stack; + int rcv_bpdu; + int notForwarding; + int forwarding_up_stack; + int unknown_state; + + /* br_tx_frame counters */ + int port_disable; + int port_not_disable; + + /* br_forward counters */ + int local_multicast; + int forwarded_multicast; /* up stack as well */ + int flood_unicast; + int aged_flood_unicast; + int forwarded_unicast; + int forwarded_unicast_up_stack; + int forwarded_ip_up_stack; + int forwarded_ip_up_stack_lie; /* received on alternate device */ + int arp_for_local_mac; + int drop_same_port; + int drop_same_port_aged; + int drop_multicast; +} br_stats_counter; + +struct br_stat { + unsigned int flags; + Bridge_data bridge_data; + Port_data port_data[No_of_ports]; + unsigned int policy; + unsigned int exempt_protocols; + unsigned short protocols[BR_MAX_PROTOCOLS]; + unsigned short prot_id[BR_MAX_PROT_STATS]; /* Protocol encountered */ + unsigned int prot_counter[BR_MAX_PROT_STATS]; /* How many packets ? */ + br_stats_counter packet_cnts; +}; + +/* defined flags for br_stat.flags */ +#define BR_UP 0x0001 /* bridging enabled */ +#define BR_DEBUG 0x0002 /* debugging enabled */ +#define BR_PROT_STATS 0x0004 /* protocol statistics enabled */ +#define BR_STP_DISABLED 0x0008 /* Spanning tree protocol disabled */ + +struct br_cf { + unsigned int cmd; + unsigned int arg1; + unsigned int arg2; +}; + +/* defined cmds */ +#define BRCMD_BRIDGE_ENABLE 1 +#define BRCMD_BRIDGE_DISABLE 2 +#define BRCMD_PORT_ENABLE 3 /* arg1 = port */ +#define BRCMD_PORT_DISABLE 4 /* arg1 = port */ +#define BRCMD_SET_BRIDGE_PRIORITY 5 /* arg1 = priority */ +#define BRCMD_SET_PORT_PRIORITY 6 /* arg1 = port, arg2 = priority */ +#define BRCMD_SET_PATH_COST 7 /* arg1 = port, arg2 = cost */ +#define BRCMD_DISPLAY_FDB 8 /* arg1 = port */ +#define BRCMD_ENABLE_DEBUG 9 +#define BRCMD_DISABLE_DEBUG 10 +#define BRCMD_SET_POLICY 11 /* arg1 = default policy (1==bridge all) */ +#define BRCMD_EXEMPT_PROTOCOL 12 /* arg1 = protocol (see net/if_ether.h) */ +#define BRCMD_ENABLE_PROT_STATS 13 +#define BRCMD_DISABLE_PROT_STATS 14 +#define BRCMD_ZERO_PROT_STATS 15 +#define BRCMD_TOGGLE_STP 16 + +/* prototypes of exported bridging functions... */ + +void br_init(void); +int br_receive_frame(struct sk_buff *skb); /* 3.5 */ +int br_tx_frame(struct sk_buff *skb); +int br_ioctl(unsigned int cmd, void *arg); +int br_protocol_ok(unsigned short protocol); +void requeue_fdb(struct fdb *node, int new_port); + +struct fdb *br_avl_find_addr(unsigned char addr[6]); +struct fdb *br_avl_insert (struct fdb * new_node); +void sprintf_avl (char **pbuffer, struct fdb * tree, off_t *pos,int* len, off_t offset, int length); +int br_tree_get_info(char *buffer, char **start, off_t offset, int length, int dummy); +void br_avl_delete_by_port(int port); +/* externs */ + +extern struct br_stat br_stats; +extern Port_data port_info[]; + diff --git a/pfinet/linux-src/include/net/checksum.h b/pfinet/linux-src/include/net/checksum.h new file mode 100644 index 00000000..041d4760 --- /dev/null +++ b/pfinet/linux-src/include/net/checksum.h @@ -0,0 +1,110 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Checksumming functions for IP, TCP, UDP and so on + * + * Authors: Jorge Cwik, <jorge@laser.satlink.net> + * Arnt Gulbrandsen, <agulbra@nvg.unit.no> + * Borrows very liberally from tcp.c and ip.c, see those + * files for more names. + * + * 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. + */ + +/* + * Fixes: + * + * Ralf Baechle : generic ipv6 checksum + * <ralf@waldorf-gmbh.de> + */ + +#ifndef _CHECKSUM_H +#define _CHECKSUM_H + +#include <asm/types.h> +#include <asm/byteorder.h> +#include <net/ip.h> +#include <asm/uaccess.h> +#include <asm/checksum.h> + +#ifndef _HAVE_ARCH_IPV6_CSUM + +static __inline__ unsigned short int csum_ipv6_magic(struct in6_addr *saddr, + struct in6_addr *daddr, + __u16 len, + unsigned short proto, + unsigned int csum) +{ + + int carry; + __u32 ulen; + __u32 uproto; + + csum += saddr->s6_addr32[0]; + carry = (csum < saddr->s6_addr32[0]); + csum += carry; + + csum += saddr->s6_addr32[1]; + carry = (csum < saddr->s6_addr32[1]); + csum += carry; + + csum += saddr->s6_addr32[2]; + carry = (csum < saddr->s6_addr32[2]); + csum += carry; + + csum += saddr->s6_addr32[3]; + carry = (csum < saddr->s6_addr32[3]); + csum += carry; + + csum += daddr->s6_addr32[0]; + carry = (csum < daddr->s6_addr32[0]); + csum += carry; + + csum += daddr->s6_addr32[1]; + carry = (csum < daddr->s6_addr32[1]); + csum += carry; + + csum += daddr->s6_addr32[2]; + carry = (csum < daddr->s6_addr32[2]); + csum += carry; + + csum += daddr->s6_addr32[3]; + carry = (csum < daddr->s6_addr32[3]); + csum += carry; + + ulen = htonl((__u32) len); + csum += ulen; + carry = (csum < ulen); + csum += carry; + + uproto = htonl(proto); + csum += uproto; + carry = (csum < uproto); + csum += carry; + + return csum_fold(csum); +} + +#endif + +#ifndef _HAVE_ARCH_COPY_AND_CSUM_FROM_USER +extern __inline__ +unsigned int csum_and_copy_from_user (const char *src, char *dst, + int len, int sum, int *err_ptr) +{ + if (verify_area(VERIFY_READ, src, len) == 0) + return csum_partial_copy_from_user(src, dst, len, sum, err_ptr); + + if (len) + *err_ptr = -EFAULT; + + return sum; +} +#endif + +#endif diff --git a/pfinet/linux-src/include/net/datalink.h b/pfinet/linux-src/include/net/datalink.h new file mode 100644 index 00000000..44e56990 --- /dev/null +++ b/pfinet/linux-src/include/net/datalink.h @@ -0,0 +1,16 @@ +#ifndef _NET_INET_DATALINK_H_ +#define _NET_INET_DATALINK_H_ + +struct datalink_proto { + unsigned short type_len; + unsigned char type[8]; + const char *string_name; + unsigned short header_length; + int (*rcvfunc)(struct sk_buff *, struct device *, + struct packet_type *); + void (*datalink_header)(struct datalink_proto *, struct sk_buff *, + unsigned char *); + struct datalink_proto *next; +}; + +#endif diff --git a/pfinet/linux-src/include/net/dst.h b/pfinet/linux-src/include/net/dst.h new file mode 100644 index 00000000..baf4f414 --- /dev/null +++ b/pfinet/linux-src/include/net/dst.h @@ -0,0 +1,178 @@ +/* + * net/dst.h Protocol independent destination cache definitions. + * + * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> + * + */ + +#ifndef _NET_DST_H +#define _NET_DST_H + +#include <linux/config.h> +#include <net/neighbour.h> + +/* + * 0 - no debugging messages + * 1 - rare events and bugs (default) + * 2 - trace mode. + */ +#define RT_CACHE_DEBUG 0 + +#define DST_GC_MIN (1*HZ) +#define DST_GC_INC (5*HZ) +#define DST_GC_MAX (120*HZ) + +struct sk_buff; + +struct dst_entry +{ + struct dst_entry *next; + atomic_t refcnt; /* tree/hash references */ + atomic_t use; /* client references */ + struct device *dev; + int obsolete; + unsigned long lastuse; + unsigned long expires; + unsigned mxlock; + unsigned pmtu; + unsigned window; + unsigned rtt; + unsigned long rate_last; /* rate limiting for ICMP */ + unsigned long rate_tokens; + + int error; + + struct neighbour *neighbour; + struct hh_cache *hh; + + int (*input)(struct sk_buff*); + int (*output)(struct sk_buff*); + +#ifdef CONFIG_NET_CLS_ROUTE + __u32 tclassid; +#endif + + struct dst_ops *ops; + + char info[0]; +}; + + +struct dst_ops +{ + unsigned short family; + unsigned short protocol; + unsigned gc_thresh; + + int (*gc)(void); + struct dst_entry * (*check)(struct dst_entry *, __u32 cookie); + struct dst_entry * (*reroute)(struct dst_entry *, + struct sk_buff *); + void (*destroy)(struct dst_entry *); + struct dst_entry * (*negative_advice)(struct dst_entry *); + void (*link_failure)(struct sk_buff *); + + atomic_t entries; +}; + +#ifdef __KERNEL__ + +extern struct dst_entry * dst_garbage_list; +extern atomic_t dst_total; + +extern __inline__ +struct dst_entry * dst_clone(struct dst_entry * dst) +{ + if (dst) + atomic_inc(&dst->use); + return dst; +} + +extern __inline__ +void dst_release(struct dst_entry * dst) +{ + if (dst) + atomic_dec(&dst->use); +} + +/* The following primitive should be use if and only if + destination entry has just been removed from a location + accessed directly by hard irq. + */ +extern __inline__ +void dst_release_irqwait(struct dst_entry * dst) +{ + if (dst) { + synchronize_irq(); + atomic_dec(&dst->use); + } +} + +extern __inline__ +struct dst_entry * dst_check(struct dst_entry ** dst_p, u32 cookie) +{ + struct dst_entry * dst = *dst_p; + if (dst && dst->obsolete) + dst = dst->ops->check(dst, cookie); + return (*dst_p = dst); +} + +extern __inline__ +struct dst_entry * dst_reroute(struct dst_entry ** dst_p, struct sk_buff *skb) +{ + struct dst_entry * dst = *dst_p; + if (dst && dst->obsolete) + dst = dst->ops->reroute(dst, skb); + return (*dst_p = dst); +} + + +extern void * dst_alloc(int size, struct dst_ops * ops); +extern void __dst_free(struct dst_entry * dst); +extern void dst_destroy(struct dst_entry * dst); + +extern __inline__ +void dst_free(struct dst_entry * dst) +{ + if (dst->obsolete > 1) + return; + if (!atomic_read(&dst->use)) { + dst_destroy(dst); + return; + } + __dst_free(dst); +} + +extern __inline__ void dst_confirm(struct dst_entry *dst) +{ + if (dst) + neigh_confirm(dst->neighbour); +} + +extern __inline__ void dst_negative_advice(struct dst_entry **dst_p) +{ + struct dst_entry * dst = *dst_p; + if (dst && dst->ops->negative_advice) + *dst_p = dst->ops->negative_advice(dst); +} + +extern __inline__ void dst_link_failure(struct sk_buff *skb) +{ + struct dst_entry * dst = skb->dst; + if (dst && dst->ops && dst->ops->link_failure) + dst->ops->link_failure(skb); +} + +extern __inline__ void dst_set_expires(struct dst_entry *dst, int timeout) +{ + unsigned long expires = jiffies + timeout; + + if (expires == 0) + expires = 1; + + if (dst->expires == 0 || (long)(dst->expires - expires) > 0) + dst->expires = expires; +} +#endif + +#endif /* _NET_DST_H */ diff --git a/pfinet/linux-src/include/net/flow.h b/pfinet/linux-src/include/net/flow.h new file mode 100644 index 00000000..e1ce1b2a --- /dev/null +++ b/pfinet/linux-src/include/net/flow.h @@ -0,0 +1,101 @@ +/* + * + * Flow based forwarding rules (usage: firewalling, etc) + * + */ + +#ifndef _NET_FLOW_H +#define _NET_FLOW_H + +struct flowi { + int proto; /* {TCP, UDP, ICMP} */ + + union { + struct { + __u32 daddr; + __u32 saddr; + } ip4_u; + + struct { + struct in6_addr * daddr; + struct in6_addr * saddr; + __u32 flowlabel; + } ip6_u; + } nl_u; +#define fl6_dst nl_u.ip6_u.daddr +#define fl6_src nl_u.ip6_u.saddr +#define fl6_flowlabel nl_u.ip6_u.flowlabel +#define fl4_dst nl_u.ip4_u.daddr +#define fl4_src nl_u.ip4_u.saddr + + int oif; + + union { + struct { + __u16 sport; + __u16 dport; + } ports; + + struct { + __u8 type; + __u8 code; + } icmpt; + + unsigned long data; + } uli_u; +}; + +#define FLOWR_NODECISION 0 /* rule not appliable to flow */ +#define FLOWR_SELECT 1 /* flow must follow this rule */ +#define FLOWR_CLEAR 2 /* priority level clears flow */ +#define FLOWR_ERROR 3 + +struct fl_acc_args { + int type; + + +#define FL_ARG_FORWARD 1 +#define FL_ARG_ORIGIN 2 + + union { + struct sk_buff *skb; + struct { + struct sock *sk; + struct flowi *flow; + } fl_o; + } fl_u; +}; + + +struct pkt_filter { + atomic_t refcnt; + unsigned int offset; + __u32 value; + __u32 mask; + struct pkt_filter *next; +}; + +#define FLR_INPUT 1 +#define FLR_OUTPUT 2 + +struct flow_filter { + int type; + union { + struct pkt_filter *filter; + struct sock *sk; + } u; +}; + +struct flow_rule { + struct flow_rule_ops *ops; + unsigned char private[0]; +}; + +struct flow_rule_ops { + int (*accept)(struct rt6_info *rt, + struct rt6_info *rule, + struct fl_acc_args *args, + struct rt6_info **nrt); +}; + +#endif diff --git a/pfinet/linux-src/include/net/icmp.h b/pfinet/linux-src/include/net/icmp.h new file mode 100644 index 00000000..6e9c5418 --- /dev/null +++ b/pfinet/linux-src/include/net/icmp.h @@ -0,0 +1,42 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the ICMP module. + * + * Version: @(#)icmp.h 1.0.4 05/13/93 + * + * Authors: Ross Biro, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * + * 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. + */ +#ifndef _ICMP_H +#define _ICMP_H + +#include <linux/icmp.h> +#include <linux/skbuff.h> + +#include <net/sock.h> +#include <net/protocol.h> + +extern struct icmp_err icmp_err_convert[]; +extern struct icmp_mib icmp_statistics; + +extern void icmp_send(struct sk_buff *skb_in, int type, int code, + unsigned long info); +extern int icmp_rcv(struct sk_buff *skb, unsigned short len); +extern int icmp_ioctl(struct sock *sk, int cmd, unsigned long arg); +extern void icmp_init(struct net_proto_family *ops); + +/* Move into dst.h ? */ +extern int xrlim_allow(struct dst_entry *dst, int timeout); + +/* CONFIG_IP_TRANSPARENT_PROXY */ +extern int icmp_chkaddr(struct sk_buff *skb); + +#endif /* _ICMP_H */ diff --git a/pfinet/linux-src/include/net/if_inet6.h b/pfinet/linux-src/include/net/if_inet6.h new file mode 100644 index 00000000..4e9ed978 --- /dev/null +++ b/pfinet/linux-src/include/net/if_inet6.h @@ -0,0 +1,134 @@ +/* + * inet6 interface/address list definitions + * Linux INET6 implementation + * + * Authors: + * Pedro Roque <roque@di.fc.ul.pt> + * + * + * 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. + */ + +#ifndef _NET_IF_INET6_H +#define _NET_IF_INET6_H + +/* These flags match corresponding IFA_F_* flags but ADDR_INVALID, + which is invisible externally. + */ + +#define ADDR_PERMANENT 0x80 + +#define DAD_COMPLETE 0x00 +#define DAD_INCOMPLETE 0x40 +#define DAD_STATUS 0x40 + +#define ADDR_STATUS 0x21 +#define ADDR_DEPRECATED 0x20 +#define ADDR_INVALID 0x01 + + + +#define IF_RA_RCVD 0x20 +#define IF_RS_SENT 0x10 + +#ifdef __KERNEL__ + +struct inet6_ifaddr +{ + struct in6_addr addr; + __u32 prefix_len; + + __u32 valid_lft; + __u32 prefered_lft; + unsigned long tstamp; + + __u8 probes; + __u8 flags; + + __u16 scope; + + struct timer_list timer; + + struct inet6_dev *idev; + + struct inet6_ifaddr *lst_next; /* next addr in addr_lst */ + struct inet6_ifaddr *if_next; /* next addr in inet6_dev */ +}; + + +struct ipv6_mc_socklist +{ + struct in6_addr addr; + int ifindex; + struct ipv6_mc_socklist *next; +}; + +#define MAF_TIMER_RUNNING 0x01 +#define MAF_LAST_REPORTER 0x02 +#define MAF_LOADED 0x04 + +struct ifmcaddr6 +{ + struct in6_addr mca_addr; + struct device *dev; + struct ifmcaddr6 *next; + struct ifmcaddr6 *if_next; + struct timer_list mca_timer; + unsigned mca_flags; + atomic_t mca_users; +}; + +#define IFA_HOST IPV6_ADDR_LOOPBACK +#define IFA_LINK IPV6_ADDR_LINKLOCAL +#define IFA_SITE IPV6_ADDR_SITELOCAL +#define IFA_GLOBAL 0x0000U + +struct ipv6_devconf +{ + int forwarding; + int hop_limit; + int mtu6; + int accept_ra; + int accept_redirects; + int autoconf; + int dad_transmits; + int rtr_solicits; + int rtr_solicit_interval; + int rtr_solicit_delay; + + void *sysctl; +}; + +struct inet6_dev +{ + struct device *dev; + + struct inet6_ifaddr *addr_list; + struct ifmcaddr6 *mc_list; + __u32 if_flags; + + struct neigh_parms *nd_parms; + struct inet6_dev *next; + struct ipv6_devconf cnf; +}; + +extern struct ipv6_devconf ipv6_devconf; + +extern __inline__ void ipv6_eth_mc_map(struct in6_addr *addr, char *buf) +{ + /* + * +-------+-------+-------+-------+-------+-------+ + * | 33 | 33 | DST13 | DST14 | DST15 | DST16 | + * +-------+-------+-------+-------+-------+-------+ + */ + + buf[0]= 0x33; + buf[1]= 0x33; + + memcpy(buf + 2, &addr->s6_addr32[3], sizeof(__u32)); +} +#endif +#endif diff --git a/pfinet/linux-src/include/net/inet_common.h b/pfinet/linux-src/include/net/inet_common.h new file mode 100644 index 00000000..9c7c8b94 --- /dev/null +++ b/pfinet/linux-src/include/net/inet_common.h @@ -0,0 +1,45 @@ +#ifndef _INET_COMMON_H +#define _INET_COMMON_H + +extern struct proto_ops inet_stream_ops; +extern struct proto_ops inet_dgram_ops; + +/* + * INET4 prototypes used by INET6 + */ + +extern void inet_remove_sock(struct sock *sk1); +extern void inet_put_sock(unsigned short num, + struct sock *sk); +extern int inet_release(struct socket *sock, + struct socket *peer); +extern int inet_stream_connect(struct socket *sock, + struct sockaddr * uaddr, + int addr_len, int flags); +extern int inet_dgram_connect(struct socket *sock, + struct sockaddr * uaddr, + int addr_len, int flags); +extern int inet_accept(struct socket *sock, + struct socket *newsock, int flags); +extern int inet_recvmsg(struct socket *sock, + struct msghdr *ubuf, + int size, int flags, struct scm_cookie *scm); +extern int inet_sendmsg(struct socket *sock, + struct msghdr *msg, + int size, struct scm_cookie *scm); +extern int inet_shutdown(struct socket *sock, int how); +extern unsigned int inet_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait); +extern int inet_setsockopt(struct socket *sock, int level, + int optname, char *optval, + int optlen); +extern int inet_getsockopt(struct socket *sock, int level, + int optname, char *optval, + int *optlen); +extern int inet_fcntl(struct socket *sock, + unsigned int cmd, + unsigned long arg); +extern int inet_listen(struct socket *sock, int backlog); + +#endif + + diff --git a/pfinet/linux-src/include/net/ip.h b/pfinet/linux-src/include/net/ip.h new file mode 100644 index 00000000..5e80fb43 --- /dev/null +++ b/pfinet/linux-src/include/net/ip.h @@ -0,0 +1,251 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the IP module. + * + * Version: @(#)ip.h 1.0.2 05/07/93 + * + * Authors: Ross Biro, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * Alan Cox, <gw4pts@gw4pts.ampr.org> + * + * Changes: + * Mike McLagan : Routing by source + * + * 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. + */ +#ifndef _IP_H +#define _IP_H + + +#include <linux/types.h> +#include <linux/socket.h> +#include <linux/ip.h> +#include <linux/netdevice.h> +#include <linux/inetdevice.h> +#include <linux/in_route.h> +#include <net/route.h> +#include <net/arp.h> + +#ifndef _SNMP_H +#include <net/snmp.h> +#endif + +#include <net/sock.h> /* struct sock */ + +struct inet_skb_parm +{ + struct ip_options opt; /* Compiled IP options */ + u16 redirport; /* Redirect port */ + unsigned char flags; + +#define IPSKB_MASQUERADED 1 +#define IPSKB_TRANSLATED 2 +#define IPSKB_FORWARDED 4 +}; + +struct ipcm_cookie +{ + u32 addr; + int oif; + struct ip_options *opt; +}; + +#define IPCB(skb) ((struct inet_skb_parm*)((skb)->cb)) + +struct ip_ra_chain +{ + struct ip_ra_chain *next; + struct sock *sk; + void (*destructor)(struct sock *); +}; + +extern struct ip_ra_chain *ip_ra_chain; + +/* IP flags. */ +#define IP_CE 0x8000 /* Flag: "Congestion" */ +#define IP_DF 0x4000 /* Flag: "Don't Fragment" */ +#define IP_MF 0x2000 /* Flag: "More Fragments" */ +#define IP_OFFSET 0x1FFF /* "Fragment Offset" part */ + +#define IP_FRAG_TIME (30 * HZ) /* fragment lifetime */ + +extern void ip_mc_dropsocket(struct sock *); +extern void ip_mc_dropdevice(struct device *dev); +extern int ip_mc_procinfo(char *, char **, off_t, int, int); + +/* + * Functions provided by ip.c + */ + +extern int ip_ioctl(struct sock *sk, int cmd, unsigned long arg); +extern void ip_build_and_send_pkt(struct sk_buff *skb, struct sock *sk, + u32 saddr, u32 daddr, + struct ip_options *opt); +extern int ip_rcv(struct sk_buff *skb, struct device *dev, + struct packet_type *pt); +extern int ip_local_deliver(struct sk_buff *skb); +extern int ip_mr_input(struct sk_buff *skb); +extern int ip_output(struct sk_buff *skb); +extern int ip_mc_output(struct sk_buff *skb); +extern void ip_fragment(struct sk_buff *skb, int (*out)(struct sk_buff*)); +extern int ip_do_nat(struct sk_buff *skb); +extern void ip_send_check(struct iphdr *ip); +extern int ip_id_count; +extern void ip_queue_xmit(struct sk_buff *skb); +extern void ip_init(void); +extern int ip_build_xmit(struct sock *sk, + int getfrag (const void *, + char *, + unsigned int, + unsigned int), + const void *frag, + unsigned length, + struct ipcm_cookie *ipc, + struct rtable *rt, + int flags); + + +struct ip_reply_arg { + struct iovec iov[2]; + int n_iov; /* redundant */ + u32 csum; + int csumoffset; /* u16 offset of csum in iov[0].iov_base */ + /* -1 if not needed */ +}; + +void ip_send_reply(struct sock *sk, struct sk_buff *skb, struct ip_reply_arg *arg, + unsigned int len); + +extern int __ip_finish_output(struct sk_buff *skb); + +struct ipv4_config +{ + int log_martians; + int autoconfig; + int no_pmtu_disc; +}; + +extern struct ipv4_config ipv4_config; +extern struct ip_mib ip_statistics; +extern struct linux_mib net_statistics; + +extern int sysctl_local_port_range[2]; + +extern __inline__ int ip_finish_output(struct sk_buff *skb) +{ + struct dst_entry *dst = skb->dst; + struct device *dev = dst->dev; + struct hh_cache *hh = dst->hh; + + skb->dev = dev; + skb->protocol = __constant_htons(ETH_P_IP); + + if (hh) { + read_lock_irq(&hh->hh_lock); + memcpy(skb->data - 16, hh->hh_data, 16); + read_unlock_irq(&hh->hh_lock); + skb_push(skb, dev->hard_header_len); + return hh->hh_output(skb); + } else if (dst->neighbour) + return dst->neighbour->output(skb); + + kfree_skb(skb); + return -EINVAL; +} + +extern __inline__ void ip_send(struct sk_buff *skb) +{ + if (skb->len > skb->dst->pmtu) + ip_fragment(skb, __ip_finish_output); + else + ip_finish_output(skb); +} + +extern __inline__ +int ip_decrease_ttl(struct iphdr *iph) +{ + u16 check = iph->check; + check = ntohs(check) + 0x0100; + if ((check & 0xFF00) == 0) + check++; /* carry overflow */ + iph->check = htons(check); + return --iph->ttl; +} + +extern __inline__ +int ip_dont_fragment(struct sock *sk, struct dst_entry *dst) +{ + return (sk->ip_pmtudisc == IP_PMTUDISC_DO || + (sk->ip_pmtudisc == IP_PMTUDISC_WANT && + !(dst->mxlock&(1<<RTAX_MTU)))); +} + +/* + * Map a multicast IP onto multicast MAC for type ethernet. + */ + +extern __inline__ void ip_eth_mc_map(u32 addr, char *buf) +{ + addr=ntohl(addr); + buf[0]=0x01; + buf[1]=0x00; + buf[2]=0x5e; + buf[5]=addr&0xFF; + addr>>=8; + buf[4]=addr&0xFF; + addr>>=8; + buf[3]=addr&0x7F; +} + + +extern int ip_call_ra_chain(struct sk_buff *skb); + +/* + * Functions provided by ip_fragment.o + */ + +struct sk_buff *ip_defrag(struct sk_buff *skb); + +/* + * Functions provided by ip_forward.c + */ + +extern int ip_forward(struct sk_buff *skb); +extern int ip_net_unreachable(struct sk_buff *skb); + +/* + * Functions provided by ip_options.c + */ + +extern void ip_options_build(struct sk_buff *skb, struct ip_options *opt, u32 daddr, struct rtable *rt, int is_frag); +extern int ip_options_echo(struct ip_options *dopt, struct sk_buff *skb); +extern void ip_options_fragment(struct sk_buff *skb); +extern int ip_options_compile(struct ip_options *opt, struct sk_buff *skb); +extern int ip_options_get(struct ip_options **optp, unsigned char *data, int optlen, int user); +extern void ip_options_undo(struct ip_options * opt); +extern void ip_forward_options(struct sk_buff *skb); +extern int ip_options_rcv_srr(struct sk_buff *skb); + +/* + * Functions provided by ip_sockglue.c + */ + +extern void ip_cmsg_recv(struct msghdr *msg, struct sk_buff *skb); +extern int ip_cmsg_send(struct msghdr *msg, struct ipcm_cookie *ipc); +extern int ip_setsockopt(struct sock *sk, int level, int optname, char *optval, int optlen); +extern int ip_getsockopt(struct sock *sk, int level, int optname, char *optval, int *optlen); +extern int ip_ra_control(struct sock *sk, unsigned char on, void (*destructor)(struct sock *)); + +extern int ip_recv_error(struct sock *sk, struct msghdr *msg, int len); +extern void ip_icmp_error(struct sock *sk, struct sk_buff *skb, int err, + u16 port, u32 info, u8 *payload); +extern void ip_local_error(struct sock *sk, int err, u32 daddr, u16 dport, + u32 info); + +#endif /* _IP_H */ diff --git a/pfinet/linux-src/include/net/ip6_fib.h b/pfinet/linux-src/include/net/ip6_fib.h new file mode 100644 index 00000000..efd652f2 --- /dev/null +++ b/pfinet/linux-src/include/net/ip6_fib.h @@ -0,0 +1,177 @@ +/* + * Linux INET6 implementation + * + * Authors: + * Pedro Roque <roque@di.fc.ul.pt> + * + * 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. + */ + +#ifndef _IP6_FIB_H +#define _IP6_FIB_H + +#ifdef __KERNEL__ + +#include <linux/ipv6_route.h> + +#include <net/dst.h> +#include <net/flow.h> +#include <linux/rtnetlink.h> + +struct rt6_info; + +struct fib6_node +{ + struct fib6_node *parent; + struct fib6_node *left; + struct fib6_node *right; + + struct fib6_node *subtree; + + struct rt6_info *leaf; + + __u16 fn_bit; /* bit key */ + __u16 fn_flags; + __u32 fn_sernum; +}; + + +/* + * routing information + * + */ + +struct rt6key +{ + struct in6_addr addr; + int plen; +}; + +struct rt6_info +{ + union { + struct dst_entry dst; + struct rt6_info *next; + } u; + +#define rt6i_dev u.dst.dev +#define rt6i_nexthop u.dst.neighbour +#define rt6i_expires u.dst.expires + + struct fib6_node *rt6i_node; + + struct in6_addr rt6i_gateway; + + u32 rt6i_flags; + u32 rt6i_metric; + u8 rt6i_hoplimit; + atomic_t rt6i_ref; + + union { + struct flow_rule *rt6iu_flowr; + struct flow_filter *rt6iu_filter; + } flow_u; + +#define rt6i_flowr flow_u.rt6iu_flowr +#define rt6i_filter flow_u.rt6iu_filter + + struct rt6key rt6i_dst; + struct rt6key rt6i_src; +}; + +struct fib6_walker_t +{ + struct fib6_walker_t *prev, *next; + struct fib6_node *root, *node; + struct rt6_info *leaf; + unsigned char state; + unsigned char prune; + int (*func)(struct fib6_walker_t *); + void *args; +}; + +extern struct fib6_walker_t fib6_walker_list; + +extern __inline__ void fib6_walker_link(struct fib6_walker_t *w) +{ + w->next = fib6_walker_list.next; + w->prev = &fib6_walker_list; + w->next->prev = w; + w->prev->next = w; +} + +extern __inline__ void fib6_walker_unlink(struct fib6_walker_t *w) +{ + w->next->prev = w->prev; + w->prev->next = w->next; + w->prev = w->next = w; +} + +struct rt6_statistics { + __u32 fib_nodes; + __u32 fib_route_nodes; + __u32 fib_rt_alloc; /* permanet routes */ + __u32 fib_rt_entries; /* rt entries in table */ + __u32 fib_rt_cache; /* cache routes */ +}; + +#define RTN_TL_ROOT 0x0001 +#define RTN_ROOT 0x0002 /* tree root node */ +#define RTN_RTINFO 0x0004 /* node with valid routing info */ + +/* + * priority levels (or metrics) + * + */ + +#define RTPRI_FIREWALL 8 /* Firewall control information */ +#define RTPRI_FLOW 16 /* Flow based forwarding rules */ +#define RTPRI_KERN_CTL 32 /* Kernel control routes */ + +#define RTPRI_USER_MIN 256 /* Mimimum user priority */ +#define RTPRI_USER_MAX 1024 /* Maximum user priority */ + +#define RTPRI_KERN_DFLT 4096 /* Kernel default routes */ + +#define MAX_FLOW_BACKTRACE 32 + + +typedef void (*f_pnode)(struct fib6_node *fn, void *); + +extern struct fib6_node ip6_routing_table; + +/* + * exported functions + */ + +extern struct fib6_node *fib6_lookup(struct fib6_node *root, + struct in6_addr *daddr, + struct in6_addr *saddr); + +struct fib6_node *fib6_locate(struct fib6_node *root, + struct in6_addr *daddr, int dst_len, + struct in6_addr *saddr, int src_len); + +extern void fib6_clean_tree(struct fib6_node *root, + int (*func)(struct rt6_info *, void *arg), + int prune, void *arg); + +extern int fib6_walk(struct fib6_walker_t *w); +extern int fib6_walk_continue(struct fib6_walker_t *w); + +extern int fib6_add(struct fib6_node *root, + struct rt6_info *rt); + +extern int fib6_del(struct rt6_info *rt); + +extern void inet6_rt_notify(int event, struct rt6_info *rt); + +extern void fib6_run_gc(unsigned long dummy); + +extern void fib6_gc_cleanup(void); + +#endif +#endif diff --git a/pfinet/linux-src/include/net/ip6_fw.h b/pfinet/linux-src/include/net/ip6_fw.h new file mode 100644 index 00000000..7866273d --- /dev/null +++ b/pfinet/linux-src/include/net/ip6_fw.h @@ -0,0 +1,54 @@ +#ifndef __NET_IP6_FW_H +#define __NET_IP6_FW_H + +#define IP6_FW_LISTHEAD 0x1000 +#define IP6_FW_ACCEPT 0x0001 +#define IP6_FW_REJECT 0x0002 + +#define IP6_FW_DEBUG 2 + +#define IP6_FW_MSG_ADD 1 +#define IP6_FW_MSG_DEL 2 +#define IP6_FW_MSG_REPORT 3 + + +/* + * Fast "hack" user interface + */ +struct ip6_fw_msg { + struct in6_addr dst; + struct in6_addr src; + int dst_len; + int src_len; + int action; + int policy; + int proto; + union { + struct { + __u16 sport; + __u16 dport; + } transp; + + unsigned long data; + + int icmp_type; + } u; + + int msg_len; +}; + +#ifdef __KERNEL__ + +#include <net/flow.h> + +struct ip6_fw_rule { + struct flow_rule flowr; + struct ip6_fw_rule *next; + struct ip6_fw_rule *prev; + struct flowi info; + unsigned long policy; +}; + +#endif + +#endif diff --git a/pfinet/linux-src/include/net/ip6_route.h b/pfinet/linux-src/include/net/ip6_route.h new file mode 100644 index 00000000..9311cc34 --- /dev/null +++ b/pfinet/linux-src/include/net/ip6_route.h @@ -0,0 +1,111 @@ +#ifndef _NET_IP6_ROUTE_H +#define _NET_IP6_ROUTE_H + +#define IP6_RT_PRIO_FW 16 +#define IP6_RT_PRIO_USER 1024 +#define IP6_RT_PRIO_ADDRCONF 256 +#define IP6_RT_PRIO_KERN 512 +#define IP6_RT_FLOW_MASK 0x00ff + +#ifdef __KERNEL__ + +#include <net/flow.h> +#include <net/ip6_fib.h> + +struct pol_chain { + int type; + int priority; + struct fib6_node *rules; + struct pol_chain *next; +}; + +extern struct rt6_info ip6_null_entry; + +extern int ip6_rt_max_size; +extern int ip6_rt_gc_min; +extern int ip6_rt_gc_timeout; +extern int ip6_rt_gc_interval; + +extern void ip6_route_input(struct sk_buff *skb); + +extern struct dst_entry * ip6_route_output(struct sock *sk, + struct flowi *fl); + +extern void ip6_route_init(void); +extern void ip6_route_cleanup(void); + +extern int ipv6_route_ioctl(unsigned int cmd, void *arg); + +extern int ip6_route_add(struct in6_rtmsg *rtmsg); +extern int ip6_del_rt(struct rt6_info *); + +extern int ip6_rt_addr_add(struct in6_addr *addr, + struct device *dev); + +extern int ip6_rt_addr_del(struct in6_addr *addr, + struct device *dev); + +extern void rt6_sndmsg(int type, struct in6_addr *dst, + struct in6_addr *src, + struct in6_addr *gw, + struct device *dev, + int dstlen, int srclen, + int metric, __u32 flags); + +extern struct rt6_info *rt6_lookup(struct in6_addr *daddr, + struct in6_addr *saddr, + int oif, int flags); + +/* + * support functions for ND + * + */ +extern struct rt6_info * rt6_get_dflt_router(struct in6_addr *addr, + struct device *dev); +extern struct rt6_info * rt6_add_dflt_router(struct in6_addr *gwaddr, + struct device *dev); + +extern void rt6_purge_dflt_routers(int lst_resort); + +extern void rt6_redirect(struct in6_addr *dest, + struct in6_addr *saddr, + struct neighbour *neigh, + int on_link); + +extern void rt6_pmtu_discovery(struct in6_addr *daddr, + struct in6_addr *saddr, + struct device *dev, + u32 pmtu); + +struct nlmsghdr; +struct netlink_callback; +extern int inet6_dump_fib(struct sk_buff *skb, struct netlink_callback *cb); +extern int inet6_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet6_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet6_rtm_getroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); + +extern void rt6_ifdown(struct device *dev); +extern void rt6_mtu_change(struct device *dev, unsigned mtu); + +/* + * Store a destination cache entry in a socket + * For UDP/RAW sockets this is done on udp_connect. + */ + +extern __inline__ void ip6_dst_store(struct sock *sk, struct dst_entry *dst, + struct in6_addr *daddr) +{ + struct ipv6_pinfo *np; + struct rt6_info *rt; + + np = &sk->net_pinfo.af_inet6; + dst_release(xchg(&sk->dst_cache,dst)); + + rt = (struct rt6_info *) dst; + + np->daddr_cache = daddr; + np->dst_cookie = rt->rt6i_node ? rt->rt6i_node->fn_sernum : 0; +} + +#endif +#endif diff --git a/pfinet/linux-src/include/net/ip_fib.h b/pfinet/linux-src/include/net/ip_fib.h new file mode 100644 index 00000000..6e1fd869 --- /dev/null +++ b/pfinet/linux-src/include/net/ip_fib.h @@ -0,0 +1,257 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the Forwarding Information Base. + * + * Authors: A.N.Kuznetsov, <kuznet@ms2.inr.ac.ru> + * + * 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. + */ + +#ifndef _NET_IP_FIB_H +#define _NET_IP_FIB_H + +#include <linux/config.h> + +struct kern_rta +{ + void *rta_dst; + void *rta_src; + int *rta_iif; + int *rta_oif; + void *rta_gw; + u32 *rta_priority; + void *rta_prefsrc; + struct rtattr *rta_mx; + struct rtattr *rta_mp; + unsigned char *rta_protoinfo; + unsigned char *rta_flow; + struct rta_cacheinfo *rta_ci; +}; + +struct fib_nh +{ + struct device *nh_dev; + unsigned nh_flags; + unsigned char nh_scope; +#ifdef CONFIG_IP_ROUTE_MULTIPATH + int nh_weight; + int nh_power; +#endif +#ifdef CONFIG_NET_CLS_ROUTE + __u32 nh_tclassid; +#endif + int nh_oif; + u32 nh_gw; +}; + +/* + * This structure contains data shared by many of routes. + */ + +struct fib_info +{ + struct fib_info *fib_next; + struct fib_info *fib_prev; + int fib_refcnt; + unsigned fib_flags; + int fib_protocol; + u32 fib_prefsrc; + u32 fib_priority; +#define FIB_MAX_METRICS RTAX_RTT + unsigned fib_metrics[FIB_MAX_METRICS]; +#define fib_mtu fib_metrics[RTAX_MTU-1] +#define fib_window fib_metrics[RTAX_WINDOW-1] +#define fib_rtt fib_metrics[RTAX_RTT-1] + int fib_nhs; +#ifdef CONFIG_IP_ROUTE_MULTIPATH + int fib_power; +#endif + struct fib_nh fib_nh[0]; +#define fib_dev fib_nh[0].nh_dev +}; + + +#ifdef CONFIG_IP_MULTIPLE_TABLES +struct fib_rule; +#endif + +struct fib_result +{ + u32 *prefix; + unsigned char prefixlen; + unsigned char nh_sel; + unsigned char type; + unsigned char scope; + struct fib_info *fi; +#ifdef CONFIG_IP_MULTIPLE_TABLES + struct fib_rule *r; +#endif +}; + +#ifdef CONFIG_IP_ROUTE_MULTIPATH + +#define FIB_RES_NH(res) ((res).fi->fib_nh[(res).nh_sel]) +#define FIB_RES_RESET(res) ((res).nh_sel = 0) + +#else /* CONFIG_IP_ROUTE_MULTIPATH */ + +#define FIB_RES_NH(res) ((res).fi->fib_nh[0]) +#define FIB_RES_RESET(res) + +#endif /* CONFIG_IP_ROUTE_MULTIPATH */ + +#define FIB_RES_PREFSRC(res) ((res).fi->fib_prefsrc ? : __fib_res_prefsrc(&res)) +#define FIB_RES_GW(res) (FIB_RES_NH(res).nh_gw) +#define FIB_RES_DEV(res) (FIB_RES_NH(res).nh_dev) +#define FIB_RES_OIF(res) (FIB_RES_NH(res).nh_oif) + +struct fib_table +{ + unsigned char tb_id; + unsigned tb_stamp; + int (*tb_lookup)(struct fib_table *tb, const struct rt_key *key, struct fib_result *res); + int (*tb_insert)(struct fib_table *table, struct rtmsg *r, + struct kern_rta *rta, struct nlmsghdr *n, + struct netlink_skb_parms *req); + int (*tb_delete)(struct fib_table *table, struct rtmsg *r, + struct kern_rta *rta, struct nlmsghdr *n, + struct netlink_skb_parms *req); + int (*tb_dump)(struct fib_table *table, struct sk_buff *skb, + struct netlink_callback *cb); + int (*tb_flush)(struct fib_table *table); + int (*tb_get_info)(struct fib_table *table, char *buf, + int first, int count); + void (*tb_select_default)(struct fib_table *table, + const struct rt_key *key, struct fib_result *res); + + unsigned char tb_data[0]; +}; + +#ifndef CONFIG_IP_MULTIPLE_TABLES + +extern struct fib_table *local_table; +extern struct fib_table *main_table; + +extern __inline__ struct fib_table *fib_get_table(int id) +{ + if (id != RT_TABLE_LOCAL) + return main_table; + return local_table; +} + +extern __inline__ struct fib_table *fib_new_table(int id) +{ + return fib_get_table(id); +} + +extern __inline__ int fib_lookup(const struct rt_key *key, struct fib_result *res) +{ + if (local_table->tb_lookup(local_table, key, res) && + main_table->tb_lookup(main_table, key, res)) + return -ENETUNREACH; + return 0; +} + +extern __inline__ void fib_select_default(const struct rt_key *key, struct fib_result *res) +{ + if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) + main_table->tb_select_default(main_table, key, res); +} + +#else /* CONFIG_IP_MULTIPLE_TABLES */ +#define local_table (fib_tables[RT_TABLE_LOCAL]) +#define main_table (fib_tables[RT_TABLE_MAIN]) + +extern struct fib_table * fib_tables[RT_TABLE_MAX+1]; +extern int fib_lookup(const struct rt_key *key, struct fib_result *res); +extern struct fib_table *__fib_new_table(int id); + +extern __inline__ struct fib_table *fib_get_table(int id) +{ + if (id == 0) + id = RT_TABLE_MAIN; + + return fib_tables[id]; +} + +extern __inline__ struct fib_table *fib_new_table(int id) +{ + if (id == 0) + id = RT_TABLE_MAIN; + + return fib_tables[id] ? : __fib_new_table(id); +} + +extern void fib_select_default(const struct rt_key *key, struct fib_result *res); + +#endif /* CONFIG_IP_MULTIPLE_TABLES */ + +/* Exported by fib_frontend.c */ +extern void ip_fib_init(void); +extern void fib_flush(void); +extern int inet_rtm_delroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet_rtm_newroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet_rtm_getroute(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet_dump_fib(struct sk_buff *skb, struct netlink_callback *cb); +extern int fib_validate_source(u32 src, u32 dst, u8 tos, int oif, + struct device *dev, u32 *spec_dst, u32 *itag); +extern void fib_select_multipath(const struct rt_key *key, struct fib_result *res); + +/* Exported by fib_semantics.c */ +extern int ip_fib_check_default(u32 gw, struct device *dev); +extern void fib_release_info(struct fib_info *); +extern int fib_semantic_match(int type, struct fib_info *, + const struct rt_key *, struct fib_result*); +extern struct fib_info *fib_create_info(const struct rtmsg *r, struct kern_rta *rta, + const struct nlmsghdr *, int *err); +extern int fib_nh_match(struct rtmsg *r, struct nlmsghdr *, struct kern_rta *rta, struct fib_info *fi); +extern int fib_dump_info(struct sk_buff *skb, u32 pid, u32 seq, int event, + u8 tb_id, u8 type, u8 scope, void *dst, int dst_len, u8 tos, + struct fib_info *fi); +extern int fib_sync_down(u32 local, struct device *dev, int force); +extern int fib_sync_up(struct device *dev); +extern int fib_convert_rtentry(int cmd, struct nlmsghdr *nl, struct rtmsg *rtm, + struct kern_rta *rta, struct rtentry *r); +extern void fib_node_get_info(int type, int dead, struct fib_info *fi, u32 prefix, u32 mask, char *buffer); +extern u32 __fib_res_prefsrc(struct fib_result *res); + +/* Exported by fib_hash.c */ +extern struct fib_table *fib_hash_init(int id); + +#ifdef CONFIG_IP_MULTIPLE_TABLES +/* Exported by fib_rules.c */ + +extern int inet_rtm_delrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet_rtm_newrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg); +extern int inet_dump_rules(struct sk_buff *skb, struct netlink_callback *cb); +extern u32 fib_rules_map_destination(u32 daddr, struct fib_result *res); +#ifdef CONFIG_NET_CLS_ROUTE +extern u32 fib_rules_tclass(struct fib_result *res); +#endif +extern u32 fib_rules_policy(u32 saddr, struct fib_result *res, unsigned *flags); +extern void fib_rules_init(void); +#endif + +extern __inline__ void fib_combine_itag(u32 *itag, struct fib_result *res) +{ +#ifdef CONFIG_NET_CLS_ROUTE +#ifdef CONFIG_IP_MULTIPLE_TABLES + u32 rtag; +#endif + *itag = FIB_RES_NH(*res).nh_tclassid<<16; +#ifdef CONFIG_IP_MULTIPLE_TABLES + rtag = fib_rules_tclass(res); + if (*itag == 0) + *itag = (rtag<<16); + *itag |= (rtag>>16); +#endif +#endif +} + +#endif _NET_FIB_H diff --git a/pfinet/linux-src/include/net/ip_masq.h b/pfinet/linux-src/include/net/ip_masq.h new file mode 100644 index 00000000..1e050359 --- /dev/null +++ b/pfinet/linux-src/include/net/ip_masq.h @@ -0,0 +1,362 @@ +/* + * IP masquerading functionality definitions + */ + +#include <linux/config.h> /* for CONFIG_IP_MASQ_DEBUG */ +#ifndef _IP_MASQ_H +#define _IP_MASQ_H + +#ifdef __KERNEL__ +#include <linux/types.h> +#include <linux/netdevice.h> +#include <linux/ip.h> +#include <linux/skbuff.h> +#include <linux/list.h> +#endif /* __KERNEL__ */ + +/* + * This define affects the number of ports that can be handled + * by each of the protocol helper modules. + */ +#define MAX_MASQ_APP_PORTS 12 + +/* + * Linux ports don't normally get allocated above 32K. + * I used an extra 4K port-space + */ + +#define PORT_MASQ_BEGIN 61000 +#define PORT_MASQ_END (PORT_MASQ_BEGIN+4096) + +#define MASQUERADE_EXPIRE_TCP 15*60*HZ +#define MASQUERADE_EXPIRE_TCP_FIN 2*60*HZ +#define MASQUERADE_EXPIRE_UDP 5*60*HZ +/* + * ICMP can no longer be modified on the fly using an ioctl - this + * define is the only way to change the timeouts + */ +#define MASQUERADE_EXPIRE_ICMP 125*HZ + +#define IP_MASQ_MOD_CTL 0x00 +#define IP_MASQ_USER_CTL 0x01 + +#ifdef __KERNEL__ + +#define IP_MASQ_TAB_SIZE 256 + +#define IP_MASQ_F_NO_DADDR 0x0001 /* no daddr yet */ +#define IP_MASQ_F_NO_DPORT 0x0002 /* no dport set yet */ +#define IP_MASQ_F_NO_SADDR 0x0004 /* no sport set yet */ +#define IP_MASQ_F_NO_SPORT 0x0008 /* no sport set yet */ + +#define IP_MASQ_F_DLOOSE 0x0010 /* loose dest binding */ +#define IP_MASQ_F_NO_REPLY 0x0080 /* no reply yet from outside */ + +#define IP_MASQ_F_HASHED 0x0100 /* hashed entry */ +#define IP_MASQ_F_OUT_SEQ 0x0200 /* must do output seq adjust */ +#define IP_MASQ_F_IN_SEQ 0x0400 /* must do input seq adjust */ + +#define IP_MASQ_F_MPORT 0x1000 /* own mport specified */ +#define IP_MASQ_F_USER 0x2000 /* from uspace */ +#define IP_MASQ_F_SIMPLE_HASH 0x8000 /* prevent s+d and m+d hashing */ + +/* + * Delta seq. info structure + * Each MASQ struct has 2 (output AND input seq. changes). + */ + +struct ip_masq_seq { + __u32 init_seq; /* Add delta from this seq */ + short delta; /* Delta in sequence numbers */ + short previous_delta; /* Delta in sequence numbers before last resized pkt */ +}; + +/* + * MASQ structure allocated for each masqueraded association + */ +struct ip_masq { + struct list_head m_list, s_list, d_list; + /* hashed d-linked list heads */ + atomic_t refcnt; /* reference count */ + struct timer_list timer; /* Expiration timer */ + __u16 protocol; /* Which protocol are we talking? */ + __u16 sport, dport, mport; /* src, dst & masq ports */ + __u32 saddr, daddr, maddr; /* src, dst & masq addresses */ + struct ip_masq_seq out_seq, in_seq; + struct ip_masq_app *app; /* bound ip_masq_app object */ + void *app_data; /* Application private data */ + struct ip_masq *control; /* Master control connection */ + atomic_t n_control; /* Number of "controlled" masqs */ + unsigned flags; /* status flags */ + unsigned timeout; /* timeout */ + unsigned state; /* state info */ + struct ip_masq_timeout_table *timeout_table; +}; + +/* + * Timeout values + * ipchains holds a copy of this definition + */ + +struct ip_fw_masq { + int tcp_timeout; + int tcp_fin_timeout; + int udp_timeout; +}; + +union ip_masq_tphdr { + unsigned char *raw; + struct udphdr *uh; + struct tcphdr *th; + struct icmphdr *icmph; + __u16 *portp; +}; +/* + * [0]: UDP free_ports + * [1]: TCP free_ports + * [2]: ICMP free_ports + */ + +extern atomic_t ip_masq_free_ports[3]; + +/* + * ip_masq initializer (registers symbols and /proc/net entries) + */ +extern int ip_masq_init(void); + +/* + * functions called from ip layer + */ +extern int ip_fw_masquerade(struct sk_buff **, __u32 maddr); +extern int ip_fw_masq_icmp(struct sk_buff **, __u32 maddr); +extern int ip_fw_unmasq_icmp(struct sk_buff *); +extern int ip_fw_demasquerade(struct sk_buff **); + +/* + * ip_masq obj creation/deletion functions. + */ +extern struct ip_masq *ip_masq_new(int proto, __u32 maddr, __u16 mport, __u32 saddr, __u16 sport, __u32 daddr, __u16 dport, unsigned flags); + +extern void ip_masq_control_add(struct ip_masq *ms, struct ip_masq* ctl_ms); +extern void ip_masq_control_del(struct ip_masq *ms); +extern struct ip_masq * ip_masq_control_get(struct ip_masq *ms); + +struct ip_masq_ctl; + +struct ip_masq_hook { + int (*ctl)(int, struct ip_masq_ctl *, int); + int (*info)(char *, char **, off_t, int, int); +}; + +extern struct list_head ip_masq_m_table[IP_MASQ_TAB_SIZE]; +extern struct list_head ip_masq_s_table[IP_MASQ_TAB_SIZE]; +extern struct list_head ip_masq_d_table[IP_MASQ_TAB_SIZE]; +extern const char * ip_masq_state_name(int state); +extern struct ip_masq_hook *ip_masq_user_hook; +extern u32 ip_masq_select_addr(struct device *dev, u32 dst, int scope); +/* + * + * IP_MASQ_APP: IP application masquerading definitions + * + */ + +struct ip_masq_app +{ + struct ip_masq_app *next; + char *name; /* name of application proxy */ + unsigned type; /* type = proto<<16 | port (host byte order)*/ + int n_attach; + int (*masq_init_1) /* ip_masq initializer */ + (struct ip_masq_app *, struct ip_masq *); + int (*masq_done_1) /* ip_masq fin. */ + (struct ip_masq_app *, struct ip_masq *); + int (*pkt_out) /* output (masquerading) hook */ + (struct ip_masq_app *, struct ip_masq *, struct sk_buff **, __u32); + int (*pkt_in) /* input (demasq) hook */ + (struct ip_masq_app *, struct ip_masq *, struct sk_buff **, __u32); +}; + +/* + * ip_masq_app initializer + */ +extern int ip_masq_app_init(void); + +/* + * ip_masq_app object registration functions (port: host byte order) + */ +extern int register_ip_masq_app(struct ip_masq_app *mapp, unsigned short proto, __u16 port); +extern int unregister_ip_masq_app(struct ip_masq_app *mapp); + +/* + * get ip_masq_app obj by proto,port(net_byte_order) + */ +extern struct ip_masq_app * ip_masq_app_get(unsigned short proto, __u16 port); + +/* + * ip_masq TO ip_masq_app (un)binding functions. + */ +extern struct ip_masq_app * ip_masq_bind_app(struct ip_masq *ms); +extern int ip_masq_unbind_app(struct ip_masq *ms); + +/* + * output and input app. masquerading hooks. + * + */ +extern int ip_masq_app_pkt_out(struct ip_masq *, struct sk_buff **skb_p, __u32 maddr); +extern int ip_masq_app_pkt_in(struct ip_masq *, struct sk_buff **skb_p, __u32 maddr); + +/* + * service routine(s). + */ + +extern struct ip_masq * ip_masq_out_get(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port); +extern struct ip_masq * ip_masq_in_get(int protocol, __u32 s_addr, __u16 s_port, __u32 d_addr, __u16 d_port); + +extern int ip_masq_listen(struct ip_masq *); + +static __inline__ struct ip_masq * ip_masq_in_get_iph(const struct iphdr *iph) +{ + const __u16 *portp = (__u16 *)&(((char *)iph)[iph->ihl*4]); + return ip_masq_in_get(iph->protocol, + iph->saddr, portp[0], + iph->daddr, portp[1]); +} + +static __inline__ struct ip_masq * ip_masq_out_get_iph(const struct iphdr *iph) +{ + const __u16 *portp = (__u16 *)&(((char *)iph)[iph->ihl*4]); + return ip_masq_out_get(iph->protocol, + iph->saddr, portp[0], + iph->daddr, portp[1]); +} + +extern void ip_masq_put(struct ip_masq *ms); + + +extern rwlock_t __ip_masq_lock; + +#ifdef __SMP__ +#define read_lock_bh(lock) do { start_bh_atomic(); read_lock(lock); \ + } while (0) +#define read_unlock_bh(lock) do { read_unlock(lock); end_bh_atomic(); \ + } while (0) +#define write_lock_bh(lock) do { start_bh_atomic(); write_lock(lock); \ + } while (0) +#define write_unlock_bh(lock) do { write_unlock(lock); end_bh_atomic(); \ + } while (0) +#else +#define read_lock_bh(lock) start_bh_atomic() +#define read_unlock_bh(lock) end_bh_atomic() +#define write_lock_bh(lock) start_bh_atomic() +#define write_unlock_bh(lock) end_bh_atomic() +#endif +/* + * + */ + +/* + * Debugging stuff + */ + +extern int ip_masq_get_debug_level(void); + +#ifdef CONFIG_IP_MASQ_DEBUG +#define IP_MASQ_DEBUG(level, msg...) do { \ + if (level <= ip_masq_get_debug_level()) \ + printk(KERN_DEBUG "IP_MASQ:" ## msg); \ + } while (0) +#else /* NO DEBUGGING at ALL */ +#define IP_MASQ_DEBUG(level, msg...) do { } while (0) +#endif + +#define IP_MASQ_INFO(msg...) \ + printk(KERN_INFO "IP_MASQ:" ## msg) + +#define IP_MASQ_ERR(msg...) \ + printk(KERN_ERR "IP_MASQ:" ## msg) + +#define IP_MASQ_WARNING(msg...) \ + printk(KERN_WARNING "IP_MASQ:" ## msg) + + +/* + * /proc/net entry + */ +extern int ip_masq_proc_register(struct proc_dir_entry *); +extern void ip_masq_proc_unregister(struct proc_dir_entry *); +extern int ip_masq_app_getinfo(char *buffer, char **start, off_t offset, int length, int dummy); + +/* + * skb_replace function used by "client" modules to replace + * a segment of skb. + */ +extern struct sk_buff * ip_masq_skb_replace(struct sk_buff *skb, int pri, char *o_buf, int o_len, char *n_buf, int n_len); + +/* + * masq_proto_num returns 0 for UDP, 1 for TCP, 2 for ICMP + */ + +static __inline__ int masq_proto_num(unsigned proto) +{ + switch (proto) + { + case IPPROTO_UDP: return (0); break; + case IPPROTO_TCP: return (1); break; + case IPPROTO_ICMP: return (2); break; + default: return (-1); break; + } +} + +static __inline__ const char *masq_proto_name(unsigned proto) +{ + static char buf[20]; + static const char *strProt[] = {"UDP","TCP","ICMP"}; + int msproto = masq_proto_num(proto); + + if (msproto<0||msproto>2) { + sprintf(buf, "IP_%d", proto); + return buf; + } + return strProt[msproto]; +} + +enum { + IP_MASQ_S_NONE = 0, + IP_MASQ_S_ESTABLISHED, + IP_MASQ_S_SYN_SENT, + IP_MASQ_S_SYN_RECV, + IP_MASQ_S_FIN_WAIT, + IP_MASQ_S_TIME_WAIT, + IP_MASQ_S_CLOSE, + IP_MASQ_S_CLOSE_WAIT, + IP_MASQ_S_LAST_ACK, + IP_MASQ_S_LISTEN, + IP_MASQ_S_UDP, + IP_MASQ_S_ICMP, + IP_MASQ_S_LAST +}; + +struct ip_masq_timeout_table { + atomic_t refcnt; + int scale; + int timeout[IP_MASQ_S_LAST+1]; +}; + +static __inline__ void ip_masq_timeout_attach(struct ip_masq *ms, struct ip_masq_timeout_table *mstim) +{ + atomic_inc (&mstim->refcnt); + ms->timeout_table=mstim; +} + +static __inline__ void ip_masq_timeout_detach(struct ip_masq *ms) +{ + struct ip_masq_timeout_table *mstim = ms->timeout_table; + + if (!mstim) + return; + atomic_dec(&mstim->refcnt); +} + +#endif /* __KERNEL__ */ + +#endif /* _IP_MASQ_H */ diff --git a/pfinet/linux-src/include/net/ip_masq_mod.h b/pfinet/linux-src/include/net/ip_masq_mod.h new file mode 100644 index 00000000..a7a67d6f --- /dev/null +++ b/pfinet/linux-src/include/net/ip_masq_mod.h @@ -0,0 +1,86 @@ +/* + * IP Masquerading Modules Support + * + * Version: @(#)ip_masq_mod.h 0.01 97/10/30 + * + * Author: Juan Jose Ciarlante, <jjciarla@raiz.uncu.edu.ar> + * + */ + + +#ifdef __KERNEL__ +#include <linux/types.h> +#include <linux/ip_fw.h> +#include <linux/proc_fs.h> +#include <net/ip_masq.h> + +#define IP_MASQ_MOD_NOP 0 +#define IP_MASQ_MOD_ACCEPT 1 +#define IP_MASQ_MOD_REJECT -1 + +struct ip_masq_mod { + struct ip_masq_mod *next; /* next mod for addrs. lookups */ + struct ip_masq_mod *next_reg; /* next mod for configuration ctls */ + char *mmod_name; + atomic_t refcnt; + atomic_t mmod_nent; /* number of entries */ + struct proc_dir_entry *mmod_proc_ent; + int (*mmod_ctl) (int optname, struct ip_masq_ctl *, int optlen); + int (*mmod_init) (void); + int (*mmod_done) (void); + int (*mmod_in_rule) (const struct sk_buff *, const struct iphdr *); + int (*mmod_in_update) (const struct sk_buff *, const struct iphdr *, + struct ip_masq *); + struct ip_masq * (*mmod_in_create) (const struct sk_buff *, const struct iphdr *, __u32); + int (*mmod_out_rule) (const struct sk_buff *, const struct iphdr *); + int (*mmod_out_update) (const struct sk_buff *, const struct iphdr *, + struct ip_masq *); + struct ip_masq * (*mmod_out_create) (const struct sk_buff *, const struct iphdr *, __u32); +}; + +/* + * Service routines (called from ip_masq.c) + */ + +int ip_masq_mod_out_rule(const struct sk_buff *, const struct iphdr *); +int ip_masq_mod_out_update(const struct sk_buff *, const struct iphdr *, struct ip_masq *ms); +struct ip_masq * ip_masq_mod_out_create(const struct sk_buff *, const struct iphdr *iph, __u32 maddr); + +int ip_masq_mod_in_rule(const struct sk_buff *, const struct iphdr *iph); +int ip_masq_mod_in_update(const struct sk_buff *, const struct iphdr *iph, struct ip_masq *ms); +struct ip_masq * ip_masq_mod_in_create(const struct sk_buff *, const struct iphdr *iph, __u32 maddr); + +extern int ip_masq_mod_ctl(int optname, struct ip_masq_ctl *, int len); + +/* + * ip_masq_mod registration functions + */ +extern int register_ip_masq_mod(struct ip_masq_mod *mmod); +extern int unregister_ip_masq_mod(struct ip_masq_mod *mmod); +extern int ip_masq_mod_lkp_unlink(struct ip_masq_mod *mmod); +extern int ip_masq_mod_lkp_link(struct ip_masq_mod *mmod); + +/* + * init functions protos + */ +extern int ip_portfw_init(void); +extern int ip_mfw_init(void); +extern int ip_autofw_init(void); + +/* + * Utility ... + */ +static __inline__ void ip_masq_mod_dec_nent(struct ip_masq_mod *mmod) +{ + if (atomic_dec_and_test(&mmod->mmod_nent)) { + ip_masq_mod_lkp_unlink(mmod); + } +} +static __inline__ void ip_masq_mod_inc_nent(struct ip_masq_mod *mmod) +{ + atomic_inc(&mmod->mmod_nent); + if (atomic_read(&mmod->mmod_nent)==1) + ip_masq_mod_lkp_link(mmod); +} + +#endif /* __KERNEL__ */ diff --git a/pfinet/linux-src/include/net/ipconfig.h b/pfinet/linux-src/include/net/ipconfig.h new file mode 100644 index 00000000..f9356946 --- /dev/null +++ b/pfinet/linux-src/include/net/ipconfig.h @@ -0,0 +1,21 @@ +/* + * $Id: ipconfig.h,v 1.3 1999/01/04 20:13:29 davem Exp $ + * + * Copyright (C) 1997 Martin Mares + * + * Automatic IP Layer Configuration + */ + +extern __u32 root_server_addr; +extern u8 root_server_path[]; +extern u32 ic_myaddr; +extern u32 ic_servaddr; +extern u32 ic_gateway; +extern u32 ic_netmask; +extern int ic_enable; +extern int ic_host_name_set; +extern int ic_set_manually; +extern int ic_proto_enabled; + +#define IC_BOOTP 1 +#define IC_RARP 2 diff --git a/pfinet/linux-src/include/net/ipip.h b/pfinet/linux-src/include/net/ipip.h new file mode 100644 index 00000000..22c464c3 --- /dev/null +++ b/pfinet/linux-src/include/net/ipip.h @@ -0,0 +1,33 @@ +#ifndef __NET_IPIP_H +#define __NET_IPIP_H 1 + +#include <linux/if_tunnel.h> + +/* Keep error state on tunnel for 30 sec */ +#define IPTUNNEL_ERR_TIMEO (30*HZ) + +struct ip_tunnel +{ + struct ip_tunnel *next; + struct device *dev; + struct net_device_stats stat; + + int recursion; /* Depth of hard_start_xmit recursion */ + int err_count; /* Number of arrived ICMP errors */ + unsigned long err_time; /* Time when the last ICMP error arrived */ + + /* These four fields used only by GRE */ + __u32 i_seqno; /* The last seen seqno */ + __u32 o_seqno; /* The last output seqno */ + int hlen; /* Precalculated GRE header length */ + int mlink; + + struct ip_tunnel_parm parms; +}; + +extern int ipip_init(void); +extern int ipgre_init(void); +extern int sit_init(void); +extern void sit_cleanup(void); + +#endif diff --git a/pfinet/linux-src/include/net/ipv6.h b/pfinet/linux-src/include/net/ipv6.h new file mode 100644 index 00000000..50e2299f --- /dev/null +++ b/pfinet/linux-src/include/net/ipv6.h @@ -0,0 +1,325 @@ +/* + * Linux INET6 implementation + * + * Authors: + * Pedro Roque <roque@di.fc.ul.pt> + * + * $Id: ipv6.h,v 1.16 1999/04/22 10:07:27 davem Exp $ + * + * 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. + */ + +#ifndef _NET_IPV6_H +#define _NET_IPV6_H + +#include <linux/ipv6.h> +#include <asm/hardirq.h> +#include <net/ndisc.h> +#include <net/flow.h> + +/* + * NextHeader field of IPv6 header + */ + +#define NEXTHDR_HOP 0 /* Hop-by-hop option header. */ +#define NEXTHDR_TCP 6 /* TCP segment. */ +#define NEXTHDR_UDP 17 /* UDP message. */ +#define NEXTHDR_IPV6 41 /* IPv6 in IPv6 */ +#define NEXTHDR_ROUTING 43 /* Routing header. */ +#define NEXTHDR_FRAGMENT 44 /* Fragmentation/reassembly header. */ +#define NEXTHDR_ESP 50 /* Encapsulating security payload. */ +#define NEXTHDR_AUTH 51 /* Authentication header. */ +#define NEXTHDR_ICMP 58 /* ICMP for IPv6. */ +#define NEXTHDR_NONE 59 /* No next header */ +#define NEXTHDR_DEST 60 /* Destination options header. */ + +#define NEXTHDR_MAX 255 + + + +#define IPV6_DEFAULT_HOPLIMIT 64 +#define IPV6_DEFAULT_MCASTHOPS 1 + +/* + * Addr type + * + * type - unicast | multicast | anycast + * scope - local | site | global + * v4 - compat + * v4mapped + * any + * loopback + */ + +#define IPV6_ADDR_ANY 0x0000U + +#define IPV6_ADDR_UNICAST 0x0001U +#define IPV6_ADDR_MULTICAST 0x0002U +#define IPV6_ADDR_ANYCAST 0x0004U + +#define IPV6_ADDR_LOOPBACK 0x0010U +#define IPV6_ADDR_LINKLOCAL 0x0020U +#define IPV6_ADDR_SITELOCAL 0x0040U + +#define IPV6_ADDR_COMPATv4 0x0080U + +#define IPV6_ADDR_SCOPE_MASK 0x00f0U + +#define IPV6_ADDR_MAPPED 0x1000U +#define IPV6_ADDR_RESERVED 0x2000U /* reserved address space */ + +/* + * fragmentation header + */ + +struct frag_hdr { + unsigned char nexthdr; + unsigned char reserved; + unsigned short frag_off; + __u32 identification; +}; + +#ifdef __KERNEL__ + +#include <net/sock.h> + +extern struct ipv6_mib ipv6_statistics; +extern struct icmpv6_mib icmpv6_statistics; +extern struct udp_mib udp_stats_in6; + +struct ip6_ra_chain +{ + struct ip6_ra_chain *next; + struct sock *sk; + int sel; + void (*destructor)(struct sock *); +}; + +extern struct ip6_ra_chain *ip6_ra_chain; + +/* + This structure is prepared by protocol, when parsing + ancillary data and passed to IPv6. + */ + +struct ipv6_txoptions +{ + /* Length of this structure */ + int tot_len; + + /* length of extension headers */ + + __u16 opt_flen; /* after fragment hdr */ + __u16 opt_nflen; /* before fragment hdr */ + + struct ipv6_opt_hdr *hopopt; + struct ipv6_opt_hdr *dst0opt; + struct ipv6_rt_hdr *srcrt; /* Routing Header */ + struct ipv6_opt_hdr *auth; + struct ipv6_opt_hdr *dst1opt; + + /* Option buffer, as read by IPV6_PKTOPTIONS, starts here. */ +}; + +struct ip6_flowlabel +{ + struct ip6_flowlabel *next; + u32 label; + struct in6_addr dst; + struct ipv6_txoptions *opt; + atomic_t users; + u32 linger; + u8 share; + u32 owner; + unsigned long lastuse; + unsigned long expires; +}; + +#define IPV6_FLOWINFO_MASK __constant_htonl(0x0FFFFFFF) +#define IPV6_FLOWLABEL_MASK __constant_htonl(0x000FFFFF) + +struct ipv6_fl_socklist +{ + struct ipv6_fl_socklist *next; + struct ip6_flowlabel *fl; +}; + +extern struct ip6_flowlabel *fl6_sock_lookup(struct sock *sk, u32 label); +extern struct ipv6_txoptions *fl6_merge_options(struct ipv6_txoptions * opt_space, + struct ip6_flowlabel * fl, + struct ipv6_txoptions * fopt); +extern void fl6_free_socklist(struct sock *sk); +extern int ipv6_flowlabel_opt(struct sock *sk, char *optval, int optlen); +extern void ip6_flowlabel_init(void); +extern void ip6_flowlabel_cleanup(void); + +extern __inline__ void fl6_sock_release(struct ip6_flowlabel *fl) +{ + if (fl) + atomic_dec(&fl->users); +} + +extern int ip6_ra_control(struct sock *sk, int sel, + void (*destructor)(struct sock *)); + + +extern int ip6_call_ra_chain(struct sk_buff *skb, int sel); + +extern u8 * ipv6_reassembly(struct sk_buff **skb, u8 *nhptr); + +extern u8 * ipv6_parse_hopopts(struct sk_buff *skb, u8 *nhptr); + +extern u8 * ipv6_parse_exthdrs(struct sk_buff **skb, u8 *nhptr); + +extern struct ipv6_txoptions * ipv6_dup_options(struct sock *sk, struct ipv6_txoptions *opt); + +#define IPV6_FRAG_TIMEOUT (60*HZ) /* 60 seconds */ + +/* + * Function prototype for build_xmit + */ + +typedef int (*inet_getfrag_t) (const void *data, + struct in6_addr *addr, + char *, + unsigned int, unsigned int); + + +extern int ipv6_addr_type(struct in6_addr *addr); + +extern __inline__ int ipv6_addr_scope(struct in6_addr *addr) +{ + return ipv6_addr_type(addr) & IPV6_ADDR_SCOPE_MASK; +} + +extern __inline__ int ipv6_addr_cmp(struct in6_addr *a1, struct in6_addr *a2) +{ + return memcmp((void *) a1, (void *) a2, sizeof(struct in6_addr)); +} + +extern __inline__ void ipv6_addr_copy(struct in6_addr *a1, struct in6_addr *a2) +{ + memcpy((void *) a1, (void *) a2, sizeof(struct in6_addr)); +} + +#ifndef __HAVE_ARCH_ADDR_SET +extern __inline__ void ipv6_addr_set(struct in6_addr *addr, + __u32 w1, __u32 w2, + __u32 w3, __u32 w4) +{ + addr->s6_addr32[0] = w1; + addr->s6_addr32[1] = w2; + addr->s6_addr32[2] = w3; + addr->s6_addr32[3] = w4; +} +#endif + +extern __inline__ int ipv6_addr_any(struct in6_addr *a) +{ + return ((a->s6_addr32[0] | a->s6_addr32[1] | + a->s6_addr32[2] | a->s6_addr32[3] ) == 0); +} + +/* + * Prototypes exported by ipv6 + */ + +/* + * rcv function (called from netdevice level) + */ + +extern int ipv6_rcv(struct sk_buff *skb, + struct device *dev, + struct packet_type *pt); + +/* + * upper-layer output functions + */ +extern int ip6_xmit(struct sock *sk, + struct sk_buff *skb, + struct flowi *fl, + struct ipv6_txoptions *opt); + +extern int ip6_nd_hdr(struct sock *sk, + struct sk_buff *skb, + struct device *dev, + struct in6_addr *saddr, + struct in6_addr *daddr, + int proto, int len); + +extern int ip6_build_xmit(struct sock *sk, + inet_getfrag_t getfrag, + const void *data, + struct flowi *fl, + unsigned length, + struct ipv6_txoptions *opt, + int hlimit, int flags); + +/* + * skb processing functions + */ + +extern int ip6_output(struct sk_buff *skb); +extern int ip6_forward(struct sk_buff *skb); +extern int ip6_input(struct sk_buff *skb); +extern int ip6_mc_input(struct sk_buff *skb); + +/* + * Extension header (options) processing + */ + +extern u8 * ipv6_build_nfrag_opts(struct sk_buff *skb, + u8 *prev_hdr, + struct ipv6_txoptions *opt, + struct in6_addr *daddr, + u32 jumbolen); +extern u8 * ipv6_build_frag_opts(struct sk_buff *skb, + u8 *prev_hdr, + struct ipv6_txoptions *opt); +extern void ipv6_push_nfrag_opts(struct sk_buff *skb, + struct ipv6_txoptions *opt, + u8 *proto, + struct in6_addr **daddr_p); +extern void ipv6_push_frag_opts(struct sk_buff *skb, + struct ipv6_txoptions *opt, + u8 *proto); + +extern u8 * ipv6_skip_exthdr(struct ipv6_opt_hdr *hdr, + u8 *nexthdrp, int len); + +extern struct ipv6_txoptions * ipv6_invert_rthdr(struct sock *sk, + struct ipv6_rt_hdr *hdr); + + +/* + * socket options (ipv6_sockglue.c) + */ + +extern int ipv6_setsockopt(struct sock *sk, int level, + int optname, char *optval, + int optlen); +extern int ipv6_getsockopt(struct sock *sk, int level, + int optname, char *optval, + int *optlen); + +extern void ipv6_packet_init(void); + +extern void ipv6_netdev_notif_init(void); + +extern void ipv6_packet_cleanup(void); + +extern void ipv6_netdev_notif_cleanup(void); + +extern int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len); +extern void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err, u16 port, + u32 info, u8 *payload); +extern void ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info); + +#endif /* __KERNEL__ */ +#endif /* _NET_IPV6_H */ + + + diff --git a/pfinet/linux-src/include/net/ipx.h b/pfinet/linux-src/include/net/ipx.h new file mode 100644 index 00000000..2152e388 --- /dev/null +++ b/pfinet/linux-src/include/net/ipx.h @@ -0,0 +1,82 @@ +/* + * The following information is in its entirety obtained from: + * + * Novell 'IPX Router Specification' Version 1.10 + * Part No. 107-000029-001 + * + * Which is available from ftp.novell.com + */ + +#ifndef _NET_INET_IPX_H_ +#define _NET_INET_IPX_H_ + +#include <linux/netdevice.h> +#include <net/datalink.h> +#include <linux/ipx.h> + +typedef struct +{ + __u32 net; + __u8 node[IPX_NODE_LEN]; + __u16 sock; +} ipx_address; + +#define ipx_broadcast_node "\377\377\377\377\377\377" +#define ipx_this_node "\0\0\0\0\0\0" + +struct ipxhdr +{ + __u16 ipx_checksum __attribute__ ((packed)); +#define IPX_NO_CHECKSUM 0xFFFF + __u16 ipx_pktsize __attribute__ ((packed)); + __u8 ipx_tctrl; + __u8 ipx_type; +#define IPX_TYPE_UNKNOWN 0x00 +#define IPX_TYPE_RIP 0x01 /* may also be 0 */ +#define IPX_TYPE_SAP 0x04 /* may also be 0 */ +#define IPX_TYPE_SPX 0x05 /* SPX protocol */ +#define IPX_TYPE_NCP 0x11 /* $lots for docs on this (SPIT) */ +#define IPX_TYPE_PPROP 0x14 /* complicated flood fill brdcast [Not supported] */ + ipx_address ipx_dest __attribute__ ((packed)); + ipx_address ipx_source __attribute__ ((packed)); +}; + +#include <net/ipxcall.h> + +typedef struct ipx_interface { + /* IPX address */ + __u32 if_netnum; + unsigned char if_node[IPX_NODE_LEN]; + + /* physical device info */ + struct device *if_dev; + struct datalink_proto *if_dlink; + unsigned short if_dlink_type; + + /* socket support */ + unsigned short if_sknum; + struct sock *if_sklist; + + /* administrative overhead */ + int if_ipx_offset; + unsigned char if_internal; + unsigned char if_primary; + + struct ipx_interface *if_next; +} ipx_interface; + +typedef struct ipx_route { + __u32 ir_net; + ipx_interface *ir_intrfc; + unsigned char ir_routed; + unsigned char ir_router_node[IPX_NODE_LEN]; + struct ipx_route *ir_next; +} ipx_route; + +#define IPX_MIN_EPHEMERAL_SOCKET 0x4000 +#define IPX_MAX_EPHEMERAL_SOCKET 0x7fff + +extern int ipx_register_spx(struct proto_ops **, struct net_proto_family *); +extern int ipx_unregister_spx(void); + +#endif /* def _NET_INET_IPX_H_ */ diff --git a/pfinet/linux-src/include/net/ipxcall.h b/pfinet/linux-src/include/net/ipxcall.h new file mode 100644 index 00000000..eb5bd2bd --- /dev/null +++ b/pfinet/linux-src/include/net/ipxcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void ipx_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/lapb.h b/pfinet/linux-src/include/net/lapb.h new file mode 100644 index 00000000..7cc9b345 --- /dev/null +++ b/pfinet/linux-src/include/net/lapb.h @@ -0,0 +1,150 @@ +#ifndef _LAPB_H +#define _LAPB_H +#include <linux/lapb.h> + +#define LAPB_HEADER_LEN 20 /* LAPB over Ethernet + a bit more */ + +#define LAPB_ACK_PENDING_CONDITION 0x01 +#define LAPB_REJECT_CONDITION 0x02 +#define LAPB_PEER_RX_BUSY_CONDITION 0x04 + +/* Control field templates */ +#define LAPB_I 0x00 /* Information frames */ +#define LAPB_S 0x01 /* Supervisory frames */ +#define LAPB_U 0x03 /* Unnumbered frames */ + +#define LAPB_RR 0x01 /* Receiver ready */ +#define LAPB_RNR 0x05 /* Receiver not ready */ +#define LAPB_REJ 0x09 /* Reject */ + +#define LAPB_SABM 0x2F /* Set Asynchronous Balanced Mode */ +#define LAPB_SABME 0x6F /* Set Asynchronous Balanced Mode Extended */ +#define LAPB_DISC 0x43 /* Disconnect */ +#define LAPB_DM 0x0F /* Disconnected mode */ +#define LAPB_UA 0x63 /* Unnumbered acknowledge */ +#define LAPB_FRMR 0x87 /* Frame reject */ + +#define LAPB_ILLEGAL 0x100 /* Impossible to be a real frame type */ + +#define LAPB_SPF 0x10 /* Poll/final bit for standard LAPB */ +#define LAPB_EPF 0x01 /* Poll/final bit for extended LAPB */ + +#define LAPB_FRMR_W 0x01 /* Control field invalid */ +#define LAPB_FRMR_X 0x02 /* I field invalid */ +#define LAPB_FRMR_Y 0x04 /* I field too long */ +#define LAPB_FRMR_Z 0x08 /* Invalid N(R) */ + +#define LAPB_POLLOFF 0 +#define LAPB_POLLON 1 + +/* LAPB C-bit */ +#define LAPB_COMMAND 1 +#define LAPB_RESPONSE 2 + +#define LAPB_ADDR_A 0x03 +#define LAPB_ADDR_B 0x01 +#define LAPB_ADDR_C 0x0F +#define LAPB_ADDR_D 0x07 + +/* Define Link State constants. */ +enum { + LAPB_STATE_0, /* Disconnected State */ + LAPB_STATE_1, /* Awaiting Connection State */ + LAPB_STATE_2, /* Awaiting Disconnection State */ + LAPB_STATE_3, /* Data Transfer State */ + LAPB_STATE_4 /* Frame Reject State */ +}; + +#define LAPB_DEFAULT_MODE (LAPB_STANDARD | LAPB_SLP | LAPB_DTE) +#define LAPB_DEFAULT_WINDOW 7 /* Window=7 */ +#define LAPB_DEFAULT_T1 (5 * HZ) /* T1=5s */ +#define LAPB_DEFAULT_T2 (1 * HZ) /* T2=1s */ +#define LAPB_DEFAULT_N2 20 /* N2=20 */ + +#define LAPB_SMODULUS 8 +#define LAPB_EMODULUS 128 + +/* + * Information about the current frame. + */ +struct lapb_frame { + unsigned short type; /* Parsed type */ + unsigned short nr, ns; /* N(R), N(S) */ + unsigned char cr; /* Command/Response */ + unsigned char pf; /* Poll/Final */ + unsigned char control[2]; /* Original control data*/ +}; + +/* + * The per LAPB connection control structure. + */ +typedef struct lapb_cb { + struct lapb_cb *next; + void *token; + + /* Link status fields */ + unsigned int mode; + unsigned char state; + unsigned short vs, vr, va; + unsigned char condition; + unsigned short n2, n2count; + unsigned short t1, t2; + struct timer_list t1timer, t2timer; + + /* Internal control information */ + struct sk_buff_head write_queue; + struct sk_buff_head ack_queue; + unsigned char window; + struct lapb_register_struct callbacks; + + /* FRMR control information */ + struct lapb_frame frmr_data; + unsigned char frmr_type; +} lapb_cb; + +/* lapb_iface.c */ +extern void lapb_connect_confirmation(lapb_cb *, int); +extern void lapb_connect_indication(lapb_cb *, int); +extern void lapb_disconnect_confirmation(lapb_cb *, int); +extern void lapb_disconnect_indication(lapb_cb *, int); +extern int lapb_data_indication(lapb_cb *, struct sk_buff *); +extern int lapb_data_transmit(lapb_cb *, struct sk_buff *); + +/* lapb_in.c */ +extern void lapb_data_input(lapb_cb *, struct sk_buff *); + +/* lapb_out.c */ +extern void lapb_kick(lapb_cb *); +extern void lapb_transmit_buffer(lapb_cb *, struct sk_buff *, int); +extern void lapb_establish_data_link(lapb_cb *); +extern void lapb_enquiry_response(lapb_cb *); +extern void lapb_timeout_response(lapb_cb *); +extern void lapb_check_iframes_acked(lapb_cb *, unsigned short); +extern void lapb_check_need_response(lapb_cb *, int, int); + +/* lapb_subr.c */ +extern void lapb_clear_queues(lapb_cb *); +extern void lapb_frames_acked(lapb_cb *, unsigned short); +extern void lapb_requeue_frames(lapb_cb *); +extern int lapb_validate_nr(lapb_cb *, unsigned short); +extern void lapb_decode(lapb_cb *, struct sk_buff *, struct lapb_frame *); +extern void lapb_send_control(lapb_cb *, int, int, int); +extern void lapb_transmit_frmr(lapb_cb *); + +/* lapb_timer.c */ +extern void lapb_start_t1timer(lapb_cb *); +extern void lapb_start_t2timer(lapb_cb *); +extern void lapb_stop_t1timer(lapb_cb *); +extern void lapb_stop_t2timer(lapb_cb *); +extern int lapb_t1timer_running(lapb_cb *); + +/* + * Debug levels. + * 0 = Off + * 1 = State Changes + * 2 = Packets I/O and State Changes + * 3 = Hex dumps, Packets I/O and State Changes. + */ +#define LAPB_DEBUG 0 + +#endif diff --git a/pfinet/linux-src/include/net/lapbcall.h b/pfinet/linux-src/include/net/lapbcall.h new file mode 100644 index 00000000..825e7f2c --- /dev/null +++ b/pfinet/linux-src/include/net/lapbcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void lapb_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/llc.h b/pfinet/linux-src/include/net/llc.h new file mode 100644 index 00000000..654a658d --- /dev/null +++ b/pfinet/linux-src/include/net/llc.h @@ -0,0 +1,135 @@ +#include <linux/skbuff.h> + +#define LLC_MODULE + +typedef struct llc_struct llc; +typedef struct llc_struct *llcptr; + +/* + * LLC private data area structure. + */ + +struct llc_struct +{ + char eye[4]; /* To recognize llc area in dump */ + int retry_count; /* LLC link state variables */ + unsigned char name[9]; /* name of this llc instance */ + unsigned char s_flag; + unsigned char p_flag; + unsigned char f_flag; + unsigned char data_flag; + unsigned char cause_flag; + unsigned char vs; /* Send state variable */ + unsigned char vr; /* Receive state variable */ + unsigned char remote_busy; + unsigned char state; /* Current state of type2 llc procedure */ + int n1; /* Maximum number of bytes in I pdu 7.8.2 */ + int n2; /* Naximum number of retransmissions 7.8.2 */ + unsigned char k; /* Transmit window size 7.8.4, tw in IBM doc*/ + unsigned char rw; /* Receive window size */ + struct + { + /* + * FRMR_RSP info field structure: 5.4.2.3.5 p55 + */ + + unsigned char cntl1; + unsigned char cntl2; + unsigned char vs; + unsigned char vr_cr; + unsigned char xxyz; + } frmr_info_fld; + + /* + * Timers in 7.8.1 page 78 + */ + +#define P_TIMER 0 +#define REJ_TIMER 1 +#define ACK_TIMER 2 +#define BUSY_TIMER 3 + unsigned long timer_expire_time[4]; + unsigned char timer_state[4]; /* The state of each timer */ +#define TIMER_IDLE 0 +#define TIMER_RUNNING 1 +#define TIMER_EXPIRED 2 + unsigned long timer_interval[4]; + struct timer_list tl[4]; + + /* + * Client entry point, called by the LLC. + */ + + void (*llc_event)(struct llc_struct *); + + /* + * Mux and Demux variables + */ + + char * client_data; /* Pointer to clients context */ + unsigned char local_sap; + unsigned char remote_sap ; + char remote_mac[MAX_ADDR_LEN]; /* MAC address of remote session partner */ + struct device *dev; /* Device we are attached to */ + + unsigned char llc_mode; /* See doc 7.1 on p70 */ +#define MODE_ADM 1 +#define MODE_ABM 2 + + int llc_callbacks; /* Pending callbacks */ +#define LLC_CONN_INDICATION 1 /* We have to ensure the names don't */ +#define LLC_CONN_CONFIRM 2 /* mix up with the 802 state table */ +#define LLC_DATA_INDIC 4 +#define LLC_DISC_INDICATION 8 +#define LLC_RESET_INDIC_LOC 16 +#define LLC_RESET_INDIC_REM 32 +#define LLC_RST_CONFIRM 64 +#define LLC_FRMR_RECV 128 +#define LLC_FRMR_SENT 256 +#define LLC_REMOTE_BUSY 512 +#define LLC_REMOTE_NOTBUSY 1024 +#define LLC_TEST_INDICATION 2048 +#define LLC_XID_INDICATION 4096 +#define LLC_UI_DATA 8192 + + struct sk_buff *inc_skb; /* Saved data buffer for indications */ + + struct sk_buff_head rtq; /* Retransmit queue */ + struct sk_buff_head atq; /* Await transit queue */ + + unsigned char xid_count; + + struct llc_struct *nextllc; /* ptr to next llc struct in proto chain */ +}; + +#define ADD_TO_RTQ(skb) skb_queue_tail(&lp->rtq,skb) +#define ADD_TO_ATQ(skb) skb_queue_tail(&lp->atq,skb) + +void llc_cancel_timers(llcptr lp); +int llc_decode_frametype(frameptr fr); +llcptr llc_find(void); +int llc_free_acknowledged_skbs(llcptr lp, unsigned char ack); +void llc_handle_xid_indication( char *chsp, short int ll, char *xid_data); +void llc_interpret_pseudo_code(llcptr lp, int pc_label, struct sk_buff *skb, char type); +void llc_add_to_queue(struct sk_buff *skb, struct sk_buff **f, struct sk_buff **b); +void llc_process_otype2_frame(llcptr lp, struct sk_buff *skb, char type); +struct sk_buff *llc_pull_from_atq(llcptr lp); +int llc_resend_ipdu(llcptr lp, unsigned char ack_nr, unsigned char type, char p); +void llc_sendpdu(llcptr lp, char type, char pf, int data_len, char *pdu_data); +void llc_sendipdu(llcptr lp, char type, char pf, struct sk_buff *skb); +void llc_start_timer(llcptr lp, int t); +void llc_stop_timer(llcptr lp, int t); +void llc_timer_expired(llcptr lp, int t); +int llc_validate_seq_nos(llcptr lp, frameptr fr); + +int llc_data_request(llcptr lp, struct sk_buff *skb); +void llc_unit_data_request(llcptr lp, int ll, char * data); +void llc_disconnect_request(llcptr lp); +void llc_connect_request(llcptr lp); +void llc_xid_request(llcptr lp, char opt, int data_len, char *pdu_data); +void llc_test_request(llcptr lp, int data_len, char *pdu_data); + +int register_cl2llc_client(llcptr llc, const char *device, void (*ops)(llcptr), u8 *rmac, u8 ssap, u8 dsap); +void unregister_cl2llc_client(llcptr lp); +int llc_mac_data_indicate(llcptr lp, struct sk_buff *skb ); + diff --git a/pfinet/linux-src/include/net/llc_frame.h b/pfinet/linux-src/include/net/llc_frame.h new file mode 100644 index 00000000..e8fb198d --- /dev/null +++ b/pfinet/linux-src/include/net/llc_frame.h @@ -0,0 +1,98 @@ +/* if_ether.h needed for definition of ETH_DATA_LEN and ETH_ALEN + */ +#include "linux/if_ether.h" + +/* frame layout based on par3.2 "LLC PDU format" + */ +typedef union { /* pdu layout from pages 40 & 44 */ + struct { /* general header, all pdu types */ + unsigned dsap : 8; /* dest service access point */ + unsigned ssap : 8; /* source service access point */ + unsigned f1 : 1; /* I- U- or S- format id bits */ + unsigned f2 : 1; + unsigned : 6; + unsigned : 8; + } pdu_hdr; + struct { + char dummy1[2]; /* dsap + ssap */ + char byte1; + char byte2; + } pdu_cntl; /* unformatted control bytes */ + struct { /* header of an Information pdu */ + unsigned char dummy2[2]; + unsigned : 1; + unsigned ns : 7; + unsigned i_pflag : 1; /* poll/final bit */ + unsigned nr : 7; /* N(R) */ + unsigned char is_info[ ETH_DATA_LEN ]; + } i_hdr; + struct { /* header of a Supervisory pdu */ + unsigned char dummy3[2]; + unsigned : 2; + unsigned ss : 2; /* supervisory function bits */ + unsigned : 4; + unsigned s_pflag : 1; /* poll/final bit */ + unsigned nr : 7; /* N(R) */ + } s_hdr; + +/* when accessing the P/F bit or the N(R) field there's no need to distinguish + I pdus from S pdus i_pflag and s_pflag / i_nr and s_nr map to the same + physical location. + */ + struct { /* header of an Unnumbered pdu */ + unsigned char dummy4[2]; + unsigned : 2; + unsigned mm1 : 2; /* modifier function part1 */ + unsigned u_pflag : 1; /* P/F for U- pdus */ + unsigned mm2 : 3; /* modifier function part2 */ + unsigned char u_info[ ETH_DATA_LEN-1]; + } u_hdr; + struct { /* mm field in an Unnumbered pdu */ + unsigned char dummy5[2]; + unsigned : 2; + unsigned mm : 6; /* must be masked to get ridd of P/F ! */ + } u_mm; + +} frame_type, *frameptr; + +/* frame format test macros: */ + +#define IS_UFRAME( fr ) ( ( (fr)->pdu_hdr.f1) & ( (fr)->pdu_hdr.f2) ) + +#define IS_IFRAME( fr ) ( !( (fr)->pdu_hdr.f1) ) + +#define IS_SFRAME( fr ) ( ( (fr)->pdu_hdr.f1) & !( (fr)->pdu_hdr.f2) ) + +#define IS_RSP( fr ) ( fr->pdu_hdr.ssap & 0x01 ) + + +/* The transition table, the _encode tables and some tests in the + source code depend on the numeric order of these values. + Think twice before changing. + */ + +/* frame names for TYPE 2 operation: */ +#define I_CMD 0 +#define RR_CMD 1 +#define RNR_CMD 2 +#define REJ_CMD 3 +#define DISC_CMD 4 +#define SABME_CMD 5 +#define I_RSP 6 +#define RR_RSP 7 +#define RNR_RSP 8 +#define REJ_RSP 9 +#define UA_RSP 10 +#define DM_RSP 11 +#define FRMR_RSP 12 + +/* junk frame name: */ +#define BAD_FRAME 13 +#define NO_FRAME 13 + +/* frame names for TYPE 1 operation: */ +#define UI_CMD 14 +#define XID_CMD 15 +#define TEST_CMD 16 +#define XID_RSP 17 +#define TEST_RSP 18 diff --git a/pfinet/linux-src/include/net/llc_name.h b/pfinet/linux-src/include/net/llc_name.h new file mode 100644 index 00000000..72128719 --- /dev/null +++ b/pfinet/linux-src/include/net/llc_name.h @@ -0,0 +1,7 @@ +char *frame_names[] = + {"I_CMD","RR_CMD","RNR_CMD","REJ_CMD","DISC_CMD", + "SABME_CMD","I_RSP","RR_RSP","RNR_RSP","REJ_RSP", + "UA_RSP","DM_RSP","FRMR_RSP","BAD_FRAME","UI_CMD", + "XID_CMD","TEST_CMD","XID_RSP","TEST_RSP" +}; + diff --git a/pfinet/linux-src/include/net/llc_state.h b/pfinet/linux-src/include/net/llc_state.h new file mode 100644 index 00000000..bb18e9bd --- /dev/null +++ b/pfinet/linux-src/include/net/llc_state.h @@ -0,0 +1,4 @@ +char *state_names[] = { + "ADM","CONN","RESET_WAIT","RESET_CHECK","SETUP", + "RESET","D_CONN","ERROR","NORMAL" +}; diff --git a/pfinet/linux-src/include/net/llccall.h b/pfinet/linux-src/include/net/llccall.h new file mode 100644 index 00000000..07013ba3 --- /dev/null +++ b/pfinet/linux-src/include/net/llccall.h @@ -0,0 +1,3 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void llc_init(struct net_proto *pro); + diff --git a/pfinet/linux-src/include/net/ndisc.h b/pfinet/linux-src/include/net/ndisc.h new file mode 100644 index 00000000..7a51f367 --- /dev/null +++ b/pfinet/linux-src/include/net/ndisc.h @@ -0,0 +1,123 @@ +#ifndef _NDISC_H +#define _NDISC_H + +/* + * ICMP codes for neighbour discovery messages + */ + +#define NDISC_ROUTER_SOLICITATION 133 +#define NDISC_ROUTER_ADVERTISEMENT 134 +#define NDISC_NEIGHBOUR_SOLICITATION 135 +#define NDISC_NEIGHBOUR_ADVERTISEMENT 136 +#define NDISC_REDIRECT 137 + +/* + * ndisc options + */ + +#define ND_OPT_SOURCE_LL_ADDR 1 +#define ND_OPT_TARGET_LL_ADDR 2 +#define ND_OPT_PREFIX_INFO 3 +#define ND_OPT_REDIRECT_HDR 4 +#define ND_OPT_MTU 5 + +#define MAX_RTR_SOLICITATION_DELAY HZ + +#define ND_REACHABLE_TIME (30*HZ) +#define ND_RETRANS_TIMER HZ + +#define ND_MIN_RANDOM_FACTOR (1/2) +#define ND_MAX_RANDOM_FACTOR (3/2) + +#ifdef __KERNEL__ + +#include <linux/skbuff.h> +#include <linux/netdevice.h> +#include <linux/icmpv6.h> +#include <net/neighbour.h> +#include <asm/atomic.h> + +extern struct neigh_table nd_tbl; + +struct nd_msg { + struct icmp6hdr icmph; + struct in6_addr target; + struct { + __u8 opt_type; + __u8 opt_len; + __u8 link_addr[MAX_ADDR_LEN]; + } opt; +}; + +struct ra_msg { + struct icmp6hdr icmph; + __u32 reachable_time; + __u32 retrans_timer; +}; + + +extern int ndisc_init(struct net_proto_family *ops); + +extern void ndisc_cleanup(void); + +extern int ndisc_rcv(struct sk_buff *skb, unsigned long len); + +extern void ndisc_send_ns(struct device *dev, + struct neighbour *neigh, + struct in6_addr *solicit, + struct in6_addr *daddr, + struct in6_addr *saddr); + +extern void ndisc_send_rs(struct device *dev, + struct in6_addr *saddr, + struct in6_addr *daddr); + +extern void ndisc_forwarding_on(void); +extern void ndisc_forwarding_off(void); + +extern void ndisc_send_redirect(struct sk_buff *skb, + struct neighbour *neigh, + struct in6_addr *target); + +extern int ndisc_mc_map(struct in6_addr *addr, char *buf, struct device *dev, int dir); + + +struct rt6_info * dflt_rt_lookup(void); + +/* + * IGMP + */ +extern int igmp6_init(struct net_proto_family *ops); + +extern void igmp6_cleanup(void); + +extern int igmp6_event_query(struct sk_buff *skb, + struct icmp6hdr *hdr, + int len); + +extern int igmp6_event_report(struct sk_buff *skb, + struct icmp6hdr *hdr, + int len); + +extern void igmp6_cleanup(void); + +extern __inline__ struct neighbour * ndisc_get_neigh(struct device *dev, struct in6_addr *addr) +{ + + if (dev) { + struct neighbour *neigh; + + start_bh_atomic(); + neigh = __neigh_lookup(&nd_tbl, addr, dev, 1); + end_bh_atomic(); + + return neigh; + } + return NULL; +} + + +#endif /* __KERNEL__ */ + + +#endif diff --git a/pfinet/linux-src/include/net/neighbour.h b/pfinet/linux-src/include/net/neighbour.h new file mode 100644 index 00000000..5c5d90bb --- /dev/null +++ b/pfinet/linux-src/include/net/neighbour.h @@ -0,0 +1,272 @@ +#ifndef _NET_NEIGHBOUR_H +#define _NET_NEIGHBOUR_H + +/* + * Generic neighbour manipulation + * + * Authors: + * Pedro Roque <roque@di.fc.ul.pt> + * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> + */ + +/* The following flags & states are exported to user space, + so that they should be moved to include/linux/ directory. + */ + +/* + * Neighbor Cache Entry Flags + */ + +#define NTF_PROXY 0x08 /* == ATF_PUBL */ +#define NTF_ROUTER 0x80 + +/* + * Neighbor Cache Entry States. + */ + +#define NUD_INCOMPLETE 0x01 +#define NUD_REACHABLE 0x02 +#define NUD_STALE 0x04 +#define NUD_DELAY 0x08 +#define NUD_PROBE 0x10 +#define NUD_FAILED 0x20 + +/* Dummy states */ +#define NUD_NOARP 0x40 +#define NUD_PERMANENT 0x80 +#define NUD_NONE 0x00 + +/* NUD_NOARP & NUD_PERMANENT are pseudostates, they never change + and make no address resolution or NUD. + NUD_PERMANENT is also cannot be deleted by garbage collectors. + */ + +#ifdef __KERNEL__ + +#include <asm/atomic.h> +#include <linux/skbuff.h> + +#define NUD_IN_TIMER (NUD_INCOMPLETE|NUD_DELAY|NUD_PROBE) +#define NUD_VALID (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE|NUD_PROBE|NUD_STALE|NUD_DELAY) +#define NUD_CONNECTED (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE) + +struct neigh_parms +{ + struct neigh_parms *next; + int (*neigh_setup)(struct neighbour *); + struct neigh_table *tbl; + int entries; + void *priv; + + void *sysctl_table; + + int base_reachable_time; + int retrans_time; + int gc_staletime; + int reachable_time; + int delay_probe_time; + + int queue_len; + int ucast_probes; + int app_probes; + int mcast_probes; + int anycast_delay; + int proxy_delay; + int proxy_qlen; + int locktime; +}; + +struct neigh_statistics +{ + unsigned long allocs; + unsigned long res_failed; + unsigned long rcv_probes_mcast; + unsigned long rcv_probes_ucast; +}; + +struct neighbour +{ + struct neighbour *next; + struct neigh_table *tbl; + struct neigh_parms *parms; + struct device *dev; + unsigned long used; + unsigned long confirmed; + unsigned long updated; + __u8 flags; + __u8 nud_state; + __u8 type; + __u8 probes; + unsigned char ha[MAX_ADDR_LEN]; + struct hh_cache *hh; + atomic_t refcnt; + int (*output)(struct sk_buff *skb); + struct sk_buff_head arp_queue; + struct timer_list timer; + struct neigh_ops *ops; + u8 primary_key[0]; +}; + +struct neigh_ops +{ + int family; + void (*destructor)(struct neighbour *); + void (*solicit)(struct neighbour *, struct sk_buff*); + void (*error_report)(struct neighbour *, struct sk_buff*); + int (*output)(struct sk_buff*); + int (*connected_output)(struct sk_buff*); + int (*hh_output)(struct sk_buff*); + int (*queue_xmit)(struct sk_buff*); +}; + +struct pneigh_entry +{ + struct pneigh_entry *next; + struct device *dev; + u8 key[0]; +}; + +#define NEIGH_HASHMASK 0x1F +#define PNEIGH_HASHMASK 0xF + +/* + * neighbour table manipulation + */ + + +struct neigh_table +{ + struct neigh_table *next; + int family; + int entry_size; + int key_len; + int (*constructor)(struct neighbour *); + int (*pconstructor)(struct pneigh_entry *); + void (*pdestructor)(struct pneigh_entry *); + void (*proxy_redo)(struct sk_buff *skb); + struct neigh_parms parms; + /* HACK. gc_* shoul follow parms without a gap! */ + int gc_interval; + int gc_thresh1; + int gc_thresh2; + int gc_thresh3; + unsigned long last_flush; + struct timer_list gc_timer; + struct timer_list proxy_timer; + struct sk_buff_head proxy_queue; + int entries; + atomic_t lock; + unsigned long last_rand; + struct neigh_parms *parms_list; + struct neigh_statistics stats; + struct neighbour *hash_buckets[NEIGH_HASHMASK+1]; + struct pneigh_entry *phash_buckets[PNEIGH_HASHMASK+1]; +}; + +extern void neigh_table_init(struct neigh_table *tbl); +extern int neigh_table_clear(struct neigh_table *tbl); +extern struct neighbour *__neigh_lookup(struct neigh_table *tbl, + const void *pkey, struct device *dev, + int creat); +extern void neigh_destroy(struct neighbour *neigh); +extern int __neigh_event_send(struct neighbour *neigh, struct sk_buff *skb); +extern int neigh_update(struct neighbour *neigh, u8 *lladdr, u8 new, int override, int arp); +extern int neigh_ifdown(struct neigh_table *tbl, struct device *dev); +extern int neigh_resolve_output(struct sk_buff *skb); +extern int neigh_connected_output(struct sk_buff *skb); +extern int neigh_compat_output(struct sk_buff *skb); +extern struct neighbour *neigh_event_ns(struct neigh_table *tbl, + u8 *lladdr, void *saddr, + struct device *dev); + +extern struct neigh_parms *neigh_parms_alloc(struct device *dev, struct neigh_table *tbl); +extern void neigh_parms_release(struct neigh_table *tbl, struct neigh_parms *parms); +extern unsigned long neigh_rand_reach_time(unsigned long base); + +extern void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p, + struct sk_buff *skb); +extern struct pneigh_entry *pneigh_lookup(struct neigh_table *tbl, const void *key, struct device *dev, int creat); +extern int pneigh_delete(struct neigh_table *tbl, const void *key, struct device *dev); + +struct netlink_callback; +struct nlmsghdr; +extern int neigh_dump_info(struct sk_buff *skb, struct netlink_callback *cb); +extern int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg); +extern int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg); +extern void neigh_app_ns(struct neighbour *n); + +extern int neigh_sysctl_register(struct device *dev, struct neigh_parms *p, + int p_id, int pdev_id, char *p_name); +extern void neigh_sysctl_unregister(struct neigh_parms *p); + +/* + * Neighbour references + * + * When neighbour pointers are passed to "client" code the + * reference count is increased. The count is 0 if the node + * is only referenced by the corresponding table. + */ + +extern __inline__ void neigh_release(struct neighbour *neigh) +{ + if (atomic_dec_and_test(&neigh->refcnt) && neigh->tbl == NULL) + neigh_destroy(neigh); +} + +extern __inline__ struct neighbour * neigh_clone(struct neighbour *neigh) +{ + if (neigh) + atomic_inc(&neigh->refcnt); + return neigh; +} + +extern __inline__ void neigh_confirm(struct neighbour *neigh) +{ + if (neigh) + neigh->confirmed = jiffies; +} + +extern __inline__ struct neighbour * +neigh_lookup(struct neigh_table *tbl, const void *pkey, struct device *dev) +{ + struct neighbour *neigh; + start_bh_atomic(); + neigh = __neigh_lookup(tbl, pkey, dev, 0); + end_bh_atomic(); + return neigh; +} + +extern __inline__ int neigh_is_connected(struct neighbour *neigh) +{ + return neigh->nud_state&NUD_CONNECTED; +} + +extern __inline__ int neigh_is_valid(struct neighbour *neigh) +{ + return neigh->nud_state&NUD_VALID; +} + +extern __inline__ int neigh_event_send(struct neighbour *neigh, struct sk_buff *skb) +{ + neigh->used = jiffies; + if (!(neigh->nud_state&(NUD_CONNECTED|NUD_DELAY|NUD_PROBE))) + return __neigh_event_send(neigh, skb); + return 0; +} + +extern __inline__ void neigh_table_lock(struct neigh_table *tbl) +{ + atomic_inc(&tbl->lock); + synchronize_bh(); +} + +extern __inline__ void neigh_table_unlock(struct neigh_table *tbl) +{ + atomic_dec(&tbl->lock); +} + + +#endif +#endif + + diff --git a/pfinet/linux-src/include/net/netbeuicall.h b/pfinet/linux-src/include/net/netbeuicall.h new file mode 100644 index 00000000..5176f82b --- /dev/null +++ b/pfinet/linux-src/include/net/netbeuicall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void netbeui_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/netrom.h b/pfinet/linux-src/include/net/netrom.h new file mode 100644 index 00000000..356a7d27 --- /dev/null +++ b/pfinet/linux-src/include/net/netrom.h @@ -0,0 +1,181 @@ +/* + * Declarations of NET/ROM type objects. + * + * Jonathan Naylor G4KLX 9/4/95 + */ + +#ifndef _NETROM_H +#define _NETROM_H +#include <linux/netrom.h> + +#define NR_NETWORK_LEN 15 +#define NR_TRANSPORT_LEN 5 + +#define NR_PROTO_IP 0x0C + +#define NR_PROTOEXT 0x00 +#define NR_CONNREQ 0x01 +#define NR_CONNACK 0x02 +#define NR_DISCREQ 0x03 +#define NR_DISCACK 0x04 +#define NR_INFO 0x05 +#define NR_INFOACK 0x06 + +#define NR_CHOKE_FLAG 0x80 +#define NR_NAK_FLAG 0x40 +#define NR_MORE_FLAG 0x20 + +/* Define Link State constants. */ +enum { + NR_STATE_0, + NR_STATE_1, + NR_STATE_2, + NR_STATE_3 +}; + +#define NR_COND_ACK_PENDING 0x01 +#define NR_COND_REJECT 0x02 +#define NR_COND_PEER_RX_BUSY 0x04 +#define NR_COND_OWN_RX_BUSY 0x08 + +#define NR_DEFAULT_T1 (120 * HZ) /* Outstanding frames - 120 seconds */ +#define NR_DEFAULT_T2 (5 * HZ) /* Response delay - 5 seconds */ +#define NR_DEFAULT_N2 3 /* Number of Retries - 3 */ +#define NR_DEFAULT_T4 (180 * HZ) /* Busy Delay - 180 seconds */ +#define NR_DEFAULT_IDLE (0 * 60 * HZ) /* No Activity Timeout - none */ +#define NR_DEFAULT_WINDOW 4 /* Default Window Size - 4 */ +#define NR_DEFAULT_OBS 6 /* Default Obsolescence Count - 6 */ +#define NR_DEFAULT_QUAL 10 /* Default Neighbour Quality - 10 */ +#define NR_DEFAULT_TTL 16 /* Default Time To Live - 16 */ +#define NR_DEFAULT_ROUTING 1 /* Is routing enabled ? */ +#define NR_DEFAULT_FAILS 2 /* Link fails until route fails */ + +#define NR_MODULUS 256 +#define NR_MAX_WINDOW_SIZE 127 /* Maximum Window Allowable - 127 */ +#define NR_MAX_PACKET_SIZE 236 /* Maximum Packet Length - 236 */ + +typedef struct { + ax25_address user_addr, source_addr, dest_addr; + struct device *device; + unsigned char my_index, my_id; + unsigned char your_index, your_id; + unsigned char state, condition, bpqext, window; + unsigned short vs, vr, va, vl; + unsigned char n2, n2count; + unsigned long t1, t2, t4, idle; + unsigned short fraglen; + struct timer_list t1timer; + struct timer_list t2timer; + struct timer_list t4timer; + struct timer_list idletimer; + struct sk_buff_head ack_queue; + struct sk_buff_head reseq_queue; + struct sk_buff_head frag_queue; + struct sock *sk; /* Backlink to socket */ +} nr_cb; + +struct nr_neigh { + struct nr_neigh *next; + ax25_address callsign; + ax25_digi *digipeat; + ax25_cb *ax25; + struct device *dev; + unsigned char quality; + unsigned char locked; + unsigned short count; + unsigned int number; + unsigned char failed; +}; + +struct nr_route { + unsigned char quality; + unsigned char obs_count; + struct nr_neigh *neighbour; +}; + +struct nr_node { + struct nr_node *next; + ax25_address callsign; + char mnemonic[7]; + unsigned char which; + unsigned char count; + struct nr_route routes[3]; +}; + +/* af_netrom.c */ +extern int sysctl_netrom_default_path_quality; +extern int sysctl_netrom_obsolescence_count_initialiser; +extern int sysctl_netrom_network_ttl_initialiser; +extern int sysctl_netrom_transport_timeout; +extern int sysctl_netrom_transport_maximum_tries; +extern int sysctl_netrom_transport_acknowledge_delay; +extern int sysctl_netrom_transport_busy_delay; +extern int sysctl_netrom_transport_requested_window_size; +extern int sysctl_netrom_transport_no_activity_timeout; +extern int sysctl_netrom_routing_control; +extern int sysctl_netrom_link_fails_count; +extern int nr_rx_frame(struct sk_buff *, struct device *); +extern void nr_destroy_socket(struct sock *); + +/* nr_dev.c */ +extern int nr_rx_ip(struct sk_buff *, struct device *); +extern int nr_init(struct device *); + +#include <net/nrcall.h> + +/* nr_in.c */ +extern int nr_process_rx_frame(struct sock *, struct sk_buff *); + +/* nr_loopback.c */ +extern void nr_loopback_init(void); +extern void nr_loopback_clear(void); +extern int nr_loopback_queue(struct sk_buff *); + +/* nr_out.c */ +extern void nr_output(struct sock *, struct sk_buff *); +extern void nr_send_nak_frame(struct sock *); +extern void nr_kick(struct sock *); +extern void nr_transmit_buffer(struct sock *, struct sk_buff *); +extern void nr_establish_data_link(struct sock *); +extern void nr_enquiry_response(struct sock *); +extern void nr_check_iframes_acked(struct sock *, unsigned short); + +/* nr_route.c */ +extern void nr_rt_device_down(struct device *); +extern struct device *nr_dev_first(void); +extern struct device *nr_dev_get(ax25_address *); +extern int nr_rt_ioctl(unsigned int, void *); +extern void nr_link_failed(ax25_cb *, int); +extern int nr_route_frame(struct sk_buff *, ax25_cb *); +extern int nr_nodes_get_info(char *, char **, off_t, int, int); +extern int nr_neigh_get_info(char *, char **, off_t, int, int); +extern void nr_rt_free(void); + +/* nr_subr.c */ +extern void nr_clear_queues(struct sock *); +extern void nr_frames_acked(struct sock *, unsigned short); +extern void nr_requeue_frames(struct sock *); +extern int nr_validate_nr(struct sock *, unsigned short); +extern int nr_in_rx_window(struct sock *, unsigned short); +extern void nr_write_internal(struct sock *, int); +extern void nr_transmit_refusal(struct sk_buff *, int); +extern void nr_disconnect(struct sock *, int); + +/* nr_timer.c */ +extern void nr_start_heartbeat(struct sock *); +extern void nr_start_t1timer(struct sock *); +extern void nr_start_t2timer(struct sock *); +extern void nr_start_t4timer(struct sock *); +extern void nr_start_idletimer(struct sock *); +extern void nr_stop_heartbeat(struct sock *); +extern void nr_stop_t1timer(struct sock *); +extern void nr_stop_t2timer(struct sock *); +extern void nr_stop_t4timer(struct sock *); +extern void nr_stop_idletimer(struct sock *); +extern int nr_t1timer_running(struct sock *); + +/* sysctl_net_netrom.c */ +extern void nr_register_sysctl(void); +extern void nr_unregister_sysctl(void); + +#endif diff --git a/pfinet/linux-src/include/net/nrcall.h b/pfinet/linux-src/include/net/nrcall.h new file mode 100644 index 00000000..09ee699d --- /dev/null +++ b/pfinet/linux-src/include/net/nrcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void nr_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/p8022.h b/pfinet/linux-src/include/net/p8022.h new file mode 100644 index 00000000..03d7c3d6 --- /dev/null +++ b/pfinet/linux-src/include/net/p8022.h @@ -0,0 +1,7 @@ +#ifndef _NET_P8022_H +#define _NET_P8022_H + +extern struct datalink_proto *register_8022_client(unsigned char type, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *)); +extern void unregister_8022_client(unsigned char type); + +#endif diff --git a/pfinet/linux-src/include/net/p8022call.h b/pfinet/linux-src/include/net/p8022call.h new file mode 100644 index 00000000..14f0c2ce --- /dev/null +++ b/pfinet/linux-src/include/net/p8022call.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of Space.c simpler */ +extern void p8022_proto_init(struct net_proto *); diff --git a/pfinet/linux-src/include/net/pkt_cls.h b/pfinet/linux-src/include/net/pkt_cls.h new file mode 100644 index 00000000..b8547e60 --- /dev/null +++ b/pfinet/linux-src/include/net/pkt_cls.h @@ -0,0 +1,93 @@ +#ifndef __NET_PKT_CLS_H +#define __NET_PKT_CLS_H + + +#include <linux/pkt_cls.h> + +struct rtattr; +struct tcmsg; + +/* Basic packet classifier frontend definitions. */ + +struct tcf_result +{ + unsigned long class; + u32 classid; +}; + +struct tcf_proto +{ + /* Fast access part */ + struct tcf_proto *next; + void *root; + int (*classify)(struct sk_buff*, struct tcf_proto*, struct tcf_result *); + u32 protocol; + + /* All the rest */ + u32 prio; + u32 classid; + struct Qdisc *q; + void *data; + struct tcf_proto_ops *ops; +}; + +struct tcf_walker +{ + int stop; + int skip; + int count; + int (*fn)(struct tcf_proto *, unsigned long node, struct tcf_walker *); +}; + +struct tcf_proto_ops +{ + struct tcf_proto_ops *next; + char kind[IFNAMSIZ]; + + int (*classify)(struct sk_buff*, struct tcf_proto*, struct tcf_result *); + int (*init)(struct tcf_proto*); + void (*destroy)(struct tcf_proto*); + + unsigned long (*get)(struct tcf_proto*, u32 handle); + void (*put)(struct tcf_proto*, unsigned long); + int (*change)(struct tcf_proto*, unsigned long, u32 handle, struct rtattr **, unsigned long *); + int (*delete)(struct tcf_proto*, unsigned long); + void (*walk)(struct tcf_proto*, struct tcf_walker *arg); + + /* rtnetlink specific */ + int (*dump)(struct tcf_proto*, unsigned long, struct sk_buff *skb, struct tcmsg*); +}; + +/* Main classifier routine: scans classifier chain attached + to this qdisc, (optionally) tests for protocol and asks + specific classifiers. + */ + +extern __inline__ int tc_classify(struct sk_buff *skb, struct tcf_proto *tp, struct tcf_result *res) +{ + int err = 0; + u32 protocol = skb->protocol; + + for ( ; tp; tp = tp->next) { + if ((tp->protocol == protocol || + tp->protocol == __constant_htons(ETH_P_ALL)) && + (err = tp->classify(skb, tp, res)) >= 0) + return err; + } + return -1; +} + +extern __inline__ unsigned long cls_set_class(unsigned long *clp, unsigned long cl) +{ + unsigned long old_cl; + + old_cl = *clp; + *clp = cl; + synchronize_bh(); + return old_cl; +} + +extern int register_tcf_proto_ops(struct tcf_proto_ops *ops); +extern int unregister_tcf_proto_ops(struct tcf_proto_ops *ops); + +#endif diff --git a/pfinet/linux-src/include/net/pkt_sched.h b/pfinet/linux-src/include/net/pkt_sched.h new file mode 100644 index 00000000..9911464f --- /dev/null +++ b/pfinet/linux-src/include/net/pkt_sched.h @@ -0,0 +1,407 @@ +#ifndef __NET_PKT_SCHED_H +#define __NET_PKT_SCHED_H + +#define PSCHED_GETTIMEOFDAY 1 +#define PSCHED_JIFFIES 2 +#define PSCHED_CPU 3 + +#define PSCHED_CLOCK_SOURCE PSCHED_JIFFIES + +#include <linux/pkt_sched.h> +#include <net/pkt_cls.h> + +struct rtattr; +struct Qdisc; + +struct qdisc_walker +{ + int stop; + int skip; + int count; + int (*fn)(struct Qdisc *, unsigned long cl, struct qdisc_walker *); +}; + +struct Qdisc_class_ops +{ + /* Child qdisc manipulation */ + int (*graft)(struct Qdisc *, unsigned long cl, struct Qdisc *, struct Qdisc **); + struct Qdisc * (*leaf)(struct Qdisc *, unsigned long cl); + + /* Class manipulation routines */ + unsigned long (*get)(struct Qdisc *, u32 classid); + void (*put)(struct Qdisc *, unsigned long); + int (*change)(struct Qdisc *, u32, u32, struct rtattr **, unsigned long *); + int (*delete)(struct Qdisc *, unsigned long); + void (*walk)(struct Qdisc *, struct qdisc_walker * arg); + + /* Filter manipulation */ + struct tcf_proto ** (*tcf_chain)(struct Qdisc *, unsigned long); + unsigned long (*bind_tcf)(struct Qdisc *, unsigned long, u32 classid); + void (*unbind_tcf)(struct Qdisc *, unsigned long); + + /* rtnetlink specific */ + int (*dump)(struct Qdisc *, unsigned long, struct sk_buff *skb, struct tcmsg*); +}; + +struct Qdisc_ops +{ + struct Qdisc_ops *next; + struct Qdisc_class_ops *cl_ops; + char id[IFNAMSIZ]; + int priv_size; + + int (*enqueue)(struct sk_buff *, struct Qdisc *); + struct sk_buff * (*dequeue)(struct Qdisc *); + int (*requeue)(struct sk_buff *, struct Qdisc *); + int (*drop)(struct Qdisc *); + + int (*init)(struct Qdisc *, struct rtattr *arg); + void (*reset)(struct Qdisc *); + void (*destroy)(struct Qdisc *); + int (*change)(struct Qdisc *, struct rtattr *arg); + + int (*dump)(struct Qdisc *, struct sk_buff *); +}; + +struct Qdisc_head +{ + struct Qdisc_head *forw; +}; + +extern struct Qdisc_head qdisc_head; + +struct Qdisc +{ + struct Qdisc_head h; + int (*enqueue)(struct sk_buff *skb, struct Qdisc *dev); + struct sk_buff * (*dequeue)(struct Qdisc *dev); + unsigned flags; +#define TCQ_F_BUILTIN 1 +#define TCQ_F_THROTTLED 2 + struct Qdisc_ops *ops; + struct Qdisc *next; + u32 handle; + atomic_t refcnt; + struct sk_buff_head q; + struct device *dev; + + struct tc_stats stats; + unsigned long tx_timeo; + unsigned long tx_last; + int (*reshape_fail)(struct sk_buff *skb, struct Qdisc *q); + + /* This field is deprecated, but it is still used by CBQ + * and it will live until better solution will be invented. + */ + struct Qdisc *__parent; + + char data[0]; +}; + +struct qdisc_rate_table +{ + struct tc_ratespec rate; + u32 data[256]; + struct qdisc_rate_table *next; + int refcnt; +}; + + +/* + Timer resolution MUST BE < 10% of min_schedulable_packet_size/bandwidth + + Normal IP packet size ~ 512byte, hence: + + 0.5Kbyte/1Mbyte/sec = 0.5msec, so that we need 50usec timer for + 10Mbit ethernet. + + 10msec resolution -> <50Kbit/sec. + + The result: [34]86 is not good choice for QoS router :-( + + The things are not so bad, because we may use artifical + clock evaluated by integration of network data flow + in the most critical places. + + Note: we do not use fastgettimeofday. + The reason is that, when it is not the same thing as + gettimeofday, it returns invalid timestamp, which is + not updated, when net_bh is active. + + So, use PSCHED_CLOCK_SOURCE = PSCHED_CPU on alpha and pentiums + with rtdsc. And PSCHED_JIFFIES on all other architectures, including [34]86 + and pentiums without rtdsc. + You can use PSCHED_GETTIMEOFDAY on another architectures, + which have fast and precise clock source, but it is too expensive. + */ + +/* General note about internal clock. + + Any clock source returns time intervals, measured in units + close to 1usec. With source PSCHED_GETTIMEOFDAY it is precisely + microseconds, otherwise something close but different chosen to minimize + arithmetic cost. Ratio usec/internal untis in form nominator/denominator + may be read from /proc/net/psched. + */ + + +#if PSCHED_CLOCK_SOURCE == PSCHED_GETTIMEOFDAY + +typedef struct timeval psched_time_t; +typedef long psched_tdiff_t; + +#define PSCHED_GET_TIME(stamp) do_gettimeofday(&(stamp)) +#define PSCHED_US2JIFFIE(usecs) (((usecs)+(1000000/HZ-1))/(1000000/HZ)) + +#define PSCHED_EXPORTLIST EXPORT_SYMBOL(psched_tod_diff); + +#else /* PSCHED_CLOCK_SOURCE != PSCHED_GETTIMEOFDAY */ + +#define PSCHED_EXPORTLIST PSCHED_EXPORTLIST_1 PSCHED_EXPORTLIST_2 + +typedef u64 psched_time_t; +typedef long psched_tdiff_t; + +extern psched_time_t psched_time_base; + +#if PSCHED_CLOCK_SOURCE == PSCHED_JIFFIES + +#if HZ == 100 +#define PSCHED_JSCALE 13 +#elif HZ == 1024 +#define PSCHED_JSCALE 10 +#else +#define PSCHED_JSCALE 0 +#endif + +#define PSCHED_EXPORTLIST_2 + +#if ~0UL == 0xFFFFFFFF + +#define PSCHED_WATCHER unsigned long + +extern PSCHED_WATCHER psched_time_mark; + +#define PSCHED_GET_TIME(stamp) ((stamp) = psched_time_base + (((unsigned long)(jiffies-psched_time_mark))<<PSCHED_JSCALE)) + +#define PSCHED_EXPORTLIST_1 EXPORT_SYMBOL(psched_time_base); \ + EXPORT_SYMBOL(psched_time_mark); + +#else + +#define PSCHED_GET_TIME(stamp) ((stamp) = (jiffies<<PSCHED_JSCALE)) + +#define PSCHED_EXPORTLIST_1 + +#endif + +#define PSCHED_US2JIFFIE(delay) (((delay)+(1<<PSCHED_JSCALE)-1)>>PSCHED_JSCALE) + +#elif PSCHED_CLOCK_SOURCE == PSCHED_CPU + +extern psched_tdiff_t psched_clock_per_hz; +extern int psched_clock_scale; + +#define PSCHED_EXPORTLIST_2 EXPORT_SYMBOL(psched_clock_per_hz); \ + EXPORT_SYMBOL(psched_clock_scale); + +#define PSCHED_US2JIFFIE(delay) (((delay)+psched_clock_per_hz-1)/psched_clock_per_hz) + +#if CPU == 586 || CPU == 686 + +#define PSCHED_GET_TIME(stamp) \ +({ u64 __cur; \ + __asm__ __volatile__ (".byte 0x0f,0x31" :"=A" (__cur)); \ + (stamp) = __cur>>psched_clock_scale; \ +}) + +#define PSCHED_EXPORTLIST_1 + +#elif defined (__alpha__) + +#define PSCHED_WATCHER u32 + +extern PSCHED_WATCHER psched_time_mark; + +#define PSCHED_GET_TIME(stamp) \ +({ u32 __res; \ + __asm__ __volatile__ ("rpcc %0" : "r="(__res)); \ + if (__res <= psched_time_mark) psched_time_base += 0x100000000UL; \ + psched_time_mark = __res; \ + (stamp) = (psched_time_base + __res)>>psched_clock_scale; \ +}) + +#define PSCHED_EXPORTLIST_1 EXPORT_SYMBOL(psched_time_base); \ + EXPORT_SYMBOL(psched_time_mark); + +#else + +#error PSCHED_CLOCK_SOURCE=PSCHED_CPU is not supported on this arch. + +#endif /* ARCH */ + +#endif /* PSCHED_CLOCK_SOURCE == PSCHED_JIFFIES */ + +#endif /* PSCHED_CLOCK_SOURCE == PSCHED_GETTIMEOFDAY */ + +#if PSCHED_CLOCK_SOURCE == PSCHED_GETTIMEOFDAY +#define PSCHED_TDIFF(tv1, tv2) \ +({ \ + int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; \ + int __delta = (tv1).tv_usec - (tv2).tv_usec; \ + if (__delta_sec) { \ + switch (__delta_sec) { \ + default: \ + __delta = 0; \ + case 2: \ + __delta += 1000000; \ + case 1: \ + __delta += 1000000; \ + } \ + } \ + __delta; \ +}) + +extern int psched_tod_diff(int delta_sec, int bound); + +#define PSCHED_TDIFF_SAFE(tv1, tv2, bound, guard) \ +({ \ + int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; \ + int __delta = (tv1).tv_usec - (tv2).tv_usec; \ + switch (__delta_sec) { \ + default: \ + __delta = psched_tod_diff(__delta_sec, bound); guard; break; \ + case 2: \ + __delta += 1000000; \ + case 1: \ + __delta += 1000000; \ + case 0: ; \ + } \ + __delta; \ +}) + +#define PSCHED_TLESS(tv1, tv2) (((tv1).tv_usec < (tv2).tv_usec && \ + (tv1).tv_sec <= (tv2).tv_sec) || \ + (tv1).tv_sec < (tv2).tv_sec) + +#define PSCHED_TADD2(tv, delta, tv_res) \ +({ \ + int __delta = (tv).tv_usec + (delta); \ + (tv_res).tv_sec = (tv).tv_sec; \ + if (__delta > 1000000) { (tv_res).tv_sec++; __delta -= 1000000; } \ + (tv_res).tv_usec = __delta; \ +}) + +#define PSCHED_TADD(tv, delta) \ +({ \ + (tv).tv_usec += (delta); \ + if ((tv).tv_usec > 1000000) { (tv).tv_sec++; \ + (tv).tv_usec -= 1000000; } \ +}) + +/* Set/check that time is in the "past perfect"; + it depends on concrete representation of system time + */ + +#define PSCHED_SET_PASTPERFECT(t) ((t).tv_sec = 0) +#define PSCHED_IS_PASTPERFECT(t) ((t).tv_sec == 0) + +#define PSCHED_AUDIT_TDIFF(t) ({ if ((t) > 2000000) (t) = 2000000; }) + +#else + +#define PSCHED_TDIFF(tv1, tv2) (long)((tv1) - (tv2)) +#define PSCHED_TDIFF_SAFE(tv1, tv2, bound, guard) \ +({ \ + long __delta = (tv1) - (tv2); \ + if ( __delta > (bound)) { __delta = (bound); guard; } \ + __delta; \ +}) + + +#define PSCHED_TLESS(tv1, tv2) ((tv1) < (tv2)) +#define PSCHED_TADD2(tv, delta, tv_res) ((tv_res) = (tv) + (delta)) +#define PSCHED_TADD(tv, delta) ((tv) += (delta)) +#define PSCHED_SET_PASTPERFECT(t) ((t) = 0) +#define PSCHED_IS_PASTPERFECT(t) ((t) == 0) +#define PSCHED_AUDIT_TDIFF(t) + +#endif + +struct tcf_police +{ + struct tcf_police *next; + int refcnt; + u32 index; + + int action; + int result; + u32 ewma_rate; + u32 burst; + u32 mtu; + + u32 toks; + u32 ptoks; + psched_time_t t_c; + struct qdisc_rate_table *R_tab; + struct qdisc_rate_table *P_tab; + + struct tc_stats stats; +}; + +extern void tcf_police_destroy(struct tcf_police *p); +extern struct tcf_police * tcf_police_locate(struct rtattr *rta, struct rtattr *est); +extern int tcf_police_dump(struct sk_buff *skb, struct tcf_police *p); +extern int tcf_police(struct sk_buff *skb, struct tcf_police *p); + +extern __inline__ void tcf_police_release(struct tcf_police *p) +{ + if (p && --p->refcnt == 0) + tcf_police_destroy(p); +} + +extern struct Qdisc noop_qdisc; +extern struct Qdisc_ops noop_qdisc_ops; +extern struct Qdisc_ops pfifo_qdisc_ops; +extern struct Qdisc_ops bfifo_qdisc_ops; + +int register_qdisc(struct Qdisc_ops *qops); +int unregister_qdisc(struct Qdisc_ops *qops); +struct Qdisc *qdisc_lookup(struct device *dev, u32 handle); +struct Qdisc *qdisc_lookup_class(struct device *dev, u32 handle); +void dev_init_scheduler(struct device *dev); +void dev_shutdown(struct device *dev); +void dev_activate(struct device *dev); +void dev_deactivate(struct device *dev); +void qdisc_reset(struct Qdisc *qdisc); +void qdisc_destroy(struct Qdisc *qdisc); +struct Qdisc * qdisc_create_dflt(struct device *dev, struct Qdisc_ops *ops); +int qdisc_new_estimator(struct tc_stats *stats, struct rtattr *opt); +void qdisc_kill_estimator(struct tc_stats *stats); +struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct rtattr *tab); +void qdisc_put_rtab(struct qdisc_rate_table *tab); +int teql_init(void); +int tc_filter_init(void); +int pktsched_init(void); + +void qdisc_run_queues(void); +int qdisc_restart(struct device *dev); + +extern __inline__ void qdisc_wakeup(struct device *dev) +{ + if (!dev->tbusy) { + struct Qdisc *q = dev->qdisc; + if (qdisc_restart(dev) && q->h.forw == NULL) { + q->h.forw = qdisc_head.forw; + qdisc_head.forw = &q->h; + } + } +} + +extern __inline__ unsigned psched_mtu(struct device *dev) +{ + unsigned mtu = dev->mtu; + return dev->hard_header ? mtu + dev->hard_header_len : mtu; +} + +#endif diff --git a/pfinet/linux-src/include/net/profile.h b/pfinet/linux-src/include/net/profile.h new file mode 100644 index 00000000..82fad0a3 --- /dev/null +++ b/pfinet/linux-src/include/net/profile.h @@ -0,0 +1,311 @@ +#include <linux/config.h> /* for CONFIG_NET_PROFILE */ +#ifndef _NET_PROFILE_H_ +#define _NET_PROFILE_H_ 1 + +#ifdef CONFIG_NET_PROFILE + +#include <linux/types.h> +#include <linux/time.h> +#include <linux/kernel.h> +#include <asm/system.h> + +struct net_profile_slot +{ + char id[16]; + struct net_profile_slot *next; + struct timeval entered; + struct timeval accumulator; + struct timeval irq; + int hits; + int active; + int underflow; +}; + +extern atomic_t net_profile_active; +extern struct timeval net_profile_adjust; +extern void net_profile_irq_adjust(struct timeval *entered, struct timeval* leaved); + +#if CPU == 586 || CPU == 686 + + +extern __inline__ void net_profile_stamp(struct timeval *pstamp) +{ + __asm__ __volatile__ (".byte 0x0f,0x31" + :"=a" (pstamp->tv_usec), + "=d" (pstamp->tv_sec)); +} + +extern __inline__ void net_profile_accumulate(struct timeval *entered, + struct timeval *leaved, + struct timeval *acc) +{ + __asm__ __volatile__ ("subl %2,%0\n\t" + "sbbl %3,%1\n\t" + "addl %4,%0\n\t" + "adcl %5,%1\n\t" + "subl " SYMBOL_NAME_STR(net_profile_adjust) "+4,%0\n\t" + "sbbl $0,%1\n\t" + : "=r" (acc->tv_usec), "=r" (acc->tv_sec) + : "g" (entered->tv_usec), "g" (entered->tv_sec), + "g" (leaved->tv_usec), "g" (leaved->tv_sec), + "0" (acc->tv_usec), "1" (acc->tv_sec)); +} + +extern __inline__ void net_profile_sub(struct timeval *sub, + struct timeval *acc) +{ + __asm__ __volatile__ ("subl %2,%0\n\t" + "sbbl %3,%1\n\t" + : "=r" (acc->tv_usec), "=r" (acc->tv_sec) + : "g" (sub->tv_usec), "g" (sub->tv_sec), + "0" (acc->tv_usec), "1" (acc->tv_sec)); +} + +extern __inline__ void net_profile_add(struct timeval *add, + struct timeval *acc) +{ + __asm__ __volatile__ ("addl %2,%0\n\t" + "adcl %3,%1\n\t" + : "=r" (acc->tv_usec), "=r" (acc->tv_sec) + : "g" (add->tv_usec), "g" (add->tv_sec), + "0" (acc->tv_usec), "1" (acc->tv_sec)); +} + + +#elif defined (__alpha__) + +extern __u32 alpha_lo; +extern long alpha_hi; + +/* On alpha cycle counter has only 32 bits :-( :-( */ + +extern __inline__ void net_profile_stamp(struct timeval *pstamp) +{ + __u32 result; + __asm__ __volatile__ ("rpcc %0" : "r="(result)); + if (result <= alpha_lo) + alpha_hi++; + alpha_lo = result; + pstamp->tv_sec = alpha_hi; + pstamp->tv_usec = alpha_lo; +} + +extern __inline__ void net_profile_accumulate(struct timeval *entered, + struct timeval *leaved, + struct timeval *acc) +{ + time_t usecs = acc->tv_usec + leaved->tv_usec - entered->tv_usec + - net_profile_adjust.tv_usec; + time_t secs = acc->tv_sec + leaved->tv_sec - entered->tv_sec; + + if (usecs >= 0x100000000L) { + usecs -= 0x100000000L; + secs++; + } else if (usecs < -0x100000000L) { + usecs += 0x200000000L; + secs -= 2; + } else if (usecs < 0) { + usecs += 0x100000000L; + secs--; + } + acc->tv_sec = secs; + acc->tv_usec = usecs; +} + +extern __inline__ void net_profile_sub(struct timeval *entered, + struct timeval *leaved) +{ + time_t usecs = leaved->tv_usec - entered->tv_usec; + time_t secs = leaved->tv_sec - entered->tv_sec; + + if (usecs < 0) { + usecs += 0x100000000L; + secs--; + } + leaved->tv_sec = secs; + leaved->tv_usec = usecs; +} + +extern __inline__ void net_profile_add(struct timeval *entered, struct timeval *leaved) +{ + time_t usecs = leaved->tv_usec + entered->tv_usec; + time_t secs = leaved->tv_sec + entered->tv_sec; + + if (usecs >= 0x100000000L) { + usecs -= 0x100000000L; + secs++; + } + leaved->tv_sec = secs; + leaved->tv_usec = usecs; +} + + +#else + +extern __inline__ void net_profile_stamp(struct timeval *pstamp) +{ + /* Not "fast" counterpart! On architectures without + cpu clock "fast" routine is absolutely useless in this + situation. do_gettimeofday still says something on slow-slow-slow + boxes, though it eats more cpu time than the sobject of + investigation :-) :-) + */ + do_gettimeofday(pstamp); +} + +extern __inline__ void net_profile_accumulate(struct timeval *entered, + struct timeval *leaved, + struct timeval *acc) +{ + time_t usecs = acc->tv_usec + leaved->tv_usec - entered->tv_usec + - net_profile_adjust.tv_usec; + time_t secs = acc->tv_sec + leaved->tv_sec - entered->tv_sec; + + if (usecs >= 1000000) { + usecs -= 1000000; + secs++; + } else if (usecs < -1000000) { + usecs += 2000000; + secs -= 2; + } else if (usecs < 0) { + usecs += 1000000; + secs--; + } + acc->tv_sec = secs; + acc->tv_usec = usecs; +} + +extern __inline__ void net_profile_sub(struct timeval *entered, + struct timeval *leaved) +{ + time_t usecs = leaved->tv_usec - entered->tv_usec; + time_t secs = leaved->tv_sec - entered->tv_sec; + + if (usecs < 0) { + usecs += 1000000; + secs--; + } + leaved->tv_sec = secs; + leaved->tv_usec = usecs; +} + +extern __inline__ void net_profile_add(struct timeval *entered, struct timeval *leaved) +{ + time_t usecs = leaved->tv_usec + entered->tv_usec; + time_t secs = leaved->tv_sec + entered->tv_sec; + + if (usecs >= 1000000) { + usecs -= 1000000; + secs++; + } + leaved->tv_sec = secs; + leaved->tv_usec = usecs; +} + + + +#endif + +extern __inline__ void net_profile_enter(struct net_profile_slot *s) +{ + unsigned long flags; + + save_flags(flags); + cli(); + if (s->active++ == 0) { + net_profile_stamp(&s->entered); + atomic_inc(&net_profile_active); + } + restore_flags(flags); +} + +extern __inline__ void net_profile_leave_irq(struct net_profile_slot *s) +{ + unsigned long flags; + + save_flags(flags); + cli(); + if (--s->active <= 0) { + if (s->active == 0) { + struct timeval curr_pstamp; + net_profile_stamp(&curr_pstamp); + net_profile_accumulate(&s->entered, &curr_pstamp, &s->accumulator); + if (!atomic_dec_and_test(&net_profile_active)) + net_profile_irq_adjust(&s->entered, &curr_pstamp); + } else { + s->underflow++; + } + } + s->hits++; + restore_flags(flags); +} + +extern __inline__ void net_profile_leave(struct net_profile_slot *s) +{ + unsigned long flags; + save_flags(flags); + cli(); + if (--s->active <= 0) { + if (s->active == 0) { + struct timeval curr_pstamp; + net_profile_stamp(&curr_pstamp); + net_profile_accumulate(&s->entered, &curr_pstamp, &s->accumulator); + atomic_dec(&net_profile_active); + } else { + s->underflow++; + } + } + s->hits++; + restore_flags(flags); +} + + +#define NET_PROFILE_ENTER(slot) net_profile_enter(&net_prof_##slot) +#define NET_PROFILE_LEAVE(slot) net_profile_leave(&net_prof_##slot) +#define NET_PROFILE_LEAVE_IRQ(slot) net_profile_leave_irq(&net_prof_##slot) + +#define NET_PROFILE_SKB_CLEAR(skb) ({ \ + skb->pstamp.tv_usec = 0; \ +}) + +#define NET_PROFILE_SKB_INIT(skb) ({ \ + net_profile_stamp(&skb->pstamp); \ +}) + +#define NET_PROFILE_SKB_PASSED(skb, slot) ({ \ + if (skb->pstamp.tv_usec) { \ + struct timeval cur_pstamp = skb->pstamp; \ + net_profile_stamp(&skb->pstamp); \ + net_profile_accumulate(&cur_pstamp, &skb->pstamp, &net_prof_##slot.accumulator); \ + net_prof_##slot.hits++; \ + }}) + +#define NET_PROFILE_DECL(slot) \ + extern struct net_profile_slot net_prof_##slot; + +#define NET_PROFILE_DEFINE(slot) \ + struct net_profile_slot net_prof_##slot = { #slot, }; + +#define NET_PROFILE_REGISTER(slot) net_profile_register(&net_prof_##slot) +#define NET_PROFILE_UNREGISTER(slot) net_profile_unregister(&net_prof_##slot) + +extern int net_profile_init(void); +extern int net_profile_register(struct net_profile_slot *); +extern int net_profile_unregister(struct net_profile_slot *); + +#else + +#define NET_PROFILE_ENTER(slot) do { /* nothing */ } while(0) +#define NET_PROFILE_LEAVE(slot) do { /* nothing */ } while(0) +#define NET_PROFILE_LEAVE_IRQ(slot) do { /* nothing */ } while(0) +#define NET_PROFILE_SKB_CLEAR(skb) do { /* nothing */ } while(0) +#define NET_PROFILE_SKB_INIT(skb) do { /* nothing */ } while(0) +#define NET_PROFILE_SKB_PASSED(skb, slot) do { /* nothing */ } while(0) +#define NET_PROFILE_DECL(slot) +#define NET_PROFILE_DEFINE(slot) +#define NET_PROFILE_REGISTER(slot) do { /* nothing */ } while(0) +#define NET_PROFILE_UNREGISTER(slot) do { /* nothing */ } while(0) + +#endif + +#endif diff --git a/pfinet/linux-src/include/net/protocol.h b/pfinet/linux-src/include/net/protocol.h new file mode 100644 index 00000000..f6e947b1 --- /dev/null +++ b/pfinet/linux-src/include/net/protocol.h @@ -0,0 +1,82 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the protocol dispatcher. + * + * Version: @(#)protocol.h 1.0.2 05/07/93 + * + * Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * + * 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. + * + * Changes: + * Alan Cox : Added a name field and a frag handler + * field for later. + * Alan Cox : Cleaned up, and sorted types. + * Pedro Roque : inet6 protocols + */ + +#ifndef _PROTOCOL_H +#define _PROTOCOL_H + +#include <linux/config.h> +#include <linux/in6.h> +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +#include <linux/ipv6.h> +#endif + +#define MAX_INET_PROTOS 32 /* Must be a power of 2 */ + + +/* This is used to register protocols. */ +struct inet_protocol +{ + int (*handler)(struct sk_buff *skb, unsigned short len); + void (*err_handler)(struct sk_buff *skb, unsigned char *dp, int len); + struct inet_protocol *next; + unsigned char protocol; + unsigned char copy:1; + void *data; + const char *name; +}; + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +struct inet6_protocol +{ + int (*handler)(struct sk_buff *skb, + unsigned long len); + + void (*err_handler)(struct sk_buff *skb, struct ipv6hdr *hdr, + struct inet6_skb_parm *opt, + int type, int code, unsigned char *buff, + __u32 info); + struct inet6_protocol *next; + unsigned char protocol; + unsigned char copy:1; + void *data; + const char *name; +}; +#endif + +extern struct inet_protocol *inet_protocol_base; +extern struct inet_protocol *inet_protos[MAX_INET_PROTOS]; + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +extern struct inet6_protocol *inet6_protocol_base; +extern struct inet6_protocol *inet6_protos[MAX_INET_PROTOS]; +#endif + +extern void inet_add_protocol(struct inet_protocol *prot); +extern int inet_del_protocol(struct inet_protocol *prot); + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +extern void inet6_add_protocol(struct inet6_protocol *prot); +extern int inet6_del_protocol(struct inet6_protocol *prot); +#endif + +#endif /* _PROTOCOL_H */ diff --git a/pfinet/linux-src/include/net/psnap.h b/pfinet/linux-src/include/net/psnap.h new file mode 100644 index 00000000..49a68f7e --- /dev/null +++ b/pfinet/linux-src/include/net/psnap.h @@ -0,0 +1,7 @@ +#ifndef _NET_PSNAP_H +#define _NET_PSNAP_H + +extern struct datalink_proto *register_snap_client(unsigned char *desc, int (*rcvfunc)(struct sk_buff *, struct device *, struct packet_type *)); +extern void unregister_snap_client(unsigned char *desc); + +#endif diff --git a/pfinet/linux-src/include/net/psnapcall.h b/pfinet/linux-src/include/net/psnapcall.h new file mode 100644 index 00000000..9da5763c --- /dev/null +++ b/pfinet/linux-src/include/net/psnapcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of Space.c simpler */ +extern void snap_proto_init(struct net_proto *); diff --git a/pfinet/linux-src/include/net/rarp.h b/pfinet/linux-src/include/net/rarp.h new file mode 100644 index 00000000..7bfb08ef --- /dev/null +++ b/pfinet/linux-src/include/net/rarp.h @@ -0,0 +1,12 @@ +/* linux/net/inet/rarp.h */ +#ifndef _RARP_H +#define _RARP_H + +extern int rarp_ioctl(unsigned int cmd, void *arg); +extern int rarp_get_info(char *buffer, + char **start, + off_t offset, + int length, + int dummy); +#endif /* _RARP_H */ + diff --git a/pfinet/linux-src/include/net/raw.h b/pfinet/linux-src/include/net/raw.h new file mode 100644 index 00000000..4d2e6e98 --- /dev/null +++ b/pfinet/linux-src/include/net/raw.h @@ -0,0 +1,38 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the RAW-IP module. + * + * Version: @(#)raw.h 1.0.2 05/07/93 + * + * Author: Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * + * 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. + */ +#ifndef _RAW_H +#define _RAW_H + + +extern struct proto raw_prot; + + +extern void raw_err(struct sock *, struct sk_buff *); +extern int raw_rcv(struct sock *, struct sk_buff *); + +/* Note: v4 ICMP wants to get at this stuff, if you change the + * hashing mechanism, make sure you update icmp.c as well. + */ +#define RAWV4_HTABLE_SIZE MAX_INET_PROTOS +extern struct sock *raw_v4_htable[RAWV4_HTABLE_SIZE]; + + +extern struct sock *raw_v4_lookup(struct sock *sk, unsigned short num, + unsigned long raddr, unsigned long laddr, + int dif); + +#endif /* _RAW_H */ diff --git a/pfinet/linux-src/include/net/rawv6.h b/pfinet/linux-src/include/net/rawv6.h new file mode 100644 index 00000000..d54572d1 --- /dev/null +++ b/pfinet/linux-src/include/net/rawv6.h @@ -0,0 +1,27 @@ +#ifndef _NET_RAWV6_H +#define _NET_RAWV6_H + +#ifdef __KERNEL__ + +#define RAWV6_HTABLE_SIZE MAX_INET_PROTOS +extern struct sock *raw_v6_htable[RAWV6_HTABLE_SIZE]; + + +extern struct sock *raw_v6_lookup(struct sock *sk, unsigned short num, + struct in6_addr *loc_addr, struct in6_addr *rmt_addr); + +extern int rawv6_rcv(struct sock *sk, + struct sk_buff *skb, + unsigned long len); + + +extern void rawv6_err(struct sock *sk, + struct sk_buff *skb, + struct ipv6hdr *hdr, + struct inet6_skb_parm *opt, + int type, int code, + unsigned char *buff, u32 info); + +#endif + +#endif diff --git a/pfinet/linux-src/include/net/rose.h b/pfinet/linux-src/include/net/rose.h new file mode 100644 index 00000000..1c8684d2 --- /dev/null +++ b/pfinet/linux-src/include/net/rose.h @@ -0,0 +1,241 @@ +/* + * Declarations of Rose type objects. + * + * Jonathan Naylor G4KLX 25/8/96 + */ + +#ifndef _ROSE_H +#define _ROSE_H +#include <linux/rose.h> + +#define ROSE_ADDR_LEN 5 + +#define ROSE_MIN_LEN 3 + +#define ROSE_GFI 0x10 +#define ROSE_Q_BIT 0x80 +#define ROSE_D_BIT 0x40 +#define ROSE_M_BIT 0x10 + +#define ROSE_CALL_REQUEST 0x0B +#define ROSE_CALL_ACCEPTED 0x0F +#define ROSE_CLEAR_REQUEST 0x13 +#define ROSE_CLEAR_CONFIRMATION 0x17 +#define ROSE_DATA 0x00 +#define ROSE_INTERRUPT 0x23 +#define ROSE_INTERRUPT_CONFIRMATION 0x27 +#define ROSE_RR 0x01 +#define ROSE_RNR 0x05 +#define ROSE_REJ 0x09 +#define ROSE_RESET_REQUEST 0x1B +#define ROSE_RESET_CONFIRMATION 0x1F +#define ROSE_REGISTRATION_REQUEST 0xF3 +#define ROSE_REGISTRATION_CONFIRMATION 0xF7 +#define ROSE_RESTART_REQUEST 0xFB +#define ROSE_RESTART_CONFIRMATION 0xFF +#define ROSE_DIAGNOSTIC 0xF1 +#define ROSE_ILLEGAL 0xFD + +/* Define Link State constants. */ + +enum { + ROSE_STATE_0, /* Ready */ + ROSE_STATE_1, /* Awaiting Call Accepted */ + ROSE_STATE_2, /* Awaiting Clear Confirmation */ + ROSE_STATE_3, /* Data Transfer */ + ROSE_STATE_4, /* Awaiting Reset Confirmation */ + ROSE_STATE_5 /* Deferred Call Acceptance */ +}; + +#define ROSE_DEFAULT_T0 (180 * HZ) /* Default T10 T20 value */ +#define ROSE_DEFAULT_T1 (200 * HZ) /* Default T11 T21 value */ +#define ROSE_DEFAULT_T2 (180 * HZ) /* Default T12 T22 value */ +#define ROSE_DEFAULT_T3 (180 * HZ) /* Default T13 T23 value */ +#define ROSE_DEFAULT_HB (5 * HZ) /* Default Holdback value */ +#define ROSE_DEFAULT_IDLE (0 * 60 * HZ) /* No Activity Timeout - none */ +#define ROSE_DEFAULT_ROUTING 1 /* Default routing flag */ +#define ROSE_DEFAULT_FAIL_TIMEOUT (120 * HZ) /* Time until link considered usable */ +#define ROSE_DEFAULT_MAXVC 50 /* Maximum number of VCs per neighbour */ +#define ROSE_DEFAULT_WINDOW_SIZE 7 /* Default window size */ + +#define ROSE_MODULUS 8 +#define ROSE_MAX_PACKET_SIZE 251 /* Maximum packet size */ + +#define ROSE_COND_ACK_PENDING 0x01 +#define ROSE_COND_PEER_RX_BUSY 0x02 +#define ROSE_COND_OWN_RX_BUSY 0x04 + +#define FAC_NATIONAL 0x00 +#define FAC_CCITT 0x0F + +#define FAC_NATIONAL_RAND 0x7F +#define FAC_NATIONAL_FLAGS 0x3F +#define FAC_NATIONAL_DEST_DIGI 0xE9 +#define FAC_NATIONAL_SRC_DIGI 0xEB +#define FAC_NATIONAL_FAIL_CALL 0xED +#define FAC_NATIONAL_FAIL_ADD 0xEE +#define FAC_NATIONAL_DIGIS 0xEF + +#define FAC_CCITT_DEST_NSAP 0xC9 +#define FAC_CCITT_SRC_NSAP 0xCB + +struct rose_neigh { + struct rose_neigh *next; + ax25_address callsign; + ax25_digi *digipeat; + ax25_cb *ax25; + struct device *dev; + unsigned short count; + unsigned short use; + unsigned int number; + char restarted; + char dce_mode; + char loopback; + struct sk_buff_head queue; + struct timer_list t0timer; + struct timer_list ftimer; +}; + +struct rose_node { + struct rose_node *next; + rose_address address; + unsigned short mask; + unsigned char count; + char loopback; + struct rose_neigh *neighbour[3]; +}; + +struct rose_route { + struct rose_route *next; + unsigned int lci1, lci2; + rose_address src_addr, dest_addr; + ax25_address src_call, dest_call; + struct rose_neigh *neigh1, *neigh2; + unsigned int rand; +}; + +typedef struct { + rose_address source_addr, dest_addr; + ax25_address source_call, dest_call; + unsigned char source_ndigis, dest_ndigis; + ax25_address source_digis[ROSE_MAX_DIGIS]; + ax25_address dest_digis[ROSE_MAX_DIGIS]; + struct rose_neigh *neighbour; + struct device *device; + unsigned int lci, rand; + unsigned char state, condition, qbitincl, defer; + unsigned char cause, diagnostic; + unsigned short vs, vr, va, vl; + unsigned long t1, t2, t3, hb, idle; +#ifdef M_BIT + unsigned short fraglen; + struct sk_buff_head frag_queue; +#endif + struct sk_buff_head ack_queue; + struct rose_facilities_struct facilities; + struct timer_list timer; + struct timer_list idletimer; + struct sock *sk; /* Backlink to socket */ +} rose_cb; + +/* af_rose.c */ +extern ax25_address rose_callsign; +extern int sysctl_rose_restart_request_timeout; +extern int sysctl_rose_call_request_timeout; +extern int sysctl_rose_reset_request_timeout; +extern int sysctl_rose_clear_request_timeout; +extern int sysctl_rose_no_activity_timeout; +extern int sysctl_rose_ack_hold_back_timeout; +extern int sysctl_rose_routing_control; +extern int sysctl_rose_link_fail_timeout; +extern int sysctl_rose_maximum_vcs; +extern int sysctl_rose_window_size; +extern int rosecmp(rose_address *, rose_address *); +extern int rosecmpm(rose_address *, rose_address *, unsigned short); +extern char *rose2asc(rose_address *); +extern struct sock *rose_find_socket(unsigned int, struct rose_neigh *); +extern void rose_kill_by_neigh(struct rose_neigh *); +extern unsigned int rose_new_lci(struct rose_neigh *); +extern int rose_rx_call_request(struct sk_buff *, struct device *, struct rose_neigh *, unsigned int); +extern void rose_destroy_socket(struct sock *); + +/* rose_dev.c */ +extern int rose_rx_ip(struct sk_buff *, struct device *); +extern int rose_init(struct device *); + +#include <net/rosecall.h> + +/* rose_in.c */ +extern int rose_process_rx_frame(struct sock *, struct sk_buff *); + +/* rose_link.c */ +extern void rose_start_ftimer(struct rose_neigh *); +extern void rose_start_t0timer(struct rose_neigh *); +extern void rose_stop_ftimer(struct rose_neigh *); +extern void rose_stop_t0timer(struct rose_neigh *); +extern int rose_ftimer_running(struct rose_neigh *); +extern int rose_t0timer_running(struct rose_neigh *); +extern void rose_link_rx_restart(struct sk_buff *, struct rose_neigh *, unsigned short); +extern void rose_transmit_restart_request(struct rose_neigh *); +extern void rose_transmit_restart_confirmation(struct rose_neigh *); +extern void rose_transmit_diagnostic(struct rose_neigh *, unsigned char); +extern void rose_transmit_clear_request(struct rose_neigh *, unsigned int, unsigned char, unsigned char); +extern void rose_transmit_link(struct sk_buff *, struct rose_neigh *); + +/* rose_loopback.c */ +extern void rose_loopback_init(void); +extern void rose_loopback_clear(void); +extern int rose_loopback_queue(struct sk_buff *, struct rose_neigh *); + +/* rose_out.c */ +extern void rose_kick(struct sock *); +extern void rose_enquiry_response(struct sock *); + +/* rose_route.c */ +extern struct rose_neigh *rose_loopback_neigh; + +extern int rose_add_loopback_neigh(void); +extern int rose_add_loopback_node(rose_address *); +extern void rose_del_loopback_node(rose_address *); +extern void rose_rt_device_down(struct device *); +extern void rose_link_device_down(struct device *); +extern struct device *rose_dev_first(void); +extern struct device *rose_dev_get(rose_address *); +extern struct rose_route *rose_route_free_lci(unsigned int, struct rose_neigh *); +extern struct device *rose_ax25_dev_get(char *); +extern struct rose_neigh *rose_get_neigh(rose_address *, unsigned char *, unsigned char *); +extern int rose_rt_ioctl(unsigned int, void *); +extern void rose_link_failed(ax25_cb *, int); +extern int rose_route_frame(struct sk_buff *, ax25_cb *); +extern int rose_nodes_get_info(char *, char **, off_t, int, int); +extern int rose_neigh_get_info(char *, char **, off_t, int, int); +extern int rose_routes_get_info(char *, char **, off_t, int, int); +extern void rose_rt_free(void); + +/* rose_subr.c */ +extern void rose_clear_queues(struct sock *); +extern void rose_frames_acked(struct sock *, unsigned short); +extern void rose_requeue_frames(struct sock *); +extern int rose_validate_nr(struct sock *, unsigned short); +extern void rose_write_internal(struct sock *, int); +extern int rose_decode(struct sk_buff *, int *, int *, int *, int *, int *); +extern int rose_parse_facilities(unsigned char *, struct rose_facilities_struct *); +extern int rose_create_facilities(unsigned char *, rose_cb *); +extern void rose_disconnect(struct sock *, int, int, int); + +/* rose_timer.c */ +extern void rose_start_heartbeat(struct sock *); +extern void rose_start_t1timer(struct sock *); +extern void rose_start_t2timer(struct sock *); +extern void rose_start_t3timer(struct sock *); +extern void rose_start_hbtimer(struct sock *); +extern void rose_start_idletimer(struct sock *); +extern void rose_stop_heartbeat(struct sock *); +extern void rose_stop_timer(struct sock *); +extern void rose_stop_idletimer(struct sock *); + +/* sysctl_net_rose.c */ +extern void rose_register_sysctl(void); +extern void rose_unregister_sysctl(void); + +#endif diff --git a/pfinet/linux-src/include/net/rosecall.h b/pfinet/linux-src/include/net/rosecall.h new file mode 100644 index 00000000..5bbe69cc --- /dev/null +++ b/pfinet/linux-src/include/net/rosecall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void rose_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/route.h b/pfinet/linux-src/include/net/route.h new file mode 100644 index 00000000..66df4712 --- /dev/null +++ b/pfinet/linux-src/include/net/route.h @@ -0,0 +1,153 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the IP router. + * + * Version: @(#)route.h 1.0.4 05/27/93 + * + * Authors: Ross Biro, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * Fixes: + * Alan Cox : Reformatted. Added ip_rt_local() + * Alan Cox : Support for TCP parameters. + * Alexey Kuznetsov: Major changes for new routing code. + * Mike McLagan : Routing by source + * + * 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. + */ +#ifndef _ROUTE_H +#define _ROUTE_H + +#include <linux/config.h> +#include <net/dst.h> +#include <linux/in_route.h> +#include <linux/rtnetlink.h> +#include <linux/route.h> + +#ifndef __KERNEL__ +#warning This file is not supposed to be used outside of kernel. +#endif + +#define RT_HASH_DIVISOR 256 + +/* + * Prevents LRU trashing, entries considered equivalent, + * if the difference between last use times is less then this number. + */ +#define RT_CACHE_BUBBLE_THRESHOLD (5*HZ) + + +#define RTO_ONLINK 0x01 +#define RTO_TPROXY 0x80000000 + +#ifdef CONFIG_IP_TRANSPARENT_PROXY +#define RTO_CONN RTO_TPROXY +#else +#define RTO_CONN 0 +#endif + +struct rt_key +{ + __u32 dst; + __u32 src; + int iif; + int oif; +#ifdef CONFIG_IP_ROUTE_FWMARK + __u32 fwmark; +#endif + __u8 tos; + __u8 scope; +}; + +struct rtable +{ + union + { + struct dst_entry dst; + struct rtable *rt_next; + } u; + + unsigned rt_flags; + unsigned rt_type; + + __u32 rt_dst; /* Path destination */ + __u32 rt_src; /* Path source */ + int rt_iif; + + /* Info on neighbour */ + __u32 rt_gateway; + + /* Cache lookup keys */ + struct rt_key key; + + /* Miscellaneous cached information */ + __u32 rt_spec_dst; /* RFC1122 specific destination */ + +#ifdef CONFIG_IP_ROUTE_NAT + __u32 rt_src_map; + __u32 rt_dst_map; +#endif +}; + +extern struct rtable *rt_hash_table[RT_HASH_DIVISOR]; + +struct ip_rt_acct +{ + __u32 o_bytes; + __u32 o_packets; + __u32 i_bytes; + __u32 i_packets; +}; + +extern struct ip_rt_acct ip_rt_acct[256]; + +extern void ip_rt_init(void); +extern void ip_rt_redirect(u32 old_gw, u32 dst, u32 new_gw, + u32 src, u8 tos, struct device *dev); +extern void ip_rt_advice(struct rtable **rp, int advice); +extern void rt_cache_flush(int how); +extern int ip_route_output(struct rtable **, u32 dst, u32 src, u32 tos, int oif); +extern int ip_route_input(struct sk_buff*, u32 dst, u32 src, u8 tos, struct device *devin); +extern unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu); +extern void ip_rt_update_pmtu(struct dst_entry *dst, unsigned mtu); +extern void ip_rt_send_redirect(struct sk_buff *skb); + +extern unsigned inet_addr_type(u32 addr); +extern void ip_rt_multicast_event(struct in_device *); +extern int ip_rt_ioctl(unsigned int cmd, void *arg); +extern void ip_rt_get_source(u8 *src, struct rtable *rt); +extern int ip_rt_dump(struct sk_buff *skb, struct netlink_callback *cb); + + +extern __inline__ void ip_rt_put(struct rtable * rt) +{ + if (rt) + dst_release(&rt->u.dst); +} + +extern __u8 ip_tos2prio[16]; + +extern __inline__ char rt_tos2priority(u8 tos) +{ + return ip_tos2prio[IPTOS_TOS(tos)>>1]; +} + +extern __inline__ int ip_route_connect(struct rtable **rp, u32 dst, u32 src, u32 tos, int oif) +{ + int err; + err = ip_route_output(rp, dst, src, tos, oif); + if (err || (dst && src)) + return err; + dst = (*rp)->rt_dst; + src = (*rp)->rt_src; + ip_rt_put(*rp); + *rp = NULL; + return ip_route_output(rp, dst, src, tos, oif); +} + +#endif /* _ROUTE_H */ diff --git a/pfinet/linux-src/include/net/scm.h b/pfinet/linux-src/include/net/scm.h new file mode 100644 index 00000000..98c2dc91 --- /dev/null +++ b/pfinet/linux-src/include/net/scm.h @@ -0,0 +1,67 @@ +#ifndef __LINUX_NET_SCM_H +#define __LINUX_NET_SCM_H + +/* Well, we should have at least one descriptor open + * to accept passed FDs 8) + */ +#define SCM_MAX_FD (OPEN_MAX-1) + +struct scm_fp_list +{ + int count; + struct file *fp[SCM_MAX_FD]; +}; + +struct scm_cookie +{ + struct ucred creds; /* Skb credentials */ + struct scm_fp_list *fp; /* Passed files */ + unsigned long seq; /* Connection seqno */ +}; + +extern void scm_detach_fds(struct msghdr *msg, struct scm_cookie *scm); +extern int __scm_send(struct socket *sock, struct msghdr *msg, struct scm_cookie *scm); +extern void __scm_destroy(struct scm_cookie *scm); +extern struct scm_fp_list * scm_fp_dup(struct scm_fp_list *fpl); + +static __inline__ void scm_destroy(struct scm_cookie *scm) +{ + if (scm && scm->fp) + __scm_destroy(scm); +} + +static __inline__ int scm_send(struct socket *sock, struct msghdr *msg, + struct scm_cookie *scm) +{ + memset(scm, 0, sizeof(*scm)); + scm->creds.uid = current->uid; + scm->creds.gid = current->gid; + scm->creds.pid = current->pid; + if (msg->msg_controllen <= 0) + return 0; + return __scm_send(sock, msg, scm); +} + +static __inline__ void scm_recv(struct socket *sock, struct msghdr *msg, + struct scm_cookie *scm, int flags) +{ + if (!msg->msg_control) + { + if (sock->passcred || scm->fp) + msg->msg_flags |= MSG_CTRUNC; + scm_destroy(scm); + return; + } + + if (sock->passcred) + put_cmsg(msg, SOL_SOCKET, SCM_CREDENTIALS, sizeof(scm->creds), &scm->creds); + + if (!scm->fp) + return; + + scm_detach_fds(msg, scm); +} + + +#endif __LINUX_NET_SCM_H + diff --git a/pfinet/linux-src/include/net/slhc.h b/pfinet/linux-src/include/net/slhc.h new file mode 100644 index 00000000..c7b39db5 --- /dev/null +++ b/pfinet/linux-src/include/net/slhc.h @@ -0,0 +1,6 @@ +#ifndef __NET_SLHC_H +#define __NET_SLHC_H + +extern void slhc_install(void); + +#endif diff --git a/pfinet/linux-src/include/net/slhc_vj.h b/pfinet/linux-src/include/net/slhc_vj.h new file mode 100644 index 00000000..04387d8a --- /dev/null +++ b/pfinet/linux-src/include/net/slhc_vj.h @@ -0,0 +1,187 @@ +#ifndef _SLHC_H +#define _SLHC_H +/* + * Definitions for tcp compression routines. + * + * $Header: slcompress.h,v 1.10 89/12/31 08:53:02 van Exp $ + * + * Copyright (c) 1989 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: + * - Initial distribution. + * + * + * modified for KA9Q Internet Software Package by + * Katie Stevens (dkstevens@ucdavis.edu) + * University of California, Davis + * Computing Services + * - 01-31-90 initial adaptation + * + * - Feb 1991 Bill_Simpson@um.cc.umich.edu + * variable number of conversation slots + * allow zero or one slots + * separate routines + * status display + */ + +/* + * Compressed packet format: + * + * The first octet contains the packet type (top 3 bits), TCP + * 'push' bit, and flags that indicate which of the 4 TCP sequence + * numbers have changed (bottom 5 bits). The next octet is a + * conversation number that associates a saved IP/TCP header with + * the compressed packet. The next two octets are the TCP checksum + * from the original datagram. The next 0 to 15 octets are + * sequence number changes, one change per bit set in the header + * (there may be no changes and there are two special cases where + * the receiver implicitly knows what changed -- see below). + * + * There are 5 numbers which can change (they are always inserted + * in the following order): TCP urgent pointer, window, + * acknowledgment, sequence number and IP ID. (The urgent pointer + * is different from the others in that its value is sent, not the + * change in value.) Since typical use of SLIP links is biased + * toward small packets (see comments on MTU/MSS below), changes + * use a variable length coding with one octet for numbers in the + * range 1 - 255 and 3 octets (0, MSB, LSB) for numbers in the + * range 256 - 65535 or 0. (If the change in sequence number or + * ack is more than 65535, an uncompressed packet is sent.) + */ + +/* + * Packet types (must not conflict with IP protocol version) + * + * The top nibble of the first octet is the packet type. There are + * three possible types: IP (not proto TCP or tcp with one of the + * control flags set); uncompressed TCP (a normal IP/TCP packet but + * with the 8-bit protocol field replaced by an 8-bit connection id -- + * this type of packet syncs the sender & receiver); and compressed + * TCP (described above). + * + * LSB of 4-bit field is TCP "PUSH" bit (a worthless anachronism) and + * is logically part of the 4-bit "changes" field that follows. Top + * three bits are actual packet type. For backward compatibility + * and in the interest of conserving bits, numbers are chosen so the + * IP protocol version number (4) which normally appears in this nibble + * means "IP packet". + */ + +/* SLIP compression masks for len/vers byte */ +#define SL_TYPE_IP 0x40 +#define SL_TYPE_UNCOMPRESSED_TCP 0x70 +#define SL_TYPE_COMPRESSED_TCP 0x80 +#define SL_TYPE_ERROR 0x00 + +/* Bits in first octet of compressed packet */ +#define NEW_C 0x40 /* flag bits for what changed in a packet */ +#define NEW_I 0x20 +#define NEW_S 0x08 +#define NEW_A 0x04 +#define NEW_W 0x02 +#define NEW_U 0x01 + +/* reserved, special-case values of above */ +#define SPECIAL_I (NEW_S|NEW_W|NEW_U) /* echoed interactive traffic */ +#define SPECIAL_D (NEW_S|NEW_A|NEW_W|NEW_U) /* unidirectional data */ +#define SPECIALS_MASK (NEW_S|NEW_A|NEW_W|NEW_U) + +#define TCP_PUSH_BIT 0x10 + +/* + * data type and sizes conversion assumptions: + * + * VJ code KA9Q style generic + * u_char byte_t unsigned char 8 bits + * u_short int16 unsigned short 16 bits + * u_int int16 unsigned short 16 bits + * u_long unsigned long unsigned long 32 bits + * int int32 long 32 bits + */ + +typedef __u8 byte_t; +typedef __u32 int32; + +/* + * "state" data for each active tcp conversation on the wire. This is + * basically a copy of the entire IP/TCP header from the last packet + * we saw from the conversation together with a small identifier + * the transmit & receive ends of the line use to locate saved header. + */ +struct cstate { + byte_t cs_this; /* connection id number (xmit) */ + struct cstate *next; /* next in ring (xmit) */ + struct iphdr cs_ip; /* ip/tcp hdr from most recent packet */ + struct tcphdr cs_tcp; + unsigned char cs_ipopt[64]; + unsigned char cs_tcpopt[64]; + int cs_hsize; +}; +#define NULLSLSTATE (struct cstate *)0 + +/* + * all the state data for one serial line (we need one of these per line). + */ +struct slcompress { + struct cstate *tstate; /* transmit connection states (array)*/ + struct cstate *rstate; /* receive connection states (array)*/ + + byte_t tslot_limit; /* highest transmit slot id (0-l)*/ + byte_t rslot_limit; /* highest receive slot id (0-l)*/ + + byte_t xmit_oldest; /* oldest xmit in ring */ + byte_t xmit_current; /* most recent xmit id */ + byte_t recv_current; /* most recent rcvd id */ + + byte_t flags; +#define SLF_TOSS 0x01 /* tossing rcvd frames until id received */ + + int32 sls_o_nontcp; /* outbound non-TCP packets */ + int32 sls_o_tcp; /* outbound TCP packets */ + int32 sls_o_uncompressed; /* outbound uncompressed packets */ + int32 sls_o_compressed; /* outbound compressed packets */ + int32 sls_o_searches; /* searches for connection state */ + int32 sls_o_misses; /* times couldn't find conn. state */ + + int32 sls_i_uncompressed; /* inbound uncompressed packets */ + int32 sls_i_compressed; /* inbound compressed packets */ + int32 sls_i_error; /* inbound error packets */ + int32 sls_i_tossed; /* inbound packets tossed because of error */ + + int32 sls_i_runt; + int32 sls_i_badcheck; +}; +#define NULLSLCOMPR (struct slcompress *)0 + +#define __ARGS(x) x + +/* In slhc.c: */ +struct slcompress *slhc_init __ARGS((int rslots, int tslots)); +void slhc_free __ARGS((struct slcompress *comp)); + +int slhc_compress __ARGS((struct slcompress *comp, unsigned char *icp, + int isize, unsigned char *ocp, unsigned char **cpp, + int compress_cid)); +int slhc_uncompress __ARGS((struct slcompress *comp, unsigned char *icp, + int isize)); +int slhc_remember __ARGS((struct slcompress *comp, unsigned char *icp, + int isize)); +int slhc_toss __ARGS((struct slcompress *comp)); + +void slhc_i_status __ARGS((struct slcompress *comp)); +void slhc_o_status __ARGS((struct slcompress *comp)); + +#endif /* _SLHC_H */ diff --git a/pfinet/linux-src/include/net/snmp.h b/pfinet/linux-src/include/net/snmp.h new file mode 100644 index 00000000..cc8354b6 --- /dev/null +++ b/pfinet/linux-src/include/net/snmp.h @@ -0,0 +1,183 @@ +/* + * + * SNMP MIB entries for the IP subsystem. + * + * Alan Cox <gw4pts@gw4pts.ampr.org> + * + * We don't chose to implement SNMP in the kernel (this would + * be silly as SNMP is a pain in the backside in places). We do + * however need to collect the MIB statistics and export them + * out of /proc (eventually) + * + * 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. + * + */ + +#ifndef _SNMP_H +#define _SNMP_H + +/* + * We use all unsigned longs. Linux will soon be so reliable that even these + * will rapidly get too small 8-). Seriously consider the IpInReceives count + * on the 20Gb/s + networks people expect in a few years time! + */ + +struct ip_mib +{ + unsigned long IpForwarding; + unsigned long IpDefaultTTL; + unsigned long IpInReceives; + unsigned long IpInHdrErrors; + unsigned long IpInAddrErrors; + unsigned long IpForwDatagrams; + unsigned long IpInUnknownProtos; + unsigned long IpInDiscards; + unsigned long IpInDelivers; + unsigned long IpOutRequests; + unsigned long IpOutDiscards; + unsigned long IpOutNoRoutes; + unsigned long IpReasmTimeout; + unsigned long IpReasmReqds; + unsigned long IpReasmOKs; + unsigned long IpReasmFails; + unsigned long IpFragOKs; + unsigned long IpFragFails; + unsigned long IpFragCreates; +}; + +struct ipv6_mib +{ + unsigned long Ip6InReceives; + unsigned long Ip6InHdrErrors; + unsigned long Ip6InTooBigErrors; + unsigned long Ip6InNoRoutes; + unsigned long Ip6InAddrErrors; + unsigned long Ip6InUnknownProtos; + unsigned long Ip6InTruncatedPkts; + unsigned long Ip6InDiscards; + unsigned long Ip6InDelivers; + unsigned long Ip6OutForwDatagrams; + unsigned long Ip6OutRequests; + unsigned long Ip6OutDiscards; + unsigned long Ip6OutNoRoutes; + unsigned long Ip6ReasmTimeout; + unsigned long Ip6ReasmReqds; + unsigned long Ip6ReasmOKs; + unsigned long Ip6ReasmFails; + unsigned long Ip6FragOKs; + unsigned long Ip6FragFails; + unsigned long Ip6FragCreates; + unsigned long Ip6InMcastPkts; + unsigned long Ip6OutMcastPkts; +}; + +struct icmp_mib +{ + unsigned long IcmpInMsgs; + unsigned long IcmpInErrors; + unsigned long IcmpInDestUnreachs; + unsigned long IcmpInTimeExcds; + unsigned long IcmpInParmProbs; + unsigned long IcmpInSrcQuenchs; + unsigned long IcmpInRedirects; + unsigned long IcmpInEchos; + unsigned long IcmpInEchoReps; + unsigned long IcmpInTimestamps; + unsigned long IcmpInTimestampReps; + unsigned long IcmpInAddrMasks; + unsigned long IcmpInAddrMaskReps; + unsigned long IcmpOutMsgs; + unsigned long IcmpOutErrors; + unsigned long IcmpOutDestUnreachs; + unsigned long IcmpOutTimeExcds; + unsigned long IcmpOutParmProbs; + unsigned long IcmpOutSrcQuenchs; + unsigned long IcmpOutRedirects; + unsigned long IcmpOutEchos; + unsigned long IcmpOutEchoReps; + unsigned long IcmpOutTimestamps; + unsigned long IcmpOutTimestampReps; + unsigned long IcmpOutAddrMasks; + unsigned long IcmpOutAddrMaskReps; +}; + +struct icmpv6_mib +{ + unsigned long Icmp6InMsgs; + unsigned long Icmp6InErrors; + + unsigned long Icmp6InDestUnreachs; + unsigned long Icmp6InPktTooBigs; + unsigned long Icmp6InTimeExcds; + unsigned long Icmp6InParmProblems; + + unsigned long Icmp6InEchos; + unsigned long Icmp6InEchoReplies; + unsigned long Icmp6InGroupMembQueries; + unsigned long Icmp6InGroupMembResponses; + unsigned long Icmp6InGroupMembReductions; + unsigned long Icmp6InRouterSolicits; + unsigned long Icmp6InRouterAdvertisements; + unsigned long Icmp6InNeighborSolicits; + unsigned long Icmp6InNeighborAdvertisements; + unsigned long Icmp6InRedirects; + + unsigned long Icmp6OutMsgs; + + unsigned long Icmp6OutDestUnreachs; + unsigned long Icmp6OutPktTooBigs; + unsigned long Icmp6OutTimeExcds; + unsigned long Icmp6OutParmProblems; + + unsigned long Icmp6OutEchoReplies; + unsigned long Icmp6OutRouterSolicits; + unsigned long Icmp6OutNeighborSolicits; + unsigned long Icmp6OutNeighborAdvertisements; + unsigned long Icmp6OutRedirects; + unsigned long Icmp6OutGroupMembResponses; + unsigned long Icmp6OutGroupMembReductions; +}; + +struct tcp_mib +{ + unsigned long TcpRtoAlgorithm; + unsigned long TcpRtoMin; + unsigned long TcpRtoMax; + unsigned long TcpMaxConn; + unsigned long TcpActiveOpens; + unsigned long TcpPassiveOpens; + unsigned long TcpAttemptFails; + unsigned long TcpEstabResets; + unsigned long TcpCurrEstab; + unsigned long TcpInSegs; + unsigned long TcpOutSegs; + unsigned long TcpRetransSegs; + unsigned long TcpInErrs; + unsigned long TcpOutRsts; +}; + +struct udp_mib +{ + unsigned long UdpInDatagrams; + unsigned long UdpNoPorts; + unsigned long UdpInErrors; + unsigned long UdpOutDatagrams; +}; + +struct linux_mib +{ + unsigned long SyncookiesSent; + unsigned long SyncookiesRecv; + unsigned long SyncookiesFailed; + unsigned long EmbryonicRsts; + unsigned long PruneCalled; + unsigned long RcvPruned; + unsigned long OfoPruned; + unsigned long OutOfWindowIcmps; + unsigned long LockDroppedIcmps; +}; + +#endif diff --git a/pfinet/linux-src/include/net/sock.h b/pfinet/linux-src/include/net/sock.h new file mode 100644 index 00000000..28cf919e --- /dev/null +++ b/pfinet/linux-src/include/net/sock.h @@ -0,0 +1,950 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the AF_INET socket handler. + * + * Version: @(#)sock.h 1.0.4 05/13/93 + * + * Authors: Ross Biro, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * Corey Minyard <wf-rch!minyard@relay.EU.net> + * Florian La Roche <flla@stud.uni-sb.de> + * + * Fixes: + * Alan Cox : Volatiles in skbuff pointers. See + * skbuff comments. May be overdone, + * better to prove they can be removed + * than the reverse. + * Alan Cox : Added a zapped field for tcp to note + * a socket is reset and must stay shut up + * Alan Cox : New fields for options + * Pauline Middelink : identd support + * Alan Cox : Eliminate low level recv/recvfrom + * David S. Miller : New socket lookup architecture. + * Steve Whitehouse: Default routines for sock_ops + * + * 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. + */ +#ifndef _SOCK_H +#define _SOCK_H + +#include <linux/config.h> +#include <linux/timer.h> +#include <linux/in.h> /* struct sockaddr_in */ + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +#include <linux/in6.h> /* struct sockaddr_in6 */ +#include <linux/ipv6.h> /* dest_cache, inet6_options */ +#include <linux/icmpv6.h> +#include <net/if_inet6.h> /* struct ipv6_mc_socklist */ +#endif + +#if defined(CONFIG_INET) || defined (CONFIG_INET_MODULE) +#include <linux/icmp.h> +#endif +#include <linux/tcp.h> /* struct tcphdr */ + +#include <linux/netdevice.h> +#include <linux/skbuff.h> /* struct sk_buff */ +#include <net/protocol.h> /* struct inet_protocol */ +#if defined(CONFIG_X25) || defined(CONFIG_X25_MODULE) +#include <net/x25.h> +#endif +#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) +#include <net/ax25.h> +#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE) +#include <net/netrom.h> +#endif +#if defined(CONFIG_ROSE) || defined(CONFIG_ROSE_MODULE) +#include <net/rose.h> +#endif +#endif + +#if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE) +#if defined(CONFIG_SPX) || defined(CONFIG_SPX_MODULE) +#include <net/spx.h> +#else +#include <net/ipx.h> +#endif /* CONFIG_SPX */ +#endif /* CONFIG_IPX */ + +#if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE) +#include <linux/atalk.h> +#endif + +#if defined(CONFIG_DECNET) || defined(CONFIG_DECNET_MODULE) +#include <net/dn.h> +#endif + +#if defined(CONFIG_IRDA) || defined(CONFIG_IRDA_MODULE) +#include <net/irda/irda.h> +#endif + +#ifdef CONFIG_FILTER +#include <linux/filter.h> +#endif + +#include <asm/atomic.h> + +#define MIN_WRITE_SPACE 2048 + +/* The AF_UNIX specific socket options */ +struct unix_opt { + int family; + char * name; + int locks; + struct unix_address *addr; + struct dentry * dentry; + struct semaphore readsem; + struct sock * other; + struct sock ** list; + struct sock * gc_tree; + int inflight; +}; + +#ifdef CONFIG_NETLINK +struct netlink_callback; + +struct netlink_opt { + pid_t pid; + unsigned groups; + pid_t dst_pid; + unsigned dst_groups; + int (*handler)(int unit, struct sk_buff *skb); + atomic_t locks; + struct netlink_callback *cb; +}; +#endif + +/* Once the IPX ncpd patches are in these are going into protinfo. */ +#if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE) +struct ipx_opt { + ipx_address dest_addr; + ipx_interface *intrfc; + unsigned short port; +#ifdef CONFIG_IPX_INTERN + unsigned char node[IPX_NODE_LEN]; +#endif + unsigned short type; +/* + * To handle special ncp connection-handling sockets for mars_nwe, + * the connection number must be stored in the socket. + */ + unsigned short ipx_ncp_conn; +}; +#endif + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +struct ipv6_pinfo { + struct in6_addr saddr; + struct in6_addr rcv_saddr; + struct in6_addr daddr; + struct in6_addr *daddr_cache; + + __u32 flow_label; + __u32 frag_size; + int hop_limit; + int mcast_hops; + int mcast_oif; + + /* pktoption flags */ + union { + struct { + __u8 srcrt:2, + rxinfo:1, + rxhlim:1, + hopopts:1, + dstopts:1, + authhdr:1, + rxflow:1; + } bits; + __u8 all; + } rxopt; + + /* sockopt flags */ + __u8 mc_loop:1, + recverr:1, + sndflow:1, + pmtudisc:2; + + struct ipv6_mc_socklist *ipv6_mc_list; + struct ipv6_fl_socklist *ipv6_fl_list; + __u32 dst_cookie; + + struct ipv6_txoptions *opt; + struct sk_buff *pktoptions; +}; + +struct raw6_opt { + __u32 checksum; /* perform checksum */ + __u32 offset; /* checksum offset */ + + struct icmp6_filter filter; +}; + +#endif /* IPV6 */ + +#if defined(CONFIG_INET) || defined(CONFIG_INET_MODULE) +struct raw_opt { + struct icmp_filter filter; +}; +#endif + +/* This defines a selective acknowledgement block. */ +struct tcp_sack_block { + __u32 start_seq; + __u32 end_seq; +}; + +struct tcp_opt { + int tcp_header_len; /* Bytes of tcp header to send */ + +/* + * Header prediction flags + * 0x5?10 << 16 + snd_wnd in net byte order + */ + __u32 pred_flags; + +/* + * RFC793 variables by their proper names. This means you can + * read the code and the spec side by side (and laugh ...) + * See RFC793 and RFC1122. The RFC writes these in capitals. + */ + __u32 rcv_nxt; /* What we want to receive next */ + __u32 snd_nxt; /* Next sequence we send */ + + __u32 snd_una; /* First byte we want an ack for */ + __u32 rcv_tstamp; /* timestamp of last received packet */ + __u32 lrcvtime; /* timestamp of last received data packet*/ + __u32 srtt; /* smothed round trip time << 3 */ + + __u32 ato; /* delayed ack timeout */ + __u32 snd_wl1; /* Sequence for window update */ + + __u32 snd_wl2; /* Ack sequence for update */ + __u32 snd_wnd; /* The window we expect to receive */ + __u32 max_window; + __u32 pmtu_cookie; /* Last pmtu seen by socket */ + __u16 mss_cache; /* Cached effective mss, not including SACKS */ + __u16 mss_clamp; /* Maximal mss, negotiated at connection setup */ + __u16 ext_header_len; /* Dave, do you allow mw to use this hole? 8) --ANK */ + __u8 pending; /* pending events */ + __u8 retransmits; + __u32 last_ack_sent; /* last ack we sent */ + + __u32 backoff; /* backoff */ + __u32 mdev; /* medium deviation */ + __u32 snd_cwnd; /* Sending congestion window */ + __u32 rto; /* retransmit timeout */ + + __u32 packets_out; /* Packets which are "in flight" */ + __u32 fackets_out; /* Non-retrans SACK'd packets */ + __u32 retrans_out; /* Fast-retransmitted packets out */ + __u32 high_seq; /* snd_nxt at onset of congestion */ +/* + * Slow start and congestion control (see also Nagle, and Karn & Partridge) + */ + __u32 snd_ssthresh; /* Slow start size threshold */ + __u16 snd_cwnd_cnt; /* Linear increase counter */ + __u8 dup_acks; /* Consequetive duplicate acks seen from other end */ + __u8 delayed_acks; + __u16 user_mss; /* mss requested by user in ioctl */ + + /* Two commonly used timers in both sender and receiver paths. */ + struct timer_list retransmit_timer; /* Resend (no ack) */ + struct timer_list delack_timer; /* Ack delay */ + + struct sk_buff_head out_of_order_queue; /* Out of order segments go here */ + + struct tcp_func *af_specific; /* Operations which are AF_INET{4,6} specific */ + struct sk_buff *send_head; /* Front of stuff to transmit */ + struct sk_buff *retrans_head; /* retrans head can be + * different to the head of + * write queue if we are doing + * fast retransmit + */ + + __u32 rcv_wnd; /* Current receiver window */ + __u32 rcv_wup; /* rcv_nxt on last window update sent */ + __u32 write_seq; + __u32 copied_seq; +/* + * Options received (usually on last packet, some only on SYN packets). + */ + char tstamp_ok, /* TIMESTAMP seen on SYN packet */ + wscale_ok, /* Wscale seen on SYN packet */ + sack_ok; /* SACK seen on SYN packet */ + char saw_tstamp; /* Saw TIMESTAMP on last packet */ + __u8 snd_wscale; /* Window scaling received from sender */ + __u8 rcv_wscale; /* Window scaling to send to receiver */ + __u8 rexmt_done; /* Retransmitted up to send head? */ + __u32 rcv_tsval; /* Time stamp value */ + __u32 rcv_tsecr; /* Time stamp echo reply */ + __u32 ts_recent; /* Time stamp to echo next */ + __u32 ts_recent_stamp;/* Time we stored ts_recent (for aging) */ + int num_sacks; /* Number of SACK blocks */ + struct tcp_sack_block selective_acks[4]; /* The SACKS themselves*/ + + struct timer_list probe_timer; /* Probes */ + __u32 window_clamp; /* XXX Document this... -DaveM */ + __u32 probes_out; /* unanswered 0 window probes */ + __u32 syn_seq; + __u32 fin_seq; + __u32 urg_seq; + __u32 urg_data; + + __u32 last_seg_size; /* Size of last incoming segment */ + __u32 rcv_mss; /* MSS used for delayed ACK decisions */ + __u32 partial_writers; /* # of clients wanting at the head packet */ + + struct open_request *syn_wait_queue; + struct open_request **syn_wait_last; + + int syn_backlog; /* Backlog of received SYNs */ +}; + + +/* + * This structure really needs to be cleaned up. + * Most of it is for TCP, and not used by any of + * the other protocols. + */ + +/* + * The idea is to start moving to a newer struct gradualy + * + * IMHO the newer struct should have the following format: + * + * struct sock { + * sockmem [mem, proto, callbacks] + * + * union or struct { + * ax25; + * } ll_pinfo; + * + * union { + * ipv4; + * ipv6; + * ipx; + * netrom; + * rose; + * x25; + * } net_pinfo; + * + * union { + * tcp; + * udp; + * spx; + * netrom; + * } tp_pinfo; + * + * } + */ + +/* Define this to get the sk->debug debugging facility. */ +#define SOCK_DEBUGGING +#ifdef SOCK_DEBUGGING +#define SOCK_DEBUG(sk, msg...) do { if((sk) && ((sk)->debug)) printk(KERN_DEBUG ## msg); } while (0) +#else +#define SOCK_DEBUG(sk, msg...) do { } while (0) +#endif + +struct sock { + /* This must be first. */ + struct sock *sklist_next; + struct sock *sklist_prev; + + /* Local port binding hash linkage. */ + struct sock *bind_next; + struct sock **bind_pprev; + + /* Socket demultiplex comparisons on incoming packets. */ + __u32 daddr; /* Foreign IPv4 addr */ + __u32 rcv_saddr; /* Bound local IPv4 addr */ + __u16 dport; /* Destination port */ + unsigned short num; /* Local port */ + int bound_dev_if; /* Bound device index if != 0 */ + + /* Main hash linkage for various protocol lookup tables. */ + struct sock *next; + struct sock **pprev; + + volatile unsigned char state, /* Connection state */ + zapped; /* In ax25 & ipx means not linked */ + __u16 sport; /* Source port */ + + unsigned short family; /* Address family */ + unsigned char reuse, /* SO_REUSEADDR setting */ + nonagle; /* Disable Nagle algorithm? */ + + atomic_t sock_readers; /* User count */ + int rcvbuf; /* Size of receive buffer in bytes */ + + struct wait_queue **sleep; /* Sock wait queue */ + struct dst_entry *dst_cache; /* Destination cache */ + atomic_t rmem_alloc; /* Receive queue bytes committed */ + struct sk_buff_head receive_queue; /* Incoming packets */ + atomic_t wmem_alloc; /* Transmit queue bytes committed */ + struct sk_buff_head write_queue; /* Packet sending queue */ + atomic_t omem_alloc; /* "o" is "option" or "other" */ + __u32 saddr; /* Sending source */ + unsigned int allocation; /* Allocation mode */ + int sndbuf; /* Size of send buffer in bytes */ + struct sock *prev; + + /* Not all are volatile, but some are, so we might as well say they all are. + * XXX Make this a flag word -DaveM + */ + volatile char dead, + done, + urginline, + keepopen, + linger, + destroy, + no_check, + broadcast, + bsdism; + unsigned char debug; + int proc; + unsigned long lingertime; + + int hashent; + struct sock *pair; + + /* Error and backlog packet queues, rarely used. */ + struct sk_buff_head back_log, + error_queue; + + struct proto *prot; + + unsigned short shutdown; + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) + union { + struct ipv6_pinfo af_inet6; + } net_pinfo; +#endif + + union { + struct tcp_opt af_tcp; +#if defined(CONFIG_INET) || defined (CONFIG_INET_MODULE) + struct raw_opt tp_raw4; +#endif +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) + struct raw6_opt tp_raw; +#endif /* CONFIG_IPV6 */ +#if defined(CONFIG_SPX) || defined (CONFIG_SPX_MODULE) + struct spx_opt af_spx; +#endif /* CONFIG_SPX */ + + } tp_pinfo; + + int err, err_soft; /* Soft holds errors that don't + cause failure but are the cause + of a persistent failure not just + 'timed out' */ + unsigned short ack_backlog; + unsigned short max_ack_backlog; + __u32 priority; + unsigned short type; + unsigned char localroute; /* Route locally only */ + unsigned char protocol; + struct ucred peercred; + +#ifdef CONFIG_FILTER + /* Socket Filtering Instructions */ + struct sk_filter *filter; +#endif /* CONFIG_FILTER */ + + /* This is where all the private (optional) areas that don't + * overlap will eventually live. + */ + union { + void *destruct_hook; + struct unix_opt af_unix; +#if defined(CONFIG_ATALK) || defined(CONFIG_ATALK_MODULE) + struct atalk_sock af_at; +#endif +#if defined(CONFIG_IPX) || defined(CONFIG_IPX_MODULE) + struct ipx_opt af_ipx; +#endif +#if defined (CONFIG_DECNET) || defined(CONFIG_DECNET_MODULE) + struct dn_scp dn; +#endif +#if defined (CONFIG_PACKET) || defined(CONFIG_PACKET_MODULE) + struct packet_opt *af_packet; +#endif +#if defined(CONFIG_X25) || defined(CONFIG_X25_MODULE) + x25_cb *x25; +#endif +#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) + ax25_cb *ax25; +#endif +#if defined(CONFIG_NETROM) || defined(CONFIG_NETROM_MODULE) + nr_cb *nr; +#endif +#if defined(CONFIG_ROSE) || defined(CONFIG_ROSE_MODULE) + rose_cb *rose; +#endif +#ifdef CONFIG_NETLINK + struct netlink_opt af_netlink; +#endif +#if defined(CONFIG_ECONET) || defined(CONFIG_ECONET_MODULE) + struct econet_opt *af_econet; +#endif +#if defined(CONFIG_IRDA) || defined(CONFIG_IRDA_MODULE) + struct irda_sock *irda; +#endif + } protinfo; + + /* IP 'private area' or will be eventually. */ + int ip_ttl; /* TTL setting */ + int ip_tos; /* TOS */ + unsigned ip_cmsg_flags; + struct ip_options *opt; + unsigned char ip_hdrincl; /* Include headers ? */ + __u8 ip_mc_ttl; /* Multicasting TTL */ + __u8 ip_mc_loop; /* Loopback */ + __u8 ip_recverr; + __u8 ip_pmtudisc; + int ip_mc_index; /* Multicast device index */ + __u32 ip_mc_addr; + struct ip_mc_socklist *ip_mc_list; /* Group array */ + + /* This part is used for the timeout functions (timer.c). */ + int timeout; /* What are we waiting for? */ + struct timer_list timer; /* This is the sock cleanup timer. */ + struct timeval stamp; + + /* Identd */ + struct socket *socket; + + /* RPC layer private data */ + void *user_data; + + /* Callbacks */ + void (*state_change)(struct sock *sk); + void (*data_ready)(struct sock *sk,int bytes); + void (*write_space)(struct sock *sk); + void (*error_report)(struct sock *sk); + + int (*backlog_rcv) (struct sock *sk, + struct sk_buff *skb); + void (*destruct)(struct sock *sk); +}; + +/* IP protocol blocks we attach to sockets. + * socket layer -> transport layer interface + * transport -> network interface is defined by struct inet_proto + */ +struct proto { + /* These must be first. */ + struct sock *sklist_next; + struct sock *sklist_prev; + + void (*close)(struct sock *sk, + long timeout); + int (*connect)(struct sock *sk, + struct sockaddr *uaddr, + int addr_len); + + struct sock * (*accept) (struct sock *sk, int flags); + void (*retransmit)(struct sock *sk, int all); + void (*write_wakeup)(struct sock *sk); + void (*read_wakeup)(struct sock *sk); + + unsigned int (*poll)(struct file * file, struct socket *sock, + struct poll_table_struct *wait); + + int (*ioctl)(struct sock *sk, int cmd, + unsigned long arg); + int (*init)(struct sock *sk); + int (*destroy)(struct sock *sk); + void (*shutdown)(struct sock *sk, int how); + int (*setsockopt)(struct sock *sk, int level, + int optname, char *optval, int optlen); + int (*getsockopt)(struct sock *sk, int level, + int optname, char *optval, + int *option); + int (*sendmsg)(struct sock *sk, struct msghdr *msg, + int len); + int (*recvmsg)(struct sock *sk, struct msghdr *msg, + int len, int noblock, int flags, + int *addr_len); + int (*bind)(struct sock *sk, + struct sockaddr *uaddr, int addr_len); + + int (*backlog_rcv) (struct sock *sk, + struct sk_buff *skb); + + /* Keeping track of sk's, looking them up, and port selection methods. */ + void (*hash)(struct sock *sk); + void (*unhash)(struct sock *sk); + int (*get_port)(struct sock *sk, unsigned short snum); + + unsigned short max_header; + unsigned long retransmits; + char name[32]; + int inuse, highestinuse; +}; + +#define TIME_WRITE 1 /* Not yet used */ +#define TIME_RETRANS 2 /* Retransmit timer */ +#define TIME_DACK 3 /* Delayed ack timer */ +#define TIME_CLOSE 4 +#define TIME_KEEPOPEN 5 +#define TIME_DESTROY 6 +#define TIME_DONE 7 /* Used to absorb those last few packets */ +#define TIME_PROBE0 8 + +/* About 10 seconds */ +#define SOCK_DESTROY_TIME (10*HZ) + +/* Sockets 0-1023 can't be bound to unless you are superuser */ +#define PROT_SOCK 1024 + +#define SHUTDOWN_MASK 3 +#define RCV_SHUTDOWN 1 +#define SEND_SHUTDOWN 2 + +/* Per-protocol hash table implementations use this to make sure + * nothing changes. + */ +#define SOCKHASH_LOCK() start_bh_atomic() +#define SOCKHASH_UNLOCK() end_bh_atomic() + +/* Some things in the kernel just want to get at a protocols + * entire socket list commensurate, thus... + */ +static __inline__ void __add_to_prot_sklist(struct sock *sk) +{ + struct proto *p = sk->prot; + + sk->sklist_prev = (struct sock *) p; + sk->sklist_next = p->sklist_next; + p->sklist_next->sklist_prev = sk; + p->sklist_next = sk; + + /* Charge the protocol. */ + sk->prot->inuse += 1; + if(sk->prot->highestinuse < sk->prot->inuse) + sk->prot->highestinuse = sk->prot->inuse; +} + +static __inline__ void add_to_prot_sklist(struct sock *sk) +{ + SOCKHASH_LOCK(); + if(!sk->sklist_next) + __add_to_prot_sklist(sk); + SOCKHASH_UNLOCK(); +} + +static __inline__ void del_from_prot_sklist(struct sock *sk) +{ + SOCKHASH_LOCK(); + if(sk->sklist_next) { + sk->sklist_next->sklist_prev = sk->sklist_prev; + sk->sklist_prev->sklist_next = sk->sklist_next; + sk->sklist_next = NULL; + sk->prot->inuse--; + } + SOCKHASH_UNLOCK(); +} + +/* + * Used by processes to "lock" a socket state, so that + * interrupts and bottom half handlers won't change it + * from under us. It essentially blocks any incoming + * packets, so that we won't get any new data or any + * packets that change the state of the socket. + * + * Note the 'barrier()' calls: gcc may not move a lock + * "downwards" or a unlock "upwards" when optimizing. + */ +extern void __release_sock(struct sock *sk); + +static inline void lock_sock(struct sock *sk) +{ +#if 0 +/* debugging code: the test isn't even 100% correct, but it can catch bugs */ +/* Note that a double lock is ok in theory - it's just _usually_ a bug */ +/* Actually it can easily happen with multiple writers */ + if (atomic_read(&sk->sock_readers)) { + printk("double lock on socket at %p\n", gethere()); +here: + } +#endif + atomic_inc(&sk->sock_readers); + synchronize_bh(); +} + +static inline void release_sock(struct sock *sk) +{ + barrier(); + if (atomic_dec_and_test(&sk->sock_readers)) + __release_sock(sk); +} + +/* + * This might not be the most appropriate place for this two + * but since they are used by a lot of the net related code + * at least they get declared on a include that is common to all + */ + +static __inline__ int min(unsigned int a, unsigned int b) +{ + if (a > b) + a = b; + return a; +} + +static __inline__ int max(unsigned int a, unsigned int b) +{ + if (a < b) + a = b; + return a; +} + +extern struct sock * sk_alloc(int family, int priority, int zero_it); +extern void sk_free(struct sock *sk); +extern void destroy_sock(struct sock *sk); + +extern struct sk_buff *sock_wmalloc(struct sock *sk, + unsigned long size, int force, + int priority); +extern struct sk_buff *sock_rmalloc(struct sock *sk, + unsigned long size, int force, + int priority); +extern void sock_wfree(struct sk_buff *skb); +extern void sock_rfree(struct sk_buff *skb); +extern unsigned long sock_rspace(struct sock *sk); +extern unsigned long sock_wspace(struct sock *sk); + +extern int sock_setsockopt(struct socket *sock, int level, + int op, char *optval, + int optlen); + +extern int sock_getsockopt(struct socket *sock, int level, + int op, char *optval, + int *optlen); +extern struct sk_buff *sock_alloc_send_skb(struct sock *sk, + unsigned long size, + unsigned long fallback, + int noblock, + int *errcode); +extern void *sock_kmalloc(struct sock *sk, int size, int priority); +extern void sock_kfree_s(struct sock *sk, void *mem, int size); + + +/* + * Functions to fill in entries in struct proto_ops when a protocol + * does not implement a particular function. + */ +extern int sock_no_dup(struct socket *, struct socket *); +extern int sock_no_release(struct socket *, + struct socket *); +extern int sock_no_bind(struct socket *, + struct sockaddr *, int); +extern int sock_no_connect(struct socket *, + struct sockaddr *, int, int); +extern int sock_no_socketpair(struct socket *, + struct socket *); +extern int sock_no_accept(struct socket *, + struct socket *, int); +extern int sock_no_getname(struct socket *, + struct sockaddr *, int *, int); +extern unsigned int sock_no_poll(struct file *, struct socket *, + struct poll_table_struct *); +extern int sock_no_ioctl(struct socket *, unsigned int, + unsigned long); +extern int sock_no_listen(struct socket *, int); +extern int sock_no_shutdown(struct socket *, int); +extern int sock_no_getsockopt(struct socket *, int , int, + char *, int *); +extern int sock_no_setsockopt(struct socket *, int, int, + char *, int); +extern int sock_no_fcntl(struct socket *, + unsigned int, unsigned long); +extern int sock_no_sendmsg(struct socket *, + struct msghdr *, int, + struct scm_cookie *); +extern int sock_no_recvmsg(struct socket *, + struct msghdr *, int, + struct scm_cookie *); + +/* + * Default socket callbacks and setup code + */ + +extern void sock_def_callback1(struct sock *); +extern void sock_def_callback2(struct sock *, int); +extern void sock_def_callback3(struct sock *); +extern void sock_def_destruct(struct sock *); + +/* Initialise core socket variables */ +extern void sock_init_data(struct socket *sock, struct sock *sk); + +extern void sklist_remove_socket(struct sock **list, struct sock *sk); +extern void sklist_insert_socket(struct sock **list, struct sock *sk); +extern void sklist_destroy_socket(struct sock **list, struct sock *sk); + +#ifdef CONFIG_FILTER +/* + * Run the filter code and then cut skb->data to correct size returned by + * sk_run_filter. If pkt_len is 0 we toss packet. If skb->len is smaller + * than pkt_len we keep whole skb->data. + */ +extern __inline__ int sk_filter(struct sk_buff *skb, struct sk_filter *filter) +{ + int pkt_len; + + pkt_len = sk_run_filter(skb, filter->insns, filter->len); + if(!pkt_len) + return 1; /* Toss Packet */ + else + skb_trim(skb, pkt_len); + + return 0; +} + +extern __inline__ void sk_filter_release(struct sock *sk, struct sk_filter *fp) +{ + unsigned int size = sk_filter_len(fp); + + atomic_sub(size, &sk->omem_alloc); + + if (atomic_dec_and_test(&fp->refcnt)) + kfree_s(fp, size); +} + +extern __inline__ void sk_filter_charge(struct sock *sk, struct sk_filter *fp) +{ + atomic_inc(&fp->refcnt); + atomic_add(sk_filter_len(fp), &sk->omem_alloc); +} + +#endif /* CONFIG_FILTER */ + +/* + * Queue a received datagram if it will fit. Stream and sequenced + * protocols can't normally use this as they need to fit buffers in + * and play with them. + * + * Inlined as it's very short and called for pretty much every + * packet ever received. + */ + +extern __inline__ void skb_set_owner_w(struct sk_buff *skb, struct sock *sk) +{ + skb->sk = sk; + skb->destructor = sock_wfree; + atomic_add(skb->truesize, &sk->wmem_alloc); +} + +extern __inline__ void skb_set_owner_r(struct sk_buff *skb, struct sock *sk) +{ + skb->sk = sk; + skb->destructor = sock_rfree; + atomic_add(skb->truesize, &sk->rmem_alloc); +} + + +extern __inline__ int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb) +{ +#ifdef CONFIG_FILTER + struct sk_filter *filter; +#endif + /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces + number of warnings when compiling with -W --ANK + */ + if (atomic_read(&sk->rmem_alloc) + skb->truesize >= (unsigned)sk->rcvbuf) + return -ENOMEM; + +#ifdef CONFIG_FILTER + if ((filter = sk->filter) != NULL && sk_filter(skb, filter)) + return -EPERM; /* Toss packet */ +#endif /* CONFIG_FILTER */ + + skb_set_owner_r(skb, sk); + skb_queue_tail(&sk->receive_queue, skb); + if (!sk->dead) + sk->data_ready(sk,skb->len); + return 0; +} + +extern __inline__ int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb) +{ + /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces + number of warnings when compiling with -W --ANK + */ + if (atomic_read(&sk->rmem_alloc) + skb->truesize >= (unsigned)sk->rcvbuf) + return -ENOMEM; + skb_set_owner_r(skb, sk); + skb_queue_tail(&sk->error_queue,skb); + if (!sk->dead) + sk->data_ready(sk,skb->len); + return 0; +} + +/* + * Recover an error report and clear atomically + */ + +extern __inline__ int sock_error(struct sock *sk) +{ + int err=xchg(&sk->err,0); + return -err; +} + +extern __inline__ unsigned long sock_wspace(struct sock *sk) +{ + int amt = 0; + + if (!(sk->shutdown & SEND_SHUTDOWN)) { + amt = sk->sndbuf - atomic_read(&sk->wmem_alloc); + if (amt < 0) + amt = 0; + } + return amt; +} + +/* + * Default write policy as shown to user space via poll/select/SIGIO + * Kernel internally doesn't use the MIN_WRITE_SPACE threshold. + */ +extern __inline__ int sock_writeable(struct sock *sk) +{ + return sock_wspace(sk) >= MIN_WRITE_SPACE; +} + +/* + * Declarations from timer.c + */ + +extern struct sock *timer_base; + +extern void net_delete_timer (struct sock *); +extern void net_reset_timer (struct sock *, int, unsigned long); +extern void net_timer (unsigned long); + +extern __inline__ int gfp_any(void) +{ + return in_interrupt() ? GFP_ATOMIC : GFP_KERNEL; +} + +/* + * Enable debug/info messages + */ + +#if 1 +#define NETDEBUG(x) do { } while (0) +#else +#define NETDEBUG(x) do { x; } while (0) +#endif + +#endif /* _SOCK_H */ diff --git a/pfinet/linux-src/include/net/spx.h b/pfinet/linux-src/include/net/spx.h new file mode 100644 index 00000000..a449b891 --- /dev/null +++ b/pfinet/linux-src/include/net/spx.h @@ -0,0 +1,93 @@ +#ifndef __NET_SPX_H +#define __NET_SPX_H + +#include <net/ipx.h> + +struct spxhdr +{ __u8 cctl; + __u8 dtype; +#define SPX_DTYPE_ECONN 0xFE /* Finished */ +#define SPX_DTYPE_ECACK 0xFF /* Ok */ + __u16 sconn; /* Connection ID */ + __u16 dconn; /* Connection ID */ + __u16 sequence; + __u16 ackseq; + __u16 allocseq; +}; + +struct ipxspxhdr +{ struct ipxhdr ipx; + struct spxhdr spx; +}; + +#define SPX_SYS_PKT_LEN (sizeof(struct ipxspxhdr)) + +#ifdef __KERNEL__ +struct spx_opt +{ int state; + int sndbuf; + int retries; /* Number of WD retries */ + int retransmits; /* Number of retransmits */ + int max_retries; + int wd_interval; + void *owner; + __u16 dest_connid; /* Net order */ + __u16 source_connid; /* Net order */ + __u16 sequence; /* Host order - our current pkt # */ + __u16 alloc; /* Host order - max seq we can rcv now */ + __u16 rmt_ack; /* Host order - last pkt ACKd by remote */ + __u16 rmt_seq; + __u16 acknowledge; + __u16 rmt_alloc; /* Host order - max seq remote can handle now */ + ipx_address dest_addr; + ipx_address source_addr; + struct timer_list watchdog; /* Idle watch */ + struct timer_list retransmit; /* Retransmit timer */ + struct sk_buff_head rcv_queue; + struct sk_buff_head transmit_queue; + struct sk_buff_head retransmit_queue; +}; + +/* Packet connectino control defines */ +#define CCTL_SPXII_XHD 0x01 /* SPX2 extended header */ +#define CCTL_SPX_UNKNOWN 0x02 /* Unknown (unused ??) */ +#define CCTL_SPXII_NEG 0x04 /* Negotiate size */ +#define CCTL_SPXII 0x08 /* Set for SPX2 */ +#define CCTL_EOM 0x10 /* End of message marker */ +#define CCTL_URG 0x20 /* Urgent marker in SPP (not used in SPX?) */ +#define CCTL_ACK 0x40 /* Send me an ACK */ +#define CCTL_CTL 0x80 /* Control message */ +#define CCTL_SYS CCTL_CTL /* Spec uses CCTL_SYS */ + +/* Connection state defines */ +#define SPX_CLOSED 7 +#define SPX_CONNECTING 8 +#define SPX_CONNECTED 9 + +/* Packet transmit types - Internal */ +#define DATA 0 /* Data */ +#define ACK 1 /* Data ACK */ +#define WDACK 2 /* WD ACK */ +#define CONACK 3 /* Connection Request ACK */ +#define CONREQ 4 /* Connection Request */ +#define WDREQ 5 /* WD Request */ +#define DISCON 6 /* Informed Disconnect */ +#define DISACK 7 /* Informed Disconnect ACK */ +#define RETRAN 8 /* Int. Retransmit of packet */ +#define TQUEUE 9 /* Int. Transmit of a queued packet */ + +/* + * These are good canidates for IOcontrol calls + */ + +/* Watchdog defines */ +#define VERIFY_TIMEOUT 3 * HZ +#define ABORT_TIMEOUT 30 * HZ + +/* Packet retransmit defines */ +#define RETRY_COUNT 10 +#define RETRY_TIME 1 * HZ +#define MAX_RETRY_DELAY 5 * HZ + +#endif /* __KERNEL__ */ +#endif /* def __NET_SPX_H */ diff --git a/pfinet/linux-src/include/net/spxcall.h b/pfinet/linux-src/include/net/spxcall.h new file mode 100644 index 00000000..0461fbbe --- /dev/null +++ b/pfinet/linux-src/include/net/spxcall.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void spx_proto_init(struct net_proto *pro); diff --git a/pfinet/linux-src/include/net/tcp.h b/pfinet/linux-src/include/net/tcp.h new file mode 100644 index 00000000..8b050c63 --- /dev/null +++ b/pfinet/linux-src/include/net/tcp.h @@ -0,0 +1,1100 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the TCP module. + * + * Version: @(#)tcp.h 1.0.5 05/23/93 + * + * Authors: Ross Biro, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * + * 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. + */ +#ifndef _TCP_H +#define _TCP_H + +#include <linux/config.h> +#include <linux/tcp.h> +#include <linux/slab.h> +#include <net/checksum.h> + +/* This is for all connections with a full identity, no wildcards. + * New scheme, half the table is for TIME_WAIT, the other half is + * for the rest. I'll experiment with dynamic table growth later. + */ +#define TCP_HTABLE_SIZE 512 + +/* This is for listening sockets, thus all sockets which possess wildcards. */ +#define TCP_LHTABLE_SIZE 32 /* Yes, really, this is all you need. */ + +/* This is for all sockets, to keep track of the local port allocations. */ +#define TCP_BHTABLE_SIZE 512 + +/* tcp_ipv4.c: These need to be shared by v4 and v6 because the lookup + * and hashing code needs to work with different AF's yet + * the port space is shared. + */ +extern struct sock *tcp_established_hash[TCP_HTABLE_SIZE]; +extern struct sock *tcp_listening_hash[TCP_LHTABLE_SIZE]; + +/* There are a few simple rules, which allow for local port reuse by + * an application. In essence: + * + * 1) Sockets bound to different interfaces may share a local port. + * Failing that, goto test 2. + * 2) If all sockets have sk->reuse set, and none of them are in + * TCP_LISTEN state, the port may be shared. + * Failing that, goto test 3. + * 3) If all sockets are bound to a specific sk->rcv_saddr local + * address, and none of them are the same, the port may be + * shared. + * Failing this, the port cannot be shared. + * + * The interesting point, is test #2. This is what an FTP server does + * all day. To optimize this case we use a specific flag bit defined + * below. As we add sockets to a bind bucket list, we perform a + * check of: (newsk->reuse && (newsk->state != TCP_LISTEN)) + * As long as all sockets added to a bind bucket pass this test, + * the flag bit will be set. + * The resulting situation is that tcp_v[46]_verify_bind() can just check + * for this flag bit, if it is set and the socket trying to bind has + * sk->reuse set, we don't even have to walk the owners list at all, + * we return that it is ok to bind this socket to the requested local port. + * + * Sounds like a lot of work, but it is worth it. In a more naive + * implementation (ie. current FreeBSD etc.) the entire list of ports + * must be walked for each data port opened by an ftp server. Needless + * to say, this does not scale at all. With a couple thousand FTP + * users logged onto your box, isn't it nice to know that new data + * ports are created in O(1) time? I thought so. ;-) -DaveM + */ +struct tcp_bind_bucket { + unsigned short port; + unsigned short fastreuse; + struct tcp_bind_bucket *next; + struct sock *owners; + struct tcp_bind_bucket **pprev; +}; + +extern struct tcp_bind_bucket *tcp_bound_hash[TCP_BHTABLE_SIZE]; +extern kmem_cache_t *tcp_bucket_cachep; +extern struct tcp_bind_bucket *tcp_bucket_create(unsigned short snum); +extern void tcp_bucket_unlock(struct sock *sk); +extern int tcp_port_rover; + +/* Level-1 socket-demux cache. */ +#define TCP_NUM_REGS 32 +extern struct sock *tcp_regs[TCP_NUM_REGS]; + +#define TCP_RHASH_FN(__fport) \ + ((((__fport) >> 7) ^ (__fport)) & (TCP_NUM_REGS - 1)) +#define TCP_RHASH(__fport) tcp_regs[TCP_RHASH_FN((__fport))] +#define TCP_SK_RHASH_FN(__sock) TCP_RHASH_FN((__sock)->dport) +#define TCP_SK_RHASH(__sock) tcp_regs[TCP_SK_RHASH_FN((__sock))] + +static __inline__ void tcp_reg_zap(struct sock *sk) +{ + struct sock **rpp; + + rpp = &(TCP_SK_RHASH(sk)); + if(*rpp == sk) + *rpp = NULL; +} + +/* These are AF independent. */ +static __inline__ int tcp_bhashfn(__u16 lport) +{ + return (lport & (TCP_BHTABLE_SIZE - 1)); +} + +/* This is a TIME_WAIT bucket. It works around the memory consumption + * problems of sockets in such a state on heavily loaded servers, but + * without violating the protocol specification. + */ +struct tcp_tw_bucket { + /* These _must_ match the beginning of struct sock precisely. + * XXX Yes I know this is gross, but I'd have to edit every single + * XXX networking file if I created a "struct sock_header". -DaveM + * Just don't forget -fno-strict-aliasing, but it should be really + * fixed -AK + */ + struct sock *sklist_next; + struct sock *sklist_prev; + struct sock *bind_next; + struct sock **bind_pprev; + __u32 daddr; + __u32 rcv_saddr; + __u16 dport; + unsigned short num; + int bound_dev_if; + struct sock *next; + struct sock **pprev; + unsigned char state, + zapped; + __u16 sport; + unsigned short family; + unsigned char reuse, + nonagle; + + /* And these are ours. */ + __u32 rcv_nxt, snd_nxt; + __u16 window; + struct tcp_func *af_specific; + struct tcp_bind_bucket *tb; + struct tcp_tw_bucket *next_death; + struct tcp_tw_bucket **pprev_death; + int death_slot; + +#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE) + struct in6_addr v6_daddr; + struct in6_addr v6_rcv_saddr; +#endif +}; + +extern kmem_cache_t *tcp_timewait_cachep; + +/* Socket demux engine toys. */ +#ifdef __BIG_ENDIAN +#define TCP_COMBINED_PORTS(__sport, __dport) \ + (((__u32)(__sport)<<16) | (__u32)(__dport)) +#else /* __LITTLE_ENDIAN */ +#define TCP_COMBINED_PORTS(__sport, __dport) \ + (((__u32)(__dport)<<16) | (__u32)(__sport)) +#endif + +#if (BITS_PER_LONG == 64) +#ifdef __BIG_ENDIAN +#define TCP_V4_ADDR_COOKIE(__name, __saddr, __daddr) \ + __u64 __name = (((__u64)(__saddr))<<32)|((__u64)(__daddr)); +#else /* __LITTLE_ENDIAN */ +#define TCP_V4_ADDR_COOKIE(__name, __saddr, __daddr) \ + __u64 __name = (((__u64)(__daddr))<<32)|((__u64)(__saddr)); +#endif /* __BIG_ENDIAN */ +#define TCP_IPV4_MATCH(__sk, __cookie, __saddr, __daddr, __ports, __dif)\ + (((*((__u64 *)&((__sk)->daddr)))== (__cookie)) && \ + ((*((__u32 *)&((__sk)->dport)))== (__ports)) && \ + (!((__sk)->bound_dev_if) || ((__sk)->bound_dev_if == (__dif)))) +#else /* 32-bit arch */ +#define TCP_V4_ADDR_COOKIE(__name, __saddr, __daddr) +#define TCP_IPV4_MATCH(__sk, __cookie, __saddr, __daddr, __ports, __dif)\ + (((__sk)->daddr == (__saddr)) && \ + ((__sk)->rcv_saddr == (__daddr)) && \ + ((*((__u32 *)&((__sk)->dport)))== (__ports)) && \ + (!((__sk)->bound_dev_if) || ((__sk)->bound_dev_if == (__dif)))) +#endif /* 64-bit arch */ + +#define TCP_IPV6_MATCH(__sk, __saddr, __daddr, __ports, __dif) \ + (((*((__u32 *)&((__sk)->dport)))== (__ports)) && \ + ((__sk)->family == AF_INET6) && \ + !ipv6_addr_cmp(&(__sk)->net_pinfo.af_inet6.daddr, (__saddr)) && \ + !ipv6_addr_cmp(&(__sk)->net_pinfo.af_inet6.rcv_saddr, (__daddr)) && \ + (!((__sk)->bound_dev_if) || ((__sk)->bound_dev_if == (__dif)))) + +/* These can have wildcards, don't try too hard. */ +static __inline__ int tcp_lhashfn(unsigned short num) +{ + return num & (TCP_LHTABLE_SIZE - 1); +} + +static __inline__ int tcp_sk_listen_hashfn(struct sock *sk) +{ + return tcp_lhashfn(sk->num); +} + +/* Note, that it is > than ipv6 header */ +#define NETHDR_SIZE (sizeof(struct iphdr) + 40) + +/* + * 40 is maximal IP options size + * 20 is the maximum TCP options size we can currently construct on a SYN. + * 40 is the maximum possible TCP options size. + */ + +#define MAX_SYN_SIZE (NETHDR_SIZE + sizeof(struct tcphdr) + 20 + MAX_HEADER + 15) +#define MAX_FIN_SIZE (NETHDR_SIZE + sizeof(struct tcphdr) + MAX_HEADER + 15) +#define BASE_ACK_SIZE (NETHDR_SIZE + MAX_HEADER + 15) +#define MAX_ACK_SIZE (NETHDR_SIZE + sizeof(struct tcphdr) + MAX_HEADER + 15) +#define MAX_RESET_SIZE (NETHDR_SIZE + sizeof(struct tcphdr) + MAX_HEADER + 15) +#define MAX_TCPHEADER_SIZE (NETHDR_SIZE + sizeof(struct tcphdr) + 20 + MAX_HEADER + 15) + +/* + * Never offer a window over 32767 without using window scaling. Some + * poor stacks do signed 16bit maths! + */ +#define MAX_WINDOW 32767 +#define MIN_WINDOW 2048 +#define MAX_ACK_BACKLOG 2 +#define MAX_DELAY_ACK 2 +#define TCP_WINDOW_DIFF 2048 + +/* urg_data states */ +#define URG_VALID 0x0100 +#define URG_NOTYET 0x0200 +#define URG_READ 0x0400 + +#define TCP_RETR1 7 /* + * This is how many retries it does before it + * tries to figure out if the gateway is + * down. + */ + +#define TCP_RETR2 15 /* + * This should take at least + * 90 minutes to time out. + */ + +#define TCP_TIMEOUT_LEN (15*60*HZ) /* should be about 15 mins */ +#define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to successfully + * close the socket, about 60 seconds */ +#define TCP_FIN_TIMEOUT (3*60*HZ) /* BSD style FIN_WAIT2 deadlock breaker */ + +#define TCP_ACK_TIME (3*HZ) /* time to delay before sending an ACK */ +#define TCP_DONE_TIME (5*HZ/2)/* maximum time to wait before actually + * destroying a socket */ +#define TCP_WRITE_TIME (30*HZ) /* initial time to wait for an ACK, + * after last transmit */ +#define TCP_TIMEOUT_INIT (3*HZ) /* RFC 1122 initial timeout value */ +#define TCP_SYN_RETRIES 10 /* number of times to retry opening a + * connection (TCP_RETR2-....) */ +#define TCP_PROBEWAIT_LEN (1*HZ)/* time to wait between probes when + * I've got something to write and + * there is no window */ +#define TCP_KEEPALIVE_TIME (120*60*HZ) /* two hours */ +#define TCP_KEEPALIVE_PROBES 9 /* Max of 9 keepalive probes */ +#define TCP_KEEPALIVE_PERIOD ((75*HZ)>>2) /* period of keepalive check */ + +#define TCP_SYNACK_PERIOD (HZ/2) /* How often to run the synack slow timer */ +#define TCP_QUICK_TRIES 8 /* How often we try to retransmit, until + * we tell the link layer that it is something + * wrong (e.g. that it can expire redirects) */ + +#define TCP_BUCKETGC_PERIOD (HZ) + +/* TIME_WAIT reaping mechanism. */ +#define TCP_TWKILL_SLOTS 8 /* Please keep this a power of 2. */ +#define TCP_TWKILL_PERIOD ((HZ*60)/TCP_TWKILL_SLOTS) + +/* + * TCP option + */ + +#define TCPOPT_NOP 1 /* Padding */ +#define TCPOPT_EOL 0 /* End of options */ +#define TCPOPT_MSS 2 /* Segment size negotiating */ +#define TCPOPT_WINDOW 3 /* Window scaling */ +#define TCPOPT_SACK_PERM 4 /* SACK Permitted */ +#define TCPOPT_SACK 5 /* SACK Block */ +#define TCPOPT_TIMESTAMP 8 /* Better RTT estimations/PAWS */ + +/* + * TCP option lengths + */ + +#define TCPOLEN_MSS 4 +#define TCPOLEN_WINDOW 3 +#define TCPOLEN_SACK_PERM 2 +#define TCPOLEN_TIMESTAMP 10 + +/* But this is what stacks really send out. */ +#define TCPOLEN_TSTAMP_ALIGNED 12 +#define TCPOLEN_WSCALE_ALIGNED 4 +#define TCPOLEN_SACKPERM_ALIGNED 4 +#define TCPOLEN_SACK_BASE 2 +#define TCPOLEN_SACK_BASE_ALIGNED 4 +#define TCPOLEN_SACK_PERBLOCK 8 + +struct open_request; + +struct or_calltable { + void (*rtx_syn_ack) (struct sock *sk, struct open_request *req); + void (*destructor) (struct open_request *req); + void (*send_reset) (struct sk_buff *skb); +}; + +struct tcp_v4_open_req { + __u32 loc_addr; + __u32 rmt_addr; + struct ip_options *opt; +}; + +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) +struct tcp_v6_open_req { + struct in6_addr loc_addr; + struct in6_addr rmt_addr; + struct sk_buff *pktopts; + int iif; +}; +#endif + +/* this structure is too big */ +struct open_request { + struct open_request *dl_next; /* Must be first member! */ + __u32 rcv_isn; + __u32 snt_isn; + __u16 rmt_port; + __u16 mss; + __u8 retrans; + __u8 __pad; + unsigned snd_wscale : 4, + rcv_wscale : 4, + tstamp_ok : 1, + sack_ok : 1, + wscale_ok : 1; + /* The following two fields can be easily recomputed I think -AK */ + __u32 window_clamp; /* window clamp at creation time */ + __u32 rcv_wnd; /* rcv_wnd offered first time */ + __u32 ts_recent; + unsigned long expires; + struct or_calltable *class; + struct sock *sk; + union { + struct tcp_v4_open_req v4_req; +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) + struct tcp_v6_open_req v6_req; +#endif + } af; +#ifdef CONFIG_IP_TRANSPARENT_PROXY + __u16 lcl_port; /* LVE */ +#endif +}; + +/* SLAB cache for open requests. */ +extern kmem_cache_t *tcp_openreq_cachep; + +#define tcp_openreq_alloc() kmem_cache_alloc(tcp_openreq_cachep, SLAB_ATOMIC) +#define tcp_openreq_free(req) kmem_cache_free(tcp_openreq_cachep, req) + +/* + * Pointers to address related TCP functions + * (i.e. things that depend on the address family) + * + * BUGGG_FUTURE: all the idea behind this struct is wrong. + * It mixes socket frontend with transport function. + * With port sharing between IPv6/v4 it gives the only advantage, + * only poor IPv6 needs to permanently recheck, that it + * is still IPv6 8)8) It must be cleaned up as soon as possible. + * --ANK (980802) + */ + +struct tcp_func { + void (*queue_xmit) (struct sk_buff *skb); + + void (*send_check) (struct sock *sk, + struct tcphdr *th, + int len, + struct sk_buff *skb); + + int (*rebuild_header) (struct sock *sk); + + int (*conn_request) (struct sock *sk, + struct sk_buff *skb, + __u32 isn); + + struct sock * (*syn_recv_sock) (struct sock *sk, + struct sk_buff *skb, + struct open_request *req, + struct dst_entry *dst); + + struct sock * (*get_sock) (struct sk_buff *skb, + struct tcphdr *th); + + __u16 net_header_len; + + + + int (*setsockopt) (struct sock *sk, + int level, + int optname, + char *optval, + int optlen); + + int (*getsockopt) (struct sock *sk, + int level, + int optname, + char *optval, + int *optlen); + + + void (*addr2sockaddr) (struct sock *sk, + struct sockaddr *); + + int sockaddr_len; +}; + +/* + * The next routines deal with comparing 32 bit unsigned ints + * and worry about wraparound (automatic with unsigned arithmetic). + */ + +extern __inline int before(__u32 seq1, __u32 seq2) +{ + return (__s32)(seq1-seq2) < 0; +} + +extern __inline int after(__u32 seq1, __u32 seq2) +{ + return (__s32)(seq2-seq1) < 0; +} + + +/* is s2<=s1<=s3 ? */ +extern __inline int between(__u32 seq1, __u32 seq2, __u32 seq3) +{ + return seq3 - seq2 >= seq1 - seq2; +} + + +extern struct proto tcp_prot; +extern struct tcp_mib tcp_statistics; + +extern void tcp_put_port(struct sock *sk); +extern void __tcp_put_port(struct sock *sk); +extern void tcp_inherit_port(struct sock *sk, struct sock *child); + +extern void tcp_v4_err(struct sk_buff *skb, + unsigned char *, int); + +extern void tcp_shutdown (struct sock *sk, int how); + +extern int tcp_v4_rcv(struct sk_buff *skb, + unsigned short len); + +extern int tcp_do_sendmsg(struct sock *sk, struct msghdr *msg); + +extern int tcp_ioctl(struct sock *sk, + int cmd, + unsigned long arg); + +extern int tcp_rcv_state_process(struct sock *sk, + struct sk_buff *skb, + struct tcphdr *th, + unsigned len); + +extern int tcp_rcv_established(struct sock *sk, + struct sk_buff *skb, + struct tcphdr *th, + unsigned len); + +enum tcp_tw_status { + TCP_TW_SUCCESS = 0, + TCP_TW_RST = 1, + TCP_TW_ACK = 2 + }; + +extern enum tcp_tw_status tcp_timewait_state_process(struct tcp_tw_bucket *tw, + struct sk_buff *skb, + struct tcphdr *th, + unsigned len); + +extern void tcp_close(struct sock *sk, + long timeout); +extern struct sock * tcp_accept(struct sock *sk, int flags); +extern unsigned int tcp_poll(struct file * file, struct socket *sock, struct poll_table_struct *wait); +extern void tcp_write_space(struct sock *sk); + +extern int tcp_getsockopt(struct sock *sk, int level, + int optname, char *optval, + int *optlen); +extern int tcp_setsockopt(struct sock *sk, int level, + int optname, char *optval, + int optlen); +extern void tcp_set_keepalive(struct sock *sk, int val); +extern int tcp_recvmsg(struct sock *sk, + struct msghdr *msg, + int len, int nonblock, + int flags, int *addr_len); + +extern void tcp_parse_options(struct sock *sk, struct tcphdr *th, + struct tcp_opt *tp, int no_fancy); + +/* + * TCP v4 functions exported for the inet6 API + */ + +extern int tcp_v4_rebuild_header(struct sock *sk); + +extern int tcp_v4_build_header(struct sock *sk, + struct sk_buff *skb); + +extern void tcp_v4_send_check(struct sock *sk, + struct tcphdr *th, int len, + struct sk_buff *skb); + +extern int tcp_v4_conn_request(struct sock *sk, + struct sk_buff *skb, + __u32 isn); + +extern struct sock * tcp_create_openreq_child(struct sock *sk, + struct open_request *req, + struct sk_buff *skb); + +extern struct sock * tcp_v4_syn_recv_sock(struct sock *sk, + struct sk_buff *skb, + struct open_request *req, + struct dst_entry *dst); + +extern int tcp_v4_do_rcv(struct sock *sk, + struct sk_buff *skb); + +extern int tcp_v4_connect(struct sock *sk, + struct sockaddr *uaddr, + int addr_len); + +extern void tcp_connect(struct sock *sk, + struct sk_buff *skb, + int est_mss); + +extern struct sk_buff * tcp_make_synack(struct sock *sk, + struct dst_entry *dst, + struct open_request *req, + int mss); + + +/* From syncookies.c */ +extern struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb, + struct ip_options *opt); +extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, + __u16 *mss); + +/* tcp_output.c */ + +extern void tcp_read_wakeup(struct sock *); +extern void tcp_write_xmit(struct sock *); +extern void tcp_time_wait(struct sock *); +extern int tcp_retransmit_skb(struct sock *, struct sk_buff *); +extern void tcp_fack_retransmit(struct sock *); +extern void tcp_xmit_retransmit_queue(struct sock *); +extern void tcp_simple_retransmit(struct sock *); + +extern void tcp_send_probe0(struct sock *); +extern void tcp_send_partial(struct sock *); +extern void tcp_write_wakeup(struct sock *); +extern void tcp_send_fin(struct sock *sk); +extern void tcp_send_active_reset(struct sock *sk); +extern int tcp_send_synack(struct sock *); +extern void tcp_transmit_skb(struct sock *, struct sk_buff *); +extern void tcp_send_skb(struct sock *, struct sk_buff *, int force_queue); +extern void tcp_send_ack(struct sock *sk); +extern void tcp_send_delayed_ack(struct tcp_opt *tp, int max_timeout); + +/* CONFIG_IP_TRANSPARENT_PROXY */ +extern int tcp_chkaddr(struct sk_buff *); + +/* tcp_timer.c */ +#define tcp_reset_msl_timer(x,y,z) net_reset_timer(x,y,z) +extern void tcp_reset_xmit_timer(struct sock *, int, unsigned long); +extern void tcp_init_xmit_timers(struct sock *); +extern void tcp_clear_xmit_timers(struct sock *); + +extern void tcp_retransmit_timer(unsigned long); +extern void tcp_delack_timer(unsigned long); +extern void tcp_probe_timer(unsigned long); + +extern struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb, + struct open_request *req); + +/* + * TCP slow timer + */ +extern struct timer_list tcp_slow_timer; + +struct tcp_sl_timer { + atomic_t count; + unsigned long period; + unsigned long last; + void (*handler) (unsigned long); +}; + +#define TCP_SLT_SYNACK 0 +#define TCP_SLT_KEEPALIVE 1 +#define TCP_SLT_TWKILL 2 +#define TCP_SLT_MAX 3 + +extern struct tcp_sl_timer tcp_slt_array[TCP_SLT_MAX]; + +extern int tcp_sync_mss(struct sock *sk, u32 pmtu); + +/* Compute the current effective MSS, taking SACKs and IP options, + * and even PMTU discovery events into account. + */ + +static __inline__ unsigned int tcp_current_mss(struct sock *sk) +{ + struct tcp_opt *tp = &sk->tp_pinfo.af_tcp; + struct dst_entry *dst = sk->dst_cache; + int mss_now = tp->mss_cache; + + if (dst && dst->pmtu != tp->pmtu_cookie) + mss_now = tcp_sync_mss(sk, dst->pmtu); + + if(tp->sack_ok && tp->num_sacks) + mss_now -= (TCPOLEN_SACK_BASE_ALIGNED + + (tp->num_sacks * TCPOLEN_SACK_PERBLOCK)); + return mss_now > 8 ? mss_now : 8; +} + +/* Compute the actual receive window we are currently advertising. + * Rcv_nxt can be after the window if our peer push more data + * than the offered window. + */ +static __inline__ u32 tcp_receive_window(struct tcp_opt *tp) +{ + s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt; + + if (win < 0) + win = 0; + return (u32) win; +} + +/* Choose a new window, without checks for shrinking, and without + * scaling applied to the result. The caller does these things + * if necessary. This is a "raw" window selection. + */ +extern u32 __tcp_select_window(struct sock *sk); + +/* Chose a new window to advertise, update state in tcp_opt for the + * socket, and return result with RFC1323 scaling applied. The return + * value can be stuffed directly into th->window for an outgoing + * frame. + */ +extern __inline__ u16 tcp_select_window(struct sock *sk) +{ + struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp); + u32 cur_win = tcp_receive_window(tp); + u32 new_win = __tcp_select_window(sk); + + /* Never shrink the offered window */ + if(new_win < cur_win) { + /* Danger Will Robinson! + * Don't update rcv_wup/rcv_wnd here or else + * we will not be able to advertise a zero + * window in time. --DaveM + */ + new_win = cur_win; + } else { + tp->rcv_wnd = new_win; + tp->rcv_wup = tp->rcv_nxt; + } + + /* RFC1323 scaling applied */ + return new_win >> tp->rcv_wscale; +} + +/* See if we can advertise non-zero, and if so how much we + * can increase our advertisement. If it becomes more than + * twice what we are talking about right now, return true. + */ +extern __inline__ int tcp_raise_window(struct sock *sk) +{ + struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp); + u32 cur_win = tcp_receive_window(tp); + u32 new_win = __tcp_select_window(sk); + + return (new_win && (new_win > (cur_win << 1))); +} + +/* Recalculate snd_ssthresh, we want to set it to: + * + * one half the current congestion window, but no + * less than two segments + * + * We must take into account the current send window + * as well, however we keep track of that using different + * units so a conversion is necessary. -DaveM + */ +extern __inline__ __u32 tcp_recalc_ssthresh(struct tcp_opt *tp) +{ + __u32 snd_wnd_packets = tp->snd_wnd / max(tp->mss_cache, 1); + + return max(min(snd_wnd_packets, tp->snd_cwnd) >> 1, 2); +} + +/* TCP timestamps are only 32-bits, this causes a slight + * complication on 64-bit systems since we store a snapshot + * of jiffies in the buffer control blocks below. We decidely + * only use of the low 32-bits of jiffies and hide the ugly + * casts with the following macro. + */ +#define tcp_time_stamp ((__u32)(jiffies)) + +/* This is what the send packet queueing engine uses to pass + * TCP per-packet control information to the transmission + * code. We also store the host-order sequence numbers in + * here too. This is 36 bytes on 32-bit architectures, + * 40 bytes on 64-bit machines, if this grows please adjust + * skbuff.h:skbuff->cb[xxx] size appropriately. + */ +struct tcp_skb_cb { + union { + struct inet_skb_parm h4; +#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE) + struct inet6_skb_parm h6; +#endif + } header; /* For incoming frames */ + __u32 seq; /* Starting sequence number */ + __u32 end_seq; /* SEQ + FIN + SYN + datalen */ + __u32 when; /* used to compute rtt's */ + __u8 flags; /* TCP header flags. */ + + /* NOTE: These must match up to the flags byte in a + * real TCP header. + */ +#define TCPCB_FLAG_FIN 0x01 +#define TCPCB_FLAG_SYN 0x02 +#define TCPCB_FLAG_RST 0x04 +#define TCPCB_FLAG_PSH 0x08 +#define TCPCB_FLAG_ACK 0x10 +#define TCPCB_FLAG_URG 0x20 + + __u8 sacked; /* State flags for SACK/FACK. */ +#define TCPCB_SACKED_ACKED 0x01 /* SKB ACK'd by a SACK block */ +#define TCPCB_SACKED_RETRANS 0x02 /* SKB retransmitted */ + + __u16 urg_ptr; /* Valid w/URG flags is set. */ + __u32 ack_seq; /* Sequence number ACK'd */ +}; + +#define TCP_SKB_CB(__skb) ((struct tcp_skb_cb *)&((__skb)->cb[0])) + +/* This determines how many packets are "in the network" to the best + * of our knowledge. In many cases it is conservative, but where + * detailed information is available from the receiver (via SACK + * blocks etc.) we can make more aggressive calculations. + * + * Use this for decisions involving congestion control, use just + * tp->packets_out to determine if the send queue is empty or not. + * + * Read this equation as: + * + * "Packets sent once on transmission queue" MINUS + * "Packets acknowledged by FACK information" PLUS + * "Packets fast retransmitted" + */ +static __inline__ int tcp_packets_in_flight(struct tcp_opt *tp) +{ + return tp->packets_out - tp->fackets_out + tp->retrans_out; +} + +/* This checks if the data bearing packet SKB (usually tp->send_head) + * should be put on the wire right now. + */ +static __inline__ int tcp_snd_test(struct sock *sk, struct sk_buff *skb) +{ + struct tcp_opt *tp = &(sk->tp_pinfo.af_tcp); + int nagle_check = 1; + + /* RFC 1122 - section 4.2.3.4 + * + * We must queue if + * + * a) The right edge of this frame exceeds the window + * b) There are packets in flight and we have a small segment + * [SWS avoidance and Nagle algorithm] + * (part of SWS is done on packetization) + * c) We are retransmiting [Nagle] + * d) We have too many packets 'in flight' + * + * Don't use the nagle rule for urgent data (or + * for the final FIN -DaveM). + */ + if ((sk->nonagle == 2 && (skb->len < tp->mss_cache)) || + (!sk->nonagle && + skb->len < (tp->mss_cache >> 1) && + tp->packets_out && + !(TCP_SKB_CB(skb)->flags & (TCPCB_FLAG_URG|TCPCB_FLAG_FIN)))) + nagle_check = 0; + + /* Don't be strict about the congestion window for the + * final FIN frame. -DaveM + */ + return (nagle_check && + ((tcp_packets_in_flight(tp) < tp->snd_cwnd) || + (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN)) && + !after(TCP_SKB_CB(skb)->end_seq, tp->snd_una + tp->snd_wnd) && + tp->retransmits == 0); +} + +/* Push out any pending frames which were held back due to + * TCP_CORK or attempt at coalescing tiny packets. + * The socket must be locked by the caller. + */ +static __inline__ void tcp_push_pending_frames(struct sock *sk, struct tcp_opt *tp) +{ + if(tp->send_head) { + if(tcp_snd_test(sk, tp->send_head)) + tcp_write_xmit(sk); + else if(tp->packets_out == 0 && !tp->pending) { + /* We held off on this in tcp_send_skb() */ + tp->pending = TIME_PROBE0; + tcp_reset_xmit_timer(sk, TIME_PROBE0, tp->rto); + } + } +} + +/* This tells the input processing path that an ACK should go out + * right now. + */ +#define tcp_enter_quickack_mode(__tp) ((__tp)->ato |= (1<<31)) +#define tcp_exit_quickack_mode(__tp) ((__tp)->ato &= ~(1<<31)) +#define tcp_in_quickack_mode(__tp) (((__tp)->ato & (1 << 31)) != 0) + +/* + * List all states of a TCP socket that can be viewed as a "connected" + * state. This now includes TCP_SYN_RECV, although I am not yet fully + * convinced that this is the solution for the 'getpeername(2)' + * problem. Thanks to Stephen A. Wood <saw@cebaf.gov> -FvK + */ + +extern __inline const int tcp_connected(const int state) +{ + return ((1 << state) & + (TCPF_ESTABLISHED|TCPF_CLOSE_WAIT|TCPF_FIN_WAIT1| + TCPF_FIN_WAIT2|TCPF_SYN_RECV)); +} + +/* + * Calculate(/check) TCP checksum + */ +static __inline__ u16 tcp_v4_check(struct tcphdr *th, int len, + unsigned long saddr, unsigned long daddr, + unsigned long base) +{ + return csum_tcpudp_magic(saddr,daddr,len,IPPROTO_TCP,base); +} + +#undef STATE_TRACE + +#ifdef STATE_TRACE +static char *statename[]={ + "Unused","Established","Syn Sent","Syn Recv", + "Fin Wait 1","Fin Wait 2","Time Wait", "Close", + "Close Wait","Last ACK","Listen","Closing" +}; +#endif + +static __inline__ void tcp_set_state(struct sock *sk, int state) +{ + int oldstate = sk->state; + + sk->state = state; + +#ifdef STATE_TRACE + SOCK_DEBUG(sk, "TCP sk=%p, State %s -> %s\n",sk, statename[oldstate],statename[state]); +#endif + + switch (state) { + case TCP_ESTABLISHED: + if (oldstate != TCP_ESTABLISHED) + tcp_statistics.TcpCurrEstab++; + break; + + case TCP_CLOSE: + { + struct tcp_opt *tp = &sk->tp_pinfo.af_tcp; + /* Should be about 2 rtt's */ + net_reset_timer(sk, TIME_DONE, min(tp->srtt * 2, TCP_DONE_TIME)); + sk->prot->unhash(sk); + /* fall through */ + } + default: + if (oldstate==TCP_ESTABLISHED) + tcp_statistics.TcpCurrEstab--; + } +} + +static __inline__ void tcp_build_and_update_options(__u32 *ptr, struct tcp_opt *tp, __u32 tstamp) +{ + if (tp->tstamp_ok) { + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | + (TCPOPT_NOP << 16) | + (TCPOPT_TIMESTAMP << 8) | + TCPOLEN_TIMESTAMP); + *ptr++ = htonl(tstamp); + *ptr++ = htonl(tp->ts_recent); + } + if(tp->sack_ok && tp->num_sacks) { + int this_sack; + + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | + (TCPOPT_NOP << 16) | + (TCPOPT_SACK << 8) | + (TCPOLEN_SACK_BASE + + (tp->num_sacks * TCPOLEN_SACK_PERBLOCK))); + for(this_sack = 0; this_sack < tp->num_sacks; this_sack++) { + *ptr++ = htonl(tp->selective_acks[this_sack].start_seq); + *ptr++ = htonl(tp->selective_acks[this_sack].end_seq); + } + } +} + +/* Construct a tcp options header for a SYN or SYN_ACK packet. + * If this is every changed make sure to change the definition of + * MAX_SYN_SIZE to match the new maximum number of options that you + * can generate. + */ +extern __inline__ void tcp_syn_build_options(__u32 *ptr, int mss, int ts, int sack, + int offer_wscale, int wscale, __u32 tstamp, __u32 ts_recent) +{ + /* We always get an MSS option. + * The option bytes which will be seen in normal data + * packets should timestamps be used, must be in the MSS + * advertised. But we subtract them from sk->mss so + * that calculations in tcp_sendmsg are simpler etc. + * So account for this fact here if necessary. If we + * don't do this correctly, as a receiver we won't + * recognize data packets as being full sized when we + * should, and thus we won't abide by the delayed ACK + * rules correctly. + * SACKs don't matter, we never delay an ACK when we + * have any of those going out. + */ + *ptr++ = htonl((TCPOPT_MSS << 24) | (TCPOLEN_MSS << 16) | mss); + if (ts) { + if(sack) + *ptr++ = __constant_htonl((TCPOPT_SACK_PERM << 24) | (TCPOLEN_SACK_PERM << 16) | + (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); + else + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | + (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP); + *ptr++ = htonl(tstamp); /* TSVAL */ + *ptr++ = htonl(ts_recent); /* TSECR */ + } else if(sack) + *ptr++ = __constant_htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) | + (TCPOPT_SACK_PERM << 8) | TCPOLEN_SACK_PERM); + if (offer_wscale) + *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_WINDOW << 16) | (TCPOLEN_WINDOW << 8) | (wscale)); +} + +/* Determine a window scaling and initial window to offer. + * Based on the assumption that the given amount of space + * will be offered. Store the results in the tp structure. + * NOTE: for smooth operation initial space offering should + * be a multiple of mss if possible. We assume here that mss >= 1. + * This MUST be enforced by all callers. + */ +extern __inline__ void tcp_select_initial_window(__u32 space, __u16 mss, + __u32 *rcv_wnd, + __u32 *window_clamp, + int wscale_ok, + __u8 *rcv_wscale) +{ + /* If no clamp set the clamp to the max possible scaled window */ + if (*window_clamp == 0) + (*window_clamp) = (65535<<14); + space = min(*window_clamp,space); + + /* Quantize space offering to a multiple of mss if possible. */ + if (space > mss) + space = (space/mss)*mss; + + /* NOTE: offering an initial window larger than 32767 + * will break some buggy TCP stacks. We try to be nice. + * If we are not window scaling, then this truncates + * our initial window offering to 32k. There should also + * be a sysctl option to stop being nice. + */ + (*rcv_wnd) = min(space, MAX_WINDOW); + (*rcv_wscale) = 0; + if (wscale_ok) { + /* See RFC1323 for an explanation of the limit to 14 */ + while (space > 65535 && (*rcv_wscale) < 14) { + space >>= 1; + (*rcv_wscale)++; + } + } + /* Set the clamp no higher than max representable value */ + (*window_clamp) = min(65535<<(*rcv_wscale),*window_clamp); +} + +extern __inline__ void tcp_synq_unlink(struct tcp_opt *tp, struct open_request *req, struct open_request *prev) +{ + if(!req->dl_next) + tp->syn_wait_last = (struct open_request **)prev; + prev->dl_next = req->dl_next; +} + +extern __inline__ void tcp_synq_queue(struct tcp_opt *tp, struct open_request *req) +{ + req->dl_next = NULL; + *tp->syn_wait_last = req; + tp->syn_wait_last = &req->dl_next; +} + +extern __inline__ void tcp_synq_init(struct tcp_opt *tp) +{ + tp->syn_wait_queue = NULL; + tp->syn_wait_last = &tp->syn_wait_queue; +} + +extern void __tcp_inc_slow_timer(struct tcp_sl_timer *slt); +extern __inline__ void tcp_inc_slow_timer(int timer) +{ + struct tcp_sl_timer *slt = &tcp_slt_array[timer]; + + if (atomic_read(&slt->count) == 0) + { + __tcp_inc_slow_timer(slt); + } + + atomic_inc(&slt->count); +} + +extern __inline__ void tcp_dec_slow_timer(int timer) +{ + struct tcp_sl_timer *slt = &tcp_slt_array[timer]; + + atomic_dec(&slt->count); +} + +extern const char timer_bug_msg[]; + +static inline void tcp_clear_xmit_timer(struct sock *sk, int what) +{ + struct tcp_opt *tp = &sk->tp_pinfo.af_tcp; + struct timer_list *timer; + + switch (what) { + case TIME_RETRANS: + timer = &tp->retransmit_timer; + break; + case TIME_DACK: + timer = &tp->delack_timer; + break; + case TIME_PROBE0: + timer = &tp->probe_timer; + break; + default: + printk(timer_bug_msg); + return; + }; + if(timer->prev != NULL) + del_timer(timer); +} + +static inline int tcp_timer_is_set(struct sock *sk, int what) +{ + struct tcp_opt *tp = &sk->tp_pinfo.af_tcp; + + switch (what) { + case TIME_RETRANS: + return tp->retransmit_timer.prev != NULL; + break; + case TIME_DACK: + return tp->delack_timer.prev != NULL; + break; + case TIME_PROBE0: + return tp->probe_timer.prev != NULL; + break; + default: + printk(timer_bug_msg); + }; + return 0; +} + + +#endif /* _TCP_H */ diff --git a/pfinet/linux-src/include/net/transp_v6.h b/pfinet/linux-src/include/net/transp_v6.h new file mode 100644 index 00000000..d49bc86e --- /dev/null +++ b/pfinet/linux-src/include/net/transp_v6.h @@ -0,0 +1,46 @@ +#ifndef _TRANSP_V6_H +#define _TRANSP_V6_H + +#include <net/checksum.h> + +/* + * IPv6 transport protocols + */ + +#ifdef __KERNEL__ + +extern struct proto rawv6_prot; +extern struct proto udpv6_prot; +extern struct proto tcpv6_prot; + +struct flowi; + +extern void rawv6_init(void); +extern void udpv6_init(void); +extern void tcpv6_init(void); + +extern int udpv6_connect(struct sock *sk, + struct sockaddr *uaddr, + int addr_len); + +extern int datagram_recv_ctl(struct sock *sk, + struct msghdr *msg, + struct sk_buff *skb); + +extern int datagram_send_ctl(struct msghdr *msg, + struct flowi *fl, + struct ipv6_txoptions *opt, + int *hlimit); + +#define LOOPBACK4_IPV6 __constant_htonl(0x7f000006) + +/* + * address family specific functions + */ +extern struct tcp_func ipv4_specific; + +extern int inet6_destroy_sock(struct sock *sk); + +#endif + +#endif diff --git a/pfinet/linux-src/include/net/udp.h b/pfinet/linux-src/include/net/udp.h new file mode 100644 index 00000000..f3ceadb5 --- /dev/null +++ b/pfinet/linux-src/include/net/udp.h @@ -0,0 +1,66 @@ +/* + * INET An implementation of the TCP/IP protocol suite for the LINUX + * operating system. INET is implemented using the BSD Socket + * interface as the means of communication with the user level. + * + * Definitions for the UDP module. + * + * Version: @(#)udp.h 1.0.2 05/07/93 + * + * Authors: Ross Biro, <bir7@leland.Stanford.Edu> + * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> + * + * Fixes: + * Alan Cox : Turned on udp checksums. I don't want to + * chase 'memory corruption' bugs that aren't! + * + * 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. + */ +#ifndef _UDP_H +#define _UDP_H + +#include <linux/udp.h> +#include <net/sock.h> + +#define UDP_HTABLE_SIZE 128 + +/* udp.c: This needs to be shared by v4 and v6 because the lookup + * and hashing code needs to work with different AF's yet + * the port space is shared. + */ +extern struct sock *udp_hash[UDP_HTABLE_SIZE]; + +#define UDP_NO_CHECK 0 + +extern int udp_port_rover; + +static inline int udp_lport_inuse(u16 num) +{ + struct sock *sk = udp_hash[num & (UDP_HTABLE_SIZE - 1)]; + + for(; sk != NULL; sk = sk->next) { + if(sk->num == num) + return 1; + } + return 0; +} + +extern struct proto udp_prot; + + +extern void udp_err(struct sk_buff *, unsigned char *, int); +extern int udp_connect(struct sock *sk, + struct sockaddr *usin, int addr_len); + +extern int udp_sendmsg(struct sock *sk, struct msghdr *msg, int len); + +extern int udp_rcv(struct sk_buff *skb, unsigned short len); +extern int udp_ioctl(struct sock *sk, int cmd, unsigned long arg); + +/* CONFIG_IP_TRANSPARENT_PROXY */ +extern int udp_chkaddr(struct sk_buff *skb); + +#endif /* _UDP_H */ diff --git a/pfinet/linux-src/include/net/x25.h b/pfinet/linux-src/include/net/x25.h new file mode 100644 index 00000000..5ac507bd --- /dev/null +++ b/pfinet/linux-src/include/net/x25.h @@ -0,0 +1,221 @@ +/* + * Declarations of X.25 Packet Layer type objects. + * + * Jonathan Naylor 17/11/96 + */ + +#ifndef _X25_H +#define _X25_H +#include <linux/x25.h> + +#define X25_ADDR_LEN 16 + +#define X25_MAX_L2_LEN 18 /* 802.2 LLC */ + +#define X25_STD_MIN_LEN 3 +#define X25_EXT_MIN_LEN 4 + +#define X25_GFI_SEQ_MASK 0x30 +#define X25_GFI_STDSEQ 0x10 +#define X25_GFI_EXTSEQ 0x20 + +#define X25_Q_BIT 0x80 +#define X25_D_BIT 0x40 +#define X25_STD_M_BIT 0x10 +#define X25_EXT_M_BIT 0x01 + +#define X25_CALL_REQUEST 0x0B +#define X25_CALL_ACCEPTED 0x0F +#define X25_CLEAR_REQUEST 0x13 +#define X25_CLEAR_CONFIRMATION 0x17 +#define X25_DATA 0x00 +#define X25_INTERRUPT 0x23 +#define X25_INTERRUPT_CONFIRMATION 0x27 +#define X25_RR 0x01 +#define X25_RNR 0x05 +#define X25_REJ 0x09 +#define X25_RESET_REQUEST 0x1B +#define X25_RESET_CONFIRMATION 0x1F +#define X25_REGISTRATION_REQUEST 0xF3 +#define X25_REGISTRATION_CONFIRMATION 0xF7 +#define X25_RESTART_REQUEST 0xFB +#define X25_RESTART_CONFIRMATION 0xFF +#define X25_DIAGNOSTIC 0xF1 +#define X25_ILLEGAL 0xFD + +/* Define the various conditions that may exist */ + +#define X25_COND_ACK_PENDING 0x01 +#define X25_COND_OWN_RX_BUSY 0x02 +#define X25_COND_PEER_RX_BUSY 0x04 + +/* Define Link State constants. */ +enum { + X25_STATE_0, /* Ready */ + X25_STATE_1, /* Awaiting Call Accepted */ + X25_STATE_2, /* Awaiting Clear Confirmation */ + X25_STATE_3, /* Data Transfer */ + X25_STATE_4 /* Awaiting Reset Confirmation */ +}; + +enum { + X25_LINK_STATE_0, + X25_LINK_STATE_1, + X25_LINK_STATE_2, + X25_LINK_STATE_3 +}; + +#define X25_DEFAULT_T20 (180 * HZ) /* Default T20 value */ +#define X25_DEFAULT_T21 (200 * HZ) /* Default T21 value */ +#define X25_DEFAULT_T22 (180 * HZ) /* Default T22 value */ +#define X25_DEFAULT_T23 (180 * HZ) /* Default T23 value */ +#define X25_DEFAULT_T2 (3 * HZ) /* Default ack holdback value */ + +#define X25_DEFAULT_WINDOW_SIZE 2 /* Default Window Size */ +#define X25_DEFAULT_PACKET_SIZE X25_PS128 /* Default Packet Size */ +#define X25_DEFAULT_THROUGHPUT 0x0A /* Deafult Throughput */ +#define X25_DEFAULT_REVERSE 0x00 /* Default Reverse Charging */ + +#define X25_SMODULUS 8 +#define X25_EMODULUS 128 + +/* + * X.25 Facilities constants. + */ + +#define X25_FAC_CLASS_MASK 0xC0 + +#define X25_FAC_CLASS_A 0x00 +#define X25_FAC_CLASS_B 0x40 +#define X25_FAC_CLASS_C 0x80 +#define X25_FAC_CLASS_D 0xC0 + +#define X25_FAC_REVERSE 0x01 +#define X25_FAC_THROUGHPUT 0x02 +#define X25_FAC_PACKET_SIZE 0x42 +#define X25_FAC_WINDOW_SIZE 0x43 + +#define X25_MAX_FAC_LEN 20 /* Plenty to spare */ +#define X25_MAX_CUD_LEN 128 + +struct x25_route { + struct x25_route *next; + x25_address address; /* Start of address range */ + unsigned int sigdigits; /* Number of sig digits */ + struct device *dev; /* More than one for MLP */ +}; + +struct x25_neigh { + struct x25_neigh *next; + struct device *dev; + unsigned int state; + unsigned int extended; + struct sk_buff_head queue; + unsigned long t20; + struct timer_list t20timer; +}; + +typedef struct { + x25_address source_addr, dest_addr; + struct x25_neigh *neighbour; + unsigned int lci; + unsigned char state, condition, qbitincl, intflag; + unsigned short vs, vr, va, vl; + unsigned long t2, t21, t22, t23; + unsigned short fraglen; + struct sk_buff_head ack_queue; + struct sk_buff_head fragment_queue; + struct sk_buff_head interrupt_in_queue; + struct sk_buff_head interrupt_out_queue; + struct sock *sk; /* Backlink to socket */ + struct timer_list timer; + struct x25_causediag causediag; + struct x25_facilities facilities; + struct x25_calluserdata calluserdata; +} x25_cb; + +/* af_x25.c */ +extern int sysctl_x25_restart_request_timeout; +extern int sysctl_x25_call_request_timeout; +extern int sysctl_x25_reset_request_timeout; +extern int sysctl_x25_clear_request_timeout; +extern int sysctl_x25_ack_holdback_timeout; + +extern int x25_addr_ntoa(unsigned char *, x25_address *, x25_address *); +extern int x25_addr_aton(unsigned char *, x25_address *, x25_address *); +extern unsigned int x25_new_lci(struct x25_neigh *); +extern struct sock *x25_find_socket(unsigned int, struct x25_neigh *); +extern void x25_destroy_socket(struct sock *); +extern int x25_rx_call_request(struct sk_buff *, struct x25_neigh *, unsigned int); +extern void x25_kill_by_neigh(struct x25_neigh *); + +#include <net/x25call.h> + +/* x25_dev.c */ +extern void x25_send_frame(struct sk_buff *, struct x25_neigh *); +extern int x25_lapb_receive_frame(struct sk_buff *, struct device *, struct packet_type *); +extern int x25_llc_receive_frame(struct sk_buff *, struct device *, struct packet_type *); +extern void x25_establish_link(struct x25_neigh *); +extern void x25_terminate_link(struct x25_neigh *); + +/* x25_facilities.c */ +extern int x25_parse_facilities(struct sk_buff *, struct x25_facilities *); +extern int x25_create_facilities(unsigned char *, struct x25_facilities *); +extern int x25_negotiate_facilities(struct sk_buff *, struct sock *, struct x25_facilities *); +extern void x25_limit_facilities(struct x25_facilities *, struct x25_neigh *); + +/* x25_in.c */ +extern int x25_process_rx_frame(struct sock *, struct sk_buff *); + +/* x25_link.c */ +extern void x25_link_control(struct sk_buff *, struct x25_neigh *, unsigned short); +extern void x25_link_device_up(struct device *); +extern void x25_link_device_down(struct device *); +extern void x25_link_established(struct x25_neigh *); +extern void x25_link_terminated(struct x25_neigh *); +extern void x25_transmit_restart_request(struct x25_neigh *); +extern void x25_transmit_restart_confirmation(struct x25_neigh *); +extern void x25_transmit_diagnostic(struct x25_neigh *, unsigned char); +extern void x25_transmit_clear_request(struct x25_neigh *, unsigned int, unsigned char); +extern void x25_transmit_link(struct sk_buff *, struct x25_neigh *); +extern int x25_subscr_ioctl(unsigned int, void *); +extern struct x25_neigh *x25_get_neigh(struct device *); +extern void x25_link_free(void); + +/* x25_out.c */ +extern void x25_output(struct sock *, struct sk_buff *); +extern void x25_kick(struct sock *); +extern void x25_enquiry_response(struct sock *); + +/* x25_route.c */ +extern struct device *x25_get_route(x25_address *); +extern struct device *x25_dev_get(char *); +extern void x25_route_device_down(struct device *); +extern int x25_route_ioctl(unsigned int, void *); +extern int x25_routes_get_info(char *, char **, off_t, int, int); +extern void x25_route_free(void); + +/* x25_subr.c */ +extern void x25_clear_queues(struct sock *); +extern void x25_frames_acked(struct sock *, unsigned short); +extern void x25_requeue_frames(struct sock *); +extern int x25_validate_nr(struct sock *, unsigned short); +extern void x25_write_internal(struct sock *, int); +extern int x25_decode(struct sock *, struct sk_buff *, int *, int *, int *, int *, int *); +extern void x25_disconnect(struct sock *, int, unsigned char, unsigned char); + +/* x25_timer.c */ +extern void x25_start_heartbeat(struct sock *); +extern void x25_start_t2timer(struct sock *); +extern void x25_start_t21timer(struct sock *); +extern void x25_start_t22timer(struct sock *); +extern void x25_start_t23timer(struct sock *); +extern void x25_stop_heartbeat(struct sock *); +extern void x25_stop_timer(struct sock *); +extern unsigned long x25_display_timer(struct sock *); + +/* sysctl_net_x25.c */ +extern void x25_register_sysctl(void); +extern void x25_unregister_sysctl(void); + +#endif diff --git a/pfinet/linux-src/include/net/x25call.h b/pfinet/linux-src/include/net/x25call.h new file mode 100644 index 00000000..7c478a1d --- /dev/null +++ b/pfinet/linux-src/include/net/x25call.h @@ -0,0 +1,2 @@ +/* Separate to keep compilation of protocols.c simpler */ +extern void x25_proto_init(struct net_proto *pro); |