![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atp.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / netat|
Return to atp.h CVS log | Up to [Apple XNU] / XNU / bsd / netat |
1.1 root 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:
325: /*
326: * reply control block (local context at repling end)
327: */
328:
329: struct atp_rcb {
330: struct atp_rcb_q rc_list; /* rcb list */
331: struct atp_rcb_q rc_tlist;
332: struct atp_state *rc_queue; /* state data structure */
333: gbuf_t *rc_xmt; /* replys being sent */
334: gbuf_t *rc_ioctl; /* waiting ioctl */
335: char rc_snd[8]; /* replys actually to be sent */
336: int rc_pktcnt; /* no of pkts in this trans */
337: short rc_state; /* current state */
338: unsigned char rc_xo; /* execute once transaction */
339: at_node rc_local_node;
340: at_net rc_local_net;
341: short rc_rep_waiting; /* in the reply wait list */
342: int rc_timestamp; /* reply timer */
343: unsigned char rc_bitmap; /* replied bitmask */
344: unsigned char rc_not_sent_bitmap; /* replied bitmask */
345: unsigned short rc_tid; /* transaction id */
346: struct atp_socket rc_socket; /* the remote socket id */
347: };
348:
349: #define RCB_UNQUEUED 0 /* newly allocated, not q'd */
350: #define RCB_RESPONDING 2 /* waiting all of response from process*/
351: #define RCB_RESPONSE_FULL 3 /* got all of response */
352: #define RCB_RELEASED 4 /* got our release */
353: #define RCB_PENDING 5 /* a no wait rcb is full */
354: #define RCB_NOTIFIED 6
355: #define RCB_SENDING 7 /* we're currently xmitting this trans */
356:
357: /*
358: * socket state (per module data structure)
359: */
360:
361: struct atp_state {
362: gref_t *atp_gref; /* must be the first entry */
363: int atp_pid; /* process id, must be the second entry */
364: gbuf_t *atp_msgq; /* data msg, must be the third entry */
365: unsigned char dflag; /* structure flag, must be the fourth entry */
366: unsigned char filler;
367: short atp_socket_no;
368: short atp_flags; /* general flags */
369: struct atp_trans_qhead atp_trans_wait; /* pending transaction list */
370: struct atp_state *atp_trans_waiting; /* list of atps waiting for a
371: free transaction */
372: unsigned int atp_retry; /* retry count */
373: unsigned int atp_timeout; /* retry timeout */
374: struct atp_state *atp_rcb_waiting;
375: struct atp_rcb_qhead atp_rcb; /* active rcbs */
376: struct atp_rcb_qhead atp_attached; /* rcb's waiting to be read */
377: atlock_t atp_lock;
378: atevent_t atp_event;
379: atlock_t atp_delay_lock;
380: atevent_t atp_delay_event;
381: };
382:
383:
384: /*
385: * atp_state flag definitions
386: */
387: #define ATP_CLOSING 0x08 /* atp stream in process of closing */
388:
389:
390: /*
391: * tcb/rcb/state allocation queues
392: */
393:
394: /*
395: * Size defines; must be outside following #ifdef to permit
396: * debugging code to reference independent of ATP_DECLARE
397: */
398: #define NATP_RCB 512 /* the number of ATP RCBs at once */
399: #define NATP_STATE 192 /* the number of ATP sockets open at once */
400: /* note: I made NATP_STATE == NSOCKETS */
401:
402: #ifdef ATP_DECLARE
403: struct atp_trans *atp_trans_free_list = NULL; /* free transactions */
404: struct atp_rcb *atp_rcb_free_list = NULL; /* free rcbs */
405: static struct atp_state *atp_free_list = NULL; /* free atp states */
406: static struct atp_rcb atp_rcb_data[NATP_RCB];
407: static struct atp_state atp_state_data[NATP_STATE];
408:
409: #else
410: extern struct atp_trans *atp_trans_free_list; /* free transactions */
411: extern struct atp_rcb *atp_rcb_free_list; /* free rcbs */
412: extern struct atp_state *atp_free_list; /* free atp states */
413: extern struct atp_rcb atp_rcb_data[];
414: extern struct atp_state atp_state_data[];
415:
416: extern void atp_req_timeout();
417: extern void atp_rcb_timer();
418: extern void atp_x_done();
419: extern struct atp_rcb *atp_rcb_alloc();
420: extern struct atp_trans *atp_trans_alloc();
421: #endif /* ATP_DECLARE */
422:
423: /* prototypes */
424: void atp_send_req(gref_t *, gbuf_t *);
425: void atp_drop_req(gref_t *, gbuf_t *);
426: void atp_send_rsp(gref_t *, gbuf_t *, int);
427: void atp_wput(gref_t *, gbuf_t *);
428: void atp_rput(gref_t *, gbuf_t *);
429: void atp_retry_req(gbuf_t *);
430: void atp_stop(gbuf_t *, int);
431: void atp_cancel_req(gref_t *, unsigned short);
432: int atp_open(gref_t *, int);
433: int atp_bind(gref_t *, unsigned int, unsigned char *);
434: int atp_close(gref_t *, int);
435: gbuf_t *atp_build_release(struct atp_trans *);
436: void atp_req_timeout(struct atp_trans *);
437: void atp_free(struct atp_trans *);
438: void atp_x_done(struct atp_trans *);
439: void atp_send(struct atp_trans *);
440: void atp_rsp_ind(struct atp_trans *, gbuf_t *);
441: void atp_trans_free(struct atp_trans *);
442: void atp_reply(struct atp_rcb *);
443: void atp_rcb_free(struct atp_rcb *);
444: void atp_send_replies(struct atp_state *, struct atp_rcb *);
445: void atp_dequeue_atp(struct atp_state *);
446: int atp_iocack(struct atp_state *, gbuf_t *);
447: void atp_req_ind(struct atp_state *, gbuf_t *);
448: int atp_iocnak(struct atp_state *, gbuf_t *, int);
449: void atp_trp_timer(void *, int);
450: void atp_timout(void (*func)(), struct atp_trans *, int);
451: void atp_untimout(void (*func)(), struct atp_trans *);
452: int atp_tid(struct atp_state *);
453:
454: #endif /* KERNEL */
455: #endif /* _NETAT_ATP_H_ */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.