]> git.saurik.com Git - apple/xnu.git/blob - bsd/netat/atp_write.c
projects / apple / xnu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
xnu-792.6.76.tar.gz
[apple/xnu.git] / bsd / netat / atp_write.c
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 * Copyright (c) 1996-1998 Apple Computer, Inc.
24 * All Rights Reserved.
25 */
26
27 /* Modified for MP, 1996 by Tuyen Nguyen
28 * Modified, March 17, 1997 by Tuyen Nguyen for MacOSX.
29 */
30 #define RESOLVE_DBG
31
32 #include <sys/errno.h>
33 #include <sys/types.h>
34 #include <sys/param.h>
35 #include <machine/spl.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/proc.h>
39 #include <sys/filedesc.h>
40 #include <sys/fcntl.h>
41 #include <kern/locks.h>
42 #include <sys/mbuf.h>
43 #include <sys/ioctl.h>
44 #include <sys/malloc.h>
45 #include <sys/socket.h>
46 #include <sys/socketvar.h>
47
48 #include <net/if.h>
49
50 #include <netat/sysglue.h>
51 #include <netat/appletalk.h>
52 #include <netat/ddp.h>
53 #include <netat/at_pcb.h>
54 #include <netat/atp.h>
55 #include <netat/at_var.h>
56 #include <netat/asp.h>
57 #include <netat/at_pat.h>
58 #include <netat/debug.h>
59
60 static int loop_cnt; /* for debugging loops */
61 #define CHK_LOOP(str) { \
62 if (loop_cnt++ > 100) { \
63 kprintf("%s", str); \
64 break; \
65 } \
66 }
67
68 static int atp_pack_bdsp(struct atp_trans *, struct atpBDS *);
69 static int atp_unpack_bdsp(struct atp_state *, gbuf_t *, struct atp_rcb *,
70 int, int);
71 void atp_trp_clock(), asp_clock(), asp_clock_locked(), atp_trp_clock_locked();;
72
73 extern struct atp_rcb_qhead atp_need_rel;
74 extern int atp_inited;
75 extern struct atp_state *atp_used_list;
76 extern asp_scb_t *scb_free_list;
77 extern atlock_t atpgen_lock;
78 extern atlock_t atpall_lock;
79 extern atlock_t atptmo_lock;
80
81 extern gbuf_t *scb_resource_m;
82 extern gbuf_t *atp_resource_m;
83 extern gref_t *atp_inputQ[];
84 extern int atp_pidM[];
85 extern at_ifaddr_t *ifID_home;
86 extern lck_mtx_t * atalk_mutex;
87
88 static struct atp_trans *trp_tmo_list;
89 struct atp_trans *trp_tmo_rcb;
90
91 /* first bds entry gives number of bds entries in total (hack) */
92 #define get_bds_entries(m) \
93 ((gbuf_len(m) > TOTAL_ATP_HDR_SIZE)? \
94 (UAS_VALUE(((struct atpBDS *)(AT_ATP_HDR(m)->data))->bdsDataSz)): 0)
95
96 #define atpBDSsize (sizeof(struct atpBDS)*ATP_TRESP_MAX)
97
98 void atp_link()
99 {
100 trp_tmo_list = 0;
101 trp_tmo_rcb = atp_trans_alloc(0);
102 atp_timout(atp_rcb_timer, trp_tmo_rcb, 10 * HZ);
103 atp_trp_clock((void *)&atp_inited);
104 asp_clock((void *)&atp_inited);
105 }
106
107 void atp_unlink()
108 {
109 untimeout(asp_clock_locked, (void *)&atp_inited);
110 untimeout(atp_trp_clock_locked, (void *)&atp_inited);
111 atp_untimout(atp_rcb_timer, trp_tmo_rcb);
112 trp_tmo_list = 0;
113
114 #ifdef BAD_IDEA
115 /* allocated in asp_scb_alloc(), which is called
116 by asp_open() */
117 if (scb_resource_m) {
118 gbuf_freem(scb_resource_m);
119 scb_resource_m = 0;
120 scb_free_list = 0;
121 }
122 /* allocated in atp_trans_alloc() */
123 if (atp_resource_m) {
124 gbuf_freem(atp_resource_m);
125 atp_resource_m = 0;
126 atp_trans_free_list = 0;
127 }
128 #endif
129 }
130
131 /*
132 * write queue put routine .... filter out other than IOCTLs
133 * Version 1.8 of atp_write.c on 89/02/09 17:53:26
134 */
135
136 void
137 atp_wput(gref, m)
138 register gref_t *gref;
139 register gbuf_t *m;
140 {
141 register ioc_t *iocbp;
142 int i, xcnt, s;
143 struct atp_state *atp;
144 struct atp_trans *trp;
145 struct atp_rcb *rcbp;
146 at_socket skt;
147
148 atp = (struct atp_state *)gref->info;
149 if (atp->dflag)
150 atp = (struct atp_state *)atp->atp_msgq;
151
152 switch(gbuf_type(m)) {
153 case MSG_DATA:
154 if (atp->atp_msgq) {
155 gbuf_freem(m);
156 dPrintf(D_M_ATP, D_L_WARNING,
157 ("atp_wput: atp_msgq discarded\n"));
158 } else
159 atp->atp_msgq = m;
160 break;
161
162 case MSG_IOCTL:
163 /* Need to ensure that all copyin/copyout calls are made at
164 * put routine time which should be in the user context. (true when
165 * we are the stream head). The service routine can be called on an
166 * unpredictable context and copyin/copyout calls will get wrong results
167 * or even panic the kernel.
168 */
169 iocbp = (ioc_t *)gbuf_rptr(m);
170
171 switch (iocbp->ioc_cmd) {
172 case AT_ATP_BIND_REQ:
173 if (gbuf_cont(m) == NULL) {
174 iocbp->ioc_rval = -1;
175 atp_iocnak(atp, m, EINVAL);
176 return;
177 }
178 skt = *(at_socket *)gbuf_rptr(gbuf_cont(m));
179 if ((skt = (at_socket)atp_bind(gref, (unsigned int)skt, 0)) == 0)
180 atp_iocnak(atp, m, EINVAL);
181 else {
182 *(at_socket *)gbuf_rptr(gbuf_cont(m)) = skt;
183 iocbp->ioc_rval = 0;
184 atp_iocack(atp, m);
185 atp_dequeue_atp(atp);
186 }
187 return;
188
189 case AT_ATP_GET_CHANID:
190 if (gbuf_cont(m) == NULL) {
191 iocbp->ioc_rval = -1;
192 atp_iocnak(atp, m, EINVAL);
193 return;
194 }
195 *(gref_t **)gbuf_rptr(gbuf_cont(m)) = gref;
196 atp_iocack(atp, m);
197 return;
198
199 /* not the close and not the tickle(?) */
200 case AT_ATP_ISSUE_REQUEST_DEF:
201 case AT_ATP_ISSUE_REQUEST_DEF_NOTE: {
202 gbuf_t *bds, *tmp, *m2;
203 struct atp_rcb *rcbp;
204 at_ddp_t *ddp;
205 at_atp_t *athp;
206
207 if ((tmp = gbuf_cont(m)) != 0) {
208 if ((bds = gbuf_dupb(tmp)) == NULL) {
209 atp_iocnak(atp, m, ENOBUFS);
210 return;
211 }
212 gbuf_rinc(tmp,atpBDSsize);
213 gbuf_wset(bds,atpBDSsize);
214 iocbp->ioc_count -= atpBDSsize;
215 gbuf_cont(tmp) = bds;
216 }
217
218 /*
219 * send a response to a transaction
220 * first check it out
221 */
222 if (iocbp->ioc_count < TOTAL_ATP_HDR_SIZE) {
223 atp_iocnak(atp, m, EINVAL);
224 break;
225 }
226
227 /*
228 * remove the response from the message
229 */
230 m2 = gbuf_cont(m);
231 gbuf_cont(m) = NULL;
232 iocbp->ioc_count = 0;
233 ddp = AT_DDP_HDR(m2);
234 athp = AT_ATP_HDR(m2);
235 if (atp->atp_msgq) {
236 gbuf_cont(m2) = atp->atp_msgq;
237 atp->atp_msgq = 0;
238 }
239
240 ATDISABLE(s, atp->atp_lock);
241 /*
242 * search for the corresponding rcb
243 */
244 for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) {
245 if (rcbp->rc_tid == UAS_VALUE(athp->tid) &&
246 rcbp->rc_socket.node == ddp->dst_node &&
247 rcbp->rc_socket.net == NET_VALUE(ddp->dst_net) &&
248 rcbp->rc_socket.socket == ddp->dst_socket)
249 break;
250 }
251 ATENABLE(s, atp->atp_lock);
252
253 /*
254 * If it has already been sent then return an error
255 */
256 if ((rcbp && rcbp->rc_state != RCB_NOTIFIED) ||
257 (rcbp == NULL && athp->xo)) {
258 atp_iocnak(atp, m, ENOENT);
259 gbuf_freem(m2);
260 return;
261 }
262 if (rcbp == NULL) { /* a response for an ALO transaction */
263 if ((rcbp = atp_rcb_alloc(atp)) == NULL) {
264 atp_iocnak(atp, m, ENOBUFS);
265 gbuf_freem(m2);
266 return;
267 }
268 rcbp->rc_ioctl = 0;
269 rcbp->rc_socket.socket = ddp->dst_socket;
270 rcbp->rc_socket.node = ddp->dst_node;
271 rcbp->rc_socket.net = NET_VALUE(ddp->dst_net);
272 rcbp->rc_tid = UAS_VALUE(athp->tid);
273 rcbp->rc_bitmap = 0xff;
274 rcbp->rc_xo = 0;
275 ATDISABLE(s, atp->atp_lock);
276 rcbp->rc_state = RCB_SENDING;
277 ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list);
278 ATENABLE(s, atp->atp_lock);
279 }
280 xcnt = get_bds_entries(m2);
281 if ((i = atp_unpack_bdsp(atp, m2, rcbp, xcnt, FALSE))) {
282 if ( !rcbp->rc_xo)
283 atp_rcb_free(rcbp);
284 atp_iocnak(atp, m, i);
285 return;
286 }
287 atp_send_replies(atp, rcbp);
288
289 /*
290 * send the ack back to the responder
291 */
292 atp_iocack(atp, m);
293 return;
294 }
295
296 case AT_ATP_GET_POLL: {
297 if (gbuf_cont(m)) {
298 gbuf_freem(gbuf_cont(m));
299 gbuf_cont(m) = NULL;
300 iocbp->ioc_count = 0;
301 }
302
303 /*
304 * search for a waiting request
305 */
306 ATDISABLE(s, atp->atp_lock);
307 if ((rcbp = atp->atp_attached.head)) {
308 /*
309 * Got one, move it to the active response Q
310 */
311 gbuf_cont(m) = rcbp->rc_ioctl;
312 rcbp->rc_ioctl = NULL;
313 if (rcbp->rc_xo) {
314 ATP_Q_REMOVE(atp->atp_attached, rcbp, rc_list);
315 rcbp->rc_state = RCB_NOTIFIED;
316 ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list);
317 } else {
318 /* detach rcbp from attached queue,
319 * and free any outstanding resources
320 */
321 atp_rcb_free(rcbp);
322 }
323 ATENABLE(s, atp->atp_lock);
324 atp_iocack(atp, m);
325 } else {
326 /*
327 * None available - can out
328 */
329 ATENABLE(s, atp->atp_lock);
330 atp_iocnak(atp, m, EAGAIN);
331 }
332 break;
333 }
334
335 case AT_ATP_CANCEL_REQUEST: {
336 /*
337 * Cancel a pending request
338 */
339 if (iocbp->ioc_count != sizeof(int)) {
340 atp_iocnak(atp, m, EINVAL);
341 break;
342 }
343 i = *(int *)gbuf_rptr(gbuf_cont(m));
344 gbuf_freem(gbuf_cont(m));
345 gbuf_cont(m) = NULL;
346 ATDISABLE(s, atp->atp_lock);
347 for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) {
348 if (trp->tr_tid == i)
349 break;
350 }
351 if (trp == NULL) {
352 ATENABLE(s, atp->atp_lock);
353 atp_iocnak(atp, m, ENOENT);
354 } else {
355 ATENABLE(s, atp->atp_lock);
356 atp_free(trp);
357 atp_iocack(atp, m);
358 }
359 break;
360 }
361
362 case AT_ATP_PEEK: {
363 unsigned char event;
364 if (atalk_peek(gref, &event) == -1)
365 atp_iocnak(atp, m, EAGAIN);
366 else {
367 *gbuf_rptr(gbuf_cont(m)) = event;
368 atp_iocack(atp, m);
369 }
370 break;
371 }
372
373 case DDP_IOC_GET_CFG:
374 #ifdef APPLETALK_DEBUG
375 kprintf("atp_wput: DDP_IOC_GET_CFG\n");
376 #endif
377 if (gbuf_cont(m) == 0) {
378 atp_iocnak(atp, m, EINVAL);
379 break;
380 }
381 {
382 /* *** was ddp_get_cfg() *** */
383 ddp_addr_t *cfgp =
384 (ddp_addr_t *)gbuf_rptr(gbuf_cont(m));
385 cfgp->inet.net = ifID_home->ifThisNode.s_net;
386 cfgp->inet.node = ifID_home->ifThisNode.s_node;
387 cfgp->inet.socket = atp->atp_socket_no;
388 cfgp->ddptype = DDP_ATP;
389 #ifdef NOT_YET
390 cfgp->inet.net = atp->atp_gref->laddr.s_net;
391 cfgp->inet.node = atp->atp_gref->laddr.s_node;
392 cfgp->inet.socket = atp->atp_gref->lport;
393 cfgp->ddptype = atp->atp_gref->ddptype;
394 #endif
395 }
396 gbuf_wset(gbuf_cont(m), sizeof(ddp_addr_t));
397 atp_iocack(atp, m);
398 break;
399
400 default:
401 /*
402 * Otherwise pass it on, if possible
403 */
404 iocbp->ioc_private = (void *)gref;
405 DDP_OUTPUT(m);
406 break;
407 }
408 break;
409
410 default:
411 gbuf_freem(m);
412 break;
413 }
414 } /* atp_wput */
415
416 gbuf_t *atp_build_release(trp)
417 register struct atp_trans *trp;
418 {
419 register gbuf_t *m;
420 register at_ddp_t *ddp;
421 register at_atp_t *athp;
422
423 /*
424 * Now try and allocate enough space to send the message
425 * if none is available the caller will schedule
426 * a timeout so we can retry for more space soon
427 */
428 if ((m = (gbuf_t *)gbuf_alloc(AT_WR_OFFSET+ATP_HDR_SIZE, PRI_HI)) != NULL) {
429 gbuf_rinc(m,AT_WR_OFFSET);
430 gbuf_wset(m,TOTAL_ATP_HDR_SIZE);
431 ddp = AT_DDP_HDR(m);
432 ddp->type = DDP_ATP;
433 UAS_ASSIGN(ddp->checksum, 0);
434 ddp->dst_socket = trp->tr_socket.socket;
435 ddp->dst_node = trp->tr_socket.node;
436 NET_ASSIGN(ddp->dst_net, trp->tr_socket.net);
437 ddp->src_node = trp->tr_local_node;
438 NET_NET(ddp->src_net, trp->tr_local_net);
439
440 /*
441 * clear the cmd/xo/eom/sts/unused fields
442 */
443 athp = AT_ATP_HDR(m);
444 ATP_CLEAR_CONTROL(athp);
445 athp->cmd = ATP_CMD_TREL;
446 UAS_ASSIGN(athp->tid, trp->tr_tid);
447 }
448
449 return (m);
450 }
451
452 void atp_send_replies(atp, rcbp)
453 register struct atp_state *atp;
454 register struct atp_rcb *rcbp;
455 { register gbuf_t *m;
456 register int i, len;
457 int s_gen, s, cnt, err, offset, space;
458 unsigned char *m0_rptr = NULL, *m0_wptr = NULL;
459 register at_atp_t *athp;
460 register struct atpBDS *bdsp;
461 register gbuf_t *m2, *m1, *m0, *mhdr;
462 caddr_t lastPage;
463 gbuf_t *mprev, *mlist = 0;
464 at_socket src_socket = (at_socket)atp->atp_socket_no;
465 gbuf_t *rc_xmt[ATP_TRESP_MAX];
466 struct ddp_atp {
467 char ddp_atp_hdr[TOTAL_ATP_HDR_SIZE];
468 };
469 struct timeval timenow;
470
471 ATDISABLE(s, atp->atp_lock);
472 if (rcbp->rc_queue != atp) {
473 ATENABLE(s, atp->atp_lock);
474 return;
475 }
476 if (rcbp->rc_not_sent_bitmap == 0)
477 goto nothing_to_send;
478
479 dPrintf(D_M_ATP_LOW, D_L_OUTPUT, ("atp_send_replies\n"));
480 /*
481 * Do this for each message that hasn't been sent
482 */
483 cnt = rcbp->rc_pktcnt;
484 for (i = 0; i < cnt; i++) {
485 rc_xmt[i] = 0;
486 if (rcbp->rc_snd[i]) {
487 if ((rc_xmt[i] =
488 gbuf_alloc(AT_WR_OFFSET+TOTAL_ATP_HDR_SIZE,PRI_MED))
489 == NULL) {
490 for (cnt = 0; cnt < i; cnt++)
491 if (rc_xmt[cnt])
492 gbuf_freeb(rc_xmt[cnt]);
493 goto nothing_to_send;
494 }
495 }
496 }
497
498 m = rcbp->rc_xmt;
499 m0 = gbuf_cont(m);
500 if (gbuf_len(m) > TOTAL_ATP_HDR_SIZE)
501 bdsp = (struct atpBDS *)(AT_ATP_HDR(m)->data);
502 else
503 bdsp = 0;
504 offset = 0;
505 if (m0)
506 space = gbuf_msgsize(m0);
507 else
508 space = 0;
509 for (i = 0; i < cnt; i++) {
510 if (rcbp->rc_snd[i] == 0) {
511 if ((len = UAS_VALUE(bdsp->bdsBuffSz))) {
512 offset += len;
513 space -= len;
514 }
515 } else {
516 mhdr = rc_xmt[i];
517 /* setup header fields */
518 gbuf_rinc(mhdr,AT_WR_OFFSET);
519 gbuf_wset(mhdr,TOTAL_ATP_HDR_SIZE);
520 *(struct ddp_atp *)(gbuf_rptr(mhdr))= *(struct ddp_atp *)(gbuf_rptr(m));
521 athp = AT_ATP_HDR(mhdr);
522 ATP_CLEAR_CONTROL(athp);
523 athp->cmd = ATP_CMD_TRESP;
524 athp->bitmap = i;
525 if (i == (cnt - 1))
526 athp->eom = 1; /* for the last fragment */
527 if (bdsp) {
528 UAL_UAL(athp->user_bytes, bdsp->bdsUserData);
529 if ((len = UAS_VALUE(bdsp->bdsBuffSz)) && m0 != 0 && space > 0) {
530 if ((m1 = m_copym(m0, offset, len, M_DONTWAIT)) == 0) {
531 for (i = 0; i < cnt; i++)
532 if (rc_xmt[i])
533 gbuf_freem(rc_xmt[i]);
534 goto nothing_to_send;
535 }
536 offset += len;
537 space -= len;
538 gbuf_cont(mhdr) = m1;
539 }
540 }
541
542 AT_DDP_HDR(mhdr)->src_socket = src_socket;
543 dPrintf(D_M_ATP_LOW, D_L_OUTPUT,
544 ("atp_send_replies: %d, socket=%d, size=%d\n",
545 i, atp->atp_socket_no, gbuf_msgsize(gbuf_cont(m2))));
546
547 if (mlist)
548 gbuf_next(mprev) = mhdr;
549 else
550 mlist = mhdr;
551 mprev = mhdr;
552
553 rcbp->rc_snd[i] = 0;
554 rcbp->rc_not_sent_bitmap &= ~atp_mask[i];
555 if (rcbp->rc_not_sent_bitmap == 0)
556 break;
557 }
558 /*
559 * on to the next frag
560 */
561 bdsp++;
562 }
563 if (mlist) {
564 ATENABLE(s, atp->atp_lock);
565 DDP_OUTPUT(mlist);
566 ATDISABLE(s, atp->atp_lock);
567 }
568
569 nothing_to_send:
570 /*
571 * If all replies from this reply block have been sent then
572 * remove it from the queue and mark it so
573 */
574 if (rcbp->rc_queue != atp) {
575 ATENABLE(s, atp->atp_lock);
576 return;
577 }
578 rcbp->rc_rep_waiting = 0;
579
580 /*
581 * If we are doing execute once re-set the rcb timeout
582 * each time we send back any part of the response. Note
583 * that this timer is started when an initial request is
584 * received. Each response reprimes the timer. Duplicate
585 * requests do not reprime the timer.
586 *
587 * We have sent all of a response so free the
588 * resources.
589 */
590 if (rcbp->rc_xo && rcbp->rc_state != RCB_RELEASED) {
591 getmicrouptime(&timenow);
592 ATDISABLE(s_gen, atpgen_lock);
593 if (rcbp->rc_timestamp == 0) {
594 rcbp->rc_timestamp = timenow.tv_sec;
595 if (rcbp->rc_timestamp == 0)
596 rcbp->rc_timestamp = 1;
597 ATP_Q_APPEND(atp_need_rel, rcbp, rc_tlist);
598 }
599 rcbp->rc_state = RCB_RESPONSE_FULL;
600 ATENABLE(s_gen, atpgen_lock);
601 } else
602 atp_rcb_free(rcbp);
603 ATENABLE(s, atp->atp_lock);
604 } /* atp_send_replies */
605
606
607 static int
608 atp_pack_bdsp(trp, bdsp)
609 register struct atp_trans *trp;
610 register struct atpBDS *bdsp;
611 {
612 register gbuf_t *m = NULL;
613 register int i, datsize = 0;
614 struct atpBDS *bdsbase = bdsp;
615 int error = 0;
616
617 dPrintf(D_M_ATP, D_L_INFO, ("atp_pack_bdsp: socket=%d\n",
618 trp->tr_queue->atp_socket_no));
619
620 for (i = 0; i < ATP_TRESP_MAX; i++, bdsp++) {
621 unsigned short bufsize = UAS_VALUE(bdsp->bdsBuffSz);
622 long bufaddr = UAL_VALUE(bdsp->bdsBuffAddr);
623
624 if ((m = trp->tr_rcv[i]) == NULL)
625 break;
626
627 /* discard ddp hdr on first packet */
628 if (i == 0)
629 gbuf_rinc(m,DDP_X_HDR_SIZE);
630
631 /* this field may contain control information even when
632 no data is present */
633 UAL_UAL(bdsp->bdsUserData,
634 (((at_atp_t *)(gbuf_rptr(m)))->user_bytes));
635 gbuf_rinc(m, ATP_HDR_SIZE);
636
637 if ((bufsize != 0) && (bufaddr != 0)) {
638 /* user expects data back */
639 short tmp = 0;
640 register char *buf = (char *)bufaddr;
641
642 while (m) {
643 unsigned short len = (unsigned short)(gbuf_len(m));
644 if (len) {
645 if (len > bufsize)
646 len = bufsize;
647 if ((error = copyout((caddr_t)gbuf_rptr(m),
648 CAST_USER_ADDR_T(&buf[tmp]),
649 len)) != 0) {
650 return error;
651 }
652 bufsize -= len;
653 tmp += len;
654 }
655 m = gbuf_cont(m);
656 }
657
658 UAS_ASSIGN(bdsp->bdsDataSz, tmp);
659 datsize += (int)tmp;
660 }
661 gbuf_freem(trp->tr_rcv[i]);
662 trp->tr_rcv[i] = NULL;
663 }
664
665 /* report the number of packets */
666 UAS_ASSIGN(((struct atpBDS *)bdsbase)->bdsBuffSz, i);
667
668 dPrintf(D_M_ATP, D_L_INFO, (" : size=%d\n",
669 datsize));
670
671 return 0;
672 } /* atp_pack_bdsp */
673
674
675 /* create an mbuf chain with mbuf packet headers for each ATP response packet
676 * to be sent. m contains the DDP hdr, ATP hdr, and and array of atpBDS structs.
677 * chained to m is an mbuf that contians the actual data pointed to by the atpBDS
678 * structs.
679 */
680 static int
681 atp_unpack_bdsp(atp, m, rcbp, cnt, wait)
682 struct atp_state *atp;
683 gbuf_t *m; /* ddp, atp and bdsp gbuf_t */
684 register struct atp_rcb *rcbp;
685 register int cnt, wait;
686 {
687 register struct atpBDS *bdsp;
688 register gbuf_t *m2, *m1, *m0, *mhdr;
689 caddr_t lastPage;
690 at_atp_t *athp;
691 int i, len, s_gen;
692 at_socket src_socket;
693
694 struct ddp_atp {
695 char ddp_atp_hdr[TOTAL_ATP_HDR_SIZE];
696 };
697 gbuf_t *mprev, *mlist = 0;
698 gbuf_t *rc_xmt[ATP_TRESP_MAX];
699 unsigned char *m0_rptr, *m0_wptr;
700 int err, offset, space;
701 struct timeval timenow;
702
703 /*
704 * get the user data structure pointer
705 */
706 bdsp = (struct atpBDS *)(AT_ATP_HDR(m)->data);
707
708 /*
709 * Guard against bogus count argument.
710 */
711 if ((unsigned) cnt > ATP_TRESP_MAX) {
712 dPrintf(D_M_ATP, D_L_ERROR,
713 ("atp_unpack_bdsp: bad bds count 0x%x\n", cnt));
714 gbuf_freem(m);
715 return(EINVAL);
716 }
717 if ((src_socket = (at_socket)atp->atp_socket_no) == 0xFF) {
718 /* comparison was to -1, however src_socket is a u_char */
719 gbuf_freem(m);
720 return EPIPE;
721 }
722
723 m0 = gbuf_cont(m);
724 rcbp->rc_xmt = m;
725 rcbp->rc_pktcnt = cnt;
726 rcbp->rc_state = RCB_SENDING;
727 rcbp->rc_not_sent_bitmap = 0;
728
729 if (cnt <= 1) {
730 /*
731 * special case this to
732 * improve AFP write transactions to the server
733 */
734 rcbp->rc_pktcnt = 1;
735 if ((m2 = gbuf_alloc_wait(AT_WR_OFFSET+TOTAL_ATP_HDR_SIZE,
736 wait)) == NULL)
737 return 0;
738 gbuf_rinc(m2,AT_WR_OFFSET);
739 gbuf_wset(m2,TOTAL_ATP_HDR_SIZE);
740 *(struct ddp_atp *)(gbuf_rptr(m2))= *(struct ddp_atp *)(gbuf_rptr(m));
741 athp = AT_ATP_HDR(m2);
742 ATP_CLEAR_CONTROL(athp);
743 athp->cmd = ATP_CMD_TRESP;
744 athp->bitmap = 0;
745 athp->eom = 1; /* there's only 1 fragment */
746
747 /* *** why only if cnt > 0? *** */
748 if (cnt > 0)
749 UAL_UAL(athp->user_bytes, bdsp->bdsUserData);
750 if (m0)
751 if (!append_copy((struct mbuf *)m2,
752 (struct mbuf *)m0, wait)) {
753 gbuf_freeb(m2);
754 return 0;
755 }
756 /*
757 * send the message and mark it as sent
758 */
759 AT_DDP_HDR(m2)->src_socket = src_socket;
760 dPrintf(D_M_ATP_LOW, D_L_INFO,
761 ("atp_unpack_bdsp %d, socket=%d, size=%d, cnt=%d\n",
762 0,atp->atp_socket_no,gbuf_msgsize(gbuf_cont(m2)),cnt));
763 mlist = m2;
764 goto l_send;
765 }
766
767 /* create an array of mbuf packet headers for the packets to be sent
768 * to contain the atp and ddp headers with room at the front for the
769 * datalink header.
770 */
771 for (i = 0; i < cnt; i++) {
772 /* all hdrs, packet data and dst addr storage */
773 if ((rc_xmt[i] =
774 gbuf_alloc_wait(AT_WR_OFFSET+TOTAL_ATP_HDR_SIZE, wait)) == NULL) {
775 for (cnt = 0; cnt < i; cnt++)
776 if (rc_xmt[cnt])
777 gbuf_freeb(rc_xmt[cnt]);
778 return 0;
779 }
780 }
781
782 /* run through the atpBDS structs and create an mbuf for the data
783 * portion of each packet to be sent. these get chained to the mbufs
784 * containing the ATP and DDP headers. this code assumes that no ATP
785 * packet is contained in more than 2 mbufs (e.i crosses mbuf boundary
786 * no more than one time).
787 */
788 offset = 0;
789 if (m0)
790 space = gbuf_msgsize(m0);
791 for (i = 0; i < cnt; i++) { /* for each hdr mbuf */
792 mhdr = rc_xmt[i];
793 /* setup header fields */
794 gbuf_rinc(mhdr,AT_WR_OFFSET);
795 gbuf_wset(mhdr,TOTAL_ATP_HDR_SIZE);
796 *(struct ddp_atp *)(gbuf_rptr(mhdr))= *(struct ddp_atp *)(gbuf_rptr(m));
797 athp = AT_ATP_HDR(mhdr);
798 ATP_CLEAR_CONTROL(athp);
799 athp->cmd = ATP_CMD_TRESP;
800 athp->bitmap = i;
801 if (i == (cnt - 1))
802 athp->eom = 1; /* for the last fragment */
803 UAL_UAL(athp->user_bytes, bdsp->bdsUserData);
804
805 if ((len = UAS_VALUE(bdsp->bdsBuffSz)) != 0 && m0 != 0 && space > 0) {
806 if ((m1 = m_copym(m0, offset, len, wait)) == 0) {
807 for (i = 0; i < cnt; i++)
808 if (rc_xmt[i])
809 gbuf_freem(rc_xmt[i]);
810 return 0;
811 }
812 gbuf_cont(mhdr) = m1;
813 space -= len;
814 offset += len;
815 }
816
817 AT_DDP_HDR(mhdr)->src_socket = src_socket;
818 dPrintf(D_M_ATP_LOW,D_L_INFO,
819 ("atp_unpack_bdsp %d, socket=%d, size=%d, cnt=%d\n",
820 i,atp->atp_socket_no,gbuf_msgsize(gbuf_cont(mhdr)),cnt));
821 if (mlist)
822 gbuf_next(mprev) = mhdr;
823 else
824 mlist = mhdr;
825 mprev = mhdr;
826 /*
827 * on to the next frag
828 */
829 bdsp++;
830 }
831 /*
832 * send the message
833 */
834 l_send:
835 if (rcbp->rc_xo) {
836 getmicrouptime(&timenow);
837 ATDISABLE(s_gen, atpgen_lock);
838 if (rcbp->rc_timestamp == 0) {
839 if ((rcbp->rc_timestamp = timenow.tv_sec) == 0)
840 rcbp->rc_timestamp = 1;
841 ATP_Q_APPEND(atp_need_rel, rcbp, rc_tlist);
842 }
843 ATENABLE(s_gen, atpgen_lock);
844 }
845
846 DDP_OUTPUT(mlist);
847 return 0;
848
849 } /* atp_unpack_bdsp */
850
851 #define ATP_SOCKET_LAST (DDP_SOCKET_LAST-6)
852 #define ATP_SOCKET_FIRST (DDP_SOCKET_1st_DYNAMIC)
853 static unsigned int sNext = 0;
854
855 int atp_bind(gref, sVal, flag)
856 gref_t *gref;
857 unsigned int sVal;
858 unsigned char *flag;
859 {
860 extern unsigned char asp_inpC[];
861 extern asp_scb_t *asp_scbQ[];
862 unsigned char inpC, sNextUsed = 0;
863 unsigned int sMin, sMax, sSav;
864 struct atp_state *atp;
865 int s;
866
867 atp = (struct atp_state *)gref->info;
868 if (atp->dflag)
869 atp = (struct atp_state *)atp->atp_msgq;
870
871 sMax = ATP_SOCKET_LAST;
872 sMin = ATP_SOCKET_FIRST;
873 ATDISABLE(s, atpgen_lock);
874 if (flag && (*flag == 3)) {
875 sMin += 40;
876 if (sMin < sNext) {
877 sMin = sNext;
878 sNextUsed = 1;
879 }
880 }
881
882 if ( (sVal != 0) &&
883 ((sVal > sMax) || (sVal < 2) || (sVal == 6) ||
884 (ddp_socket_inuse(sVal, DDP_ATP) &&
885 (atp_inputQ[sVal] != (gref_t *)1)))) {
886 ATENABLE(s, atpgen_lock);
887 return 0;
888 }
889
890 if (sVal == 0) {
891 inpC = 255;
892 again:
893 for (sVal=sMin; sVal <= sMax; sVal++) {
894 if (!ddp_socket_inuse(sVal, DDP_ATP) ||
895 atp_inputQ[sVal] == (gref_t *)1)
896 break;
897 else if (flag && (*flag == 3) && asp_scbQ[sVal]) {
898 if ((asp_scbQ[sVal]->dflag == *flag)
899 && (asp_inpC[sVal] < inpC) ) {
900 inpC = asp_inpC[sVal];
901 sSav = sVal;
902 }
903 }
904 }
905 if (sVal > sMax) {
906 if (flag && (*flag == 3)) {
907 if (sNextUsed) {
908 sNextUsed = 0;
909 sMax = sNext - 1;
910 sMin = ATP_SOCKET_FIRST+40;
911 goto again;
912 }
913 sNext = 0;
914 *flag = (unsigned char)sSav;
915 }
916 ATENABLE(s, atpgen_lock);
917 return 0;
918 }
919 }
920 atp->atp_socket_no = (short)sVal;
921 atp_inputQ[sVal] = gref;
922 if (flag == 0)
923 atp_pidM[sVal] = atp->atp_pid;
924 else if (*flag == 3) {
925 sNext = sVal + 1;
926 if (sNext > ATP_SOCKET_LAST)
927 sNext = 0;
928 }
929
930 ATENABLE(s, atpgen_lock);
931 return (int)sVal;
932 }
933
934 void atp_req_ind(atp, mioc)
935 register struct atp_state *atp;
936 register gbuf_t *mioc;
937 {
938 register struct atp_rcb *rcbp;
939 int s;
940
941 if ((rcbp = atp->atp_attached.head) != 0) {
942 gbuf_cont(mioc) = rcbp->rc_ioctl;
943 rcbp->rc_ioctl = NULL;
944 ATDISABLE(s, atp->atp_lock);
945 if (rcbp->rc_xo) {
946 ATP_Q_REMOVE(atp->atp_attached, rcbp, rc_list);
947 rcbp->rc_state = RCB_NOTIFIED;
948 ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list);
949 } else
950 atp_rcb_free(rcbp);
951 ATENABLE(s, atp->atp_lock);
952 if (gbuf_cont(mioc))
953 ((ioc_t *)gbuf_rptr(mioc))->ioc_count = gbuf_msgsize(gbuf_cont(mioc));
954 else
955 ((ioc_t *)gbuf_rptr(mioc))->ioc_count = 0;
956 asp_ack_reply(atp->atp_gref, mioc);
957 } else
958 gbuf_freeb(mioc);
959 }
960
961 void atp_rsp_ind(trp, mioc)
962 register struct atp_trans *trp;
963 register gbuf_t *mioc;
964 {
965 register struct atp_state *atp = trp->tr_queue;
966 register int err;
967 gbuf_t *xm = 0;
968
969 err = 0;
970 {
971 switch (trp->tr_state) {
972 case TRANS_DONE:
973 if (asp_pack_bdsp(trp, &xm) < 0)
974 err = EFAULT;
975 gbuf_cont(mioc) = trp->tr_xmt;
976 trp->tr_xmt = NULL;
977 break;
978
979 case TRANS_FAILED:
980 err = ETIMEDOUT;
981 break;
982
983 default:
984 err = ENOENT;
985 break;
986 }
987 atp_free(trp);
988
989 if (err) {
990 dPrintf(D_M_ATP, D_L_ERROR,
991 ("atp_rsp_ind: TRANSACTION error\n"));
992 atp_iocnak(atp, mioc, err);
993 } else {
994 gbuf_cont(gbuf_cont(mioc)) = xm;
995 atp_iocack(atp, mioc);
996 }
997 }
998 }
999
1000 void atp_cancel_req(gref, tid)
1001 gref_t *gref;
1002 unsigned short tid;
1003 {
1004 int s;
1005 struct atp_state *atp;
1006 struct atp_trans *trp;
1007
1008 atp = (struct atp_state *)gref->info;
1009 if (atp->dflag)
1010 atp = (struct atp_state *)atp->atp_msgq;
1011
1012 ATDISABLE(s, atp->atp_lock);
1013 for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) {
1014 if (trp->tr_tid == tid)
1015 break;
1016 }
1017 ATENABLE(s, atp->atp_lock);
1018 if (trp != NULL)
1019 atp_free(trp);
1020 }
1021
1022 /*
1023 * remove atp from the use list
1024 */
1025 void
1026 atp_dequeue_atp(atp)
1027 struct atp_state *atp;
1028 {
1029 int s;
1030
1031 ATDISABLE(s, atpall_lock);
1032 if (atp == atp_used_list) {
1033 if ((atp_used_list = atp->atp_trans_waiting) != 0)
1034 atp->atp_trans_waiting->atp_rcb_waiting = 0;
1035 } else if (atp->atp_rcb_waiting) {
1036 if ((atp->atp_rcb_waiting->atp_trans_waiting
1037 = atp->atp_trans_waiting) != 0)
1038 atp->atp_trans_waiting->atp_rcb_waiting = atp->atp_rcb_waiting;
1039 }
1040
1041 atp->atp_trans_waiting = 0;
1042 atp->atp_rcb_waiting = 0;
1043 ATENABLE(s, atpall_lock);
1044 }
1045
1046 void
1047 atp_timout(func, trp, ticks)
1048 void (*func)();
1049 struct atp_trans *trp;
1050 int ticks;
1051 {
1052 int s;
1053 unsigned int sum;
1054 struct atp_trans *curr_trp, *prev_trp;
1055
1056 ATDISABLE(s, atptmo_lock);
1057 if (trp->tr_tmo_func) {
1058 ATENABLE(s, atptmo_lock);
1059 return;
1060 }
1061
1062 trp->tr_tmo_func = func;
1063 trp->tr_tmo_delta = 1+(ticks>>5);
1064
1065 if (trp_tmo_list == 0) {
1066 trp->tr_tmo_next = trp->tr_tmo_prev = 0;
1067 trp_tmo_list = trp;
1068 ATENABLE(s, atptmo_lock);
1069 return;
1070 }
1071
1072 prev_trp = 0;
1073 curr_trp = trp_tmo_list;
1074 sum = 0;
1075
1076 while (1) {
1077 sum += curr_trp->tr_tmo_delta;
1078 if (sum > trp->tr_tmo_delta) {
1079 sum -= curr_trp->tr_tmo_delta;
1080 trp->tr_tmo_delta -= sum;
1081 curr_trp->tr_tmo_delta -= trp->tr_tmo_delta;
1082 break;
1083 }
1084 prev_trp = curr_trp;
1085 if ((curr_trp = curr_trp->tr_tmo_next) == 0) {
1086 trp->tr_tmo_delta -= sum;
1087 break;
1088 }
1089 }
1090
1091 if (prev_trp) {
1092 trp->tr_tmo_prev = prev_trp;
1093 if ((trp->tr_tmo_next = prev_trp->tr_tmo_next) != 0)
1094 prev_trp->tr_tmo_next->tr_tmo_prev = trp;
1095 prev_trp->tr_tmo_next = trp;
1096 } else {
1097 trp->tr_tmo_prev = 0;
1098 trp->tr_tmo_next = trp_tmo_list;
1099 trp_tmo_list->tr_tmo_prev = trp;
1100 trp_tmo_list = trp;
1101 }
1102 ATENABLE(s, atptmo_lock);
1103 }
1104
1105 void
1106 atp_untimout(func, trp)
1107 void (*func)();
1108 struct atp_trans *trp;
1109 {
1110 int s;
1111
1112 ATDISABLE(s, atptmo_lock);
1113 if (trp->tr_tmo_func == 0) {
1114 ATENABLE(s, atptmo_lock);
1115 return;
1116 }
1117
1118 if (trp_tmo_list == trp) {
1119 if ((trp_tmo_list = trp->tr_tmo_next) != 0) {
1120 trp_tmo_list->tr_tmo_prev = 0;
1121 trp->tr_tmo_next->tr_tmo_delta += trp->tr_tmo_delta;
1122 }
1123 } else {
1124 if ((trp->tr_tmo_prev->tr_tmo_next = trp->tr_tmo_next) != 0) {
1125 trp->tr_tmo_next->tr_tmo_prev = trp->tr_tmo_prev;
1126 trp->tr_tmo_next->tr_tmo_delta += trp->tr_tmo_delta;
1127 }
1128 }
1129 trp->tr_tmo_func = 0;
1130 ATENABLE(s, atptmo_lock);
1131 }
1132
1133 void
1134 atp_trp_clock_locked(arg)
1135 void *arg;
1136 {
1137 atalk_lock();
1138 atp_trp_clock(arg);
1139 atalk_unlock();
1140 }
1141
1142 void
1143 atp_trp_clock(arg)
1144 void *arg;
1145 {
1146 int s;
1147 struct atp_trans *trp;
1148 void (*tr_tmo_func)();
1149
1150 ATDISABLE(s, atptmo_lock);
1151 if (trp_tmo_list)
1152 trp_tmo_list->tr_tmo_delta--;
1153 while (((trp = trp_tmo_list) != 0) && (trp_tmo_list->tr_tmo_delta == 0)) {
1154 if ((trp_tmo_list = trp->tr_tmo_next) != 0)
1155 trp_tmo_list->tr_tmo_prev = 0;
1156 if ((tr_tmo_func = trp->tr_tmo_func) != 0) {
1157 trp->tr_tmo_func = 0;
1158 ATENABLE(s, atptmo_lock);
1159 (*tr_tmo_func)(trp);
1160 ATDISABLE(s, atptmo_lock);
1161 }
1162 }
1163 ATENABLE(s, atptmo_lock);
1164
1165 timeout(atp_trp_clock_locked, (void *)arg, (1<<5));
1166 }
1167
1168 void
1169 atp_send_req(gref, mioc)
1170 gref_t *gref;
1171 gbuf_t *mioc;
1172 {
1173 register struct atp_state *atp;
1174 register struct atp_trans *trp;
1175 register ioc_t *iocbp;
1176 register at_atp_t *athp;
1177 register at_ddp_t *ddp;
1178 gbuf_t *m, *m2, *bds;
1179 struct atp_set_default *sdb;
1180 int s, old;
1181 unsigned int timer;
1182
1183 atp = (struct atp_state *)((struct atp_state *)gref->info)->atp_msgq;
1184 iocbp = (ioc_t *)gbuf_rptr(mioc);
1185
1186 if ((trp = atp_trans_alloc(atp)) == NULL) {
1187 l_retry:
1188 ((asp_scb_t *)gref->info)->stat_msg = mioc;
1189 iocbp->ioc_private = (void *)gref;
1190 timeout(atp_retry_req, mioc, 10);
1191 return;
1192 }
1193
1194 m2 = gbuf_cont(mioc);
1195 if ((bds = gbuf_dupb(m2)) == NULL) {
1196 atp_trans_free(trp);
1197 goto l_retry;
1198 }
1199 gbuf_rinc(m2,atpBDSsize);
1200 gbuf_wset(bds,atpBDSsize);
1201 iocbp->ioc_count -= atpBDSsize;
1202 gbuf_cont(m2) = NULL;
1203
1204 old = iocbp->ioc_cmd;
1205 iocbp->ioc_cmd = AT_ATP_ISSUE_REQUEST;
1206 sdb = (struct atp_set_default *)gbuf_rptr(m2);
1207
1208 /*
1209 * The at_snd_req library routine multiplies seconds by 100.
1210 * We need to divide by 100 in order to obtain the timer.
1211 */
1212 if ((timer = (sdb->def_rate * HZ)/100) == 0)
1213 timer = HZ;
1214 iocbp->ioc_count -= sizeof(struct atp_set_default);
1215 gbuf_rinc(m2,sizeof(struct atp_set_default));
1216
1217 trp->tr_retry = sdb->def_retries;
1218 trp->tr_timeout = timer;
1219 trp->tr_bdsp = bds;
1220 trp->tr_tid = atp_tid(atp);
1221 trp->tr_xmt = mioc;
1222
1223 /*
1224 * Now fill in the header (and remember the bits
1225 * we need to know)
1226 */
1227 athp = AT_ATP_HDR(m2);
1228 athp->cmd = ATP_CMD_TREQ;
1229 UAS_ASSIGN(athp->tid, trp->tr_tid);
1230 athp->eom = 0;
1231 athp->sts = 0;
1232 trp->tr_xo = athp->xo;
1233 trp->tr_bitmap = athp->bitmap;
1234 ddp = AT_DDP_HDR(m2);
1235 ddp->type = DDP_ATP;
1236 ddp->src_socket = (at_socket)atp->atp_socket_no;
1237 trp->tr_socket.socket = ddp->dst_socket;
1238 trp->tr_socket.node = ddp->dst_node;
1239 trp->tr_socket.net = NET_VALUE(ddp->dst_net);
1240 trp->tr_local_socket = atp->atp_socket_no;
1241 trp->tr_local_node = ddp->src_node;
1242 NET_NET(trp->tr_local_net, ddp->src_net);
1243
1244 #ifdef NOT_YET
1245 /* save the local information in the gref */
1246 atp->atp_gref->laddr.s_net = NET_VALUE(ddp->src_net);
1247 atp->atp_gref->laddr.s_node = ddp->src_node;
1248 atp->atp_gref->lport = ddp->src_node;
1249 atp->atp_gref->ddptype = DDP_ATP;
1250 #endif
1251
1252 /*
1253 * Put us in the transaction waiting queue
1254 */
1255 ATDISABLE(s, atp->atp_lock);
1256 ATP_Q_APPEND(atp->atp_trans_wait, trp, tr_list);
1257 ATENABLE(s, atp->atp_lock);
1258
1259 /*
1260 * Send the message and set the timer
1261 */
1262 m = (gbuf_t *)copy_pkt(m2, sizeof(llc_header_t));
1263 if (!trp->tr_retry && !trp->tr_bitmap && !trp->tr_xo)
1264 atp_x_done(trp); /* no reason to tie up resources */
1265 else
1266 atp_timout(atp_req_timeout, trp, trp->tr_timeout);
1267 if (m) {
1268 trace_mbufs(D_M_ATP_LOW, " s", m);
1269 DDP_OUTPUT(m);
1270 }
1271 } /* atp_send_req */
1272
1273 void atp_retry_req(arg)
1274 void *arg;
1275 {
1276 gbuf_t *m = (gbuf_t *)arg;
1277 gref_t *gref;
1278
1279 atalk_lock();
1280
1281 gref = (gref_t *)((ioc_t *)gbuf_rptr(m))->ioc_private;
1282 if (gref->info) {
1283 ((asp_scb_t *)gref->info)->stat_msg = 0;
1284 atp_send_req(gref, m);
1285 }
1286 atalk_unlock();
1287 }
1288
1289 void atp_send_rsp(gref, m, wait)
1290 gref_t *gref;
1291 gbuf_t *m;
1292 int wait;
1293 {
1294 register struct atp_state *atp;
1295 register struct atp_rcb *rcbp;
1296 register at_atp_t *athp;
1297 register at_ddp_t *ddp;
1298 int s, xcnt;
1299
1300 atp = (struct atp_state *)gref->info;
1301 if (atp->dflag)
1302 atp = (struct atp_state *)atp->atp_msgq;
1303 ddp = AT_DDP_HDR(m);
1304 athp = AT_ATP_HDR(m);
1305
1306 /*
1307 * search for the corresponding rcb
1308 */
1309 ATDISABLE(s, atp->atp_lock);
1310 for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) {
1311 if ( (rcbp->rc_tid == UAS_VALUE(athp->tid)) &&
1312 (rcbp->rc_socket.node == ddp->dst_node) &&
1313 (rcbp->rc_socket.net == NET_VALUE(ddp->dst_net)) &&
1314 (rcbp->rc_socket.socket == ddp->dst_socket) )
1315 break;
1316 }
1317
1318 /*
1319 * If it has already been sent then drop the request
1320 */
1321 if ((rcbp && (rcbp->rc_state != RCB_NOTIFIED)) ||
1322 (rcbp == NULL && athp->xo) ) {
1323 ATENABLE(s, atp->atp_lock);
1324 gbuf_freem(m);
1325 return;
1326 }
1327 ATENABLE(s, atp->atp_lock);
1328
1329 if (rcbp == NULL) { /* a response is being sent for an ALO transaction */
1330 if ((rcbp = atp_rcb_alloc(atp)) == NULL) {
1331 gbuf_freem(m);
1332 return;
1333 }
1334 rcbp->rc_ioctl = 0;
1335 rcbp->rc_socket.socket = ddp->dst_socket;
1336 rcbp->rc_socket.node = ddp->dst_node;
1337 rcbp->rc_socket.net = NET_VALUE(ddp->dst_net);
1338 rcbp->rc_tid = UAS_VALUE(athp->tid);
1339 rcbp->rc_bitmap = 0xff;
1340 rcbp->rc_xo = 0;
1341 rcbp->rc_state = RCB_RESPONSE_FULL;
1342 ATDISABLE(s, atp->atp_lock);
1343 ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list);
1344 ATENABLE(s, atp->atp_lock);
1345 }
1346 else if (ddp->src_node == 0) {
1347 NET_NET(ddp->src_net, rcbp->rc_local_net);
1348 ddp->src_node = rcbp->rc_local_node;
1349 }
1350
1351 xcnt = get_bds_entries(m);
1352 s = atp_unpack_bdsp(atp, m, rcbp, xcnt, wait);
1353 if (s == 0)
1354 atp_send_replies(atp, rcbp);
1355 } /* atp_send_rsp */
1356
1357 int asp_pack_bdsp(trp, xm)
1358 register struct atp_trans *trp;
1359 gbuf_t **xm;
1360 {
1361 register struct atpBDS *bdsp;
1362 register gbuf_t *m, *m2;
1363 register int i;
1364 gbuf_t *m_prev, *m_head = 0;
1365
1366 dPrintf(D_M_ATP, D_L_INFO, ("asp_pack_bdsp: socket=%d\n",
1367 trp->tr_queue->atp_socket_no));
1368
1369 if ((m2 = trp->tr_bdsp) == NULL)
1370 return 0;
1371 trp->tr_bdsp = NULL;
1372 bdsp = (struct atpBDS *)gbuf_rptr(m2);
1373
1374 for (i = 0; (i < ATP_TRESP_MAX &&
1375 bdsp < (struct atpBDS *)(gbuf_wptr(m2))); i++) {
1376 if ((m = trp->tr_rcv[i]) == NULL)
1377 break;
1378 if (i == 0) {
1379 /* discard ddp hdr on first packet */
1380 gbuf_rinc(m,DDP_X_HDR_SIZE);
1381 }
1382
1383 UAL_UAL(bdsp->bdsUserData, (((at_atp_t *)(gbuf_rptr(m)))->user_bytes));
1384 gbuf_rinc(m, ATP_HDR_SIZE);
1385
1386 if (UAL_VALUE(bdsp->bdsBuffAddr)) {
1387 short tmp = 0;
1388
1389 /* user expects data back */
1390 m = gbuf_strip(m);
1391 if (m_head == 0)
1392 m_head = m;
1393 else
1394 gbuf_cont(m_prev) = m;
1395 if (m) {
1396 tmp = (short)gbuf_len(m);
1397 while (gbuf_cont(m)) {
1398 m = gbuf_cont(m);
1399 tmp += (short)(gbuf_len(m));
1400 }
1401 m_prev = m;
1402 }
1403 UAS_ASSIGN(bdsp->bdsDataSz, tmp);
1404 }
1405 trp->tr_rcv[i] = NULL;
1406 bdsp++;
1407
1408 }
1409 /*
1410 * report the number of packets
1411 */
1412 UAS_ASSIGN(((struct atpBDS *)gbuf_rptr(m2))->bdsBuffSz, i);
1413
1414 if (trp->tr_xmt) /* an ioctl block is still held? */
1415 gbuf_cont(trp->tr_xmt) = m2;
1416 else
1417 trp->tr_xmt = m2;
1418
1419 if (m_head)
1420 *xm = m_head;
1421 else
1422 *xm = 0;
1423
1424 dPrintf(D_M_ATP, D_L_INFO, (" : size=%d\n",
1425 gbuf_msgsize(*xm)));
1426
1427 return 0;
1428 }
1429
1430 /*
1431 * The following routines are direct entries from system
1432 * calls to allow fast sending and recving of ATP data.
1433 */
1434
1435 int
1436 _ATPsndreq(fd, buf, len, nowait, err, proc)
1437 int fd;
1438 unsigned char *buf;
1439 int len;
1440 int nowait;
1441 int *err;
1442 void *proc;
1443 {
1444 gref_t *gref;
1445 int s, rc;
1446 unsigned short tid;
1447 unsigned int timer;
1448 register struct atp_state *atp;
1449 register struct atp_trans *trp;
1450 register ioc_t *iocbp;
1451 register at_atp_t *athp;
1452 register at_ddp_t *ddp;
1453 struct atp_set_default *sdb;
1454 gbuf_t *m2, *m, *mioc;
1455 char bds[atpBDSsize];
1456
1457 if ((*err = atalk_getref(0, fd, &gref, proc, 1)) != 0)
1458 return -1;
1459
1460 if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0)
1461 || (atp->atp_flags & ATP_CLOSING)) {
1462 dPrintf(D_M_ATP, D_L_ERROR, ("ATPsndreq: stale handle=0x%x, pid=%d\n",
1463 (u_int) gref, gref->pid));
1464 file_drop(fd);
1465 *err = EINVAL;
1466 return -1;
1467 }
1468
1469
1470 while ((mioc = gbuf_alloc(sizeof(ioc_t), PRI_MED)) == 0) {
1471 struct timespec ts;
1472 /* the vaue of 10n terms of hz is 100ms */
1473 ts.tv_sec = 0;
1474 ts.tv_nsec = 100 *1000 * NSEC_PER_USEC;
1475
1476 ATDISABLE(s, atp->atp_delay_lock);
1477 rc = msleep(&atp->atp_delay_event, atalk_mutex, PSOCK | PCATCH, "atpmioc", &ts);
1478 ATENABLE(s, atp->atp_delay_lock);
1479 if (rc != 0) {
1480 *err = rc;
1481 file_drop(fd);
1482 return -1;
1483 }
1484
1485 }
1486 gbuf_wset(mioc,sizeof(ioc_t));
1487 len -= atpBDSsize;
1488 while ((m2 = gbuf_alloc(len, PRI_MED)) == 0) {
1489 struct timespec ts;
1490 /* the vaue of 10n terms of hz is 100ms */
1491 ts.tv_sec = 0;
1492 ts.tv_nsec = 100 *1000 * NSEC_PER_USEC;
1493
1494 ATDISABLE(s, atp->atp_delay_lock);
1495 rc = msleep(&atp->atp_delay_event, atalk_mutex, PSOCK | PCATCH, "atpm2", &ts);
1496 ATENABLE(s, atp->atp_delay_lock);
1497 if (rc != 0) {
1498 gbuf_freeb(mioc);
1499 file_drop(fd);
1500 *err = rc;
1501 return -1;
1502 }
1503 }
1504 gbuf_wset(m2, len);
1505 gbuf_cont(mioc) = m2;
1506 if (((*err = copyin(CAST_USER_ADDR_T(buf), (caddr_t)bds, atpBDSsize)) != 0)
1507 || ((*err = copyin(CAST_USER_ADDR_T(&buf[atpBDSsize]),
1508 (caddr_t)gbuf_rptr(m2), len)) != 0)) {
1509 gbuf_freem(mioc);
1510 file_drop(fd);
1511 return -1;
1512 }
1513 gbuf_set_type(mioc, MSG_IOCTL);
1514 iocbp = (ioc_t *)gbuf_rptr(mioc);
1515 iocbp->ioc_count = len;
1516 iocbp->ioc_cmd = nowait ? AT_ATP_ISSUE_REQUEST_NOTE : AT_ATP_ISSUE_REQUEST;
1517 sdb = (struct atp_set_default *)gbuf_rptr(m2);
1518
1519 /*
1520 * The at_snd_req library routine multiplies seconds by 100.
1521 * We need to divide by 100 in order to obtain the timer.
1522 */
1523 if ((timer = (sdb->def_rate * HZ)/100) == 0)
1524 timer = HZ;
1525 iocbp->ioc_count -= sizeof(struct atp_set_default);
1526 gbuf_rinc(m2,sizeof(struct atp_set_default));
1527
1528 /*
1529 * allocate and set up the transaction record
1530 */
1531 while ((trp = atp_trans_alloc(atp)) == 0) {
1532 struct timespec ts;
1533 /* the vaue of 10n terms of hz is 100ms */
1534 ts.tv_sec = 0;
1535 ts.tv_nsec = 100 *1000 * NSEC_PER_USEC;
1536
1537 ATDISABLE(s, atp->atp_delay_lock);
1538 rc = msleep(&atp->atp_delay_event, atalk_mutex, PSOCK | PCATCH, "atptrp", &ts);
1539 ATENABLE(s, atp->atp_delay_lock);
1540 if (rc != 0) {
1541 gbuf_freem(mioc);
1542 file_drop(fd);
1543 *err = rc;
1544 return -1;
1545 }
1546 }
1547 trp->tr_retry = sdb->def_retries;
1548 trp->tr_timeout = timer;
1549 trp->tr_bdsp = NULL;
1550 trp->tr_tid = atp_tid(atp);
1551 tid = trp->tr_tid;
1552
1553 /*
1554 * remember the IOCTL packet so we can ack it
1555 * later
1556 */
1557 trp->tr_xmt = mioc;
1558
1559 /*
1560 * Now fill in the header (and remember the bits
1561 * we need to know)
1562 */
1563 athp = AT_ATP_HDR(m2);
1564 athp->cmd = ATP_CMD_TREQ;
1565 UAS_ASSIGN(athp->tid, trp->tr_tid);
1566 athp->eom = 0;
1567 athp->sts = 0;
1568 trp->tr_xo = athp->xo;
1569 trp->tr_bitmap = athp->bitmap;
1570 ddp = AT_DDP_HDR(m2);
1571 ddp->type = DDP_ATP;
1572 ddp->src_socket = (at_socket)atp->atp_socket_no;
1573 ddp->src_node = 0;
1574 trp->tr_socket.socket = ddp->dst_socket;
1575 trp->tr_socket.node = ddp->dst_node;
1576 trp->tr_socket.net = NET_VALUE(ddp->dst_net);
1577 trp->tr_local_socket = atp->atp_socket_no;
1578
1579 #ifdef NOT_YET
1580 /* save the local information in the gref */
1581 atp->atp_gref->laddr.s_net = NET_VALUE(ddp->src_net);
1582 atp->atp_gref->laddr.s_node = ddp->src_node;
1583 atp->atp_gref->lport = ddp->src_node;
1584 atp->atp_gref->ddptype = DDP_ATP;
1585 #endif
1586
1587 /*
1588 * Put us in the transaction waiting queue
1589 */
1590 ATDISABLE(s, atp->atp_lock);
1591 ATP_Q_APPEND(atp->atp_trans_wait, trp, tr_list);
1592 ATENABLE(s, atp->atp_lock);
1593
1594 /*
1595 * Send the message and set the timer
1596 */
1597 m = (gbuf_t *)copy_pkt(m2, sizeof(llc_header_t));
1598 if ( !trp->tr_retry && !trp->tr_bitmap && !trp->tr_xo)
1599 atp_x_done(trp); /* no reason to tie up resources */
1600 else
1601 atp_timout(atp_req_timeout, trp, trp->tr_timeout);
1602 if (m)
1603 DDP_OUTPUT(m);
1604
1605 if (nowait) {
1606 file_drop(fd);
1607 return (int)tid;
1608 }
1609
1610 /*
1611 * wait for the transaction to complete
1612 */
1613 ATDISABLE(s, trp->tr_lock);
1614 while ((trp->tr_state != TRANS_DONE) && (trp->tr_state != TRANS_FAILED) &&
1615 (trp->tr_state != TRANS_ABORTING)) {
1616 trp->tr_rsp_wait = 1;
1617 rc = msleep(&trp->tr_event, atalk_mutex, PSOCK | PCATCH, "atpsndreq", 0);
1618 if (rc != 0) {
1619 trp->tr_rsp_wait = 0;
1620 ATENABLE(s, trp->tr_lock);
1621 file_drop(fd);
1622 *err = rc;
1623 return -1;
1624 }
1625 }
1626 trp->tr_rsp_wait = 0;
1627 ATENABLE(s, trp->tr_lock);
1628
1629
1630 if (trp->tr_state == TRANS_FAILED || trp->tr_state == TRANS_ABORTING) {
1631 /*
1632 * transaction timed out, return error
1633 */
1634 atp_free(trp);
1635 file_drop(fd);
1636 *err = ETIMEDOUT;
1637 return -1;
1638 }
1639
1640 /*
1641 * copy out the recv data
1642 */
1643 if ((*err = atp_pack_bdsp(trp, (struct atpBDS *)bds)) != 0) {
1644 atp_free(trp);
1645 file_drop(fd);
1646 return -1;
1647 }
1648
1649 /*
1650 * copyout the result info
1651 */
1652 if ((*err = copyout((caddr_t)bds, CAST_USER_ADDR_T(buf), atpBDSsize)) != 0) {
1653 atp_free(trp);
1654 file_drop(fd);
1655 return -1;
1656 }
1657
1658 atp_free(trp);
1659 file_drop(fd);
1660
1661 return (int)tid;
1662 } /* _ATPsndreq */
1663
1664
1665 /* entry point for ATP send response. respbuf contains a DDP hdr,
1666 * ATP hdr, and atpBDS array. The bdsDataSz field of the first atpBDS
1667 * struct contains the number of atpBDS structs in the array. resplen
1668 * contains the len of the data in respbuf and datalen contains the
1669 * len of the data buffer holding the response packets which the atpBDS
1670 * struct entries point to.
1671 */
1672 int
1673 _ATPsndrsp(fd, respbuff, resplen, datalen, err, proc)
1674 int fd;
1675 unsigned char *respbuff;
1676 int resplen;
1677 int datalen;
1678 int *err;
1679 void *proc;
1680 {
1681 gref_t *gref;
1682 int s, rc;
1683 long bufaddr;
1684 gbuf_t *m, *mdata;
1685 short space;
1686 int size;
1687 struct atp_state *atp;
1688 struct atpBDS *bdsp;
1689 u_int16_t *bufsz;
1690 char *buf;
1691 int bds_cnt, count, len;
1692 caddr_t dataptr;
1693
1694 if ((*err = atalk_getref(0, fd, &gref, proc, 1)) != 0)
1695 return -1;
1696
1697 if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0)
1698 || (atp->atp_flags & ATP_CLOSING)) {
1699 dPrintf(D_M_ATP, D_L_ERROR, ("ATPsndrsp: stale handle=0x%x, pid=%d\n",
1700 (u_int) gref, gref->pid));
1701
1702 file_drop(fd);
1703 *err = EINVAL;
1704 return -1;
1705 }
1706
1707 /*
1708 * allocate buffer and copy in the response info
1709 */
1710 if ((m = gbuf_alloc_wait(resplen, TRUE)) == 0) {
1711 *err = ENOMEM;
1712 file_drop(fd);
1713 return -1;
1714 }
1715 if ((*err = copyin(CAST_USER_ADDR_T(respbuff), (caddr_t)gbuf_rptr(m), resplen)) != 0) {
1716 gbuf_freeb(m);
1717 file_drop(fd);
1718 return -1;
1719 }
1720 gbuf_wset(m,resplen);
1721 ((at_ddp_t *)gbuf_rptr(m))->src_node = 0;
1722 bdsp = (struct atpBDS *)(gbuf_rptr(m) + TOTAL_ATP_HDR_SIZE);
1723
1724 /*
1725 * allocate buffers and copy in the response data.
1726 * note that only the size field of the atpBDS field
1727 * is used internally in the kernel.
1728 */
1729 bds_cnt = get_bds_entries(m); /* count of # entries */
1730 /* check correctness of parameters */
1731 if (bds_cnt > ATP_TRESP_MAX) {
1732 gbuf_freem(m);
1733 *err = EINVAL;
1734 file_drop(fd);
1735 return -1;
1736 }
1737
1738 for (size = 0, count = 0; count < bds_cnt; count++) {
1739 size += UAS_VALUE(bdsp[count].bdsBuffSz);
1740 }
1741 if (size > datalen) {
1742 gbuf_freem(m);
1743 *err = EINVAL;
1744 file_drop(fd);
1745 return -1;
1746 }
1747
1748 /* get the first mbuf */
1749 if ((mdata = gbuf_alloc_wait((space = (size > MCLBYTES ? MCLBYTES : size)), TRUE)) == 0) {
1750 gbuf_freem(m);
1751 file_drop(fd);
1752 *err = ENOMEM;
1753 return -1;
1754 }
1755 gbuf_cont(m) = mdata;
1756 dataptr = mtod(mdata, caddr_t);
1757 for (count = 0; count < bds_cnt; bdsp++, count++) {
1758 if ((bufaddr = UAL_VALUE(bdsp->bdsBuffAddr)) != 0 &&
1759 (len = UAS_VALUE(bdsp->bdsBuffSz)) != 0) {
1760 if (len > space) { /* enough room ? */
1761 gbuf_wset(mdata, dataptr - mtod(mdata, caddr_t)); /* set len of last mbuf */
1762 /* allocate the next mbuf */
1763 if ((gbuf_cont(mdata) = m_get((M_WAIT), MSG_DATA)) == 0) {
1764 gbuf_freem(m);
1765 file_drop(fd);
1766 *err = ENOMEM;
1767 return -1;
1768 }
1769 mdata = gbuf_cont(mdata);
1770 MCLGET(mdata, M_WAIT);
1771 if (!(mdata->m_flags & M_EXT)) {
1772 m_freem(m);
1773 file_drop(fd);
1774 return(NULL);
1775 }
1776 dataptr = mtod(mdata, caddr_t);
1777 space = MCLBYTES;
1778 }
1779 /* do the copyin */
1780 if ((*err = copyin(CAST_USER_ADDR_T(bufaddr), dataptr, len)) != 0) {
1781 gbuf_freem(m);
1782 file_drop(fd);
1783 return -1;
1784 }
1785 dataptr += len;
1786 space -= len;
1787 }
1788 }
1789 gbuf_wset(mdata, dataptr - mtod(mdata, caddr_t)); /* set len of last mbuf */
1790 gbuf_cont(m)->m_pkthdr.len = size; /* set packet hdr len */
1791
1792 atp_send_rsp(gref, m, TRUE);
1793 file_drop(fd);
1794 return 0;
1795 }
1796
1797 int
1798 _ATPgetreq(fd, buf, buflen, err, proc)
1799 int fd;
1800 unsigned char *buf;
1801 int buflen;
1802 int *err;
1803 void *proc;
1804 {
1805 gref_t *gref;
1806 register struct atp_state *atp;
1807 register struct atp_rcb *rcbp;
1808 register gbuf_t *m, *m_head;
1809 int s, size, len;
1810
1811 if ((*err = atalk_getref(0, fd, &gref, proc, 1)) != 0)
1812 return -1;
1813
1814 if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0)
1815 || (atp->atp_flags & ATP_CLOSING)) {
1816 dPrintf(D_M_ATP, D_L_ERROR, ("ATPgetreq: stale handle=0x%x, pid=%d\n",
1817 (u_int) gref, gref->pid));
1818 file_drop(fd);
1819 *err = EINVAL;
1820 return -1;
1821 }
1822
1823 ATDISABLE(s, atp->atp_lock);
1824 if ((rcbp = atp->atp_attached.head) != NULL) {
1825 /*
1826 * Got one, move it to the active response Q
1827 */
1828 m_head = rcbp->rc_ioctl;
1829 rcbp->rc_ioctl = NULL;
1830
1831 if (rcbp->rc_xo) {
1832 ATP_Q_REMOVE(atp->atp_attached, rcbp, rc_list);
1833 rcbp->rc_state = RCB_NOTIFIED;
1834 ATP_Q_APPEND(atp->atp_rcb, rcbp, rc_list);
1835 } else {
1836 /* detach rcbp from attached queue,
1837 * and free any outstanding resources
1838 */
1839 atp_rcb_free(rcbp);
1840 }
1841 ATENABLE(s, atp->atp_lock);
1842
1843 /*
1844 * copyout the request data, including the protocol header
1845 */
1846 for (size=0, m=m_head; m; m = gbuf_cont(m)) {
1847 if ((len = gbuf_len(m)) > buflen)
1848 len = buflen;
1849 copyout((caddr_t)gbuf_rptr(m), CAST_USER_ADDR_T(&buf[size]), len);
1850 size += len;
1851 if ((buflen -= len) == 0)
1852 break;
1853 }
1854 gbuf_freem(m_head);
1855
1856 file_drop(fd);
1857 return size;
1858 }
1859 ATENABLE(s, atp->atp_lock);
1860
1861 file_drop(fd);
1862 return -1;
1863 }
1864
1865 int
1866 _ATPgetrsp(fd, bdsp, err, proc)
1867 int fd;
1868 struct atpBDS *bdsp;
1869 int *err;
1870 void *proc;
1871 {
1872 gref_t *gref;
1873 register struct atp_state *atp;
1874 register struct atp_trans *trp;
1875 int s, tid;
1876 char bds[atpBDSsize];
1877
1878 if ((*err = atalk_getref(0, fd, &gref, proc, 1)) != 0)
1879 return -1;
1880
1881 if ((gref == 0) || ((atp = (struct atp_state *)gref->info) == 0)
1882 || (atp->atp_flags & ATP_CLOSING)) {
1883 dPrintf(D_M_ATP, D_L_ERROR, ("ATPgetrsp: stale handle=0x%x, pid=%d\n",
1884 (u_int) gref, gref->pid));
1885 file_drop(fd);
1886 *err = EINVAL;
1887 return -1;
1888 }
1889
1890 ATDISABLE(s, atp->atp_lock);
1891 for (trp = atp->atp_trans_wait.head; trp; trp = trp->tr_list.next) {
1892 dPrintf(D_M_ATP, D_L_INFO,
1893 ("ATPgetrsp: atp:0x%x, trp:0x%x, state:%d\n",
1894 (u_int) atp, (u_int) trp, trp->tr_state));
1895
1896 switch (trp->tr_state) {
1897 case TRANS_DONE:
1898 ATENABLE(s, atp->atp_lock);
1899 if ((*err = copyin(CAST_USER_ADDR_T(bdsp),
1900 (caddr_t)bds, sizeof(bds))) != 0) {
1901 atp_free(trp);
1902 file_drop(fd);
1903 return -1;
1904 }
1905 if ((*err = atp_pack_bdsp(trp, (struct atpBDS *)bds)) != 0) {
1906 atp_free(trp);
1907 file_drop(fd);
1908 return -1;
1909 }
1910 tid = (int)trp->tr_tid;
1911 atp_free(trp);
1912 if ((*err = copyout((caddr_t)bds, CAST_USER_ADDR_T(bdsp), sizeof(bds))) != 0) {
1913 file_drop(fd);
1914 return -1;
1915 }
1916 file_drop(fd);
1917 return tid;
1918
1919 case TRANS_FAILED:
1920 /*
1921 * transaction timed out, return error
1922 */
1923 ATENABLE(s, atp->atp_lock);
1924 atp_free(trp);
1925 file_drop(fd);
1926 *err = ETIMEDOUT;
1927 return -1;
1928
1929 default:
1930 continue;
1931 }
1932 }
1933 ATENABLE(s, atp->atp_lock);
1934
1935 file_drop(fd);
1936 *err = EINVAL;
1937 return -1;
1938 }
1939
1940 void
1941 atp_drop_req(gref, m)
1942 gref_t *gref;
1943 gbuf_t *m;
1944 {
1945 int s;
1946 struct atp_state *atp;
1947 struct atp_rcb *rcbp;
1948 at_atp_t *athp;
1949 at_ddp_t *ddp;
1950
1951 atp = (struct atp_state *)gref->info;
1952 if (atp->dflag)
1953 atp = (struct atp_state *)atp->atp_msgq;
1954 ddp = AT_DDP_HDR(m);
1955 athp = AT_ATP_HDR(m);
1956
1957 /*
1958 * search for the corresponding rcb
1959 */
1960 ATDISABLE(s, atp->atp_lock);
1961 for (rcbp = atp->atp_rcb.head; rcbp; rcbp = rcbp->rc_list.next) {
1962 if ( (rcbp->rc_tid == UAS_VALUE(athp->tid)) &&
1963 (rcbp->rc_socket.node == ddp->src_node) &&
1964 (rcbp->rc_socket.net == NET_VALUE(ddp->src_net)) &&
1965 (rcbp->rc_socket.socket == ddp->src_socket) )
1966 break;
1967 }
1968
1969 /*
1970 * drop the request
1971 */
1972 if (rcbp)
1973 atp_rcb_free(rcbp);
1974 ATENABLE(s, atp->atp_lock);
1975
1976 gbuf_freem(m);
1977 }
mirror of XNU