1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 1996 - 2001 Brian Somers <[email protected]>
5 * based on work by Toshiharu OHNO <[email protected]>
6 * Internet Initiative Japan, Inc (IIJ)
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 *
30 * $FreeBSD$
31 */
32
33 #include <sys/param.h>
34 #include <sys/socket.h>
35 #include <netinet/in.h>
36 #include <netinet/in_systm.h>
37 #include <netinet/ip.h>
38 #ifndef NOINET6
39 #include <netinet/icmp6.h>
40 #include <netinet/ip6.h>
41 #endif
42 #include <netinet/ip_icmp.h>
43 #include <netinet/udp.h>
44 #include <netinet/tcp.h>
45 #include <sys/un.h>
46
47 #include <errno.h>
48 #include <netdb.h>
49 #include <stdio.h>
50 #include <string.h>
51 #include <termios.h>
52 #include <unistd.h>
53
54 #include "layer.h"
55 #include "proto.h"
56 #include "mbuf.h"
57 #include "log.h"
58 #include "defs.h"
59 #include "timer.h"
60 #include "fsm.h"
61 #include "lqr.h"
62 #include "hdlc.h"
63 #include "throughput.h"
64 #include "iplist.h"
65 #include "slcompress.h"
66 #include "ncpaddr.h"
67 #include "ip.h"
68 #include "ipcp.h"
69 #include "filter.h"
70 #include "descriptor.h"
71 #include "lcp.h"
72 #include "ccp.h"
73 #include "link.h"
74 #include "mp.h"
75 #ifndef NORADIUS
76 #include "radius.h"
77 #endif
78 #include "ipv6cp.h"
79 #include "ncp.h"
80 #include "bundle.h"
81 #include "tun.h"
82
83
84 #define OPCODE_QUERY 0
85 #define OPCODE_IQUERY 1
86 #define OPCODE_STATUS 2
87
88 struct dns_header {
89 u_short id;
90 unsigned qr : 1;
91 unsigned opcode : 4;
92 unsigned aa : 1;
93 unsigned tc : 1;
94 unsigned rd : 1;
95 unsigned ra : 1;
96 unsigned z : 3;
97 unsigned rcode : 4;
98 u_short qdcount;
99 u_short ancount;
100 u_short nscount;
101 u_short arcount;
102 };
103
104 static const char *
dns_Qclass2Txt(u_short qclass)105 dns_Qclass2Txt(u_short qclass)
106 {
107 static char failure[6];
108 struct {
109 u_short id;
110 const char *txt;
111 } qtxt[] = {
112 /* rfc1035 */
113 { 1, "IN" }, { 2, "CS" }, { 3, "CH" }, { 4, "HS" }, { 255, "*" }
114 };
115 unsigned f;
116
117 for (f = 0; f < sizeof qtxt / sizeof *qtxt; f++)
118 if (qtxt[f].id == qclass)
119 return qtxt[f].txt;
120
121 return HexStr(qclass, failure, sizeof failure);
122 }
123
124 static const char *
dns_Qtype2Txt(u_short qtype)125 dns_Qtype2Txt(u_short qtype)
126 {
127 static char failure[6];
128 struct {
129 u_short id;
130 const char *txt;
131 } qtxt[] = {
132 /* rfc1035/rfc1700 */
133 { 1, "A" }, { 2, "NS" }, { 3, "MD" }, { 4, "MF" }, { 5, "CNAME" },
134 { 6, "SOA" }, { 7, "MB" }, { 8, "MG" }, { 9, "MR" }, { 10, "NULL" },
135 { 11, "WKS" }, { 12, "PTR" }, { 13, "HINFO" }, { 14, "MINFO" },
136 { 15, "MX" }, { 16, "TXT" }, { 17, "RP" }, { 18, "AFSDB" },
137 { 19, "X25" }, { 20, "ISDN" }, { 21, "RT" }, { 22, "NSAP" },
138 { 23, "NSAP-PTR" }, { 24, "SIG" }, { 25, "KEY" }, { 26, "PX" },
139 { 27, "GPOS" }, { 28, "AAAA" }, { 252, "AXFR" }, { 253, "MAILB" },
140 { 254, "MAILA" }, { 255, "*" }
141 };
142 unsigned f;
143
144 for (f = 0; f < sizeof qtxt / sizeof *qtxt; f++)
145 if (qtxt[f].id == qtype)
146 return qtxt[f].txt;
147
148 return HexStr(qtype, failure, sizeof failure);
149 }
150
151 static __inline int
PortMatch(int op,u_short pport,u_short rport)152 PortMatch(int op, u_short pport, u_short rport)
153 {
154 switch (op) {
155 case OP_EQ:
156 return pport == rport;
157 case OP_GT:
158 return pport > rport;
159 case OP_LT:
160 return pport < rport;
161 default:
162 return 0;
163 }
164 }
165
166 /*
167 * Return a text string representing the cproto protocol number.
168 *
169 * The purpose of this routine is calculate this result, for
170 * the many times it is needed in FilterCheck, only on demand
171 * (i.e. when the corresponding logging functions are invoked).
172 *
173 * This optimization saves, over the previous implementation, which
174 * calculated prototxt at the beginning of FilterCheck, an
175 * open/read/close system call sequence per packet, approximately
176 * halving the ppp system overhead and reducing the overall (u + s)
177 * time by 38%.
178 *
179 * The caching performed here is just a side effect.
180 */
181 static const char *
prototxt(int cproto)182 prototxt(int cproto)
183 {
184 static int oproto = -1;
185 static char protobuff[16] = "-1";
186 struct protoent *pe;
187
188 if (cproto == oproto)
189 return protobuff;
190 if ((pe = getprotobynumber(cproto)) == NULL)
191 snprintf(protobuff, sizeof protobuff, "%d", cproto);
192 else
193 snprintf(protobuff, sizeof protobuff, "%s", pe->p_name);
194 oproto = cproto;
195 return (protobuff);
196 }
197
198 /*
199 * Check a packet against the given filter
200 * Returns 0 to accept the packet, non-zero to drop the packet.
201 * If psecs is not NULL, populate it with the timeout associated
202 * with the filter rule matched.
203 *
204 * If filtering is enabled, the initial fragment of a datagram must
205 * contain the complete protocol header, and subsequent fragments
206 * must not attempt to over-write it.
207 *
208 * One (and only one) of pip or pip6 must be set.
209 */
210 int
FilterCheck(const unsigned char * packet,u_int32_t family __unused,const struct filter * filter,unsigned * psecs)211 FilterCheck(const unsigned char *packet,
212 #ifdef NOINET6
213 u_int32_t family __unused,
214 #else
215 u_int32_t family,
216 #endif
217 const struct filter *filter, unsigned *psecs)
218 {
219 int gotinfo; /* true if IP payload decoded */
220 int cproto; /* IPPROTO_* protocol number if (gotinfo) */
221 int estab, syn, finrst; /* TCP state flags if (gotinfo) */
222 u_short sport, dport; /* src, dest port from packet if (gotinfo) */
223 int n; /* filter rule to process */
224 int len; /* bytes used in dbuff */
225 int didname; /* true if filter header printed */
226 int match; /* true if condition matched */
227 int mindata; /* minimum data size or zero */
228 const struct filterent *fp = filter->rule;
229 char dbuff[100], dstip[NCP_ASCIIBUFFERSIZE];
230 struct ncpaddr srcaddr, dstaddr;
231 const char *payload; /* IP payload */
232 int datalen; /* IP datagram length */
233
234 if (fp->f_action == A_NONE)
235 return 0; /* No rule is given. Permit this packet */
236
237 #ifndef NOINET6
238 if (family == AF_INET6) {
239 const struct ip6_hdr *pip6 = (const struct ip6_hdr *)packet;
240
241 ncpaddr_setip6(&srcaddr, &pip6->ip6_src);
242 ncpaddr_setip6(&dstaddr, &pip6->ip6_dst);
243 datalen = ntohs(pip6->ip6_plen);
244 payload = packet + sizeof *pip6;
245 cproto = pip6->ip6_nxt;
246 } else
247 #endif
248 {
249 /*
250 * Deny any packet fragment that tries to over-write the header.
251 * Since we no longer have the real header available, punt on the
252 * largest normal header - 20 bytes for TCP without options, rounded
253 * up to the next possible fragment boundary. Since the smallest
254 * `legal' MTU is 576, and the smallest recommended MTU is 296, any
255 * fragmentation within this range is dubious at best
256 */
257 const struct ip *pip = (const struct ip *)packet;
258
259 len = ntohs(pip->ip_off) & IP_OFFMASK; /* fragment offset */
260 if (len > 0) { /* Not first fragment within datagram */
261 if (len < (24 >> 3)) { /* don't allow fragment to over-write header */
262 log_Printf(LogFILTER, " error: illegal header\n");
263 return 1;
264 }
265 /* permit fragments on in and out filter */
266 if (!filter->fragok) {
267 log_Printf(LogFILTER, " error: illegal fragmentation\n");
268 return 1;
269 } else
270 return 0;
271 }
272
273 ncpaddr_setip4(&srcaddr, pip->ip_src);
274 ncpaddr_setip4(&dstaddr, pip->ip_dst);
275 datalen = ntohs(pip->ip_len) - (pip->ip_hl << 2);
276 payload = packet + (pip->ip_hl << 2);
277 cproto = pip->ip_p;
278 }
279
280
281 gotinfo = estab = syn = finrst = didname = 0;
282 sport = dport = 0;
283
284 for (n = 0; n < MAXFILTERS; ) {
285 if (fp->f_action == A_NONE) {
286 n++;
287 fp++;
288 continue;
289 }
290
291 if (!didname) {
292 log_Printf(LogDEBUG, "%s filter:\n", filter->name);
293 didname = 1;
294 }
295
296 match = 0;
297
298 if ((ncprange_family(&fp->f_src) == AF_UNSPEC ||
299 ncprange_contains(&fp->f_src, &srcaddr)) &&
300 (ncprange_family(&fp->f_dst) == AF_UNSPEC ||
301 ncprange_contains(&fp->f_dst, &dstaddr))) {
302 if (fp->f_proto != 0) {
303 if (!gotinfo) {
304 const struct tcphdr *th;
305 const struct udphdr *uh;
306 const struct icmp *ih;
307 #ifndef NOINET6
308 const struct icmp6_hdr *ih6;
309 #endif
310 mindata = 0;
311 sport = dport = 0;
312 estab = syn = finrst = -1;
313
314 switch (cproto) {
315 case IPPROTO_ICMP:
316 mindata = 8; /* ICMP must be at least 8 octets */
317 ih = (const struct icmp *)payload;
318 sport = ih->icmp_type;
319 if (log_IsKept(LogDEBUG))
320 snprintf(dbuff, sizeof dbuff, "sport = %d", sport);
321 break;
322
323 #ifndef NOINET6
324 case IPPROTO_ICMPV6:
325 mindata = 8; /* ICMP must be at least 8 octets */
326 ih6 = (const struct icmp6_hdr *)payload;
327 sport = ih6->icmp6_type;
328 if (log_IsKept(LogDEBUG))
329 snprintf(dbuff, sizeof dbuff, "sport = %d", sport);
330 break;
331 #endif
332
333 case IPPROTO_IGMP:
334 mindata = 8; /* IGMP uses 8-octet messages */
335 break;
336
337 #ifdef IPPROTO_GRE
338 case IPPROTO_GRE:
339 mindata = 2; /* GRE uses 2-octet+ messages */
340 break;
341 #endif
342 #ifdef IPPROTO_OSPFIGP
343 case IPPROTO_OSPFIGP:
344 mindata = 8; /* IGMP uses 8-octet messages */
345 break;
346 #endif
347 #ifndef NOINET6
348 case IPPROTO_IPV6:
349 mindata = 20; /* RFC2893 Section 3.5: 5 * 32bit words */
350 break;
351 #endif
352
353 case IPPROTO_UDP:
354 mindata = 8; /* UDP header is 8 octets */
355 uh = (const struct udphdr *)payload;
356 sport = ntohs(uh->uh_sport);
357 dport = ntohs(uh->uh_dport);
358 if (log_IsKept(LogDEBUG))
359 snprintf(dbuff, sizeof dbuff, "sport = %d, dport = %d",
360 sport, dport);
361 break;
362
363 case IPPROTO_TCP:
364 th = (const struct tcphdr *)payload;
365 /*
366 * TCP headers are variable length. The following code
367 * ensures that the TCP header length isn't de-referenced if
368 * the datagram is too short
369 */
370 if (datalen < 20 || datalen < (th->th_off << 2)) {
371 log_Printf(LogFILTER, " error: TCP header incorrect\n");
372 return 1;
373 }
374 sport = ntohs(th->th_sport);
375 dport = ntohs(th->th_dport);
376 estab = (th->th_flags & TH_ACK);
377 syn = (th->th_flags & TH_SYN);
378 finrst = (th->th_flags & (TH_FIN|TH_RST));
379 if (log_IsKept(LogDEBUG)) {
380 if (!estab)
381 snprintf(dbuff, sizeof dbuff,
382 "flags = %02x, sport = %d, dport = %d",
383 th->th_flags, sport, dport);
384 else
385 *dbuff = '\0';
386 }
387 break;
388 default:
389 break;
390 }
391
392 if (datalen < mindata) {
393 log_Printf(LogFILTER, " error: proto %s must be at least"
394 " %d octets\n", prototxt(cproto), mindata);
395 return 1;
396 }
397
398 if (log_IsKept(LogDEBUG)) {
399 if (estab != -1) {
400 len = strlen(dbuff);
401 snprintf(dbuff + len, sizeof dbuff - len,
402 ", estab = %d, syn = %d, finrst = %d",
403 estab, syn, finrst);
404 }
405 log_Printf(LogDEBUG, " Filter: proto = %s, %s\n",
406 prototxt(cproto), dbuff);
407 }
408 gotinfo = 1;
409 }
410
411 if (log_IsKept(LogDEBUG)) {
412 if (fp->f_srcop != OP_NONE) {
413 snprintf(dbuff, sizeof dbuff, ", src %s %d",
414 filter_Op2Nam(fp->f_srcop), fp->f_srcport);
415 len = strlen(dbuff);
416 } else
417 len = 0;
418 if (fp->f_dstop != OP_NONE) {
419 snprintf(dbuff + len, sizeof dbuff - len,
420 ", dst %s %d", filter_Op2Nam(fp->f_dstop),
421 fp->f_dstport);
422 } else if (!len)
423 *dbuff = '\0';
424
425 log_Printf(LogDEBUG, " rule = %d: Address match, "
426 "check against proto %d%s, action = %s\n",
427 n, fp->f_proto, dbuff, filter_Action2Nam(fp->f_action));
428 }
429
430 if (cproto == fp->f_proto) {
431 if ((fp->f_srcop == OP_NONE ||
432 PortMatch(fp->f_srcop, sport, fp->f_srcport)) &&
433 (fp->f_dstop == OP_NONE ||
434 PortMatch(fp->f_dstop, dport, fp->f_dstport)) &&
435 (fp->f_estab == 0 || estab) &&
436 (fp->f_syn == 0 || syn) &&
437 (fp->f_finrst == 0 || finrst)) {
438 match = 1;
439 }
440 }
441 } else {
442 /* Address is matched and no protocol specified. Make a decision. */
443 log_Printf(LogDEBUG, " rule = %d: Address match, action = %s\n", n,
444 filter_Action2Nam(fp->f_action));
445 match = 1;
446 }
447 } else
448 log_Printf(LogDEBUG, " rule = %d: Address mismatch\n", n);
449
450 if (match != fp->f_invert) {
451 /* Take specified action */
452 if (fp->f_action < A_NONE)
453 fp = &filter->rule[n = fp->f_action];
454 else {
455 if (fp->f_action == A_PERMIT) {
456 if (psecs != NULL)
457 *psecs = fp->timeout;
458 if (strcmp(filter->name, "DIAL") == 0) {
459 /* If dial filter then even print out accept packets */
460 if (log_IsKept(LogFILTER)) {
461 snprintf(dstip, sizeof dstip, "%s", ncpaddr_ntoa(&dstaddr));
462 log_Printf(LogFILTER, "%sbound rule = %d accept %s "
463 "src = %s:%d dst = %s:%d\n", filter->name, n,
464 prototxt(cproto), ncpaddr_ntoa(&srcaddr), sport,
465 dstip, dport);
466 }
467 }
468 return 0;
469 } else {
470 if (log_IsKept(LogFILTER)) {
471 snprintf(dstip, sizeof dstip, "%s", ncpaddr_ntoa(&dstaddr));
472 log_Printf(LogFILTER,
473 "%sbound rule = %d deny %s src = %s/%d dst = %s/%d\n",
474 filter->name, n, prototxt(cproto),
475 ncpaddr_ntoa(&srcaddr), sport, dstip, dport);
476 }
477 return 1;
478 } /* Explicit match. Deny this packet */
479 }
480 } else {
481 n++;
482 fp++;
483 }
484 }
485
486 if (log_IsKept(LogFILTER)) {
487 snprintf(dstip, sizeof dstip, "%s", ncpaddr_ntoa(&dstaddr));
488 log_Printf(LogFILTER,
489 "%sbound rule = implicit deny %s src = %s/%d dst = %s/%d\n",
490 filter->name, prototxt(cproto), ncpaddr_ntoa(&srcaddr),
491 sport, dstip, dport);
492 }
493
494 return 1; /* No rule matched, deny this packet */
495 }
496
497 static void
ip_LogDNS(const struct udphdr * uh,const char * direction)498 ip_LogDNS(const struct udphdr *uh, const char *direction)
499 {
500 struct dns_header header;
501 const u_short *pktptr;
502 const u_char *ptr;
503 u_short *hptr, tmp;
504 unsigned len;
505
506 ptr = (const char *)uh + sizeof *uh;
507 len = ntohs(uh->uh_ulen) - sizeof *uh;
508 if (len < sizeof header + 5) /* rfc1024 */
509 return;
510
511 pktptr = (const u_short *)ptr;
512 hptr = (u_short *)&header;
513 ptr += sizeof header;
514 len -= sizeof header;
515
516 while (pktptr < (const u_short *)ptr) {
517 *hptr++ = ntohs(*pktptr); /* Careful of macro side-effects ! */
518 pktptr++;
519 }
520
521 if (header.opcode == OPCODE_QUERY && header.qr == 0) {
522 /* rfc1035 */
523 char namewithdot[MAXHOSTNAMELEN + 1], *n;
524 const char *qtype, *qclass;
525 const u_char *end;
526
527 n = namewithdot;
528 end = ptr + len - 4;
529 if (end - ptr >= (int)sizeof namewithdot)
530 end = ptr + sizeof namewithdot - 1;
531 while (ptr < end) {
532 len = *ptr++;
533 if ((int)len > end - ptr)
534 len = end - ptr;
535 if (n != namewithdot)
536 *n++ = '.';
537 memcpy(n, ptr, len);
538 ptr += len;
539 n += len;
540 }
541 *n = '\0';
542
543 if (log_IsKept(LogDNS)) {
544 memcpy(&tmp, end, sizeof tmp);
545 qtype = dns_Qtype2Txt(ntohs(tmp));
546 memcpy(&tmp, end + 2, sizeof tmp);
547 qclass = dns_Qclass2Txt(ntohs(tmp));
548
549 log_Printf(LogDNS, "%sbound query %s %s %s\n",
550 direction, qclass, qtype, namewithdot);
551 }
552 }
553 }
554
555 /*
556 * Check if the given packet matches the given filter.
557 * One of pip or pip6 must be set.
558 */
559 int
PacketCheck(struct bundle * bundle,u_int32_t family,const unsigned char * packet,int nb,struct filter * filter,const char * prefix,unsigned * psecs)560 PacketCheck(struct bundle *bundle, u_int32_t family,
561 const unsigned char *packet, int nb, struct filter *filter,
562 const char *prefix, unsigned *psecs)
563 {
564 char logbuf[200];
565 static const char *const TcpFlags[] = {
566 "FIN", "SYN", "RST", "PSH", "ACK", "URG"
567 };
568 const struct tcphdr *th;
569 const struct udphdr *uh;
570 const struct icmp *icmph;
571 #ifndef NOINET6
572 const struct icmp6_hdr *icmp6h;
573 #endif
574 const unsigned char *payload;
575 struct ncpaddr srcaddr, dstaddr;
576 int cproto, mask, len, n, pri, logit, result, datalen, frag;
577 unsigned loglen;
578 u_char tos;
579
580 logit = (log_IsKept(LogTCPIP) || log_IsKept(LogDNS)) &&
581 (!filter || filter->logok);
582 loglen = 0;
583 pri = 0;
584
585 #ifndef NOINET6
586 if (family == AF_INET6) {
587 const struct ip6_hdr *pip6 = (const struct ip6_hdr *)packet;
588
589 ncpaddr_setip6(&srcaddr, &pip6->ip6_src);
590 ncpaddr_setip6(&dstaddr, &pip6->ip6_dst);
591 datalen = ntohs(pip6->ip6_plen);
592 payload = packet + sizeof *pip6;
593 cproto = pip6->ip6_nxt;
594 tos = 0; /* XXX: pip6->ip6_vfc >> 4 ? */
595 frag = 0; /* XXX: ??? */
596 } else
597 #endif
598 {
599 const struct ip *pip = (const struct ip *)packet;
600
601 ncpaddr_setip4(&srcaddr, pip->ip_src);
602 ncpaddr_setip4(&dstaddr, pip->ip_dst);
603 datalen = ntohs(pip->ip_len) - (pip->ip_hl << 2);
604 payload = packet + (pip->ip_hl << 2);
605 cproto = pip->ip_p;
606 tos = pip->ip_tos;
607 frag = ntohs(pip->ip_off) & IP_OFFMASK;
608 }
609
610 uh = NULL;
611
612 if (logit && loglen < sizeof logbuf) {
613 if (prefix)
614 snprintf(logbuf + loglen, sizeof logbuf - loglen, "%s", prefix);
615 else if (filter)
616 snprintf(logbuf + loglen, sizeof logbuf - loglen, "%s ", filter->name);
617 else
618 snprintf(logbuf + loglen, sizeof logbuf - loglen, " ");
619 loglen += strlen(logbuf + loglen);
620 }
621
622 switch (cproto) {
623 case IPPROTO_ICMP:
624 if (logit && loglen < sizeof logbuf) {
625 len = datalen - sizeof *icmph;
626 icmph = (const struct icmp *)payload;
627 snprintf(logbuf + loglen, sizeof logbuf - loglen,
628 "ICMP: %s:%d ---> ", ncpaddr_ntoa(&srcaddr), icmph->icmp_type);
629 loglen += strlen(logbuf + loglen);
630 snprintf(logbuf + loglen, sizeof logbuf - loglen,
631 "%s (%d/%d)", ncpaddr_ntoa(&dstaddr), len, nb);
632 loglen += strlen(logbuf + loglen);
633 }
634 break;
635
636 #ifndef NOINET6
637 case IPPROTO_ICMPV6:
638 if (logit && loglen < sizeof logbuf) {
639 len = datalen - sizeof *icmp6h;
640 icmp6h = (const struct icmp6_hdr *)payload;
641 snprintf(logbuf + loglen, sizeof logbuf - loglen,
642 "ICMP: %s:%d ---> ", ncpaddr_ntoa(&srcaddr), icmp6h->icmp6_type);
643 loglen += strlen(logbuf + loglen);
644 snprintf(logbuf + loglen, sizeof logbuf - loglen,
645 "%s (%d/%d)", ncpaddr_ntoa(&dstaddr), len, nb);
646 loglen += strlen(logbuf + loglen);
647 }
648 break;
649 #endif
650
651 case IPPROTO_UDP:
652 uh = (const struct udphdr *)payload;
653 if (tos == IPTOS_LOWDELAY && bundle->ncp.cfg.urgent.tos)
654 pri++;
655
656 if (!frag && ncp_IsUrgentUdpPort(&bundle->ncp, ntohs(uh->uh_sport),
657 ntohs(uh->uh_dport)))
658 pri++;
659
660 if (logit && loglen < sizeof logbuf) {
661 len = datalen - sizeof *uh;
662 snprintf(logbuf + loglen, sizeof logbuf - loglen,
663 "UDP: %s:%d ---> ", ncpaddr_ntoa(&srcaddr), ntohs(uh->uh_sport));
664 loglen += strlen(logbuf + loglen);
665 snprintf(logbuf + loglen, sizeof logbuf - loglen,
666 "%s:%d (%d/%d)", ncpaddr_ntoa(&dstaddr), ntohs(uh->uh_dport),
667 len, nb);
668 loglen += strlen(logbuf + loglen);
669 }
670
671 if (Enabled(bundle, OPT_FILTERDECAP) &&
672 payload[sizeof *uh] == HDLC_ADDR &&
673 payload[sizeof *uh + 1] == HDLC_UI) {
674 u_short proto;
675 const char *type;
676
677 memcpy(&proto, payload + sizeof *uh + 2, sizeof proto);
678 type = NULL;
679
680 switch (ntohs(proto)) {
681 case PROTO_IP:
682 snprintf(logbuf + loglen, sizeof logbuf - loglen, " contains ");
683 result = PacketCheck(bundle, AF_INET, payload + sizeof *uh + 4,
684 nb - (payload - packet) - sizeof *uh - 4, filter,
685 logbuf, psecs);
686 if (result != -2)
687 return result;
688 type = "IP";
689 break;
690
691 case PROTO_VJUNCOMP: type = "compressed VJ"; break;
692 case PROTO_VJCOMP: type = "uncompressed VJ"; break;
693 case PROTO_MP: type = "Multi-link"; break;
694 case PROTO_ICOMPD: type = "Individual link CCP"; break;
695 case PROTO_COMPD: type = "CCP"; break;
696 case PROTO_IPCP: type = "IPCP"; break;
697 case PROTO_LCP: type = "LCP"; break;
698 case PROTO_PAP: type = "PAP"; break;
699 case PROTO_CBCP: type = "CBCP"; break;
700 case PROTO_LQR: type = "LQR"; break;
701 case PROTO_CHAP: type = "CHAP"; break;
702 }
703 if (type) {
704 snprintf(logbuf + loglen, sizeof logbuf - loglen,
705 " - %s data", type);
706 loglen += strlen(logbuf + loglen);
707 }
708 }
709
710 break;
711
712 #ifdef IPPROTO_GRE
713 case IPPROTO_GRE:
714 if (logit && loglen < sizeof logbuf) {
715 snprintf(logbuf + loglen, sizeof logbuf - loglen,
716 "GRE: %s ---> ", ncpaddr_ntoa(&srcaddr));
717 loglen += strlen(logbuf + loglen);
718 snprintf(logbuf + loglen, sizeof logbuf - loglen,
719 "%s (%d/%d)", ncpaddr_ntoa(&dstaddr), datalen, nb);
720 loglen += strlen(logbuf + loglen);
721 }
722 break;
723 #endif
724
725 #ifdef IPPROTO_OSPFIGP
726 case IPPROTO_OSPFIGP:
727 if (logit && loglen < sizeof logbuf) {
728 snprintf(logbuf + loglen, sizeof logbuf - loglen,
729 "OSPF: %s ---> ", ncpaddr_ntoa(&srcaddr));
730 loglen += strlen(logbuf + loglen);
731 snprintf(logbuf + loglen, sizeof logbuf - loglen,
732 "%s (%d/%d)", ncpaddr_ntoa(&dstaddr), datalen, nb);
733 loglen += strlen(logbuf + loglen);
734 }
735 break;
736 #endif
737
738 #ifndef NOINET6
739 case IPPROTO_IPV6:
740 if (logit && loglen < sizeof logbuf) {
741 snprintf(logbuf + loglen, sizeof logbuf - loglen,
742 "IPv6: %s ---> ", ncpaddr_ntoa(&srcaddr));
743 loglen += strlen(logbuf + loglen);
744 snprintf(logbuf + loglen, sizeof logbuf - loglen,
745 "%s (%d/%d)", ncpaddr_ntoa(&dstaddr), datalen, nb);
746 loglen += strlen(logbuf + loglen);
747 }
748
749 if (Enabled(bundle, OPT_FILTERDECAP)) {
750 snprintf(logbuf + loglen, sizeof logbuf - loglen, " contains ");
751 result = PacketCheck(bundle, AF_INET6, payload, nb - (payload - packet),
752 filter, logbuf, psecs);
753 if (result != -2)
754 return result;
755 }
756 break;
757 #endif
758
759 case IPPROTO_IPIP:
760 if (logit && loglen < sizeof logbuf) {
761 snprintf(logbuf + loglen, sizeof logbuf - loglen,
762 "IPIP: %s ---> ", ncpaddr_ntoa(&srcaddr));
763 loglen += strlen(logbuf + loglen);
764 snprintf(logbuf + loglen, sizeof logbuf - loglen,
765 "%s", ncpaddr_ntoa(&dstaddr));
766 loglen += strlen(logbuf + loglen);
767 }
768
769 if (Enabled(bundle, OPT_FILTERDECAP) &&
770 ((const struct ip *)payload)->ip_v == 4) {
771 snprintf(logbuf + loglen, sizeof logbuf - loglen, " contains ");
772 result = PacketCheck(bundle, AF_INET, payload, nb - (payload - packet),
773 filter, logbuf, psecs);
774 loglen += strlen(logbuf + loglen);
775 if (result != -2)
776 return result;
777 }
778 break;
779
780 case IPPROTO_ESP:
781 if (logit && loglen < sizeof logbuf) {
782 snprintf(logbuf + loglen, sizeof logbuf - loglen,
783 "ESP: %s ---> ", ncpaddr_ntoa(&srcaddr));
784 loglen += strlen(logbuf + loglen);
785 snprintf(logbuf + loglen, sizeof logbuf - loglen, "%s, spi %p",
786 ncpaddr_ntoa(&dstaddr), payload);
787 loglen += strlen(logbuf + loglen);
788 }
789 break;
790
791 case IPPROTO_AH:
792 if (logit && loglen < sizeof logbuf) {
793 snprintf(logbuf + loglen, sizeof logbuf - loglen,
794 "AH: %s ---> ", ncpaddr_ntoa(&srcaddr));
795 loglen += strlen(logbuf + loglen);
796 snprintf(logbuf + loglen, sizeof logbuf - loglen, "%s, spi %p",
797 ncpaddr_ntoa(&dstaddr), payload + sizeof(u_int32_t));
798 loglen += strlen(logbuf + loglen);
799 }
800 break;
801
802 case IPPROTO_IGMP:
803 if (logit && loglen < sizeof logbuf) {
804 uh = (const struct udphdr *)payload;
805 snprintf(logbuf + loglen, sizeof logbuf - loglen,
806 "IGMP: %s:%d ---> ", ncpaddr_ntoa(&srcaddr),
807 ntohs(uh->uh_sport));
808 loglen += strlen(logbuf + loglen);
809 snprintf(logbuf + loglen, sizeof logbuf - loglen,
810 "%s:%d", ncpaddr_ntoa(&dstaddr), ntohs(uh->uh_dport));
811 loglen += strlen(logbuf + loglen);
812 }
813 break;
814
815 case IPPROTO_TCP:
816 th = (const struct tcphdr *)payload;
817 if (tos == IPTOS_LOWDELAY && bundle->ncp.cfg.urgent.tos)
818 pri++;
819
820 if (!frag && ncp_IsUrgentTcpPort(&bundle->ncp, ntohs(th->th_sport),
821 ntohs(th->th_dport)))
822 pri++;
823 else if (!frag && ncp_IsUrgentTcpLen(&bundle->ncp, datalen))
824 pri++;
825
826 if (logit && loglen < sizeof logbuf) {
827 len = datalen - (th->th_off << 2);
828 snprintf(logbuf + loglen, sizeof logbuf - loglen,
829 "TCP: %s:%d ---> ", ncpaddr_ntoa(&srcaddr), ntohs(th->th_sport));
830 loglen += strlen(logbuf + loglen);
831 snprintf(logbuf + loglen, sizeof logbuf - loglen,
832 "%s:%d", ncpaddr_ntoa(&dstaddr), ntohs(th->th_dport));
833 loglen += strlen(logbuf + loglen);
834 n = 0;
835 for (mask = TH_FIN; mask != 0x40; mask <<= 1) {
836 if (th->th_flags & mask) {
837 snprintf(logbuf + loglen, sizeof logbuf - loglen, " %s", TcpFlags[n]);
838 loglen += strlen(logbuf + loglen);
839 }
840 n++;
841 }
842 snprintf(logbuf + loglen, sizeof logbuf - loglen,
843 " seq:%lx ack:%lx (%d/%d)",
844 (u_long)ntohl(th->th_seq), (u_long)ntohl(th->th_ack), len, nb);
845 loglen += strlen(logbuf + loglen);
846 if ((th->th_flags & TH_SYN) && nb > 40) {
847 const u_short *sp;
848
849 sp = (const u_short *)(payload + 20);
850 if (ntohs(sp[0]) == 0x0204) {
851 snprintf(logbuf + loglen, sizeof logbuf - loglen,
852 " MSS = %d", ntohs(sp[1]));
853 loglen += strlen(logbuf + loglen);
854 }
855 }
856 snprintf(logbuf + loglen, sizeof logbuf - loglen, " pri:%d", pri);
857 loglen += strlen(logbuf + loglen);
858 }
859 break;
860
861 default:
862 if (prefix)
863 return -2;
864
865 if (logit && loglen < sizeof logbuf) {
866 snprintf(logbuf + loglen, sizeof logbuf - loglen,
867 "<%d>: %s ---> ", cproto, ncpaddr_ntoa(&srcaddr));
868 loglen += strlen(logbuf + loglen);
869 snprintf(logbuf + loglen, sizeof logbuf - loglen,
870 "%s (%d)", ncpaddr_ntoa(&dstaddr), nb);
871 loglen += strlen(logbuf + loglen);
872 }
873 break;
874 }
875
876 if (filter && FilterCheck(packet, family, filter, psecs)) {
877 if (logit)
878 log_Printf(LogTCPIP, "%s - BLOCKED\n", logbuf);
879 result = -1;
880 } else {
881 /* Check Keep Alive filter */
882 if (logit && log_IsKept(LogTCPIP)) {
883 unsigned alivesecs;
884
885 alivesecs = 0;
886 if (filter &&
887 FilterCheck(packet, family, &bundle->filter.alive, &alivesecs))
888 log_Printf(LogTCPIP, "%s - NO KEEPALIVE\n", logbuf);
889 else if (psecs != NULL) {
890 if(*psecs == 0)
891 *psecs = alivesecs;
892 if (*psecs) {
893 if (*psecs != alivesecs)
894 log_Printf(LogTCPIP, "%s - (timeout = %d / ALIVE = %d secs)\n",
895 logbuf, *psecs, alivesecs);
896 else
897 log_Printf(LogTCPIP, "%s - (timeout = %d secs)\n", logbuf, *psecs);
898 } else
899 log_Printf(LogTCPIP, "%s\n", logbuf);
900 }
901 }
902 result = pri;
903 }
904
905 if (filter && uh && ntohs(uh->uh_dport) == 53 && log_IsKept(LogDNS))
906 ip_LogDNS(uh, filter->name);
907
908 return result;
909 }
910
911 static size_t
ip_Input(struct bundle * bundle,struct link * l,struct mbuf * bp,u_int32_t af)912 ip_Input(struct bundle *bundle, struct link *l, struct mbuf *bp, u_int32_t af)
913 {
914 ssize_t nw;
915 size_t nb;
916 struct tun_data tun;
917 char *data;
918 unsigned secs, alivesecs;
919
920 nb = m_length(bp);
921 if (nb > sizeof tun.data) {
922 log_Printf(LogWARN, "ip_Input: %s: Packet too large (got %zd, max %d)\n",
923 l->name, nb, (int)(sizeof tun.data));
924 m_freem(bp);
925 return 0;
926 }
927 mbuf_Read(bp, tun.data, nb);
928
929 secs = 0;
930 if (PacketCheck(bundle, af, tun.data, nb, &bundle->filter.in,
931 NULL, &secs) < 0)
932 return 0;
933
934 alivesecs = 0;
935 if (!FilterCheck(tun.data, af, &bundle->filter.alive, &alivesecs)) {
936 if (secs == 0)
937 secs = alivesecs;
938 bundle_StartIdleTimer(bundle, secs);
939 }
940
941 if (bundle->dev.header) {
942 tun.header.family = htonl(af);
943 nb += sizeof tun - sizeof tun.data;
944 data = (char *)&tun;
945 } else
946 data = tun.data;
947
948 nw = write(bundle->dev.fd, data, nb);
949 if (nw != (ssize_t)nb) {
950 if (nw == -1)
951 log_Printf(LogERROR, "ip_Input: %s: wrote %zd, got %s\n",
952 l->name, nb, strerror(errno));
953 else
954 log_Printf(LogERROR, "ip_Input: %s: wrote %zd, got %zd\n", l->name, nb,
955 nw);
956 }
957
958 return nb;
959 }
960
961 struct mbuf *
ipv4_Input(struct bundle * bundle,struct link * l,struct mbuf * bp)962 ipv4_Input(struct bundle *bundle, struct link *l, struct mbuf *bp)
963 {
964 int nb;
965
966 if (bundle->ncp.ipcp.fsm.state != ST_OPENED) {
967 log_Printf(LogWARN, "ipv4_Input: IPCP not open - packet dropped\n");
968 m_freem(bp);
969 return NULL;
970 }
971
972 m_settype(bp, MB_IPIN);
973
974 nb = ip_Input(bundle, l, bp, AF_INET);
975 ipcp_AddInOctets(&bundle->ncp.ipcp, nb);
976
977 return NULL;
978 }
979
980 #ifndef NOINET6
981 struct mbuf *
ipv6_Input(struct bundle * bundle,struct link * l,struct mbuf * bp)982 ipv6_Input(struct bundle *bundle, struct link *l, struct mbuf *bp)
983 {
984 int nb;
985
986 if (bundle->ncp.ipv6cp.fsm.state != ST_OPENED) {
987 log_Printf(LogWARN, "ipv6_Input: IPV6CP not open - packet dropped\n");
988 m_freem(bp);
989 return NULL;
990 }
991
992 m_settype(bp, MB_IPV6IN);
993
994 nb = ip_Input(bundle, l, bp, AF_INET6);
995 ipv6cp_AddInOctets(&bundle->ncp.ipv6cp, nb);
996
997 return NULL;
998 }
999 #endif
1000