![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atp_read.c 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|
Return to atp_read.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netat |
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: * Copyright (c) 1996-1998 Apple Computer, Inc.
27: * All Rights Reserved.
28: *
29: * THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF APPLE COMPUTER, INC.
30: * The copyright notice above does not evidence any actual or
31: * intended publication of such source code.
32: */
33:
34: #include <appletalk.h>
35: #include <atp.h>
36: #include <ddp.h>
37: #include <at_atp.h>
38: #include <atp_inc.h>
39:
40: static void atp_trans_complete();
41:
42: /*
43: * Decide what to do about received messages
44: * Version 1.7 of atp_read.c on 89/02/09 17:53:16
45: */
46:
47: int atp_treq_event(gref)
48: register gref_t *gref;
49: {
50: register gbuf_t *m;
51: register struct atp_state *atp;
52:
53: atp = (struct atp_state *)gref->info;
54: if (atp->dflag)
55: atp = (struct atp_state *)atp->atp_msgq;
56:
57: if (atp->dflag) {
58: if ((m = gbuf_alloc(sizeof(ioc_t), PRI_HI)) != NULL) {
59: gbuf_set_type(m, MSG_IOCTL);
60: gbuf_wset(m,sizeof(ioc_t));
61: ((ioc_t *)gbuf_rptr(m))->ioc_cmd = AT_ATP_GET_POLL;
62: atp_wput(gref, m);
63: }
64: }
65: else if ((m = gbuf_alloc(1, PRI_HI)) != NULL) {
66: *gbuf_rptr(m) = 0;
67: gbuf_wset(m,1);
68: atalk_putnext(gref, m);
69: }
70:
71: if (m == 0)
72: atalk_timeout(atp_treq_event, gref, 10);
73: }
74:
75: void atp_rput(gref, m)
76: gref_t *gref;
77: gbuf_t *m;
78: {
79: register at_atp_t *athp;
80: register struct atp_state *atp;
81: register int s, s_gen;
82: gbuf_t *m_asp = NULL;
83:
84: atp = (struct atp_state *)gref->info;
85: if (atp->dflag)
86: atp = (struct atp_state *)atp->atp_msgq;
87:
88: switch(gbuf_type(m)) {
89: case MSG_DATA:
90: /*
91: * Decode the message, make sure it is an atp
92: * message
93: */
94: if (((AT_DDP_HDR(m))->type != ATP_DDP_TYPE) ||
95: (atp->atp_flags & ATP_CLOSING)) {
96: gbuf_freem(m);
97: dPrintf(D_M_ATP_LOW, (D_L_INPUT|D_L_ERROR),
98: ("atp_rput: dropping MSG, not atp\n"));
99: break;
100: }
101:
102: athp = AT_ATP_HDR(m);
103: dPrintf(D_M_ATP_LOW, D_L_INPUT,
104: ("atp_rput MSG_DATA: %s (%d)\n",
105: (athp->cmd == ATP_CMD_TRESP)? "TRESP":
106: (athp->cmd == ATP_CMD_TREL)? "TREL":
107: (athp->cmd == ATP_CMD_TREQ)? "TREQ": "unknown",
108: athp->cmd));
109:
110: switch (athp->cmd) {
111:
112: case ATP_CMD_TRESP:
113: {
114: register struct atp_trans *trp;
115: register int seqno;
116: register at_ddp_t *ddp;
117:
118: /*
119: * we just got a response, find the trans record
120: */
121:
122: ATDISABLE(s, atp->atp_lock);
123: for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) {
124: if (trp->tr_tid == UAS_VALUE(athp->tid))
125: break;
126: }
127:
128: /*
129: * If we can't find one then ignore the message
130: */
131: seqno = athp->bitmap;
132: if (trp == NULL) {
133: ATENABLE(s, atp->atp_lock);
134: ddp = AT_DDP_HDR(m);
135: dPrintf(D_M_ATP_LOW, (D_L_INPUT|D_L_ERROR),
136: ("atp_rput: dropping TRESP, no trp,tid=%d,loc=%d,rem=%d.%d,seqno=%d\n",
137: UAS_VALUE(athp->tid),
138: ddp->dst_socket,ddp->src_node,ddp->src_socket,seqno));
139: gbuf_freem(m);
140: return;
141: }
142:
143: /*
144: * If no longer valid, drop it
145: */
146: if (trp->tr_state == TRANS_FAILED) {
147: ATENABLE(s, atp->atp_lock);
148: ddp = AT_DDP_HDR(m);
149: dPrintf(D_M_ATP_LOW, (D_L_INPUT|D_L_ERROR),
150: ("atp_rput: dropping TRESP, failed trp,tid=%d,loc=%d,rem=%d.%d\n",
151: UAS_VALUE(athp->tid),
152: ddp->dst_socket, ddp->src_node, ddp->src_socket));
153: gbuf_freem(m);
154: return;
155: }
156:
157: /*
158: * If we have already received it, ignore it
159: */
160: if (!(trp->tr_bitmap&atp_mask[seqno]) || trp->tr_rcv[seqno]) {
161: ATENABLE(s, atp->atp_lock);
162: ddp = AT_DDP_HDR(m);
163: dPrintf(D_M_ATP_LOW, (D_L_INPUT|D_L_ERROR),
164: ("atp_rput: dropping TRESP, duplicate,tid=%d,loc=%d,rem=%d.%d,seqno=%d\n",
165: UAS_VALUE(athp->tid),
166: ddp->dst_socket, ddp->src_node, ddp->src_socket, seqno));
167: gbuf_freem(m);
168: return;
169: }
170:
171: /*
172: * Update the received packet bitmap
173: */
174: if (athp->eom)
175: trp->tr_bitmap &= atp_lomask[seqno];
176: else
177: trp->tr_bitmap &= ~atp_mask[seqno];
178:
179: /*
180: * Save the message in the trans record
181: */
182: trp->tr_rcv[seqno] = m;
183:
184: /*
185: * If it isn't the first message then
186: * can the header
187: */
188: if (seqno)
189: gbuf_rinc(m,DDP_X_HDR_SIZE);
190:
191: /*
192: * If we now have all the responses then return
193: * the message to the user
194: */
195: if (trp->tr_bitmap == 0) {
196: ATENABLE(s, atp->atp_lock);
197:
198: /*
199: * Cancel the request timer and any
200: * pending transmits
201: */
202: atp_untimout(atp_req_timeout, trp);
203:
204: /*
205: * Send the results back to the user
206: */
207: atp_x_done(trp);
208: return;
209: }
210: if (athp->sts) {
211: /*
212: * If they want treq again, send them
213: */
214: ATENABLE(s, atp->atp_lock);
215: atp_untimout(atp_req_timeout, trp);
216: atp_send(trp);
217: return;
218: }
219: ATENABLE(s, atp->atp_lock);
220: return;
221: }
222:
223: case ATP_CMD_TREL:
224: { register struct atp_rcb *rcbp;
225: register at_ddp_t *ddp;
226:
227: /*
228: * Search for a matching transaction
229: */
230: ddp = AT_DDP_HDR(m);
231:
232: ATDISABLE(s, atp->atp_lock);
233: for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) {
234: if (rcbp->rc_tid == UAS_VALUE(athp->tid) &&
235: rcbp->rc_socket.node == ddp->src_node &&
236: rcbp->rc_socket.net == NET_VALUE(ddp->src_net) &&
237: rcbp->rc_socket.socket == ddp->src_socket) {
238: /*
239: * Mark the rcb released
240: */
241: rcbp->rc_not_sent_bitmap = 0;
242: if (rcbp->rc_state == RCB_SENDING)
243: rcbp->rc_state = RCB_RELEASED;
244: else
245: {
246: ddp = 0;
247: atp_rcb_free(rcbp);
248: ATENABLE(s, atp->atp_lock);
249: }
250: break;
251: }
252: }
253:
254: if (ddp)
255: ATENABLE(s, atp->atp_lock);
256: gbuf_freem(m);
257: return;
258: }
259:
260:
261: case ATP_CMD_TREQ:
262: { register struct atp_rcb *rcbp;
263: register at_ddp_t *ddp;
264: gbuf_t *m2;
265:
266: /*
267: * If it is a request message, first
268: * check to see
269: * if matches something in our active
270: * request queue
271: */
272: ddp = AT_DDP_HDR(m);
273:
274: ATDISABLE(s, atp->atp_lock);
275: for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) {
276: if (rcbp->rc_tid == UAS_VALUE(athp->tid) &&
277: rcbp->rc_socket.node == ddp->src_node &&
278: rcbp->rc_socket.net == NET_VALUE(ddp->src_net) &&
279: rcbp->rc_socket.socket == ddp->src_socket)
280: break;
281: }
282: /*
283: * If this is a new req then do
284: * something with it
285: */
286: if (rcbp == NULL) {
287: /*
288: * see if it matches something in the
289: * attached request queue
290: * if it does, just release the message
291: * and go on about our buisness
292: */
293: /* we just did this, why do again? -jjs 4-10-95 */
294: for (rcbp = atp->atp_attached.head; rcbp; rcbp = rcbp->rc_list.next) {
295: if (rcbp->rc_tid == UAS_VALUE(athp->tid) &&
296: rcbp->rc_socket.node == ddp->src_node &&
297: rcbp->rc_socket.net == NET_VALUE(ddp->src_net) &&
298: rcbp->rc_socket.socket == ddp->src_socket) {
299: ATENABLE(s, atp->atp_lock);
300: gbuf_freem(m);
301: dPrintf(D_M_ATP_LOW, D_L_INPUT,
302: ("atp_rput: dropping TREQ, matches req queue\n"));
303: return;
304: }
305: }
306:
307: /*
308: * assume someone is interested in
309: * in an asynchronous incoming request
310: */
311: ATENABLE(s, atp->atp_lock);
312: if ((rcbp = atp_rcb_alloc(atp)) == NULL) {
313: gbuf_freem(m);
314: return;
315: }
316: rcbp->rc_state = RCB_UNQUEUED;
317: ATDISABLE(s, atp->atp_lock);
318:
319: rcbp->rc_local_node = ddp->dst_node;
320: NET_NET(rcbp->rc_local_net, ddp->dst_net);
321: rcbp->rc_socket.socket = ddp->src_socket;
322: rcbp->rc_socket.node = ddp->src_node;
323: rcbp->rc_socket.net = NET_VALUE(ddp->src_net);
324: rcbp->rc_tid = UAS_VALUE(athp->tid);
325: rcbp->rc_bitmap = athp->bitmap;
326: rcbp->rc_not_sent_bitmap = athp->bitmap;
327: rcbp->rc_xo = athp->xo;
328: /*
329: * if async then send it as
330: * data
331: * otherwise, it is a synchronous ioctl so
332: * complete it
333: */
334: if (atp->dflag) { /* for ASP? */
335: if (m2 = gbuf_alloc(sizeof(ioc_t), PRI_HI)) {
336: gbuf_set_type(m2, MSG_DATA);
337: gbuf_wset(m2,sizeof(ioc_t));
338: ((ioc_t *)gbuf_rptr(m2))->ioc_cmd = AT_ATP_GET_POLL;
339: m_asp = m2;
340: }
341: } else if (m2 = gbuf_alloc(1, PRI_HI)) {
342: *gbuf_rptr(m2) = 0;
343: gbuf_wset(m2,1);
344: atalk_putnext(gref, m2);
345: }
346: if (m2 == 0) {
347: dPrintf(D_M_ATP,D_L_WARNING,
348: ("atp_rput: out of buffer for TREQ\n"));
349: atalk_timeout(atp_treq_event, gref, 10);
350: }
351: rcbp->rc_ioctl = m;
352:
353: /*
354: * move it to the attached list
355: */
356: dPrintf(D_M_ATP_LOW, D_L_INPUT,
357: ("atp_rput: moving to attached list\n"));
358: rcbp->rc_state = RCB_PENDING;
359: ATP_Q_APPEND(atp->atp_attached, rcbp, rc_list);
360: if (m_asp != NULL) {
361: ATENABLE(s, atp->atp_lock);
362: atp_req_ind(atp, m_asp);
363: return;
364: }
365: } else {
366: dPrintf(D_M_ATP_LOW, D_L_INPUT,
367: ("atp_rput: found match, state:%d\n",
368: rcbp->rc_state));
369:
370: /*
371: * Otherwise we have found a matching request
372: * look for what to do
373: */
374: switch (rcbp->rc_state) {
375: case RCB_RESPONDING:
376: case RCB_RESPONSE_FULL:
377: /*
378: * If it is one we have in progress
379: * (either have all the responses
380: * or are waiting for them)
381: * update the bitmap and resend
382: * the replies
383: */
384: ATDISABLE(s_gen, atpgen_lock);
385: if (rcbp->rc_timestamp) {
386: rcbp->rc_timestamp = time.tv_sec;
387: if (rcbp->rc_timestamp == 0)
388: rcbp->rc_timestamp = 1;
389: }
390: ATENABLE(s_gen, atpgen_lock);
391: rcbp->rc_bitmap = athp->bitmap;
392: rcbp->rc_not_sent_bitmap = athp->bitmap;
393: ATENABLE(s, atp->atp_lock);
394: gbuf_freem(m);
395: atp_reply(rcbp);
396: return;
397:
398: case RCB_RELEASED:
399: default:
400: /*
401: * If we have a release or
402: * we haven't sent any data yet
403: * ignore the request
404: */
405: ATENABLE(s, atp->atp_lock);
406: gbuf_freem(m);
407: return;
408: }
409: }
410: ATENABLE(s, atp->atp_lock);
411: return;
412: }
413:
414: default:
415: gbuf_freem(m);
416: break;
417: }
418: break;
419:
420: case MSG_IOCACK:
421: if (atp->dflag)
422: asp_ack_reply(gref, m);
423: else
424: atalk_putnext(gref, m);
425: break;
426:
427: case MSG_IOCNAK:
428: if (atp->dflag)
429: asp_nak_reply(gref, m);
430: else
431: atalk_putnext(gref, m);
432: break;
433:
434: default:
435: gbuf_freem(m);
436: }
437: } /* atp_rput */
438:
439: void
440: atp_x_done(trp)
441: register struct atp_trans *trp;
442: {
443: struct atp_state *atp;
444: gbuf_t *m;
445:
446: if ( !trp->tr_xo)
447: atp_trans_complete(trp);
448: else {
449: /*
450: * If execute once send a release
451: */
452: if ((m = (gbuf_t *)atp_build_release(trp)) != NULL) {
453: AT_DDP_HDR(m)->src_socket = ((struct atp_state *)
454: trp->tr_queue)->atp_socket_no;
455: DDP_OUTPUT(m);
456: /*
457: * Now send back the transaction reply to the process
458: * or notify the process if required
459: */
460: atp_trans_complete(trp);
461: } else {
462:
463: atp = trp->tr_queue;
464: trp->tr_state = TRANS_RELEASE;
465: atalk_timeout(atp_x_done, trp, 10);
466: }
467: }
468: }
469:
470: static void
471: atp_trans_complete(trp)
472: register struct atp_trans *trp;
473: { register gbuf_t *m;
474: register int type;
475: struct atp_state *atp;
476:
477: /* we could gbuf_freem(trp->tr_xmt) here if were not planning to
478: re-use the mbuf later */
479: m = trp->tr_xmt;
480: trp->tr_xmt = NULL;
481: trp->tr_state = TRANS_DONE;
482:
483: if (gbuf_cont(m) == NULL) /* issued via the new interface */
484: type = AT_ATP_ISSUE_REQUEST_NOTE;
485: else {
486: type = ((ioc_t *)(gbuf_rptr(m)))->ioc_cmd;
487: /*
488: * free any data following the ioctl blk
489: */
490: gbuf_freem(gbuf_cont(m));
491: gbuf_cont(m) = NULL;
492: }
493: dPrintf(D_M_ATP_LOW, D_L_INPUT, ("atp_trans_comp: trp=0x%x type = %s\n",
494: (u_int) trp,
495: (type==AT_ATP_ISSUE_REQUEST)? "AT_ATP_ISSUE_REQUEST":
496: (type==AT_ATP_ISSUE_REQUEST_NOTE)? "AT_ATP_ISSUE_REQUEST_NOTE" :
497: "unknown"));
498:
499: switch(type) {
500: case AT_ATP_ISSUE_REQUEST:
501: atp = trp->tr_queue;
502: if (atp->dflag) {
503: ((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
504: ((ioc_t *)gbuf_rptr(m))->ioc_error = 0;
505: ((ioc_t *)gbuf_rptr(m))->ioc_rval = trp->tr_tid;
506: ((ioc_t *)gbuf_rptr(m))->ioc_cmd = AT_ATP_REQUEST_COMPLETE;
507: gbuf_set_type(m, MSG_IOCTL);
508: atp_rsp_ind(trp, m);
509: } else {
510: if (trp->tr_bdsp == NULL) {
511: gbuf_freem(m);
512: if (trp->tr_rsp_wait)
513: #ifdef _AIX
514: e_wakeup(&trp->tr_event);
515: #else
516: thread_wakeup(&trp->tr_event);
517: #endif
518: } else {
519: gbuf_set_type(m, MSG_IOCACK);
520: ((ioc_t *)gbuf_rptr(m))->ioc_count = 0;
521: ((ioc_t *)gbuf_rptr(m))->ioc_error = 0;
522: ((ioc_t *)gbuf_rptr(m))->ioc_rval = 0;
523: atalk_putnext(trp->tr_queue->atp_gref, m);
524: }
525: }
526: break;
527:
528: case AT_ATP_ISSUE_REQUEST_NOTE:
529: gbuf_wset(m,1);
530: *gbuf_rptr(m) = 1;
531: gbuf_set_type(m, MSG_DATA);
532: atalk_putnext(trp->tr_queue->atp_gref, m);
533: break;
534: }
535: } /* atp_trans_complete */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.