![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atp_inc.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netat / h|
Return to atp_inc.h CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat / h |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25:
26: /*
27: * Copyright (c) 1988, 1989 Apple Computer, Inc.
28: *
29: * The information contained herein is subject to change without
30: * notice and should not be construed as a commitment by Apple
31: * Computer, Inc. Apple Computer, Inc. assumes no responsibility
32: * for any errors that may appear.
33: *
34: * Confidential and Proprietary to Apple Computer, Inc.
35: */
36:
37: /* "@(#)atp_inc.h: 2.0, 1.16; 10/4/93; Copyright 1988-89, Apple Computer, Inc." */
38:
39: #include "sysglue.h"
40: #include "debug.h"
41: #include "at-config.h"
42:
43: /*
44: * Stuff for accessing protocol headers
45: */
46: #define AT_DDP_HDR(m) ((at_ddp_t *)(gbuf_rptr(m)))
47: #define AT_ATP_HDR(m) ((at_atp_t *)(&((at_ddp_t *)(gbuf_rptr(m)))->data[0]))
48:
49: /*
50: * Masks for accessing/manipulating the bitmap field in atp headers
51: */
52:
53: #ifdef ATP_DECLARE
54: unsigned char atp_mask [] = {
55: 0x01, 0x02, 0x04, 0x08,
56: 0x10, 0x20, 0x40, 0x80,
57: };
58:
59: unsigned char atp_lomask [] = {
60: 0x00, 0x01, 0x03, 0x07,
61: 0x0f, 0x1f, 0x3f, 0x7f,
62: 0xff
63: };
64: #else
65: extern unsigned char atp_mask [];
66: extern unsigned char atp_lomask [];
67: #endif /* ATP_DECLARE */
68:
69: /*
70: * doubly linked queue types and primitives
71: */
72:
73: #define ATP_Q_ENTER(hdr, object, entry) { \
74: if ((hdr).head) { \
75: (hdr).head->entry.prev = (object); \
76: (object)->entry.next = (hdr).head; \
77: } else { \
78: (hdr).tail = (object); \
79: (object)->entry.next = NULL; \
80: } \
81: (object)->entry.prev = NULL; \
82: (hdr).head = (object); \
83: }
84:
85: #define ATP_Q_APPEND(hdr, object, entry) { \
86: if ((hdr).head) { \
87: (hdr).tail->entry.next = (object); \
88: (object)->entry.prev = (hdr).tail; \
89: } else { \
90: (hdr).head = (object); \
91: (object)->entry.prev = NULL; \
92: } \
93: (object)->entry.next = NULL; \
94: (hdr).tail = (object); \
95: }
96:
97: #define ATP_Q_REMOVE(hdr, object, entry) { \
98: if ((object)->entry.prev) { \
99: (object)->entry.prev->entry.next = (object)->entry.next;\
100: } else { \
101: (hdr).head = (object)->entry.next; \
102: } \
103: if ((object)->entry.next) { \
104: (object)->entry.next->entry.prev = (object)->entry.prev;\
105: } else { \
106: (hdr).tail = (object)->entry.prev; \
107: } \
108: }
109:
110: struct atp_rcb_qhead {
111: struct atp_rcb *head;
112: struct atp_rcb *tail;
113: };
114:
115: struct atp_rcb_q {
116: struct atp_rcb *prev;
117: struct atp_rcb *next;
118: };
119:
120: struct atp_trans_qhead {
121: struct atp_trans *head;
122: struct atp_trans *tail;
123: };
124:
125: struct atp_trans_q {
126: struct atp_trans *prev;
127: struct atp_trans *next;
128: };
129:
130: /*
131: * Locally saved remote node address
132: */
133:
134: struct atp_socket {
135: u_short net;
136: at_node node;
137: at_socket socket;
138: };
139:
140: /*
141: * transaction control block (local context at requester end)
142: */
143:
144: struct atp_trans {
145: struct atp_trans_q tr_list; /* trans list */
146: struct atp_state *tr_queue; /* state data structure */
147: gbuf_t *tr_xmt; /* message being sent */
148: gbuf_t *tr_rcv[8]; /* message being rcvd */
149: unsigned int tr_retry; /* # retries left */
150: unsigned int tr_timeout; /* timer interval */
151: char tr_state; /* current state */
152: char tr_rsp_wait; /* waiting for transaction response */
153: char filler[2];
154: unsigned char tr_xo; /* execute once transaction */
155: unsigned char tr_bitmap; /* requested bitmask */
156: unsigned short tr_tid; /* transaction id */
157: struct atp_socket tr_socket; /* the remote socket id */
158: struct atp_trans_q tr_snd_wait; /* list of transactions waiting
159: for space to send a msg */
160: at_socket tr_local_socket;
161: unsigned char tr_local_node;
162: unsigned char tr_local_net[2];
163: gbuf_t *tr_bdsp; /* bds structure pointer */
164: unsigned int tr_tmo_delta;
165: void (*tr_tmo_func)();
166: struct atp_trans *tr_tmo_next;
167: struct atp_trans *tr_tmo_prev;
168: atlock_t tr_lock;
169: atevent_t tr_event;
170: };
171:
172: #define TRANS_TIMEOUT 0 /* waiting for a reply */
173: #define TRANS_REQUEST 1 /* waiting to send a request */
174: #define TRANS_RELEASE 2 /* waiting to send a release */
175: #define TRANS_DONE 3 /* done - waiting for poll to complete */
176: #define TRANS_FAILED 4 /* done - waiting for poll to report failure */
177:
178: /*
179: * reply control block (local context at repling end)
180: */
181:
182: struct atp_rcb {
183: struct atp_rcb_q rc_list; /* rcb list */
184: struct atp_rcb_q rc_tlist;
185: struct atp_state *rc_queue; /* state data structure */
186: gbuf_t *rc_xmt; /* replys being sent */
187: gbuf_t *rc_ioctl; /* waiting ioctl */
188: char rc_snd[8]; /* replys actually to be sent */
189: int rc_pktcnt; /* no of pkts in this trans */
190: short rc_state; /* current state */
191: unsigned char rc_xo; /* execute once transaction */
192: unsigned char rc_local_node;
193: unsigned char rc_local_net[2];
194: short rc_rep_waiting; /* in the reply wait list */
195: int rc_timestamp; /* reply timer */
196: unsigned char rc_bitmap; /* replied bitmask */
197: unsigned char rc_not_sent_bitmap; /* replied bitmask */
198: unsigned short rc_tid; /* transaction id */
199: struct atp_socket rc_socket; /* the remote socket id */
200: };
201:
202: #define RCB_UNQUEUED 0 /* newly allocated, not q'd */
203: #define RCB_RESPONDING 2 /* waiting all of response from process*/
204: #define RCB_RESPONSE_FULL 3 /* got all of response */
205: #define RCB_RELEASED 4 /* got our release */
206: #define RCB_PENDING 5 /* a no wait rcb is full */
207: #define RCB_NOTIFIED 6
208: #define RCB_SENDING 7 /* we're currently xmitting this trans */
209:
210: /*
211: * socket state (per module data structure)
212: */
213:
214: struct atp_state {
215: gref_t *atp_gref; /* must be the first entry */
216: int atp_pid; /* process id, must be the second entry */
217: gbuf_t *atp_msgq; /* data msg, must be the third entry */
218: unsigned char dflag; /* structure flag, must be the fourth entry */
219: unsigned char filler;
220: short atp_minor_no;
221: short atp_socket_no;
222: short atp_flags; /* general flags */
223: struct atp_trans_qhead atp_trans_wait; /* pending transaction list */
224: struct atp_state *atp_trans_waiting; /* list of atps waiting for a
225: free transaction */
226: unsigned int atp_retry; /* retry count */
227: unsigned int atp_timeout; /* retry timeout */
228: struct atp_state *atp_rcb_waiting;
229: struct atp_rcb_qhead atp_rcb; /* active rcbs */
230: struct atp_rcb_qhead atp_attached; /* rcb's waiting to be read */
231: atlock_t atp_lock;
232: atevent_t atp_event;
233: atlock_t atp_delay_lock;
234: atevent_t atp_delay_event;
235: };
236:
237:
238: /*
239: * atp_state flag definitions
240: */
241: #define ATP_CLOSING 0x08 /* atp stream in process of closing */
242:
243:
244: /*
245: * tcb/rcb/state allocation queues
246: */
247:
248: /*
249: * Size defines; must be outside following #ifdef to permit
250: * debugging code to reference independent of ATP_DECLARE
251: */
252: #define NATP_RCB 512 /* the number of ATP RCBs at once */
253: #define NATP_STATE 192 /* the number of ATP sockets open at once */
254: /* note: I made NATP_STATE == NSOCKETS */
255:
256: #ifdef ATP_DECLARE
257: struct atp_trans *atp_trans_free_list = NULL; /* free transactions */
258: struct atp_rcb *atp_rcb_free_list = NULL; /* free rcbs */
259: static struct atp_state *atp_free_list = NULL; /* free atp states */
260: static struct atp_rcb atp_rcb_data[NATP_RCB];
261: static struct atp_state atp_state_data[NATP_STATE];
262:
263: #else
264: extern struct atp_trans *atp_trans_free_list; /* free transactions */
265: extern struct atp_rcb *atp_rcb_free_list; /* free rcbs */
266: extern struct atp_state *atp_free_list; /* free atp states */
267: extern struct atp_rcb atp_rcb_data[];
268: extern struct atp_state atp_state_data[];
269:
270: extern void atp_req_timeout();
271: extern void atp_rcb_timer();
272: extern void atp_x_done();
273: extern struct atp_rcb *atp_rcb_alloc();
274: extern struct atp_trans *atp_trans_alloc();
275: #endif /* ATP_DECLARE */
276:
277: /* prototypes */
278: void atp_send_req(gref_t *, gbuf_t *);
279: void atp_drop_req(gref_t *, gbuf_t *);
280: void atp_send_rsp(gref_t *, gbuf_t *, int);
281: void atp_wput(gref_t *, gbuf_t *);
282: void atp_rput(gref_t *, gbuf_t *);
283: void atp_retry_req(gbuf_t *);
284: void atp_stop(gbuf_t *, int);
285: void atp_cancel_req(gref_t *, unsigned short);
286: int atp_open(gref_t *, int);
287: int atp_bind(gref_t *, unsigned int, unsigned char *);
288: int atp_close(gref_t *, int);
289: gbuf_t *atp_build_release(struct atp_trans *);
290: void atp_req_timeout(struct atp_trans *);
291: void atp_free(struct atp_trans *);
292: void atp_x_done(struct atp_trans *);
293: void atp_send(struct atp_trans *);
294: void atp_rsp_ind(struct atp_trans *, gbuf_t *);
295: void atp_trans_free(struct atp_trans *);
296: void atp_reply(struct atp_rcb *);
297: void atp_rcb_free(struct atp_rcb *);
298: void atp_send_replies(struct atp_state *, struct atp_rcb *);
299: void atp_dequeue_atp(struct atp_state *);
300: int atp_iocack(struct atp_state *, gbuf_t *);
301: void atp_req_ind(struct atp_state *, gbuf_t *);
302: int atp_iocnak(struct atp_state *, gbuf_t *, int);
303: void atp_trp_timer(void *, int);
304: void atp_timout(void (*func)(), struct atp_trans *, int);
305: void atp_untimout(void (*func)(), struct atp_trans *);
306: int atp_tid(struct atp_state *);
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.