home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / darwin / darwinx86.iso / usr / include / netat / atp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2001-09-30  |  14.1 KB  |  461 lines
  1. /*
  2.  * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
  3.  *
  4.  * @APPLE_LICENSE_HEADER_START@
  5.  * 
  6.  * The contents of this file constitute Original Code as defined in and
  7.  * are subject to the Apple Public Source License Version 1.1 (the
  8.  * "License").  You may not use this file except in compliance with the
  9.  * License.  Please obtain a copy of the License at
  10.  * http://www.apple.com/publicsource and read it before using this file.
  11.  * 
  12.  * This Original Code and all software distributed under the License are
  13.  * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  14.  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  15.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  16.  * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
  17.  * License for the specific language governing rights and limitations
  18.  * under the License.
  19.  * 
  20.  * @APPLE_LICENSE_HEADER_END@
  21.  */
  22. /*
  23.  *
  24.  * ORIGINS: 82
  25.  *
  26.  * (C) COPYRIGHT Apple Computer, Inc. 1992-1996
  27.  * All Rights Reserved
  28.  *
  29.  */                                                                   
  30.  
  31. /* Definitions for ATP protocol and streams module, per 
  32.  * AppleTalk Transaction Protocol documentation from
  33.  * `Inside AppleTalk', July 14, 1986.
  34.  */
  35.  
  36. /*
  37.  *    Copyright (c) 1988, 1989 Apple Computer, Inc. 
  38.  *
  39.  *    The information contained herein is subject to change without
  40.  *    notice and  should not be  construed as a commitment by Apple
  41.  *    Computer, Inc. Apple Computer, Inc. assumes no responsibility
  42.  *    for any errors that may appear.
  43.  *
  44.  *    Confidential and Proprietary to Apple Computer, Inc.
  45.  */
  46.  
  47. #ifndef _NETAT_ATP_H_
  48. #define _NETAT_ATP_H_
  49.  
  50. /* ATP function codes */
  51.  
  52. #define ATP_CMD_TREQ        0x01    /* TRequest packet  */
  53. #define ATP_CMD_TRESP        0x02    /* TResponse packet */
  54. #define ATP_CMD_TREL        0x03    /* TRelease packet  */
  55.  
  56. /* Miscellaneous definitions */
  57.  
  58. #define    ATP_DEF_RETRIES     8    /* Default for maximum retry count */
  59. #define    ATP_DEF_INTERVAL    2    /* Default for retry interval in seconds */
  60.  
  61. #define ATP_TRESP_MAX       8    /* Maximum number of Tresp pkts */
  62.  
  63. #define ATP_HDR_SIZE        8      /* Size of the ATP header */
  64. #define ATP_DATA_SIZE       578      /* Maximum size of the ATP data area */
  65.  
  66. /* Consts for asynch support */
  67. #define    ATP_ASYNCH_REQ    1
  68. #define    ATP_ASYNCH_RESP    2
  69.  
  70. /* Timer values for XO release timers */
  71. #define    ATP_XO_DEF_REL_TIME    0
  72. #define    ATP_XO_30SEC        0
  73. #define    ATP_XO_1MIN        1
  74. #define    ATP_XO_2MIN        2
  75. #define    ATP_XO_4MIN        3
  76. #define    ATP_XO_8MIN        4
  77.  
  78. typedef struct {
  79.         unsigned       cmd : 2,
  80.                        xo : 1,
  81.                        eom : 1,
  82.                        sts : 1,
  83.                        xo_relt : 3;
  84.         u_char         bitmap;
  85.     ua_short       tid;
  86.         ua_long        user_bytes;
  87.         u_char         data[ATP_DATA_SIZE];
  88. } at_atp_t;
  89.  
  90. #define ATP_ATP_HDR(c) ((at_atp_t *)(&((at_ddp_t *)(c))->data[0]))
  91.  
  92. #define TOTAL_ATP_HDR_SIZE    (ATP_HDR_SIZE+DDP_X_HDR_SIZE)
  93. #define ATP_CLEAR_CONTROL(c)  (*(char *)(c) = 0)
  94.  
  95. /* ATP ioctl interface */
  96.  
  97. /* Structure for the atp_set_default call */
  98.  
  99. #define    ATP_INFINITE_RETRIES    0xffffffff    /* means retry forever
  100.                          * in the def_retries field
  101.                           */
  102.  
  103. struct atp_set_default {
  104.     u_int    def_retries;        /* number of retries for a request */
  105.     u_int    def_rate;        /* retry rate (in seconds/100) NB: the
  106.                      * system may not be able to resolve
  107.                      * delays of 100th of a second but will
  108.                      * instead make a 'best effort'
  109.                      */
  110.     struct atpBDS *def_bdsp; /*  BDS structure associated with this req */
  111.     u_int    def_BDSlen;    /* size of BDS structure */
  112. };
  113.  
  114.  
  115. /* Return header from requests */
  116.  
  117. struct atp_result {
  118.     u_short        count;        /* the number of packets */
  119.     u_short        hdr;        /* offset to header in buffer */
  120.     u_short     offset[8];    /* offset to the Nth packet in the buffer */
  121.     u_short        len[8];        /* length of the Nth packet */
  122. };
  123.  
  124. struct atpBDS {
  125.     ua_short    bdsBuffSz;
  126.     ua_long        bdsBuffAddr;
  127.     ua_short    bdsDataSz;
  128.     unsigned char    bdsUserData[4];
  129. };
  130.  
  131.  
  132. typedef struct {
  133.         u_short        at_atpreq_type;
  134.         at_inet_t      at_atpreq_to;
  135.         u_char         at_atpreq_treq_user_bytes[4];
  136.         u_char         *at_atpreq_treq_data;
  137.         u_short        at_atpreq_treq_length;
  138.         u_char         at_atpreq_treq_bitmap;
  139.         u_char         at_atpreq_xo;
  140.         u_char         at_atpreq_xo_relt;
  141.         u_short        at_atpreq_retry_timeout;
  142.         u_short        at_atpreq_maximum_retries;
  143.         u_char         at_atpreq_tresp_user_bytes[ATP_TRESP_MAX][4];
  144.         u_char         *at_atpreq_tresp_data[ATP_TRESP_MAX];
  145.         u_short        at_atpreq_tresp_lengths[ATP_TRESP_MAX];
  146.         u_long         at_atpreq_debug[4];
  147.         u_short        at_atpreq_tid;
  148.         u_char         at_atpreq_tresp_bitmap;
  149.         u_char         at_atpreq_tresp_eom_seqno;
  150.         u_char         at_atpreq_got_trel;
  151. } at_atpreq;
  152.  
  153.  
  154. /* The ATP module ioctl commands */
  155.  
  156. #define AT_ATP_CANCEL_REQUEST        (('|'<<8)|1)
  157. #define AT_ATP_ISSUE_REQUEST        (('|'<<8)|2) /* ALO */
  158. #define AT_ATP_ISSUE_REQUEST_DEF    (('|'<<8)|3) /* XO */
  159. #define AT_ATP_ISSUE_REQUEST_DEF_NOTE    (('|'<<8)|4) /* XO & nowait -- not needed*/
  160. #define AT_ATP_ISSUE_REQUEST_NOTE    (('|'<<8)|5) /* ALO & nowait */
  161. #define AT_ATP_GET_POLL            (('|'<<8)|6)
  162. #define AT_ATP_RELEASE_RESPONSE        (('|'<<8)|7)
  163. #define AT_ATP_REQUEST_COMPLETE        (('|'<<8)|8)
  164. #define AT_ATP_SEND_FULL_RESPONSE    (('|'<<8)|9) /* not used */
  165. #define AT_ATP_BIND_REQ            (('|'<<8)|10)
  166. #define AT_ATP_GET_CHANID        (('|'<<8)|11)
  167. #define AT_ATP_PEEK            (('|'<<8)|12)
  168. #define AT_ATP_ISSUE_REQUEST_TICKLE     (('|'<<8)|13) /* ALO & nowait */
  169.  
  170. /* These macros don't really depend here, but since they're used only by the
  171.  * old ATP and old PAP, they're put here.  Unisoft PAP includes this file.
  172.  */
  173. #define    R16(x)        UAS_VALUE(x)
  174. #define    W16(x,v)    UAS_ASSIGN(x, v)
  175. #define    C16(x,v)    UAS_UAS(x, v)
  176.  
  177. /*
  178.  * these are the dispatch codes for
  179.  * the new atp_control system call
  180.  */
  181. #define ATP_SENDREQUEST  0
  182. #define ATP_GETRESPONSE  1
  183. #define ATP_SENDRESPONSE 2
  184. #define ATP_GETREQUEST   3
  185.  
  186. #ifdef KERNEL
  187.  
  188.  
  189.  
  190. /*
  191.  *    Stuff for accessing protocol headers 
  192.  */
  193. #define AT_DDP_HDR(m) ((at_ddp_t *)(gbuf_rptr(m)))
  194. #define AT_ATP_HDR(m) ((at_atp_t *)(&((at_ddp_t *)(gbuf_rptr(m)))->data[0]))
  195.  
  196. /*
  197.  *    Masks for accessing/manipulating the bitmap field in atp headers
  198.  */
  199.  
  200. #ifdef ATP_DECLARE
  201. unsigned char atp_mask [] = {
  202.     0x01, 0x02, 0x04, 0x08, 
  203.     0x10, 0x20, 0x40, 0x80, 
  204. };
  205.  
  206. unsigned char atp_lomask [] = {
  207.     0x00, 0x01, 0x03, 0x07, 
  208.     0x0f, 0x1f, 0x3f, 0x7f, 
  209.     0xff
  210. };
  211. #else
  212. extern unsigned char atp_mask [];
  213. extern unsigned char atp_lomask [];
  214. #endif /* ATP_DECLARE */
  215.  
  216. /*
  217.  *    doubly linked queue types and primitives
  218.  */
  219.  
  220. #define ATP_Q_ENTER(hdr, object, entry) {                    \
  221.         if ((hdr).head) {                        \
  222.             (hdr).head->entry.prev = (object);            \
  223.             (object)->entry.next = (hdr).head;            \
  224.         } else {                            \
  225.             (hdr).tail = (object);                    \
  226.             (object)->entry.next = NULL;                \
  227.         }                                \
  228.         (object)->entry.prev = NULL;                    \
  229.         (hdr).head = (object);                        \
  230.     }
  231.  
  232. #define ATP_Q_APPEND(hdr, object, entry) {                    \
  233.         if ((hdr).head) {                        \
  234.             (hdr).tail->entry.next = (object);            \
  235.             (object)->entry.prev = (hdr).tail;            \
  236.         } else {                            \
  237.             (hdr).head = (object);                    \
  238.             (object)->entry.prev = NULL;                \
  239.         }                                \
  240.         (object)->entry.next = NULL;                    \
  241.         (hdr).tail = (object);                        \
  242.     }
  243.  
  244. #define ATP_Q_REMOVE(hdr, object, entry) {                    \
  245.         if ((object)->entry.prev) {                    \
  246.             (object)->entry.prev->entry.next = (object)->entry.next;\
  247.         } else {                            \
  248.             (hdr).head = (object)->entry.next;            \
  249.         }                                \
  250.         if ((object)->entry.next) {                    \
  251.             (object)->entry.next->entry.prev = (object)->entry.prev;\
  252.         } else {                            \
  253.             (hdr).tail = (object)->entry.prev;            \
  254.         }                                \
  255.     }
  256.  
  257. struct atp_rcb_qhead {
  258.     struct atp_rcb     *head;
  259.     struct atp_rcb     *tail;
  260. };
  261.  
  262. struct atp_rcb_q {
  263.     struct atp_rcb *prev;
  264.     struct atp_rcb *next;
  265. };
  266.  
  267. struct atp_trans_qhead {
  268.     struct atp_trans *head;
  269.     struct atp_trans *tail;
  270. };
  271.  
  272. struct atp_trans_q {
  273.     struct atp_trans *prev;
  274.     struct atp_trans *next;
  275. };
  276.  
  277. /*
  278.  *    Locally saved remote node address
  279.  */
  280.  
  281. struct atp_socket {
  282.     u_short        net;
  283.     at_node        node;
  284.     at_socket    socket;
  285. };
  286.  
  287. /*
  288.  *    transaction control block (local context at requester end)
  289.  */
  290.  
  291. struct atp_trans {
  292.     struct atp_trans_q    tr_list;        /* trans list */
  293.     struct atp_state    *tr_queue;        /* state data structure */
  294.     gbuf_t            *tr_xmt;        /* message being sent */
  295.     gbuf_t            *tr_rcv[8];        /* message being rcvd */
  296.     unsigned int        tr_retry;        /* # retries left */
  297.     unsigned int        tr_timeout;        /* timer interval */
  298.     char            tr_state;        /* current state */
  299.     char            tr_rsp_wait;        /* waiting for transaction response */
  300.     char             filler[2];
  301.     unsigned char        tr_xo;            /* execute once transaction */
  302.     unsigned char        tr_bitmap;        /* requested bitmask */
  303.     unsigned short        tr_tid;            /* transaction id */
  304.     struct atp_socket    tr_socket;        /* the remote socket id */
  305.     struct atp_trans_q    tr_snd_wait;        /* list of transactions waiting
  306.                                for space to send a msg */
  307.     at_socket        tr_local_socket;
  308.     at_node            tr_local_node;
  309.     at_net            tr_local_net;
  310.     gbuf_t                  *tr_bdsp;               /* bds structure pointer */
  311.     unsigned int        tr_tmo_delta;
  312.     void                 (*tr_tmo_func)();
  313.     struct atp_trans    *tr_tmo_next;
  314.     struct atp_trans    *tr_tmo_prev;
  315.     atlock_t tr_lock;
  316.     atevent_t tr_event;
  317. };
  318.  
  319. #define    TRANS_TIMEOUT        0    /* waiting for a reply */
  320. #define    TRANS_REQUEST        1    /* waiting to send a request */
  321. #define    TRANS_RELEASE        2    /* waiting to send a release */
  322. #define    TRANS_DONE            3    /* done - waiting for poll to complete */
  323. #define    TRANS_FAILED        4    /* done - waiting for poll to report failure */
  324. #define TRANS_ABORTING        5    /* waiting on atp_trans_abort list for thread to wakeup */
  325.  
  326. /*
  327.  *    reply control block (local context at repling end)
  328.  */
  329.  
  330. struct atp_rcb {
  331.     struct atp_rcb_q    rc_list;        /* rcb list */
  332.     struct atp_rcb_q        rc_tlist;
  333.     struct atp_state    *rc_queue;        /* state data structure */
  334.     gbuf_t            *rc_xmt;        /* replys being sent */
  335.     gbuf_t            *rc_ioctl;        /* waiting ioctl */
  336.     char            rc_snd[8];        /* replys actually to be sent */
  337.     int                     rc_pktcnt;              /* no of pkts in this trans */
  338.     short            rc_state;        /* current state */
  339.     unsigned char        rc_xo;            /* execute once transaction */
  340.     at_node            rc_local_node;
  341.     at_net            rc_local_net;
  342.     short            rc_rep_waiting;        /* in the reply wait list */
  343.     int            rc_timestamp;        /* reply timer */
  344.     unsigned char        rc_bitmap;        /* replied bitmask */
  345.     unsigned char        rc_not_sent_bitmap;    /* replied bitmask */
  346.     unsigned short        rc_tid;            /* transaction id */
  347.     struct atp_socket    rc_socket;        /* the remote socket id */
  348. };
  349.  
  350. #define RCB_UNQUEUED        0     /* newly allocated, not q'd */
  351. #define RCB_RESPONDING        2    /* waiting all of response from process*/
  352. #define RCB_RESPONSE_FULL    3    /* got all of response */
  353. #define RCB_RELEASED        4    /* got our release */
  354. #define RCB_PENDING        5    /* a no wait rcb is full */
  355. #define RCB_NOTIFIED        6
  356. #define RCB_SENDING        7    /* we're currently xmitting this trans */
  357.  
  358. /*
  359.  *    socket state (per module data structure)
  360.  */
  361.  
  362. struct atp_state {
  363.     gref_t        *atp_gref;    /* must be the first entry */
  364.     int        atp_pid;     /* process id, must be the second entry */
  365.     gbuf_t         *atp_msgq;    /* data msg, must be the third entry */
  366.     unsigned char    dflag;         /* structure flag, must be the fourth entry */
  367.     unsigned char    filler;
  368.     short    atp_socket_no;
  369.     short    atp_flags;            /* general flags */
  370.     struct atp_trans_qhead    atp_trans_wait;        /* pending transaction list */
  371.     struct atp_state    *atp_trans_waiting;    /* list of atps waiting for a
  372.                                free transaction */
  373.     unsigned int        atp_retry;        /* retry count */
  374.     unsigned int        atp_timeout;        /* retry timeout */
  375.     struct atp_state    *atp_rcb_waiting;
  376.     struct atp_rcb_qhead    atp_rcb;        /* active rcbs */
  377.     struct atp_rcb_qhead    atp_attached;        /* rcb's waiting to be read */
  378.     atlock_t atp_lock;
  379.     atevent_t atp_event;
  380.     atlock_t atp_delay_lock;
  381.     atevent_t atp_delay_event;
  382. };
  383.  
  384.  
  385. /*
  386.  *     atp_state flag definitions
  387.  */
  388. #define ATP_CLOSING  0x08        /* atp stream in process of closing */
  389.  
  390.  
  391. /*
  392.  *    tcb/rcb/state allocation queues
  393.  */
  394.  
  395. /*
  396.  * Size defines; must be outside following #ifdef to permit
  397.  *  debugging code to reference independent of ATP_DECLARE
  398.  */
  399. #define    NATP_RCB    512    /* the number of ATP RCBs at once */
  400. #define NATP_STATE    192    /* the number of ATP sockets open at once */
  401.                 /* note: I made NATP_STATE == NSOCKETS */
  402.  
  403. #ifdef ATP_DECLARE
  404. struct atp_trans *atp_trans_free_list = NULL;    /* free transactions */
  405. struct atp_rcb *atp_rcb_free_list = NULL;        /* free rcbs */
  406. static struct atp_state *atp_free_list = NULL;    /* free atp states */
  407. struct atp_trans_qhead    atp_trans_abort;        /* aborted trans list */
  408. static struct atp_rcb atp_rcb_data[NATP_RCB];
  409. static struct atp_state atp_state_data[NATP_STATE];
  410.  
  411.  
  412.  
  413. #else
  414. extern struct atp_trans *atp_trans_free_list;        /* free transactions */
  415. extern struct atp_rcb *atp_rcb_free_list;            /* free rcbs */
  416. extern struct atp_state *atp_free_list;                /* free atp states */
  417. extern struct atp_rcb atp_rcb_data[];
  418. extern struct atp_state atp_state_data[];
  419. extern struct atp_trans_qhead atp_trans_abort;        /* aborting trans list */
  420.  
  421. extern void atp_req_timeout();
  422. extern void atp_rcb_timer();
  423. extern void atp_x_done();
  424. extern struct atp_rcb *atp_rcb_alloc();
  425. extern struct atp_trans *atp_trans_alloc();
  426. #endif /* ATP_DECLARE */
  427.  
  428. /* prototypes */
  429. void atp_send_req(gref_t *, gbuf_t *);
  430. void atp_drop_req(gref_t *, gbuf_t *);
  431. void atp_send_rsp(gref_t *, gbuf_t *, int);
  432. void atp_wput(gref_t *, gbuf_t *);
  433. void atp_rput(gref_t *, gbuf_t *);
  434. void atp_retry_req(gbuf_t *);
  435. void atp_stop(gbuf_t *, int);
  436. void atp_cancel_req(gref_t *, unsigned short);
  437. int atp_open(gref_t *, int);
  438. int atp_bind(gref_t *, unsigned int, unsigned char *);
  439. int atp_close(gref_t *, int);
  440. gbuf_t *atp_build_release(struct atp_trans *);
  441. void atp_req_timeout(struct atp_trans *);
  442. void atp_free(struct atp_trans *);
  443. void atp_x_done(struct atp_trans *);
  444. void atp_send(struct atp_trans *);
  445. void atp_rsp_ind(struct atp_trans *, gbuf_t *);
  446. void atp_trans_free(struct atp_trans *);
  447. void atp_reply(struct atp_rcb *);
  448. void atp_rcb_free(struct atp_rcb *);
  449. void atp_send_replies(struct atp_state *, struct atp_rcb *);
  450. void atp_dequeue_atp(struct atp_state *);
  451. int atp_iocack(struct atp_state *, gbuf_t *);
  452. void atp_req_ind(struct atp_state *, gbuf_t *);
  453. int atp_iocnak(struct atp_state *, gbuf_t *, int);
  454. void atp_trp_timer(void *, int);
  455. void atp_timout(void (*func)(), struct atp_trans *, int);
  456. void atp_untimout(void (*func)(), struct atp_trans *);
  457. int atp_tid(struct atp_state *);
  458.  
  459. #endif /* KERNEL */
  460. #endif /* _NETAT_ATP_H_ */
  461.