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