?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / dist / ipf / ipsend / ip.c
blobf357d2f8141b7e864f997752481f4815d499d856
1 /* $NetBSD: ip.c,v 1.8 2007/04/14 20:34:22 martin Exp $ */
2
3 /*
4 * ip.c (C) 1995-1998 Darren Reed
5 *
6 * See the IPFILTER.LICENCE file for details on licencing.
7 */
8 #if !defined(lint)
9 static const char sccsid[] = "%W% %G% (C)1995";
10 static const char rcsid[] = "@(#)Id: ip.c,v 2.8.2.2 2007/02/17 12:41:51 darrenr Exp";
11 #endif
12 #include <sys/param.h>
13 #include <sys/types.h>
14 #include <netinet/in_systm.h>
15 #include <sys/socket.h>
16 #ifdef __osf__
17 # include "radix_ipf_local.h"
18 #endif
19 #include <net/if.h>
20 #include <netinet/in.h>
21 #include <netinet/ip.h>
22 #include <sys/param.h>
23 #ifndef linux
24 # include <netinet/if_ether.h>
25 # include <netinet/ip_var.h>
26 # if __FreeBSD_version >= 300000
27 # include <net/if_var.h>
28 # endif
29 #endif
30 #include <errno.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <unistd.h>
34 #include <string.h>
35 #include "ipsend.h"
36
37
38 static char *ipbuf = NULL, *ethbuf = NULL;
39
40
41 u_short chksum(buf,len)
42 u_short *buf;
43 int len;
44 {
45 u_long sum = 0;
46 int nwords = len >> 1;
47
48 for(; nwords > 0; nwords--)
49 sum += *buf++;
50 sum = (sum>>16) + (sum & 0xffff);
51 sum += (sum >>16);
52 return (~sum);
53 }
54
55
56 int send_ether(nfd, buf, len, gwip)
57 int nfd, len;
58 char *buf;
59 struct in_addr gwip;
60 {
61 static struct in_addr last_gw;
62 static char last_arp[6] = { 0, 0, 0, 0, 0, 0};
63 ether_header_t *eh;
64 char *s;
65 int err;
66
67 if (!ethbuf)
68 ethbuf = (char *)calloc(1, 65536+1024);
69 s = ethbuf;
70 eh = (ether_header_t *)s;
71
72 bcopy((char *)buf, s + sizeof(*eh), len);
73 if (gwip.s_addr == last_gw.s_addr)
74 {
75 bcopy(last_arp, (char *)A_A eh->ether_dhost, 6);
76 }
77 else if (arp((char *)&gwip, (char *)A_A eh->ether_dhost) == -1)
78 {
79 perror("arp");
80 return -2;
81 }
82 eh->ether_type = htons(ETHERTYPE_IP);
83 last_gw.s_addr = gwip.s_addr;
84 err = sendip(nfd, s, sizeof(*eh) + len);
85 return err;
86 }
87
88
89 /*
90 */
91 int send_ip(nfd, mtu, ip, gwip, frag)
92 int nfd, mtu;
93 ip_t *ip;
94 struct in_addr gwip;
95 int frag;
96 {
97 static struct in_addr last_gw, local_ip;
98 static char local_arp[6] = { 0, 0, 0, 0, 0, 0};
99 static char last_arp[6] = { 0, 0, 0, 0, 0, 0};
100 static u_short id = 0;
101 ether_header_t *eh;
102 ip_t ipsv;
103 int err, iplen;
104
105 if (!ipbuf)
106 {
107 ipbuf = (char *)malloc(65536);
108 if (!ipbuf)
109 {
110 perror("malloc failed");
111 return -2;
112 }
113 }
114
115 eh = (ether_header_t *)ipbuf;
116
117 bzero((char *)A_A eh->ether_shost, sizeof(eh->ether_shost));
118 if (last_gw.s_addr && (gwip.s_addr == last_gw.s_addr))
119 {
120 bcopy(last_arp, (char *)A_A eh->ether_dhost, 6);
121 }
122 else if (arp((char *)&gwip, (char *)A_A eh->ether_dhost) == -1)
123 {
124 perror("arp");
125 return -2;
126 }
127 bcopy((char *)A_A eh->ether_dhost, last_arp, sizeof(last_arp));
128 eh->ether_type = htons(ETHERTYPE_IP);
129
130 bcopy((char *)ip, (char *)&ipsv, sizeof(*ip));
131 last_gw.s_addr = gwip.s_addr;
132 iplen = ip->ip_len;
133 ip->ip_len = htons(iplen);
134 if (!(frag & 2)) {
135 if (!IP_V(ip))
136 IP_V_A(ip, IPVERSION);
137 if (!ip->ip_id)
138 ip->ip_id = htons(id++);
139 if (!ip->ip_ttl)
140 ip->ip_ttl = 60;
141 }
142
143 if (ip->ip_src.s_addr != local_ip.s_addr) {
144 (void) arp((char *)&ip->ip_src, (char *)A_A local_arp);
145 bcopy(local_arp, (char *)A_A eh->ether_shost,sizeof(last_arp));
146 local_ip = ip->ip_src;
147 } else
148 bcopy(local_arp, (char *)A_A eh->ether_shost, 6);
149
150 if (!frag || (sizeof(*eh) + iplen < mtu))
151 {
152 ip->ip_sum = 0;
153 ip->ip_sum = chksum((u_short *)ip, IP_HL(ip) << 2);
154
155 bcopy((char *)ip, ipbuf + sizeof(*eh), iplen);
156 err = sendip(nfd, ipbuf, sizeof(*eh) + iplen);
157 }
158 else
159 {
160 /*
161 * Actually, this is bogus because we're putting all IP
162 * options in every packet, which isn't always what should be
163 * done. Will do for now.
164 */
165 ether_header_t eth;
166 char optcpy[48], ol;
167 char *s;
168 int i, sent = 0, ts, hlen, olen;
169
170 hlen = IP_HL(ip) << 2;
171 if (mtu < (hlen + 8)) {
172 fprintf(stderr, "mtu (%d) < ip header size (%d) + 8\n",
173 mtu, hlen);
174 fprintf(stderr, "can't fragment data\n");
175 return -2;
176 }
177 ol = (IP_HL(ip) << 2) - sizeof(*ip);
178 for (i = 0, s = (char*)(ip + 1); ol > 0; )
179 if (*s == IPOPT_EOL) {
180 optcpy[i++] = *s;
181 break;
182 } else if (*s == IPOPT_NOP) {
183 s++;
184 ol--;
185 } else
186 {
187 olen = (int)(*(u_char *)(s + 1));
188 ol -= olen;
189 if (IPOPT_COPIED(*s))
190 {
191 bcopy(s, optcpy + i, olen);
192 i += olen;
193 s += olen;
194 }
195 }
196 if (i)
197 {
198 /*
199 * pad out
200 */
201 while ((i & 3) && (i & 3) != 3)
202 optcpy[i++] = IPOPT_NOP;
203 if ((i & 3) == 3)
204 optcpy[i++] = IPOPT_EOL;
205 }
206
207 bcopy((char *)eh, (char *)&eth, sizeof(eth));
208 s = (char *)ip + hlen;
209 iplen = ntohs(ip->ip_len) - hlen;
210 ip->ip_off |= htons(IP_MF);
211
212 while (1)
213 {
214 if ((sent + (mtu - hlen)) >= iplen)
215 {
216 ip->ip_off ^= htons(IP_MF);
217 ts = iplen - sent;
218 }
219 else
220 ts = (mtu - hlen);
221 ip->ip_off &= htons(0xe000);
222 ip->ip_off |= htons(sent >> 3);
223 ts += hlen;
224 ip->ip_len = htons(ts);
225 ip->ip_sum = 0;
226 ip->ip_sum = chksum((u_short *)ip, hlen);
227 bcopy((char *)ip, ipbuf + sizeof(*eh), hlen);
228 bcopy(s + sent, ipbuf + sizeof(*eh) + hlen, ts - hlen);
229 err = sendip(nfd, ipbuf, sizeof(*eh) + ts);
230
231 bcopy((char *)&eth, ipbuf, sizeof(eth));
232 sent += (ts - hlen);
233 if (!(ntohs(ip->ip_off) & IP_MF))
234 break;
235 else if (!(ip->ip_off & htons(0x1fff)))
236 {
237 hlen = i + sizeof(*ip);
238 IP_HL_A(ip, (sizeof(*ip) + i) >> 2);
239 bcopy(optcpy, (char *)(ip + 1), i);
240 }
241 }
242 }
243
244 bcopy((char *)&ipsv, (char *)ip, sizeof(*ip));
245 return err;
246 }
247
248
249 /*
250 * send a tcp packet.
251 */
252 int send_tcp(nfd, mtu, ip, gwip)
253 int nfd, mtu;
254 ip_t *ip;
255 struct in_addr gwip;
256 {
257 static tcp_seq iss = 2;
258 tcphdr_t *t, *t2;
259 int thlen, i, iplen, hlen;
260 u_32_t lbuf[20];
261 ip_t *ip2;
262
263 iplen = ip->ip_len;
264 hlen = IP_HL(ip) << 2;
265 t = (tcphdr_t *)((char *)ip + hlen);
266 ip2 = (struct ip *)lbuf;
267 t2 = (tcphdr_t *)((char *)ip2 + sizeof(ip_t));
268 thlen = TCP_OFF(t) << 2;
269 if (!thlen)
270 thlen = sizeof(tcphdr_t);
271 bzero((char *)ip2, sizeof(*ip2) + sizeof(*t2));
272 ip->ip_p = IPPROTO_TCP;
273 ip2->ip_p = ip->ip_p;
274 ip2->ip_src = ip->ip_src;
275 ip2->ip_dst = ip->ip_dst;
276 bcopy((char *)ip + hlen, (char *)t2, thlen);
277
278 if (!t2->th_win)
279 t2->th_win = htons(4096);
280 iss += 63;
281
282 i = sizeof(struct tcpiphdr) / sizeof(long);
283
284 if ((t2->th_flags == TH_SYN) && !ntohs(ip->ip_off) &&
285 (lbuf[i] != htonl(0x020405b4))) {
286 lbuf[i] = htonl(0x020405b4);
287 bcopy((char *)ip + hlen + thlen, (char *)ip + hlen + thlen + 4,
288 iplen - thlen - hlen);
289 thlen += 4;
290 }
291 TCP_OFF_A(t2, thlen >> 2);
292 ip2->ip_len = htons(thlen);
293 ip->ip_len = hlen + thlen;
294 t2->th_sum = 0;
295 t2->th_sum = chksum((u_short *)ip2, thlen + sizeof(ip_t));
296
297 bcopy((char *)t2, (char *)ip + hlen, thlen);
298 return send_ip(nfd, mtu, ip, gwip, 1);
299 }
300
301
302 /*
303 * send a udp packet.
304 */
305 int send_udp(nfd, mtu, ip, gwip)
306 int nfd, mtu;
307 ip_t *ip;
308 struct in_addr gwip;
309 {
310 struct tcpiphdr *ti;
311 int thlen;
312 u_long lbuf[20];
313
314 ti = (struct tcpiphdr *)lbuf;
315 bzero((char *)ti, sizeof(*ti));
316 thlen = sizeof(udphdr_t);
317 ti->ti_pr = ip->ip_p;
318 ti->ti_src = ip->ip_src;
319 ti->ti_dst = ip->ip_dst;
320 bcopy((char *)ip + (IP_HL(ip) << 2),
321 (char *)&ti->ti_sport, sizeof(udphdr_t));
322
323 ti->ti_len = htons(thlen);
324 ip->ip_len = (IP_HL(ip) << 2) + thlen;
325 ti->ti_sum = 0;
326 ti->ti_sum = chksum((u_short *)ti, thlen + sizeof(ip_t));
327
328 bcopy((char *)&ti->ti_sport,
329 (char *)ip + (IP_HL(ip) << 2), sizeof(udphdr_t));
330 return send_ip(nfd, mtu, ip, gwip, 1);
331 }
332
333
334 /*
335 * send an icmp packet.
336 */
337 int send_icmp(nfd, mtu, ip, gwip)
338 int nfd, mtu;
339 ip_t *ip;
340 struct in_addr gwip;
341 {
342 struct icmp *ic;
343
344 ic = (struct icmp *)((char *)ip + (IP_HL(ip) << 2));
345
346 ic->icmp_cksum = 0;
347 ic->icmp_cksum = chksum((u_short *)ic, sizeof(struct icmp));
348
349 return send_ip(nfd, mtu, ip, gwip, 1);
350 }
351
352
353 int send_packet(nfd, mtu, ip, gwip)
354 int nfd, mtu;
355 ip_t *ip;
356 struct in_addr gwip;
357 {
358 switch (ip->ip_p)
359 {
360 case IPPROTO_TCP :
361 return send_tcp(nfd, mtu, ip, gwip);
362 case IPPROTO_UDP :
363 return send_udp(nfd, mtu, ip, gwip);
364 case IPPROTO_ICMP :
365 return send_icmp(nfd, mtu, ip, gwip);
366 default :
367 return send_ip(nfd, mtu, ip, gwip, 1);
368 }
369 }
NetBSD on the FriendlyARM MINI2440