include/atalk/atp.h

   1 /*
   2  * Copyright (c) 1990,1991 Regents of The University of Michigan.
   3  * All Rights Reserved.
   4  *
   5  * Permission to use, copy, modify, and distribute this software and
   6  * its documentation for any purpose and without fee is hereby granted,
   7  * provided that the above copyright notice appears in all copies and
   8  * that both that copyright notice and this permission notice appear
   9  * in supporting documentation, and that the name of The University
  10  * of Michigan not be used in advertising or publicity pertaining to
  11  * distribution of the software without specific, written prior
  12  * permission. This software is supplied as is without expressed or
  13  * implied warranties of any kind.
  14  *
  15  *      Research Systems Unix Group
  16  *      The University of Michigan
  17  *      c/o Mike Clark
  18  *      535 W. William Street
  19  *      Ann Arbor, Michigan
  20  *      +1-313-763-0525
  21  *      netatalk@itd.umich.edu
  22  */
  23
  24 #ifndef _ATALK_ATP_H
  25 #define _ATALK_ATP_H 1
  26
  27 #include <sys/types.h>
  28 #include <sys/time.h>
  29 #include <netatalk/at.h>
  30 #include <netatalk/endian.h>
  31
  32 /* ATP packet format
  33
  34  |----------------|
  35  | link header    |
  36  |      ...       |
  37  |----------------|
  38  | DDP header     |
  39  |      ...       |
  40  |   type = 3     |
  41  |----------------|
  42  | control info   | --> bits 7,6: function code
  43  |----------------|            5: XO bit
  44  | bitmap/seq no. |            4: EOM bit
  45  |----------------|            3: STS bit
  46  | TID (MSB)      |        2,1,0: release timer code (ignored under phase I)
  47  |----------------|
  48  | TID (LSB)      |
  49  |----------------|
  50  | user bytes (4) |
  51  |----------------|
  52  | data (0-578)   |
  53  |      ...       |
  54  |----------------|
  55 */
  56 struct atphdr {
  57     u_int8_t    atphd_ctrlinfo; /* control information */
  58     u_int8_t    atphd_bitmap;   /* bitmap or sequence number */
  59     u_int16_t   atphd_tid;      /* transaction id. */
  60 };
  61
  62 /* ATP protocol parameters
  63 */
  64 #define ATP_MAXDATA     (578+4)         /* maximum ATP data size */
  65 #define ATP_BUFSIZ      587             /* maximum packet size */
  66 #define ATP_HDRSIZE     5               /* includes DDP type field */
  67
  68 #define ATP_TRELMASK    0x07            /* mask all but TREL */
  69 #define ATP_RELTIME     30              /* base release timer (in secs) */
  70
  71 #define ATP_TREL30      0x0             /* release time codes */
  72 #define ATP_TREL1M      0x1             /* these are passed in flags of */
  73 #define ATP_TREL2M      0x2             /* atp_sreq call, and set in the */
  74 #define ATP_TREL4M      0x3             /* packet control info. */
  75 #define ATP_TREL8M      0x4
  76
  77 #define ATP_TRIES_INFINITE      -1      /* for atp_sreq, etc */
  78
  79 struct atpxobuf {
  80     u_int16_t           atpxo_tid;
  81     struct timeval      atpxo_tv;
  82     int                 atpxo_reltime;
  83     struct atpbuf       *atpxo_packet[8];
  84 };
  85
  86 struct atpbuf {
  87     struct atpbuf       *atpbuf_next;           /* next buffer in chain */
  88     size_t              atpbuf_dlen;            /* data length <= ATP_BUFSIZ */
  89     struct sockaddr_at  atpbuf_addr;            /* net address sent/recvd */
  90     union {
  91         char            atpbuf_data[ ATP_BUFSIZ ];      /* the data */
  92         struct atpxobuf atpbuf_xo;                      /* for XO requests */
  93     } atpbuf_info;
  94 };
  95
  96 struct atp_handle {
  97     int                 atph_socket;            /* ddp socket */
  98     struct sockaddr_at  atph_saddr;             /* address */
  99     u_int16_t           atph_tid;               /* last tid used */
 100     u_int16_t           atph_rtid;              /* last received (rreq) */
 101     u_int8_t            atph_rxo;               /* XO flag from last rreq */
 102     int                 atph_rreltime;          /* release time (secs) */
 103     struct atpbuf       *atph_sent;             /* packets we send (XO) */
 104     struct atpbuf       *atph_queue;            /* queue of pending packets */
 105     int                 atph_reqtries;          /* retry count for request */
 106     int                 atph_reqto;             /* retry timeout for request */
 107     int                 atph_rrespcount;        /* expected # of responses */
 108     u_int8_t            atph_rbitmap;           /* bitmap for request */
 109     struct atpbuf       *atph_reqpkt;           /* last request packet */
 110     struct timeval      atph_reqtv;             /* when we last sent request */
 111     struct atpbuf       *atph_resppkt[8];       /* response to request */
 112 };
 113
 114 typedef struct atp_handle *ATP;
 115
 116 #define atp_sockaddr( h )       (&(h)->atph_saddr)
 117 #define atp_fileno(x)           ((x)->atph_socket)
 118
 119 struct sreq_st {
 120     char            *atpd_data;         /* request data */
 121     int             atpd_dlen;
 122     int             atpd_tries;         /* max. retry count */
 123     int             atpd_to;            /* retry interval */
 124 };
 125
 126 struct rres_st {
 127     struct iovec    *atpd_iov;          /* for response */
 128     int             atpd_iovcnt;
 129 };
 130
 131 struct rreq_st {
 132     char            *atpd_data;         /* request data */
 133     int             atpd_dlen;
 134 };
 135
 136 struct sres_st {
 137     struct iovec    *atpd_iov;          /* for response */
 138     int             atpd_iovcnt;
 139 };
 140
 141 struct atp_block {
 142     struct sockaddr_at  *atp_saddr;             /* from/to address */
 143     union {
 144         struct sreq_st  sreqdata;
 145 #define atp_sreqdata    atp_data.sreqdata.atpd_data
 146 #define atp_sreqdlen    atp_data.sreqdata.atpd_dlen
 147 #define atp_sreqtries   atp_data.sreqdata.atpd_tries
 148 #define atp_sreqto      atp_data.sreqdata.atpd_to
 149
 150         struct rres_st  rresdata;
 151 #define atp_rresiov     atp_data.rresdata.atpd_iov
 152 #define atp_rresiovcnt  atp_data.rresdata.atpd_iovcnt
 153
 154         struct rreq_st  rreqdata;
 155 #define atp_rreqdata    atp_data.rreqdata.atpd_data
 156 #define atp_rreqdlen    atp_data.rreqdata.atpd_dlen
 157
 158         struct sres_st  sresdata;
 159 #define atp_sresiov     atp_data.sresdata.atpd_iov
 160 #define atp_sresiovcnt  atp_data.sresdata.atpd_iovcnt
 161     } atp_data;
 162     u_int8_t            atp_bitmap;     /* response buffer bitmap */
 163 };
 164
 165
 166 /* flags for ATP options (and control byte)
 167 */
 168 #define ATP_STS         (1<<3)          /* Send Transaction Status */
 169 #define ATP_EOM         (1<<4)          /* End Of Message */
 170 #define ATP_XO          (1<<5)          /* eXactly Once mode */
 171
 172 /* function codes
 173 */
 174 #define ATP_FUNCMASK    (3<<6)          /* mask all but function */
 175
 176 #define ATP_TREQ        (1<<6)          /* Trans. REQuest */
 177 #define ATP_TRESP       (2<<6)          /* Trans. RESPonse */
 178 #define ATP_TREL        (3<<6)          /* Trans. RELease */
 179
 180 extern ATP              atp_open  (u_int8_t,
 181                                        const struct at_addr *);
 182 extern int              atp_close (ATP);
 183 extern int              atp_sreq  (ATP, struct atp_block *, int,
 184                                        u_int8_t);
 185 extern int              atp_rresp (ATP, struct atp_block *);
 186 extern int              atp_rsel  (ATP, struct sockaddr_at *, int);
 187 extern int              atp_rreq  (ATP, struct atp_block *);
 188 extern int              atp_sresp (ATP, struct atp_block *);
 189
 190 #endif