![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_frag.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to clnp_frag.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 ! root 1: /*********************************************************** ! 2: Copyright IBM Corporation 1987 ! 3: ! 4: All Rights Reserved ! 5: ! 6: Permission to use, copy, modify, and distribute this software and its ! 7: documentation for any purpose and without fee is hereby granted, ! 8: provided that the above copyright notice appear in all copies and that ! 9: both that copyright notice and this permission notice appear in ! 10: supporting documentation, and that the name of IBM not be ! 11: used in advertising or publicity pertaining to distribution of the ! 12: software without specific, written prior permission. ! 13: ! 14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ! 15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL ! 16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ! 17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, ! 18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ! 19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS ! 20: SOFTWARE. ! 21: ! 22: ******************************************************************/ ! 23: ! 24: /* ! 25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison ! 26: */ ! 27: /* $Header: /var/src/sys/netiso/RCS/clnp_frag.c,v 5.1 89/02/09 16:20:26 hagens Exp $ */ ! 28: /* $Source: /var/src/sys/netiso/RCS/clnp_frag.c,v $ */ ! 29: /* @(#)clnp_frag.c 7.9 (Berkeley) 6/4/90 */ ! 30: ! 31: #ifndef lint ! 32: static char *rcsid = "$Header: /var/src/sys/netiso/RCS/clnp_frag.c,v 5.1 89/02/09 16:20:26 hagens Exp $"; ! 33: #endif lint ! 34: ! 35: #include "param.h" ! 36: #include "mbuf.h" ! 37: #include "domain.h" ! 38: #include "protosw.h" ! 39: #include "socket.h" ! 40: #include "socketvar.h" ! 41: #include "errno.h" ! 42: ! 43: #include "../net/if.h" ! 44: #include "../net/route.h" ! 45: ! 46: #include "iso.h" ! 47: #include "iso_var.h" ! 48: #include "clnp.h" ! 49: #include "clnp_stat.h" ! 50: #include "argo_debug.h" ! 51: ! 52: /* all fragments are hung off this list */ ! 53: struct clnp_fragl *clnp_frags = NULL; ! 54: ! 55: struct mbuf *clnp_comp_pdu(); ! 56: ! 57: ! 58: /* ! 59: * FUNCTION: clnp_fragment ! 60: * ! 61: * PURPOSE: Fragment a datagram, and send the itty bitty pieces ! 62: * out over an interface. ! 63: * ! 64: * RETURNS: success - 0 ! 65: * failure - unix error code ! 66: * ! 67: * SIDE EFFECTS: ! 68: * ! 69: * NOTES: If there is an error sending the packet, clnp_discard ! 70: * is called to discard the packet and send an ER. If ! 71: * clnp_fragment was called from clnp_output, then ! 72: * we generated the packet, and should not send an ! 73: * ER -- clnp_emit_er will check for this. Otherwise, ! 74: * the packet was fragmented during forwarding. In this ! 75: * case, we ought to send an ER back. ! 76: */ ! 77: clnp_fragment(ifp, m, first_hop, total_len, segoff, flags, rt) ! 78: struct ifnet *ifp; /* ptr to outgoing interface */ ! 79: struct mbuf *m; /* ptr to packet */ ! 80: struct sockaddr *first_hop; /* ptr to first hop */ ! 81: int total_len; /* length of datagram */ ! 82: int segoff; /* offset of segpart in hdr */ ! 83: int flags; /* flags passed to clnp_output */ ! 84: struct rtentry *rt; /* route if direct ether */ ! 85: { ! 86: struct clnp_fixed *clnp = mtod(m, struct clnp_fixed *); ! 87: int hdr_len = (int)clnp->cnf_hdr_len; ! 88: int frag_size = (ifp->if_mtu - hdr_len) & ~7; ! 89: ! 90: total_len -= hdr_len; ! 91: if ((clnp->cnf_type & CNF_SEG_OK) && ! 92: (total_len >= 8) && ! 93: (frag_size > 8 || (frag_size == 8 && !(total_len & 7)))) { ! 94: ! 95: struct mbuf *hdr = NULL; /* save copy of clnp hdr */ ! 96: struct mbuf *frag_hdr = NULL; ! 97: struct mbuf *frag_data = NULL; ! 98: struct clnp_segment seg_part; /* segmentation header */ ! 99: int frag_size, frag_base; ! 100: int error = 0; ! 101: ! 102: ! 103: INCSTAT(cns_fragmented); ! 104: (void) bcopy(segoff + mtod(m, caddr_t), (caddr_t)&seg_part, ! 105: sizeof(seg_part)); ! 106: frag_base = ntohs(seg_part.cng_off); ! 107: /* ! 108: * Duplicate header, and remove from packet ! 109: */ ! 110: if ((hdr = m_copy(m, 0, hdr_len)) == NULL) { ! 111: clnp_discard(m, GEN_CONGEST); ! 112: return(ENOBUFS); ! 113: } ! 114: m_adj(m, hdr_len); ! 115: ! 116: while (total_len > 0) { ! 117: int remaining, last_frag; ! 118: ! 119: IFDEBUG(D_FRAG) ! 120: struct mbuf *mdump = frag_hdr; ! 121: int tot_mlen = 0; ! 122: printf("clnp_fragment: total_len %d:\n", total_len); ! 123: while (mdump != NULL) { ! 124: printf("\tmbuf x%x, m_len %d\n", ! 125: mdump, mdump->m_len); ! 126: tot_mlen += mdump->m_len; ! 127: mdump = mdump->m_next; ! 128: } ! 129: printf("clnp_fragment: sum of mbuf chain %d:\n", tot_mlen); ! 130: ENDDEBUG ! 131: ! 132: frag_size = min(total_len, frag_size); ! 133: if ((remaining = total_len - frag_size) == 0) ! 134: last_frag = 1; ! 135: else { ! 136: /* ! 137: * If this fragment will cause the last one to ! 138: * be less than 8 bytes, shorten this fragment a bit. ! 139: * The obscure test on frag_size above ensures that ! 140: * frag_size will be positive. ! 141: */ ! 142: last_frag = 0; ! 143: if (remaining < 8) ! 144: frag_size -= 8; ! 145: } ! 146: ! 147: ! 148: IFDEBUG(D_FRAG) ! 149: printf("clnp_fragment: seg off %d, size %d, remaining %d\n", ! 150: ntohs(seg_part.cng_off), frag_size, total_len-frag_size); ! 151: if (last_frag) ! 152: printf("clnp_fragment: last fragment\n"); ! 153: ENDDEBUG ! 154: ! 155: if (last_frag) { ! 156: /* ! 157: * this is the last fragment; we don't need to get any other ! 158: * mbufs. ! 159: */ ! 160: frag_hdr = hdr; ! 161: frag_data = m; ! 162: } else { ! 163: /* duplicate header and data mbufs */ ! 164: if ((frag_hdr = m_copy(hdr, 0, (int)M_COPYALL)) == NULL) { ! 165: clnp_discard(hdr, GEN_CONGEST); ! 166: m_freem(m); ! 167: return(ENOBUFS); ! 168: } ! 169: if ((frag_data = m_copy(m, 0, frag_size)) == NULL) { ! 170: clnp_discard(hdr, GEN_CONGEST); ! 171: m_freem(m); ! 172: m_freem(frag_hdr); ! 173: return(ENOBUFS); ! 174: } ! 175: INCSTAT(cns_fragments); ! 176: } ! 177: clnp = mtod(frag_hdr, struct clnp_fixed *); ! 178: ! 179: if (!last_frag) ! 180: clnp->cnf_type |= CNF_MORE_SEGS; ! 181: ! 182: /* link together */ ! 183: m_cat(frag_hdr, frag_data); ! 184: ! 185: /* insert segmentation part; updated below */ ! 186: bcopy((caddr_t)&seg_part, mtod(frag_hdr, caddr_t) + segoff, ! 187: sizeof(struct clnp_segment)); ! 188: ! 189: { ! 190: int derived_len = hdr_len + frag_size; ! 191: HTOC(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, derived_len); ! 192: if ((frag_hdr->m_flags & M_PKTHDR) == 0) ! 193: panic("clnp_frag:lost header"); ! 194: frag_hdr->m_pkthdr.len = derived_len; ! 195: } ! 196: /* compute clnp checksum (on header only) */ ! 197: if (flags & CLNP_NO_CKSUM) { ! 198: HTOC(clnp->cnf_cksum_msb, clnp->cnf_cksum_lsb, 0); ! 199: } else { ! 200: iso_gen_csum(frag_hdr, CLNP_CKSUM_OFF, hdr_len); ! 201: } ! 202: ! 203: IFDEBUG(D_DUMPOUT) ! 204: struct mbuf *mdump = frag_hdr; ! 205: printf("clnp_fragment: sending dg:\n"); ! 206: while (mdump != NULL) { ! 207: printf("\tmbuf x%x, m_len %d\n", mdump, mdump->m_len); ! 208: mdump = mdump->m_next; ! 209: } ! 210: ENDDEBUG ! 211: ! 212: #ifdef TROLL ! 213: error = troll_output(ifp, frag_hdr, first_hop, rt); ! 214: #else ! 215: error = (*ifp->if_output)(ifp, frag_hdr, first_hop, rt); ! 216: #endif TROLL ! 217: ! 218: /* ! 219: * Tough situation: if the error occured on the last ! 220: * fragment, we can not send an ER, as the if_output ! 221: * routine consumed the packet. If the error occured ! 222: * on any intermediate packets, we can send an ER ! 223: * because we still have the original header in (m). ! 224: */ ! 225: if (error) { ! 226: if (frag_hdr != hdr) { ! 227: /* ! 228: * The error was not on the last fragment. We must ! 229: * free hdr and m before returning ! 230: */ ! 231: clnp_discard(hdr, GEN_NOREAS); ! 232: m_freem(m); ! 233: } ! 234: return(error); ! 235: } ! 236: ! 237: /* bump segment offset, trim data mbuf, and decrement count left */ ! 238: #ifdef TROLL ! 239: /* ! 240: * Decrement frag_size by some fraction. This will cause the ! 241: * next fragment to start 'early', thus duplicating the end ! 242: * of the current fragment. troll.tr_dup_size controls ! 243: * the fraction. If positive, it specifies the fraction. If ! 244: * negative, a random fraction is used. ! 245: */ ! 246: if ((trollctl.tr_ops & TR_DUPEND) && (!last_frag)) { ! 247: int num_bytes = frag_size; ! 248: ! 249: if (trollctl.tr_dup_size > 0) ! 250: num_bytes *= trollctl.tr_dup_size; ! 251: else ! 252: num_bytes *= troll_random(); ! 253: frag_size -= num_bytes; ! 254: } ! 255: #endif TROLL ! 256: total_len -= frag_size; ! 257: if (!last_frag) { ! 258: frag_base += frag_size; ! 259: seg_part.cng_off = htons(frag_base); ! 260: m_adj(m, frag_size); ! 261: } ! 262: } ! 263: return(0); ! 264: } else { ! 265: cantfrag: ! 266: INCSTAT(cns_cantfrag); ! 267: clnp_discard(m, GEN_SEGNEEDED); ! 268: return(EMSGSIZE); ! 269: } ! 270: } ! 271: ! 272: /* ! 273: * FUNCTION: clnp_reass ! 274: * ! 275: * PURPOSE: Attempt to reassemble a clnp packet given the current ! 276: * fragment. If reassembly succeeds (all the fragments ! 277: * are present), then return a pointer to an mbuf chain ! 278: * containing the reassembled packet. This packet will ! 279: * appear in the mbufs as if it had just arrived in ! 280: * one piece. ! 281: * ! 282: * If reassembly fails, then save this fragment and ! 283: * return 0. ! 284: * ! 285: * RETURNS: Ptr to assembled packet, or 0 ! 286: * ! 287: * SIDE EFFECTS: ! 288: * ! 289: * NOTES: ! 290: * clnp_slowtimo can not affect this code because clnpintr, and thus ! 291: * this code, is called at a higher priority than clnp_slowtimo. ! 292: */ ! 293: struct mbuf * ! 294: clnp_reass(m, src, dst, seg) ! 295: struct mbuf *m; /* new fragment */ ! 296: struct iso_addr *src; /* src of new fragment */ ! 297: struct iso_addr *dst; /* dst of new fragment */ ! 298: struct clnp_segment *seg; /* segment part of fragment header */ ! 299: { ! 300: register struct clnp_fragl *cfh; ! 301: ! 302: /* look for other fragments of this datagram */ ! 303: for (cfh = clnp_frags; cfh != NULL; cfh = cfh->cfl_next) { ! 304: if (seg->cng_id == cfh->cfl_id && ! 305: iso_addrmatch1(src, &cfh->cfl_src) && ! 306: iso_addrmatch1(dst, &cfh->cfl_dst)) { ! 307: IFDEBUG(D_REASS) ! 308: printf("clnp_reass: found packet\n"); ! 309: ENDDEBUG ! 310: /* ! 311: * There are other fragments here already. Lets see if ! 312: * this fragment is of any help ! 313: */ ! 314: clnp_insert_frag(cfh, m, seg); ! 315: if (m = clnp_comp_pdu(cfh)) { ! 316: register struct clnp_fixed *clnp = mtod(m, struct clnp_fixed *); ! 317: HTOC(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, ! 318: seg->cng_tot_len); ! 319: } ! 320: return (m); ! 321: } ! 322: } ! 323: ! 324: IFDEBUG(D_REASS) ! 325: printf("clnp_reass: new packet!\n"); ! 326: ENDDEBUG ! 327: ! 328: /* ! 329: * This is the first fragment. If src is not consuming too many ! 330: * resources, then create a new fragment list and add ! 331: * this fragment to the list. ! 332: */ ! 333: /* TODO: don't let one src hog all the reassembly buffers */ ! 334: if (!clnp_newpkt(m, src, dst, seg) /* || this src is a hog */) { ! 335: INCSTAT(cns_fragdropped); ! 336: clnp_discard(m, GEN_CONGEST); ! 337: } ! 338: ! 339: return(NULL); ! 340: } ! 341: ! 342: /* ! 343: * FUNCTION: clnp_newpkt ! 344: * ! 345: * PURPOSE: Create the necessary structures to handle a new ! 346: * fragmented clnp packet. ! 347: * ! 348: * RETURNS: non-zero if it succeeds, zero if fails. ! 349: * ! 350: * SIDE EFFECTS: ! 351: * ! 352: * NOTES: Failure is only due to insufficient resources. ! 353: */ ! 354: clnp_newpkt(m, src, dst, seg) ! 355: struct mbuf *m; /* new fragment */ ! 356: struct iso_addr *src; /* src of new fragment */ ! 357: struct iso_addr *dst; /* dst of new fragment */ ! 358: struct clnp_segment *seg; /* segment part of fragment header */ ! 359: { ! 360: register struct clnp_fragl *cfh; ! 361: register struct clnp_fixed *clnp; ! 362: struct mbuf *m0; ! 363: ! 364: clnp = mtod(m, struct clnp_fixed *); ! 365: ! 366: /* ! 367: * Allocate new clnp fragl structure to act as header of all fragments ! 368: * for this datagram. ! 369: */ ! 370: MGET(m0, M_DONTWAIT, MT_FTABLE); ! 371: if (m0 == NULL) { ! 372: return (0); ! 373: } ! 374: cfh = mtod(m0, struct clnp_fragl *); ! 375: ! 376: /* ! 377: * Duplicate the header of this fragment, and save in cfh. ! 378: * Free m0 and return if m_copy does not succeed. ! 379: */ ! 380: if ((cfh->cfl_orighdr = m_copy(m, 0, (int)clnp->cnf_hdr_len)) == NULL) { ! 381: m_freem(m0); ! 382: return (0); ! 383: } ! 384: ! 385: /* Fill in rest of fragl structure */ ! 386: bcopy((caddr_t)src, (caddr_t)&cfh->cfl_src, sizeof(struct iso_addr)); ! 387: bcopy((caddr_t)dst, (caddr_t)&cfh->cfl_dst, sizeof(struct iso_addr)); ! 388: cfh->cfl_id = seg->cng_id; ! 389: cfh->cfl_ttl = clnp->cnf_ttl; ! 390: cfh->cfl_last = (seg->cng_tot_len - clnp->cnf_hdr_len) - 1; ! 391: cfh->cfl_frags = NULL; ! 392: cfh->cfl_next = NULL; ! 393: ! 394: /* Insert into list of packets */ ! 395: cfh->cfl_next = clnp_frags; ! 396: clnp_frags = cfh; ! 397: ! 398: /* Insert this fragment into list headed by cfh */ ! 399: clnp_insert_frag(cfh, m, seg); ! 400: return(1); ! 401: } ! 402: ! 403: /* ! 404: * FUNCTION: clnp_insert_frag ! 405: * ! 406: * PURPOSE: Insert fragment into list headed by 'cf'. ! 407: * ! 408: * RETURNS: nothing ! 409: * ! 410: * SIDE EFFECTS: ! 411: * ! 412: * NOTES: This is the 'guts' of the reassembly algorithm. ! 413: * Each fragment in this list contains a clnp_frag ! 414: * structure followed by the data of the fragment. ! 415: * The clnp_frag structure actually lies on top of ! 416: * part of the old clnp header. ! 417: */ ! 418: clnp_insert_frag(cfh, m, seg) ! 419: struct clnp_fragl *cfh; /* header of list of packet fragments */ ! 420: struct mbuf *m; /* new fragment */ ! 421: struct clnp_segment *seg; /* segment part of fragment header */ ! 422: { ! 423: register struct clnp_fixed *clnp; /* clnp hdr of fragment */ ! 424: register struct clnp_frag *cf; /* generic fragment ptr */ ! 425: register struct clnp_frag *cf_sub = NULL; /* frag subsequent to new one */ ! 426: register struct clnp_frag *cf_prev = NULL; /* frag previous to new one */ ! 427: u_short first; /* offset of first byte of initial pdu*/ ! 428: u_short last; /* offset of last byte of initial pdu */ ! 429: u_short fraglen;/* length of fragment */ ! 430: ! 431: clnp = mtod(m, struct clnp_fixed *); ! 432: first = seg->cng_off; ! 433: CTOH(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, fraglen); ! 434: fraglen -= clnp->cnf_hdr_len; ! 435: last = (first + fraglen) - 1; ! 436: ! 437: IFDEBUG(D_REASS) ! 438: printf("clnp_insert_frag: New fragment: [%d ... %d], len %d\n", ! 439: first, last, fraglen); ! 440: printf("clnp_insert_frag: current fragments:\n"); ! 441: for (cf = cfh->cfl_frags; cf != NULL; cf = cf->cfr_next) { ! 442: printf("\tcf x%x: [%d ... %d]\n", cf, cf->cfr_first, cf->cfr_last); ! 443: } ! 444: ENDDEBUG ! 445: ! 446: if (cfh->cfl_frags != NULL) { ! 447: /* ! 448: * Find fragment which begins after the new one ! 449: */ ! 450: for (cf = cfh->cfl_frags; cf != NULL; cf_prev = cf, cf = cf->cfr_next) { ! 451: if (cf->cfr_first > first) { ! 452: cf_sub = cf; ! 453: break; ! 454: } ! 455: } ! 456: ! 457: IFDEBUG(D_REASS) ! 458: printf("clnp_insert_frag: Previous frag is "); ! 459: if (cf_prev == NULL) ! 460: printf("NULL\n"); ! 461: else ! 462: printf("[%d ... %d]\n", cf_prev->cfr_first, cf_prev->cfr_last); ! 463: printf("clnp_insert_frag: Subsequent frag is "); ! 464: if (cf_sub == NULL) ! 465: printf("NULL\n"); ! 466: else ! 467: printf("[%d ... %d]\n", cf_sub->cfr_first, cf_sub->cfr_last); ! 468: ENDDEBUG ! 469: ! 470: /* ! 471: * If there is a fragment before the new one, check if it ! 472: * overlaps the new one. If so, then trim the end of the ! 473: * previous one. ! 474: */ ! 475: if (cf_prev != NULL) { ! 476: if (cf_prev->cfr_last > first) { ! 477: u_short overlap = cf_prev->cfr_last - first; ! 478: ! 479: IFDEBUG(D_REASS) ! 480: printf("clnp_insert_frag: previous overlaps by %d\n", ! 481: overlap); ! 482: ENDDEBUG ! 483: ! 484: if (overlap > fraglen) { ! 485: /* ! 486: * The new fragment is entirely contained in the ! 487: * preceeding one. We can punt on the new frag ! 488: * completely. ! 489: */ ! 490: m_freem(m); ! 491: return; ! 492: } else { ! 493: /* Trim data off of end of previous fragment */ ! 494: /* inc overlap to prevent duplication of last byte */ ! 495: overlap++; ! 496: m_adj(cf_prev->cfr_data, -(int)overlap); ! 497: cf_prev->cfr_last -= overlap; ! 498: } ! 499: } ! 500: } ! 501: ! 502: /* ! 503: * For all fragments past the new one, check if any data on ! 504: * the new one overlaps data on existing fragments. If so, ! 505: * then trim the extra data off the end of the new one. ! 506: */ ! 507: for (cf = cf_sub; cf != NULL; cf = cf->cfr_next) { ! 508: if (cf->cfr_first < last) { ! 509: u_short overlap = last - cf->cfr_first; ! 510: ! 511: IFDEBUG(D_REASS) ! 512: printf("clnp_insert_frag: subsequent overlaps by %d\n", ! 513: overlap); ! 514: ENDDEBUG ! 515: ! 516: if (overlap > fraglen) { ! 517: /* ! 518: * The new fragment is entirely contained in the ! 519: * succeeding one. This should not happen, because ! 520: * early on in this code we scanned for the fragment ! 521: * which started after the new one! ! 522: */ ! 523: m_freem(m); ! 524: printf("clnp_insert_frag: internal error!\n"); ! 525: return; ! 526: } else { ! 527: /* Trim data off of end of new fragment */ ! 528: /* inc overlap to prevent duplication of last byte */ ! 529: overlap++; ! 530: m_adj(m, -(int)overlap); ! 531: last -= overlap; ! 532: } ! 533: } ! 534: } ! 535: } ! 536: ! 537: /* ! 538: * Insert the new fragment beween cf_prev and cf_sub ! 539: * ! 540: * Note: the clnp hdr is still in the mbuf. ! 541: * If the data of the mbuf is not word aligned, shave off enough ! 542: * so that it is. Then, cast the clnp_frag structure on top ! 543: * of the clnp header. ! 544: * The clnp_hdr will not be used again (as we already have ! 545: * saved a copy of it). ! 546: * ! 547: * Save in cfr_bytes the number of bytes to shave off to get to ! 548: * the data of the packet. This is used when we coalesce fragments; ! 549: * the clnp_frag structure must be removed before joining mbufs. ! 550: */ ! 551: { ! 552: int pad; ! 553: u_int bytes; ! 554: ! 555: /* determine if header is not word aligned */ ! 556: pad = (int)clnp % 4; ! 557: if (pad < 0) ! 558: pad = -pad; ! 559: ! 560: /* bytes is number of bytes left in front of data */ ! 561: bytes = clnp->cnf_hdr_len - pad; ! 562: ! 563: IFDEBUG(D_REASS) ! 564: printf("clnp_insert_frag: clnp x%x requires %d alignment\n", ! 565: clnp, pad); ! 566: ENDDEBUG ! 567: ! 568: /* make it word aligned if necessary */ ! 569: if (pad) ! 570: m_adj(m, pad); ! 571: ! 572: cf = mtod(m, struct clnp_frag *); ! 573: cf->cfr_bytes = bytes; ! 574: ! 575: IFDEBUG(D_REASS) ! 576: printf("clnp_insert_frag: cf now x%x, cfr_bytes %d\n", cf, ! 577: cf->cfr_bytes); ! 578: ENDDEBUG ! 579: } ! 580: cf->cfr_first = first; ! 581: cf->cfr_last = last; ! 582: ! 583: ! 584: /* ! 585: * The data is the mbuf itself, although we must remember that the ! 586: * first few bytes are actually a clnp_frag structure ! 587: */ ! 588: cf->cfr_data = m; ! 589: ! 590: /* link into place */ ! 591: cf->cfr_next = cf_sub; ! 592: if (cf_prev == NULL) ! 593: cfh->cfl_frags = cf; ! 594: else ! 595: cf_prev->cfr_next = cf; ! 596: } ! 597: ! 598: /* ! 599: * FUNCTION: clnp_comp_pdu ! 600: * ! 601: * PURPOSE: Scan the list of fragments headed by cfh. Merge ! 602: * any contigious fragments into one. If, after ! 603: * traversing all the fragments, it is determined that ! 604: * the packet is complete, then return a pointer to ! 605: * the packet (with header prepended). Otherwise, ! 606: * return NULL. ! 607: * ! 608: * RETURNS: NULL, or a pointer to the assembled pdu in an mbuf chain. ! 609: * ! 610: * SIDE EFFECTS: Will colapse contigious fragments into one. ! 611: * ! 612: * NOTES: This code assumes that there are no overlaps of ! 613: * fragment pdus. ! 614: */ ! 615: struct mbuf * ! 616: clnp_comp_pdu(cfh) ! 617: struct clnp_fragl *cfh; /* fragment header */ ! 618: { ! 619: register struct clnp_frag *cf = cfh->cfl_frags; ! 620: ! 621: while (cf->cfr_next != NULL) { ! 622: register struct clnp_frag *cf_next = cf->cfr_next; ! 623: ! 624: IFDEBUG(D_REASS) ! 625: printf("clnp_comp_pdu: comparing: [%d ... %d] to [%d ... %d]\n", ! 626: cf->cfr_first, cf->cfr_last, cf_next->cfr_first, ! 627: cf_next->cfr_last); ! 628: ENDDEBUG ! 629: ! 630: if (cf->cfr_last == (cf_next->cfr_first - 1)) { ! 631: /* ! 632: * Merge fragment cf and cf_next ! 633: * ! 634: * - update cf header ! 635: * - trim clnp_frag structure off of cf_next ! 636: * - append cf_next to cf ! 637: */ ! 638: struct clnp_frag cf_next_hdr; ! 639: struct clnp_frag *next_frag; ! 640: ! 641: cf_next_hdr = *cf_next; ! 642: next_frag = cf_next->cfr_next; ! 643: ! 644: IFDEBUG(D_REASS) ! 645: struct mbuf *mdump; ! 646: int l; ! 647: printf("clnp_comp_pdu: merging fragments\n"); ! 648: printf("clnp_comp_pdu: 1st: [%d ... %d] (bytes %d)\n", ! 649: cf->cfr_first, cf->cfr_last, cf->cfr_bytes); ! 650: mdump = cf->cfr_data; ! 651: l = 0; ! 652: while (mdump != NULL) { ! 653: printf("\tmbuf x%x, m_len %d\n", mdump, mdump->m_len); ! 654: l += mdump->m_len; ! 655: mdump = mdump->m_next; ! 656: } ! 657: printf("\ttotal len: %d\n", l); ! 658: printf("clnp_comp_pdu: 2nd: [%d ... %d] (bytes %d)\n", ! 659: cf_next->cfr_first, cf_next->cfr_last, cf_next->cfr_bytes); ! 660: mdump = cf_next->cfr_data; ! 661: l = 0; ! 662: while (mdump != NULL) { ! 663: printf("\tmbuf x%x, m_len %d\n", mdump, mdump->m_len); ! 664: l += mdump->m_len; ! 665: mdump = mdump->m_next; ! 666: } ! 667: printf("\ttotal len: %d\n", l); ! 668: ENDDEBUG ! 669: ! 670: cf->cfr_last = cf_next->cfr_last; ! 671: /* ! 672: * After this m_adj, the cf_next ptr is useless because we ! 673: * have adjusted the clnp_frag structure away... ! 674: */ ! 675: IFDEBUG(D_REASS) ! 676: printf("clnp_comp_pdu: shaving off %d bytes\n", ! 677: cf_next_hdr.cfr_bytes); ! 678: ENDDEBUG ! 679: m_adj(cf_next_hdr.cfr_data, (int)cf_next_hdr.cfr_bytes); ! 680: m_cat(cf->cfr_data, cf_next_hdr.cfr_data); ! 681: cf->cfr_next = next_frag; ! 682: } else { ! 683: cf = cf->cfr_next; ! 684: } ! 685: } ! 686: ! 687: cf = cfh->cfl_frags; ! 688: ! 689: IFDEBUG(D_REASS) ! 690: struct mbuf *mdump = cf->cfr_data; ! 691: printf("clnp_comp_pdu: first frag now: [%d ... %d]\n", cf->cfr_first, ! 692: cf->cfr_last); ! 693: printf("clnp_comp_pdu: data for frag:\n"); ! 694: while (mdump != NULL) { ! 695: printf("mbuf x%x, m_len %d\n", mdump, mdump->m_len); ! 696: /* dump_buf(mtod(mdump, caddr_t), mdump->m_len);*/ ! 697: mdump = mdump->m_next; ! 698: } ! 699: ENDDEBUG ! 700: ! 701: /* Check if datagram is complete */ ! 702: if ((cf->cfr_first == 0) && (cf->cfr_last == cfh->cfl_last)) { ! 703: /* ! 704: * We have a complete pdu! ! 705: * - Remove the frag header from (only) remaining fragment ! 706: * (which is not really a fragment anymore, as the datagram is ! 707: * complete). ! 708: * - Prepend a clnp header ! 709: */ ! 710: struct mbuf *data = cf->cfr_data; ! 711: struct mbuf *hdr = cfh->cfl_orighdr; ! 712: struct clnp_fragl *scan; ! 713: ! 714: IFDEBUG(D_REASS) ! 715: printf("clnp_comp_pdu: complete pdu!\n"); ! 716: ENDDEBUG ! 717: ! 718: m_adj(data, (int)cf->cfr_bytes); ! 719: m_cat(hdr, data); ! 720: ! 721: IFDEBUG(D_DUMPIN) ! 722: struct mbuf *mdump = hdr; ! 723: printf("clnp_comp_pdu: pdu is:\n"); ! 724: while (mdump != NULL) { ! 725: printf("mbuf x%x, m_len %d\n", mdump, mdump->m_len); ! 726: /* dump_buf(mtod(mdump, caddr_t), mdump->m_len);*/ ! 727: mdump = mdump->m_next; ! 728: } ! 729: ENDDEBUG ! 730: ! 731: /* ! 732: * Remove cfh from the list of fragmented pdus ! 733: */ ! 734: if (clnp_frags == cfh) { ! 735: clnp_frags = cfh->cfl_next; ! 736: } else { ! 737: for (scan = clnp_frags; scan != NULL; scan = scan->cfl_next) { ! 738: if (scan->cfl_next == cfh) { ! 739: scan->cfl_next = cfh->cfl_next; ! 740: break; ! 741: } ! 742: } ! 743: } ! 744: ! 745: /* free cfh */ ! 746: m_freem(dtom(cfh)); ! 747: ! 748: return(hdr); ! 749: } ! 750: ! 751: return(NULL); ! 752: } ! 753: #ifdef TROLL ! 754: static int troll_cnt; ! 755: #include "time.h" ! 756: /* ! 757: * FUNCTION: troll_random ! 758: * ! 759: * PURPOSE: generate a pseudo-random number between 0 and 1 ! 760: * ! 761: * RETURNS: the random number ! 762: * ! 763: * SIDE EFFECTS: ! 764: * ! 765: * NOTES: This is based on the clock. ! 766: */ ! 767: float troll_random() ! 768: { ! 769: extern struct timeval time; ! 770: long t = time.tv_usec % 100; ! 771: ! 772: return((float)t / (float) 100); ! 773: } ! 774: ! 775: /* ! 776: * FUNCTION: troll_output ! 777: * ! 778: * PURPOSE: Do something sneaky with the datagram passed. Possible ! 779: * operations are: ! 780: * Duplicate the packet ! 781: * Drop the packet ! 782: * Trim some number of bytes from the packet ! 783: * Munge some byte in the packet ! 784: * ! 785: * RETURNS: 0, or unix error code ! 786: * ! 787: * SIDE EFFECTS: ! 788: * ! 789: * NOTES: The operation of this procedure is regulated by the ! 790: * troll control structure (Troll). ! 791: */ ! 792: troll_output(ifp, m, dst, rt) ! 793: struct ifnet *ifp; ! 794: struct mbuf *m; ! 795: struct sockaddr *dst; ! 796: struct rtentry *rt; ! 797: { ! 798: int err = 0; ! 799: troll_cnt++; ! 800: ! 801: if (trollctl.tr_ops & TR_DUPPKT) { ! 802: /* ! 803: * Duplicate every Nth packet ! 804: * TODO: random? ! 805: */ ! 806: float f_freq = troll_cnt * trollctl.tr_dup_freq; ! 807: int i_freq = troll_cnt * trollctl.tr_dup_freq; ! 808: if (i_freq == f_freq) { ! 809: struct mbuf *dup = m_copy(m, 0, (int)M_COPYALL); ! 810: if (dup != NULL) ! 811: err = (*ifp->if_output)(ifp, dup, dst, rt); ! 812: } ! 813: if (!err) ! 814: err = (*ifp->if_output)(ifp, m, dst, rt); ! 815: return(err); ! 816: } else if (trollctl.tr_ops & TR_DROPPKT) { ! 817: } else if (trollctl.tr_ops & TR_CHANGE) { ! 818: struct clnp_fixed *clnp = mtod(m, struct clnp_fixed *); ! 819: clnp->cnf_cksum_msb = 0; ! 820: err = (*ifp->if_output)(ifp, m, dst, rt); ! 821: return(err); ! 822: } else { ! 823: err = (*ifp->if_output)(ifp, m, dst, rt); ! 824: return(err); ! 825: } ! 826: } ! 827: ! 828: #endif TROLL
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.