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