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