549 lines
20 KiB
C
549 lines
20 KiB
C
/* $NetBSD: clnp.h,v 1.19 2005/05/29 21:27:45 christos Exp $ */
|
|
|
|
/*-
|
|
* Copyright (c) 1991, 1993, 1994
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* @(#)clnp.h 8.2 (Berkeley) 4/16/94
|
|
*/
|
|
|
|
/***********************************************************
|
|
Copyright IBM Corporation 1987
|
|
|
|
All Rights Reserved
|
|
|
|
Permission to use, copy, modify, and distribute this software and its
|
|
documentation for any purpose and without fee is hereby granted,
|
|
provided that the above copyright notice appear in all copies and that
|
|
both that copyright notice and this permission notice appear in
|
|
supporting documentation, and that the name of IBM not be
|
|
used in advertising or publicity pertaining to distribution of the
|
|
software without specific, written prior permission.
|
|
|
|
IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
|
|
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
|
|
IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
|
|
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
|
|
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
|
|
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
|
|
SOFTWARE.
|
|
|
|
******************************************************************/
|
|
|
|
#ifndef _NETISO_CLNP_H
|
|
#define _NETISO_CLNP_H
|
|
|
|
/*
|
|
* ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
|
|
*/
|
|
|
|
/* should be config option but cpp breaks with too many #defines */
|
|
#define DECBIT
|
|
|
|
/*
|
|
* Return true if the mbuf is a cluster mbuf
|
|
*/
|
|
#define IS_CLUSTER(m) ((m)->m_flags & M_EXT)
|
|
|
|
/*
|
|
* Move the halfword into the two characters
|
|
*/
|
|
#define HTOC(msb, lsb, hword)\
|
|
(msb) = (u_char)((hword) >> 8);\
|
|
(lsb) = (u_char)((hword) & 0xff)
|
|
/*
|
|
* Move the two charcters into the halfword
|
|
*/
|
|
#define CTOH(msb, lsb, hword)\
|
|
(hword) = ((msb) << 8) | (lsb)
|
|
|
|
/*
|
|
* Return true if the checksum has been set - ie. the checksum is
|
|
* not zero
|
|
*/
|
|
#define CKSUM_REQUIRED(clnp)\
|
|
(((clnp)->cnf_cksum_msb != 0) || ((clnp)->cnf_cksum_lsb != 0))
|
|
|
|
/*
|
|
* Fixed part of clnp header
|
|
*/
|
|
struct clnp_fixed {
|
|
u_char cnf_proto_id; /* network layer protocol identifier */
|
|
u_char cnf_hdr_len; /* length indicator (octets) */
|
|
u_char cnf_vers; /* version/protocol identifier
|
|
* extension */
|
|
u_char cnf_ttl;/* lifetime (500 milliseconds) */
|
|
u_char cnf_type; /* type code */
|
|
/* Includes err_ok, more_segs, and seg_ok */
|
|
u_char cnf_seglen_msb; /* pdu segment length (octets) high
|
|
* byte */
|
|
u_char cnf_seglen_lsb; /* pdu segment length (octets) low
|
|
* byte */
|
|
u_char cnf_cksum_msb; /* checksum high byte */
|
|
u_char cnf_cksum_lsb; /* checksum low byte */
|
|
} __attribute__((packed));
|
|
#define CNF_TYPE 0x1f
|
|
#define CNF_ERR_OK 0x20
|
|
#define CNF_MORE_SEGS 0x40
|
|
#define CNF_SEG_OK 0x80
|
|
|
|
#define CLNP_CKSUM_OFF 0x07 /* offset of checksum */
|
|
|
|
#define clnl_fixed clnp_fixed
|
|
|
|
/*
|
|
* Segmentation part of clnp header
|
|
*/
|
|
struct clnp_segment {
|
|
u_short cng_id; /* data unit identifier */
|
|
u_short cng_off;/* segment offset */
|
|
u_short cng_tot_len; /* total length */
|
|
};
|
|
|
|
/*
|
|
* Clnp fragment reassembly structures:
|
|
*
|
|
* All packets undergoing reassembly are linked together in
|
|
* clnp_fragl structures. Each clnp_fragl structure contains a
|
|
* pointer to the original clnp packet header, as well as a
|
|
* list of packet fragments. Each packet fragment
|
|
* is headed by a clnp_frag structure. This structure contains the
|
|
* offset of the first and last byte of the fragment, as well as
|
|
* a pointer to the data (an mbuf chain) of the fragment.
|
|
*/
|
|
|
|
/*
|
|
* NOTE:
|
|
* The clnp_frag structure is stored in an mbuf immedately
|
|
* preceding the fragment data. Since there are words in
|
|
* this struct, it must be word aligned.
|
|
*
|
|
* NOTE:
|
|
* All the fragment code assumes that the entire clnp header is
|
|
* contained in the first mbuf.
|
|
*/
|
|
struct clnp_frag {
|
|
u_int cfr_first; /* offset of first byte of this frag */
|
|
u_int cfr_last; /* offset of last byte of this frag */
|
|
u_int cfr_bytes; /* bytes to shave to get to data */
|
|
struct mbuf *cfr_data; /* ptr to data for this frag */
|
|
struct clnp_frag *cfr_next; /* next fragment in list */
|
|
};
|
|
|
|
struct clnp_fragl {
|
|
struct iso_addr cfl_src;/* source of the pkt */
|
|
struct iso_addr cfl_dst;/* destination of the pkt */
|
|
u_short cfl_id; /* id of the pkt */
|
|
u_char cfl_ttl;/* current ttl of pkt */
|
|
u_short cfl_last; /* offset of last byte of packet */
|
|
struct mbuf *cfl_orighdr; /* ptr to original header */
|
|
struct clnp_frag *cfl_frags; /* linked list of fragments for pkt */
|
|
struct clnp_fragl *cfl_next; /* next pkt being reassembled */
|
|
};
|
|
|
|
/*
|
|
* The following structure is used to index into an options section
|
|
* of a clnp datagram. These values can be used without worry that
|
|
* offset or length fields are invalid or too big, etc. That is,
|
|
* the consistancy of the options will be guaranteed before this
|
|
* structure is filled in. Any pointer (field ending in p) is
|
|
* actually the offset from the beginning of the mbuf the option
|
|
* is contained in. A value of NULL for any pointer
|
|
* means that the option is not present. The length any option
|
|
* does not include the option code or option length fields.
|
|
*/
|
|
struct clnp_optidx {
|
|
u_short cni_securep; /* ptr to start of security option */
|
|
char cni_secure_len; /* length of entire security option */
|
|
|
|
u_short cni_srcrt_s; /* offset of start of src rt option */
|
|
u_short cni_srcrt_len; /* length of entire src rt option */
|
|
|
|
u_short cni_recrtp; /* ptr to beginning of recrt option */
|
|
char cni_recrt_len; /* length of entire recrt option */
|
|
|
|
char cni_priorp; /* ptr to priority option */
|
|
|
|
u_short cni_qos_formatp; /* ptr to format of qos
|
|
* option */
|
|
char cni_qos_len; /* length of entire qos option */
|
|
|
|
u_char cni_er_reason; /* reason from ER pdu option */
|
|
|
|
/* ESIS options */
|
|
|
|
u_short cni_esct; /* value from ISH ESCT option */
|
|
|
|
u_short cni_netmaskp; /* ptr to beginning of netmask option */
|
|
char cni_netmask_len; /* length of entire netmask
|
|
* option */
|
|
|
|
u_short cni_snpamaskp; /* ptr to start of snpamask option */
|
|
char cni_snpamask_len; /* length of entire snpamask
|
|
* option */
|
|
|
|
};
|
|
|
|
#define ER_INVALREAS 0xff /* code for invalid ER pdu discard reason */
|
|
|
|
/* given an mbuf and addr of option, return offset from data of mbuf */
|
|
#define CLNP_OPTTOOFF(m, opt) ((u_short) (opt - mtod(m, caddr_t)))
|
|
|
|
/* given an mbuf and offset of option, return address of option */
|
|
#define CLNP_OFFTOOPT(m, off) ((caddr_t) (mtod(m, caddr_t) + off))
|
|
|
|
/* return true iff src route is valid */
|
|
#define CLNPSRCRT_VALID(oidx) ((oidx) && (oidx->cni_srcrt_s))
|
|
|
|
/* return the offset field of the src rt */
|
|
#define CLNPSRCRT_OFF(oidx, options)\
|
|
(*((u_char *)(CLNP_OFFTOOPT(options, oidx->cni_srcrt_s) + 1)))
|
|
|
|
/* return the type field of the src rt */
|
|
#define CLNPSRCRT_TYPE(oidx, options)\
|
|
((u_char)(*(CLNP_OFFTOOPT(options, oidx->cni_srcrt_s))))
|
|
|
|
/* return the length of the current address */
|
|
#define CLNPSRCRT_CLEN(oidx, options)\
|
|
((u_char)(*(CLNP_OFFTOOPT(options, oidx->cni_srcrt_s) + CLNPSRCRT_OFF(oidx, options) - 1)))
|
|
|
|
/* return the address of the current address */
|
|
#define CLNPSRCRT_CADDR(oidx, options)\
|
|
((caddr_t)(CLNP_OFFTOOPT(options, oidx->cni_srcrt_s) + CLNPSRCRT_OFF(oidx, options)))
|
|
|
|
/*
|
|
* return true if the src route has run out of routes this is true if the
|
|
* offset of next route is greater than the end of the rt
|
|
*/
|
|
#define CLNPSRCRT_TERM(oidx, options)\
|
|
(CLNPSRCRT_OFF(oidx, options) > oidx->cni_srcrt_len)
|
|
|
|
/*
|
|
* Options a user can set/get
|
|
*/
|
|
#define CLNPOPT_FLAGS 0x01 /* flags: seg permitted, no er xmit, etc */
|
|
#define CLNPOPT_OPTS 0x02 /* datagram options */
|
|
|
|
/*
|
|
* Values for particular datagram options
|
|
*/
|
|
#define CLNPOVAL_PAD 0xcc /* padding */
|
|
#define CLNPOVAL_SECURE 0xc5 /* security */
|
|
#define CLNPOVAL_SRCRT 0xc8 /* source routing */
|
|
#define CLNPOVAL_RECRT 0xcb /* record route */
|
|
#define CLNPOVAL_QOS 0xc3 /* quality of service */
|
|
#define CLNPOVAL_PRIOR 0xcd /* priority */
|
|
#define CLNPOVAL_ERREAS 0xc1 /* ER PDU ONLY: reason for discard */
|
|
|
|
#define CLNPOVAL_SRCSPEC 0x40 /* source address specific */
|
|
#define CLNPOVAL_DSTSPEC 0x80 /* destination address specific */
|
|
#define CLNPOVAL_GLOBAL 0xc0 /* globally unique */
|
|
|
|
/* Globally Unique QOS */
|
|
#define CLNPOVAL_SEQUENCING 0x10 /* sequencing preferred */
|
|
#define CLNPOVAL_CONGESTED 0x08 /* congestion experienced */
|
|
#define CLNPOVAL_LOWDELAY 0x04 /* low transit delay */
|
|
|
|
#define CLNPOVAL_PARTRT 0x00 /* partial source routing */
|
|
#define CLNPOVAL_COMPRT 0x01 /* complete source routing */
|
|
|
|
/*
|
|
* Clnp flags used in a control block flags field.
|
|
* NOTE: these must be out of the range of bits defined in ../net/raw_cb.h
|
|
*/
|
|
#define CLNP_NO_SEG 0x010 /* segmentation not permitted */
|
|
#define CLNP_NO_ER 0x020 /* do not generate ERs */
|
|
#define CLNP_SEND_RAW 0x080 /* send pkt as RAW DT not TP DT */
|
|
#define CLNP_NO_CKSUM 0x100 /* don't use clnp checksum */
|
|
#define CLNP_ECHO 0x200 /* send echo request */
|
|
#define CLNP_NOCACHE 0x400 /* don't store cache information */
|
|
#define CLNP_ECHOR 0x800 /* send echo reply */
|
|
|
|
/* valid clnp flags */
|
|
#define CLNP_VFLAGS \
|
|
(CLNP_SEND_RAW|CLNP_NO_SEG|CLNP_NO_ER|CLNP_NO_CKSUM|\
|
|
CLNP_ECHO|CLNP_NOCACHE|CLNP_ECHOR)
|
|
|
|
/*
|
|
* Constants used by clnp
|
|
*/
|
|
#define CLNP_HDR_MIN (sizeof (struct clnp_fixed))
|
|
#define CLNP_HDR_MAX (254)
|
|
#define CLNP_TTL_UNITS 2 /* 500 milliseconds */
|
|
#define CLNP_TTL 15*CLNP_TTL_UNITS /* time to live (seconds) */
|
|
#define ISO8473_V1 0x01
|
|
|
|
/*
|
|
* Clnp packet types
|
|
* In order to test raw clnp and tp/clnp simultaneously, a third type of
|
|
* packet has been defined: CLNP_RAW. This is done so that the input
|
|
* routine can switch to the correct input routine (rclnp_input or
|
|
* tpclnp_input) based on the type field. If clnp had a higher level
|
|
* protocol field, this would not be necessary.
|
|
*/
|
|
#define CLNP_DT 0x1C /* normal data */
|
|
#define CLNP_ER 0x01 /* error report */
|
|
#define CLNP_RAW 0x1D /* debug only */
|
|
#define CLNP_EC 0x1E /* echo packet */
|
|
#define CLNP_ECR 0x1F /* echo reply */
|
|
|
|
/*
|
|
* ER pdu error codes
|
|
*/
|
|
#define GEN_NOREAS 0x00 /* reason not specified */
|
|
#define GEN_PROTOERR 0x01 /* protocol procedure error */
|
|
#define GEN_BADCSUM 0x02 /* incorrect checksum */
|
|
#define GEN_CONGEST 0x03 /* pdu discarded due to congestion */
|
|
#define GEN_HDRSYNTAX 0x04 /* header syntax error */
|
|
#define GEN_SEGNEEDED 0x05 /* need segmentation but not allowed */
|
|
#define GEN_INCOMPLETE 0x06 /* incomplete pdu received */
|
|
#define GEN_DUPOPT 0x07 /* duplicate option */
|
|
|
|
/* address errors */
|
|
#define ADDR_DESTUNREACH 0x80 /* destination address unreachable */
|
|
#define ADDR_DESTUNKNOWN 0x81 /* destination address unknown */
|
|
|
|
/* source routing */
|
|
#define SRCRT_UNSPECERR 0x90 /* unspecified src rt error */
|
|
#define SRCRT_SYNTAX 0x91 /* syntax error in src rt field */
|
|
#define SRCRT_UNKNOWNADDR 0x92 /* unknown addr in src rt field */
|
|
#define SRCRT_BADPATH 0x93 /* path not acceptable */
|
|
|
|
/* lifetime */
|
|
#define TTL_EXPTRANSIT 0xa0 /* lifetime expired during transit */
|
|
#define TTL_EXPREASS 0xa1 /* lifetime expired during reassembly */
|
|
|
|
/* pdu discarded */
|
|
#define DISC_UNSUPPOPT 0xb0 /* unsupported option not specified? */
|
|
#define DISC_UNSUPPVERS 0xb1 /* unsupported protocol version */
|
|
#define DISC_UNSUPPSECURE 0xb2 /* unsupported security option */
|
|
#define DISC_UNSUPPSRCRT 0xb3 /* unsupported src rt option */
|
|
#define DISC_UNSUPPRECRT 0xb4 /* unsupported rec rt option */
|
|
|
|
/* reassembly */
|
|
#define REASS_INTERFERE 0xc0 /* reassembly interference */
|
|
#define CLNP_ERRORS 22
|
|
|
|
|
|
#ifdef CLNP_ER_CODES
|
|
u_char clnp_er_codes[CLNP_ERRORS] = {
|
|
GEN_NOREAS, GEN_PROTOERR, GEN_BADCSUM, GEN_CONGEST,
|
|
GEN_HDRSYNTAX, GEN_SEGNEEDED, GEN_INCOMPLETE, GEN_DUPOPT,
|
|
ADDR_DESTUNREACH, ADDR_DESTUNKNOWN,
|
|
SRCRT_UNSPECERR, SRCRT_SYNTAX, SRCRT_UNKNOWNADDR, SRCRT_BADPATH,
|
|
TTL_EXPTRANSIT, TTL_EXPREASS,
|
|
DISC_UNSUPPOPT, DISC_UNSUPPVERS, DISC_UNSUPPSECURE,
|
|
DISC_UNSUPPSRCRT, DISC_UNSUPPRECRT, REASS_INTERFERE
|
|
};
|
|
#endif
|
|
|
|
#ifdef TROLL
|
|
|
|
#define TR_DUPEND 0x01 /* duplicate end of fragment */
|
|
#define TR_DUPPKT 0x02 /* duplicate entire packet */
|
|
#define TR_DROPPKT 0x04 /* drop packet on output */
|
|
#define TR_TRIM 0x08 /* trim bytes from packet */
|
|
#define TR_CHANGE 0x10 /* change bytes in packet */
|
|
#define TR_MTU 0x20 /* delta to change device mtu */
|
|
#define TR_CHUCK 0x40 /* drop packet in rclnp_input */
|
|
#define TR_BLAST 0x80 /* force rclnp_output to blast many
|
|
* packet */
|
|
#define TR_RAWLOOP 0x100 /* make if_loop call clnpintr
|
|
* directly */
|
|
struct troll {
|
|
int tr_ops; /* operations to perform */
|
|
float tr_dup_size; /* % to duplicate */
|
|
float tr_dup_freq; /* frequency to duplicate packets */
|
|
float tr_drop_freq; /* frequence to drop packets */
|
|
int tr_mtu_adj; /* delta to adjust if mtu */
|
|
int tr_blast_cnt; /* # of pkts to blast out */
|
|
};
|
|
|
|
#define SN_OUTPUT(clcp, m)\
|
|
troll_output(clcp->clc_ifp, m, clcp->clc_firsthop, clcp->clc_rt)
|
|
|
|
#define SN_MTU(ifp, rt) (((rt && rt->rt_rmx.rmx_mtu) ?\
|
|
rt->rt_rmx.rmx_mtu : clnp_badmtu(ifp, rt, __LINE__, __FILE__))\
|
|
- trollctl.tr_mtu_adj)
|
|
|
|
#ifdef _KERNEL
|
|
extern float troll_random;
|
|
#endif
|
|
|
|
#else /* NO TROLL */
|
|
|
|
#define SN_OUTPUT(clcp, m)\
|
|
(*clcp->clc_ifp->if_output)(clcp->clc_ifp, m, clcp->clc_firsthop, \
|
|
clcp->clc_rt)
|
|
|
|
#define SN_MTU(ifp, rt) (((rt && rt->rt_rmx.rmx_mtu) ?\
|
|
rt->rt_rmx.rmx_mtu : clnp_badmtu(ifp, rt, __LINE__, __FILE__)))
|
|
|
|
#endif /* TROLL */
|
|
|
|
/*
|
|
* Macro to remove an address from a clnp header
|
|
*/
|
|
#define CLNP_EXTRACT_ADDR(isoa, hoff, hend)\
|
|
{\
|
|
isoa.isoa_len = (u_char)*hoff;\
|
|
if ((((++hoff) + isoa.isoa_len) > hend) ||\
|
|
(isoa.isoa_len > 20) || (isoa.isoa_len == 0)) {\
|
|
hoff = (caddr_t)0;\
|
|
} else {\
|
|
(void) bcopy(hoff, (caddr_t)isoa.isoa_genaddr, \
|
|
isoa.isoa_len);\
|
|
hoff += isoa.isoa_len;\
|
|
}\
|
|
}
|
|
|
|
/*
|
|
* Macro to insert an address into a clnp header
|
|
*/
|
|
#define CLNP_INSERT_ADDR(hoff, isoa)\
|
|
*hoff++ = (isoa).isoa_len;\
|
|
(void) bcopy((caddr_t)((isoa).isoa_genaddr), hoff, (isoa).isoa_len);\
|
|
hoff += (isoa).isoa_len;
|
|
|
|
/*
|
|
* Clnp hdr cache. Whenever a clnp packet is sent, a copy of the
|
|
* header is made and kept in this cache. In addition to a copy of
|
|
* the cached clnp hdr, the cache contains
|
|
* information necessary to determine whether the new packet
|
|
* to send requires a new header to be built.
|
|
*/
|
|
struct clnp_cache {
|
|
/* these fields are used to check the validity of the cache */
|
|
struct iso_addr clc_dst;/* destination of packet */
|
|
struct mbuf *clc_options; /* ptr to options mbuf */
|
|
int clc_flags; /* flags passed to clnp_output */
|
|
|
|
/* these fields are state that clnp_output requires to finish the pkt */
|
|
int clc_segoff; /* offset of seg part of header */
|
|
struct rtentry *clc_rt; /* ptr to rtentry (points into the route
|
|
* structure) */
|
|
struct sockaddr *clc_firsthop; /* first hop of packet */
|
|
struct ifnet *clc_ifp;/* ptr to interface structure */
|
|
struct iso_ifaddr
|
|
*clc_ifa;/* ptr to interface address */
|
|
struct mbuf *clc_hdr;/* cached pkt hdr (finally)! */
|
|
};
|
|
|
|
#ifdef _KERNEL
|
|
struct iso_addr;
|
|
struct sockaddr_iso;
|
|
struct mbuf;
|
|
struct clnp_segment;
|
|
struct sockaddr;
|
|
struct rt_entry;
|
|
struct clnp_fragl;
|
|
struct clnp_optidx;
|
|
struct isopcb;
|
|
struct snpa_hdr;
|
|
struct iso_ifaddr;
|
|
struct route_iso;
|
|
|
|
/* clnp_debug.c */
|
|
char *clnp_hexp (const char *, int, char *);
|
|
char *clnp_iso_addrp (struct iso_addr *);
|
|
char *clnp_saddr_isop (struct sockaddr_iso *);
|
|
|
|
/* clnp_er.c */
|
|
void clnp_er_input (struct mbuf *, struct iso_addr *, u_int);
|
|
void clnp_discard (struct mbuf *, u_int);
|
|
void clnp_emit_er (struct mbuf *, u_int);
|
|
int clnp_er_index (u_int);
|
|
|
|
int clnp_fragment (struct ifnet *, struct mbuf *, struct sockaddr *,
|
|
int, int, int, struct rtentry *);
|
|
struct mbuf *clnp_reass (struct mbuf *, struct iso_addr *,
|
|
struct iso_addr *, struct clnp_segment *);
|
|
int clnp_newpkt (struct mbuf *, struct iso_addr *, struct iso_addr *,
|
|
struct clnp_segment *);
|
|
void clnp_insert_frag (struct clnp_fragl *, struct mbuf *,
|
|
struct clnp_segment *);
|
|
struct mbuf *clnp_comp_pdu (struct clnp_fragl *);
|
|
#ifdef TROLL
|
|
float troll_random (void);
|
|
int troll_output (struct ifnet *, struct mbuf *, struct sockaddr *,
|
|
struct rtentry *);
|
|
#endif
|
|
|
|
/* clnp_input.c */
|
|
void clnp_init (void);
|
|
void clnlintr (void);
|
|
void clnp_input (struct mbuf *, ...);
|
|
|
|
/* clnp_options.c */
|
|
void clnp_update_srcrt (struct mbuf *, struct clnp_optidx *);
|
|
void clnp_dooptions (struct mbuf *, struct clnp_optidx *, struct ifnet *,
|
|
struct iso_addr *);
|
|
int clnp_set_opts (struct mbuf **, struct mbuf **);
|
|
int clnp_opt_sanity (struct mbuf *, caddr_t, int, struct clnp_optidx *);
|
|
|
|
/* clnp_output.c */
|
|
int clnp_output (struct mbuf *, ...);
|
|
void clnp_ctloutput (void);
|
|
|
|
/* clnp_raw.c */
|
|
void rclnp_input (struct mbuf *, ...);
|
|
int rclnp_output (struct mbuf *, ...);
|
|
int rclnp_ctloutput (int, struct socket *, int, int, struct mbuf **);
|
|
int clnp_usrreq (struct socket *, int, struct mbuf *, struct mbuf *,
|
|
struct mbuf *, struct proc *);
|
|
|
|
/* clnp_subr.c */
|
|
struct mbuf *clnp_data_ck (struct mbuf *, int);
|
|
caddr_t clnp_extract_addr (caddr_t, int, struct iso_addr *,
|
|
struct iso_addr *);
|
|
int clnp_ours (struct iso_addr *);
|
|
void clnp_forward (struct mbuf *, int, struct iso_addr *,
|
|
struct clnp_optidx *, int, struct snpa_hdr *);
|
|
caddr_t clnp_insert_addr (caddr_t, struct iso_addr *, struct iso_addr *);
|
|
int clnp_route (struct iso_addr *, struct route_iso *, int,
|
|
struct sockaddr **, struct iso_ifaddr **);
|
|
int clnp_srcroute (struct mbuf *, struct clnp_optidx *, struct route_iso *,
|
|
struct sockaddr **, struct iso_ifaddr **,
|
|
struct iso_addr *);
|
|
int clnp_echoreply (struct mbuf *, int, struct sockaddr_iso *,
|
|
struct sockaddr_iso *, struct clnp_optidx *);
|
|
int clnp_badmtu (struct ifnet *, struct rtentry *, int, const char *);
|
|
void clnp_ypocb (caddr_t, caddr_t, u_int);
|
|
|
|
/* clnp_timer.c */
|
|
struct clnp_fragl *clnp_freefrags (struct clnp_fragl *);
|
|
void clnp_slowtimo (void);
|
|
void clnp_drain (void);
|
|
|
|
#ifdef TROLL
|
|
struct troll trollctl;
|
|
#endif /* TROLL */
|
|
|
|
#endif /* _KERNEL */
|
|
|
|
#endif /* !_NETISO_CLNP_H */
|