nicer formatting
[tridge/junkcode.git] / csum.c
1 #define __KERNEL__
2
3 #include <linux/config.h>
4 #include <asm/segment.h>
5 #include <asm/system.h>
6 #include <linux/types.h>
7 #include <linux/kernel.h>
8 #include <linux/sched.h>
9 #include <linux/string.h>
10 #include <linux/errno.h>
11 #include <linux/config.h>
12
13 #include <linux/socket.h>
14 #include <linux/sockios.h>
15 #include <linux/in.h>
16 #include <linux/inet.h>
17 #include <linux/netdevice.h>
18 #include <linux/icmp.h>
19 #include <linux/udp.h>
20 #include <net/ip.h>
21 #include <net/protocol.h>
22 #include <net/route.h>
23 #include <net/tcp.h>
24 #include <net/udp.h>
25 #include <linux/skbuff.h>
26 #include <net/sock.h>
27 #include <net/icmp.h>
28 #include <linux/firewall.h>
29 #include <linux/ip_fw.h>
30 #include <net/checksum.h>
31 #include <linux/proc_fs.h>
32 #include <linux/stat.h>
33 #include <net/checksum.h>
34
35 /*
36  * computes a partial checksum, e.g. for TCP/UDP fragments
37  */
38
39 unsigned int csum_partial(const unsigned char * buff, int len, unsigned int sum) {
40           /*
41            * Experiments with ethernet and slip connections show that buff
42            * is aligned on either a 2-byte or 4-byte boundary.  We get at
43            * least a 2x speedup on 486 and Pentium if it is 4-byte aligned.
44            * Fortunately, it is easy to convert 2-byte alignment to 4-byte
45            * alignment for the unrolled loop.
46            */
47         __asm__("
48             testl $2, %%esi             # Check alignment.
49             jz 2f                       # Jump if alignment is ok.
50             subl $2, %%ecx              # Alignment uses up two bytes.
51             jae 1f                      # Jump if we had at least two bytes.
52             addl $2, %%ecx              # ecx was < 2.  Deal with it.
53             jmp 4f
54 1:          movw (%%esi), %%bx
55             addl $2, %%esi
56             addw %%bx, %%ax
57             adcl $0, %%eax
58 2:
59             movl %%ecx, %%edx
60             shrl $5, %%ecx
61             jz 2f
62             testl %%esi, %%esi
63 1:          movl (%%esi), %%ebx
64             adcl %%ebx, %%eax
65             movl 4(%%esi), %%ebx
66             adcl %%ebx, %%eax
67             movl 8(%%esi), %%ebx
68             adcl %%ebx, %%eax
69             movl 12(%%esi), %%ebx
70             adcl %%ebx, %%eax
71             movl 16(%%esi), %%ebx
72             adcl %%ebx, %%eax
73             movl 20(%%esi), %%ebx
74             adcl %%ebx, %%eax
75             movl 24(%%esi), %%ebx
76             adcl %%ebx, %%eax
77             movl 28(%%esi), %%ebx
78             adcl %%ebx, %%eax
79             lea 32(%%esi), %%esi
80             dec %%ecx
81             jne 1b
82             adcl $0, %%eax
83 2:          movl %%edx, %%ecx
84             andl $0x1c, %%edx
85             je 4f
86             shrl $2, %%edx
87             testl %%esi, %%esi
88 3:          adcl (%%esi), %%eax
89             lea 4(%%esi), %%esi
90             dec %%edx
91             jne 3b
92             adcl $0, %%eax
93 4:          andl $3, %%ecx
94             jz 7f
95             cmpl $2, %%ecx
96             jb 5f
97             movw (%%esi),%%cx
98             leal 2(%%esi),%%esi
99             je 6f
100             shll $16,%%ecx
101 5:          movb (%%esi),%%cl
102 6:          addl %%ecx,%%eax
103             adcl $0, %%eax
104 7:          "
105         : "=a"(sum)
106         : "0"(sum), "c"(len), "S"(buff)
107         : "bx", "cx", "dx", "si");
108         return(sum);
109 }
110
111 /* 32 bits version of the checksum routines written for the Alpha by Linus */
112 static unsigned short from32to16(unsigned long x)
113 {
114         /* add up 16-bit and 17-bit words for 17+c bits */
115         x = (x & 0xffff) + (x >> 16);
116         /* add up 16-bit and 2-bit for 16+c bit */
117         x = (x & 0xffff) + (x >> 16);
118         /* add up carry.. */
119         x = (x & 0xffff) + (x >> 16);
120         return x;
121 }
122
123
124 main(int argc,char *argv[])
125 {
126   unsigned long sum1,sum2,sum3,sum4,sum5;
127   int i;
128   __u32 saddr=0x32456787,daddr=0x89764512;
129   int len=512,proto=7;
130   char data1[512];
131   int seed = time(0);
132
133   if (argc > 1) seed = atoi(argv[1]);
134
135   while (1) {
136     srandom(seed);
137     for (i=0; i<512 ; i++) {
138       data1[i] = random();
139     }
140
141   sum1 = csum_tcpudp_magic(saddr,daddr,len,proto,csum_partial(data1,512,0));
142
143   sum2 = csum_tcpudp_magic(saddr,daddr,len,proto,csum_partial(data1,256,0));
144   
145   data1[4]++;
146   daddr ^= 0x765432FE;
147
148   sum3 = csum_tcpudp_magic(saddr,daddr,len,proto,csum_partial(data1,256,0));
149   
150   sum4 = ~sum3 + (~sum1 - ~sum2);
151   if (!(sum4>>16)) sum4++;
152   sum4 = 0xFFFF & (~from32to16(sum4));
153
154   sum5 = csum_tcpudp_magic(saddr,daddr,len,proto,csum_partial(data1,512,0));
155
156   if (sum4 != sum5) {
157     printf("Failed with seed=%d\n",seed);
158     exit(1);
159   }
160   seed++;
161   if (!(seed & 0xFFF))
162     printf("seed=0x%X\n",seed);
163   }
164
165   printf("%X %X\n",~sum3,~sum3 + (~sum1 - ~sum2));
166   printf("sum1=%X\n",(unsigned int)sum1 & 0xFFFF);
167   printf("sum2=%X\n",(unsigned int)sum2 & 0xFFFF);
168   printf("sum3=%X\n",(unsigned int)sum3 & 0xFFFF);
169   printf("sum4=%X\n",(unsigned int)sum4 & 0xFFFF);
170   printf("sum5=%X\n",(unsigned int)sum5 & 0xFFFF);
171 }