FreeBSD/Linux Kernel Cross Reference
sys/contrib/ngatm/netnatm/saal/sscoppriv.h

     /*
      * Copyright (c) 1996-2003
      *      Fraunhofer Institute for Open Communication Systems (FhG Fokus).
      *      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.
     *
     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
     *
     * Author: Hartmut Brandt <harti@freebsd.org>
     *
     * $Begemot: libunimsg/netnatm/saal/sscoppriv.h,v 1.4 2004/07/08 08:22:17 brandt Exp $
     *
     * Private SSCOP definitions.
     *
     */
    #ifdef _KERNEL
    #ifdef __FreeBSD__
    #include <netgraph/atm/sscop/ng_sscop_cust.h>
    #endif
    #else   /* !_KERNEL */
    #include "sscopcust.h"
    #endif
    
    /* Argh. BSDi */
    #ifndef _BYTE_ORDER
    #ifndef BYTE_ORDER
    #error "_BYTE_ORDER not defined"
    #endif
    #define _BYTE_ORDER     BYTE_ORDER
    #define _LITTLE_ENDIAN  LITTLE_ENDIAN
    #define _BIG_ENDIAN     BIG_ENDIAN
    #endif
    
    /*
     * PDU trailer
     */
    union pdu {
      u_int                 sscop_null;
      struct {
    #if _BYTE_ORDER == _BIG_ENDIAN
            u_int           pl : 2;         /* pad length */
            u_int           : 1;            /* reserved field */
            u_int           s : 1;          /* source */
            u_int           type : 4;       /* PDU type */
            u_int           ns : 24;        /* sequence number */
    #else
            u_int           ns : 24;        /* sequence number */
            u_int           type : 4;       /* PDU type */
            u_int           s : 1;          /* source */
            u_int           : 1;            /* reserved field */
            u_int           pl : 2;         /* pad length */
    #endif
      } ss;
    };
    #define sscop_pl        ss.pl
    #define sscop_s         ss.s
    #define sscop_type      ss.type
    #define sscop_ns        ss.ns
    
    /*
     * seqno list entry format
     */
    union seqno {
      u_int                 sscop_null;
      struct {
    #if _BYTE_ORDER == _BIG_ENDIAN
            u_int           : 8;            /* pad */
            u_int           n : 24;         /* seqno */
    #else
            u_int           n : 24;         /* seqno */
            u_int           : 8;            /* pad */
    #endif
      } ss;
    };
    #define sscop_n ss.n
    
    /*
     * Begin pdu
     */
    union bgn {
      u_int                 sscop_null;
     struct {
   #if _BYTE_ORDER == _BIG_ENDIAN
           u_int   : 24;                   /* reserved */
           u_int   bgns : 8;               /* VT_MR */
   #else
           u_int   bgns : 8;               /* VT_MR */
           u_int   : 24;                   /* reserved */
   #endif
     } ss;
   };
   #define sscop_bgns      ss.bgns
   
   /*
    * pdu types
    */
   enum pdu_type {
           PDU_BGN         = 0x1,  /* request initialization */
           PDU_BGAK        = 0x2,  /* request acknowledgement */
           PDU_END         = 0x3,  /* disconnect command */
           PDU_ENDAK       = 0x4,  /* disconnect acknowledgement */
           PDU_RS          = 0x5,  /* resynchronisation command */
           PDU_RSAK        = 0x6,  /* resynchronisation acknowledgement */
           PDU_BGREJ       = 0x7,  /* connection reject */
           PDU_SD          = 0x8,  /* sequenced connection-mode data */
           PDU_ER          = 0x9,  /* recovery command */
           PDU_POLL        = 0xa,  /* xmit state info with req. for recv state */
           PDU_STAT        = 0xb,  /* solicited receiver state info */
           PDU_USTAT       = 0xc,  /* unsolicited receiver state info */
           PDU_UD          = 0xd,  /* unumbered user data */
           PDU_MD          = 0xe,  /* unumbered management data */
           PDU_ERAK        = 0xf,  /* recovery acknowledgement */
   };
   
   
   /*
    * These are all signals, that are used by SSCOP. Don't change the order or
    * number without also changing the associated tables.
    */
   enum sscop_sigtype {
           /* received PDU's */
           SIG_BGN,                /* request initialization */
           SIG_BGAK,               /* request acknowledgement */
           SIG_END,                /* disconnect command */
           SIG_ENDAK,              /* disconnect acknowledgement */
           SIG_RS,                 /* resynchronisation command */
           SIG_RSAK,               /* resynchronisation acknowledgement */
           SIG_BGREJ,              /* connection reject */
           SIG_SD,                 /* sequenced connection-mode data */
           SIG_ER,                 /* recovery command */
           SIG_POLL,               /* xmitter state info with req for recv state */
           SIG_STAT,               /* solicited receiver state info */
           SIG_USTAT,              /* unsolicited receiver state info */
           SIG_UD,                 /* unumbered user data */
           SIG_MD,                 /* unumbered management data */
           SIG_ERAK,               /* recovery acknoledgement */
   
           /* timer expiry */
           SIG_T_CC,               /* CC timer */
           SIG_T_POLL,             /* POLL timer */
           SIG_T_KA,               /* KEEP ALIVE timer */
           SIG_T_NR,               /* NO RESPONSE timer */
           SIG_T_IDLE,             /* IDLE timer */
   
           /* user originated signals */
           SIG_PDU_Q,              /* PDU enqueued pseudosignal */
           SIG_USER_DATA,          /* user data request */
           SIG_ESTAB_REQ,          /* establish connection request */
           SIG_ESTAB_RESP,         /* establish connection response */
           SIG_RELEASE_REQ,        /* release connection request */
           SIG_RECOVER,            /* automatic recover response */
           SIG_SYNC_REQ,           /* resynchronisation request */
           SIG_SYNC_RESP,          /* resynchronisation response */
           SIG_UDATA,              /* UDATA request */
           SIG_MDATA,              /* MDATA request */
           SIG_UPDU_Q,             /* UDATA PDU enqueued pseudosignal */
           SIG_MPDU_Q,             /* MDATA PDU enqueued pseudosignal */
           SIG_RETRIEVE,           /* RETRIEVE */
   
           /* number of signals */
           SIG_NUM
   };
   
   /*
    * This is a message as contained in a sscop message queue. It holds a pointer
    * to the real message.
    */
   struct sscop_msg {
           sscop_msgq_link_t link;
           u_int           seqno;          /* seq no */
           u_int           poll_seqno;     /* poll seqno (for messages in xmit buffer) */
           u_int           rexmit;         /* in retransmission queue? */
           struct SSCOP_MBUF_T *m;         /* the message */
   };
   
   /*
    * This structure is used to hold signals in the signal queue
    */
   struct sscop_sig {
           sscop_sigq_link_t link;         /* next signal */
           enum sscop_sigtype sig;         /* THE signal */
           struct sscop_msg *msg;          /* signal argument (message) */
   };
   
   /*
    * This structure holds the entire sscop state
    */
   struct sscop {
           enum sscop_state state; /* current state */
           const struct sscop_funcs *funcs;
   
           /* send state */
           u_int   vt_s;           /* seqno for next pdu first time transmitted */
           u_int   vt_ps;          /* current poll seqno */
           u_int   vt_a;           /* next expected in-sequence sd pdu */
           u_int   vt_pa;          /* poll seqno of next stat pdu */
           u_int   vt_ms;          /* maximum allowed send sd seqno */
           u_int   vt_pd;          /* poll data state */
           u_int   vt_cc;          /* connection control state */
           u_int   vt_sq;          /* transmitter connection sequence */
   
           /* receive state */
           u_int   vr_r;           /* receive state */
           u_int   vr_h;           /* highes expected state */
           u_int   vr_mr;          /* maximum acceptable */
           u_int   vr_sq;          /* receiver connection state */
   
           /* timers */
           sscop_timer_t t_cc;     /* timer_CC */
           sscop_timer_t t_nr;     /* timer_NO_RESPONSE */
           sscop_timer_t t_ka;     /* timer KEEP_ALIVE */
           sscop_timer_t t_poll;   /* timer_POLL */
           sscop_timer_t t_idle;   /* idle timer */
   
           /* maximum values */
           u_int   maxj;           /* maximum uu-info */
           u_int   maxk;           /* maximum info */
           u_int   maxcc;          /* maximum number of bgn, end, er and rs */
           u_int   maxpd;          /* maximum value of vt_pd */
           u_int   maxstat;        /* maximum length of list */
           u_int   timercc;        /* connection control timer */
           u_int   timerka;        /* keep alive timer */
           u_int   timernr;        /* no response timer */
           u_int   timerpoll;      /* polling */
           u_int   timeridle;      /* idle timer */
           u_int   robustness;     /* atmf/97-0216 robustness enhancement */
           u_int   poll_after_rex; /* optional POLL after re-transmission */
           u_int   mr;             /* initial window */
   
           /*
            * buffers and queues.
            * All expect the xq hold SD PDUs.
            */
           sscop_msgq_head_t xq;   /* xmit queue (input from user before xmit) */
           sscop_msgq_head_t uxq;  /* UD xmit queue */
           sscop_msgq_head_t mxq;  /* MD xmit queue */
           sscop_msgq_head_t xbuf; /* transmission buffer (SD PDUs transmitted) */
           int     rxq;            /* number of PDUs in retransmission queue */
           sscop_msgq_head_t rbuf; /* receive buffer (SD PDUs) */
           int     last_end_src;   /* source field from last xmitted end pdu */
           int     clear_buffers;  /* flag */
           int     credit;         /* send window not closed */
           u_int   ll_busy;        /* lower layer busy */
           u_int   rs_mr;          /* N(MR) in last RS PDU */
           u_int   rs_sq;          /* N(SQ) in last RS PDU */
           struct SSCOP_MBUF_T *uu_bgn;    /* last UU data */
           struct SSCOP_MBUF_T *uu_bgak;   /*  ... */
           struct SSCOP_MBUF_T *uu_bgrej;  /*  ... */
           struct SSCOP_MBUF_T *uu_end;    /*  ... */
           struct SSCOP_MBUF_T *uu_rs;     /*  ... */
   
           /* signal queues */
           sscop_sigq_head_t       sigs;           /* saved signals */
           sscop_sigq_head_t       saved_sigs;     /* saved signals */
           int     in_sig;         /* in signal handler */
   
           /* debugging */
           u_int           debug;
   
           /* AA interface */
           void            *aarg;
   };
   
   
   /*
    * Default values for SSCOP
    */
   enum {
           MAXK            = 4096,
           MAXMAXK         = 65528,
           MAXJ            = 4096,
           MAXMAXJ         = 65524,
           MAXCC           = 4,
           MAXSTAT         = 67,
           MAXPD           = 25,
           MAXMR           = 128,          /* ??? */
           TIMERCC         = 1000,
           TIMERKA         = 2000,
           TIMERNR         = 7000,
           TIMERPOLL       = 750,
           TIMERIDLE       = 15000,
   };
   
   /*
    * Sequence number arithmetic
    */
   #define SEQNO_DIFF(A,B)  (((A) < (B)) ? ((A) + (1<<24) - (B)) : ((A) - (B)))
   
   /*
    * Debugging
    */
   #ifdef SSCOP_DEBUG
   #define VERBOSE(S,M,F)  if ((S)->debug & (M)) (S)->funcs->verbose F
   #define VERBERR(S,M,F)  if ((S)->debug & (M)) (S)->funcs->verbose F
   #define ISVERBOSE(S,M)  ((S)->debug & (M))
   #else
   #define VERBOSE(S,M,F)
   #define VERBERR(S,M,F)
   #define ISVERBOSE(S,M)  (0)
   #endif

Cache object: 5676a447578039492a43e5d443f713a5