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