![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iso_chksum.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 iso_chksum.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: /* ! 28: * $Header: iso_chksum.c,v 4.7 88/07/29 15:31:26 nhall Exp $ ! 29: * $Source: /usr/argo/sys/netiso/RCS/iso_chksum.c,v $ ! 30: * @(#)iso_chksum.c 7.4 (Berkeley) 9/26/89 * ! 31: * ! 32: * ISO CHECKSUM ! 33: * ! 34: * The checksum generation and check routines are here. ! 35: * The checksum is 2 bytes such that the sum of all the bytes b(i) == 0 ! 36: * and the sum of i * b(i) == 0. ! 37: * The whole thing is complicated by the fact that the data are in mbuf ! 38: * chains. ! 39: * Furthermore, there is the possibility of wraparound in the running ! 40: * sums after adding up 4102 octets. In order to avoid doing a mod ! 41: * operation after EACH add, we have restricted this implementation to ! 42: * negotiating a maximum of 4096-octets per TPDU (for the transport layer). ! 43: * The routine iso_check_csum doesn't need to know where the checksum ! 44: * octets are. ! 45: * The routine iso_gen_csum takes a pointer to an mbuf chain (logically ! 46: * a chunk of data), an offset into the chunk at which the 2 octets are to ! 47: * be stuffed, and the length of the chunk. The 2 octets have to be ! 48: * logically adjacent, but may be physically located in separate mbufs. ! 49: */ ! 50: ! 51: #ifdef ISO ! 52: #ifndef lint ! 53: static char *rcsid = "$Header: iso_chksum.c,v 4.7 88/07/29 15:31:26 nhall Exp $"; ! 54: #endif ! 55: ! 56: #include "argo_debug.h" ! 57: #include "param.h" ! 58: #include "mbuf.h" ! 59: #endif ISO ! 60: ! 61: #ifndef MNULL ! 62: #define MNULL (struct mbuf *)0 ! 63: #endif MNULL ! 64: ! 65: /* ! 66: * FUNCTION: iso_check_csum ! 67: * ! 68: * PURPOSE: To check the checksum of the packet in the mbuf chain (m). ! 69: * The total length of the packet is (len). ! 70: * Called from tp_input() and clnp_intr() ! 71: * ! 72: * RETURNS: TRUE (something non-zero) if there is a checksum error, ! 73: * FALSE if there was NO checksum error. ! 74: * ! 75: * SIDE EFFECTS: none ! 76: * ! 77: * NOTES: It might be possible to gain something by optimizing ! 78: * this routine (unrolling loops, etc). But it is such ! 79: * a horrible thing to fiddle with anyway, it probably ! 80: * isn't worth it. ! 81: */ ! 82: int ! 83: iso_check_csum(m, len) ! 84: struct mbuf *m; ! 85: int len; ! 86: { ! 87: register u_char *p = mtod(m, u_char *); ! 88: register u_long c0=0, c1=0; ! 89: register int i=0; ! 90: int cum = 0; /* cumulative length */ ! 91: int l; ! 92: ! 93: l = len; ! 94: len = MIN(m->m_len, len); ! 95: i = 0; ! 96: ! 97: IFDEBUG(D_CHKSUM) ! 98: printf("iso_check_csum: m x%x, l x%x, m->m_len x%x\n", m, l, m->m_len); ! 99: ENDDEBUG ! 100: ! 101: while( i<l ) { ! 102: cum += len; ! 103: while (i<cum) { ! 104: c0 = c0 + *(p++); ! 105: c1 += c0; ! 106: i++; ! 107: } ! 108: if(i < l) { ! 109: m = m->m_next; ! 110: IFDEBUG(D_CHKSUM) ! 111: printf("iso_check_csum: new mbuf\n"); ! 112: if(l-i < m->m_len) ! 113: printf( ! 114: "bad mbuf chain in check csum l 0x%x i 0x%x m_data 0x%x", ! 115: l,i,m->m_data); ! 116: ENDDEBUG ! 117: ASSERT( m != MNULL); ! 118: len = MIN( m->m_len, l-i); ! 119: p = mtod(m, u_char *); ! 120: } ! 121: } ! 122: if ( ((int)c0 % 255) || ((int)c1 % 255) ) { ! 123: IFDEBUG(D_CHKSUM) ! 124: printf("BAD iso_check_csum l 0x%x cum 0x%x len 0x%x, i 0x%x", ! 125: l, cum, len, i); ! 126: ENDDEBUG ! 127: return ((int)c0 % 255)<<8 | ((int)c1 % 255); ! 128: } ! 129: return 0; ! 130: } ! 131: ! 132: /* ! 133: * FUNCTION: iso_gen_csum ! 134: * ! 135: * PURPOSE: To generate the checksum of the packet in the mbuf chain (m). ! 136: * The first of the 2 (logically) adjacent checksum bytes ! 137: * (x and y) go at offset (n). ! 138: * (n) is an offset relative to the beginning of the data, ! 139: * not the beginning of the mbuf. ! 140: * (l) is the length of the total mbuf chain's data. ! 141: * Called from tp_emit(), tp_error_emit() ! 142: * clnp_emit_er(), clnp_forward(), clnp_output(). ! 143: * ! 144: * RETURNS: Rien ! 145: * ! 146: * SIDE EFFECTS: Puts the 2 checksum bytes into the packet. ! 147: * ! 148: * NOTES: Ditto the note for iso_check_csum(). ! 149: */ ! 150: ! 151: void ! 152: iso_gen_csum(m,n,l) ! 153: struct mbuf *m; ! 154: int n; /* offset of 2 checksum bytes */ ! 155: int l; ! 156: { ! 157: register u_char *p = mtod(m, u_char *); ! 158: register int c0=0, c1=0; ! 159: register int i=0; ! 160: int loc = n++, len=0; /* n is position, loc is offset */ ! 161: u_char *xloc; ! 162: u_char *yloc; ! 163: int cum=0; /* cum == cumulative length */ ! 164: ! 165: IFDEBUG(D_CHKSUM) ! 166: printf("enter gen csum m 0x%x n 0x%x l 0x%x\n",m, n-1 ,l ); ! 167: ENDDEBUG ! 168: ! 169: while(i < l) { ! 170: len = MIN(m->m_len, CLBYTES); ! 171: /* RAH: don't cksum more than l bytes */ ! 172: len = MIN(len, l - i); ! 173: ! 174: cum +=len; ! 175: p = mtod(m, u_char *); ! 176: ! 177: if(loc>=0) { ! 178: if (loc < len) { ! 179: xloc = loc + mtod(m, u_char *); ! 180: IFDEBUG(D_CHKSUM) ! 181: printf("1: zeroing xloc 0x%x loc 0x%x\n",xloc, loc ); ! 182: ENDDEBUG ! 183: *xloc = (u_char)0; ! 184: if (loc+1 < len) { ! 185: /* both xloc and yloc are in same mbuf */ ! 186: yloc = 1 + xloc; ! 187: IFDEBUG(D_CHKSUM) ! 188: printf("2: zeroing yloc 0x%x loc 0x%x\n",yloc, loc ); ! 189: ENDDEBUG ! 190: *yloc = (u_char)0; ! 191: } else { ! 192: /* crosses boundary of mbufs */ ! 193: yloc = mtod(m->m_next, u_char *); ! 194: IFDEBUG(D_CHKSUM) ! 195: printf("3: zeroing yloc 0x%x \n",yloc ); ! 196: ENDDEBUG ! 197: *yloc = (u_char)0; ! 198: } ! 199: } ! 200: loc -= len; ! 201: } ! 202: ! 203: while(i < cum) { ! 204: c0 = (c0 + *p); ! 205: c1 += c0 ; ! 206: i++; ! 207: p++; ! 208: } ! 209: m = m->m_next; ! 210: } ! 211: IFDEBUG(D_CHKSUM) ! 212: printf("gen csum final xloc 0x%x yloc 0x%x\n",xloc, yloc ); ! 213: ENDDEBUG ! 214: ! 215: c1 = (((c0 * (l-n))-c1)%255) ; ! 216: *xloc = (u_char) ((c1 < 0)? c1+255 : c1); ! 217: ! 218: c1 = (-(int)(c1+c0))%255; ! 219: *yloc = (u_char) (c1 < 0? c1 + 255 : c1); ! 220: ! 221: IFDEBUG(D_CHKSUM) ! 222: printf("gen csum end \n"); ! 223: ENDDEBUG ! 224: } ! 225: ! 226: struct mbuf * ! 227: m_append(head, m) ! 228: struct mbuf *head, *m; ! 229: { ! 230: register struct mbuf *n; ! 231: ! 232: if (m == 0) ! 233: return head; ! 234: if (head == 0) ! 235: return m; ! 236: n = head; ! 237: while (n->m_next) ! 238: n = n->m_next; ! 239: n->m_next = m; ! 240: return head; ! 241: } ! 242: /* ! 243: * FUNCTION: m_datalen ! 244: * ! 245: * PURPOSE: returns length of the mbuf chain. ! 246: * used all over the iso code. ! 247: * ! 248: * RETURNS: integer ! 249: * ! 250: * SIDE EFFECTS: none ! 251: * ! 252: * NOTES: ! 253: */ ! 254: ! 255: int ! 256: m_datalen (morig) ! 257: struct mbuf *morig; ! 258: { ! 259: int s = splimp(); ! 260: register struct mbuf *n=morig; ! 261: register int datalen = 0; ! 262: ! 263: if( morig == (struct mbuf *)0) ! 264: return 0; ! 265: for(;;) { ! 266: datalen += n->m_len; ! 267: if (n->m_next == (struct mbuf *)0 ) { ! 268: break; ! 269: } ! 270: n = n->m_next; ! 271: } ! 272: splx(s); ! 273: return datalen; ! 274: } ! 275: ! 276: int ! 277: m_compress(in, out) ! 278: register struct mbuf *in, **out; ! 279: { ! 280: register int datalen = 0; ! 281: int s = splimp(); ! 282: ! 283: if( in->m_next == MNULL ) { ! 284: *out = in; ! 285: IFDEBUG(D_REQUEST) ! 286: printf("m_compress returning 0x%x: A\n", in->m_len); ! 287: ENDDEBUG ! 288: splx(s); ! 289: return in->m_len; ! 290: } ! 291: MGET((*out), M_DONTWAIT, MT_DATA); ! 292: if((*out) == MNULL) { ! 293: *out = in; ! 294: IFDEBUG(D_REQUEST) ! 295: printf("m_compress returning -1: B\n"); ! 296: ENDDEBUG ! 297: splx(s); ! 298: return -1; ! 299: } ! 300: (*out)->m_len = 0; ! 301: (*out)->m_act = MNULL; ! 302: ! 303: while (in) { ! 304: IFDEBUG(D_REQUEST) ! 305: printf("m_compress in 0x%x *out 0x%x\n", in, *out); ! 306: printf("m_compress in: len 0x%x, off 0x%x\n", in->m_len, in->m_data); ! 307: printf("m_compress *out: len 0x%x, off 0x%x\n", (*out)->m_len, ! 308: (*out)->m_data); ! 309: ENDDEBUG ! 310: if (in->m_flags & M_EXT) { ! 311: ASSERT(in->m_len == 0); ! 312: } ! 313: if ( in->m_len == 0) { ! 314: in = in->m_next; ! 315: continue; ! 316: } ! 317: if (((*out)->m_flags & M_EXT) == 0) { ! 318: int len; ! 319: ! 320: len = M_TRAILINGSPACE(*out); ! 321: len = MIN(len, in->m_len); ! 322: datalen += len; ! 323: ! 324: IFDEBUG(D_REQUEST) ! 325: printf("m_compress copying len %d\n", len); ! 326: ENDDEBUG ! 327: bcopy(mtod(in, caddr_t), mtod((*out), caddr_t) + (*out)->m_len, ! 328: (unsigned)len); ! 329: ! 330: (*out)->m_len += len; ! 331: in->m_len -= len; ! 332: continue; ! 333: } else { ! 334: /* (*out) is full */ ! 335: if(( (*out)->m_next = m_get(M_DONTWAIT, MT_DATA) ) == MNULL) { ! 336: m_freem(*out); ! 337: *out = in; ! 338: IFDEBUG(D_REQUEST) ! 339: printf("m_compress returning -1: B\n"); ! 340: ENDDEBUG ! 341: splx(s); ! 342: return -1; ! 343: } ! 344: (*out)->m_len = 0; ! 345: (*out)->m_act = MNULL; ! 346: *out = (*out)->m_next; ! 347: } ! 348: } ! 349: m_freem(in); ! 350: IFDEBUG(D_REQUEST) ! 351: printf("m_compress returning 0x%x: A\n", datalen); ! 352: ENDDEBUG ! 353: splx(s); ! 354: return datalen; ! 355: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.