1 /*
2 * demand.c - Support routines for demand-dialling.
3 *
4 * Copyright (c) 1996-2002 Paul Mackerras. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 *
13 * 2. The name(s) of the authors of this software must not be used to
14 * endorse or promote products derived from this software without
15 * prior written permission.
16 *
17 * 3. Redistributions of any form whatsoever must retain the following
18 * acknowledgment:
19 * "This product includes software developed by Paul Mackerras
20 * <paulus@samba.org>".
21 *
22 * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
23 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
24 * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
25 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
26 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
27 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
28 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
29 */
30
31 #define RCSID "$Id: demand.c,v 1.20 2005/08/25 12:14:18 paulus Exp $"
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <errno.h>
37 #include <fcntl.h>
38 #include <netdb.h>
39 #include <sys/param.h>
40 #include <sys/types.h>
41 #include <sys/wait.h>
42 #include <sys/time.h>
43 #include <sys/resource.h>
44 #include <sys/stat.h>
45 #include <sys/socket.h>
46 #ifdef PPP_FILTER
47 #include <pcap-bpf.h>
48 #endif
49
50 #include "pppd.h"
51 #include "fsm.h"
52 #include "ipcp.h"
53 #include "lcp.h"
54
55 static const char rcsid[] = RCSID;
56
57 char *frame;
58 int framelen;
59 int framemax;
60 int escape_flag;
61 int flush_flag;
62 int fcs;
63
64 struct packet {
65 int length;
66 struct packet *next;
67 unsigned char data[1];
68 };
69
70 struct packet *pend_q;
71 struct packet *pend_qtail;
72
73 static int active_packet __P((unsigned char *, int));
74
75 /*
76 * demand_conf - configure the interface for doing dial-on-demand.
77 */
78 void
demand_conf()79 demand_conf()
80 {
81 int i;
82 struct protent *protp;
83
84 /* framemax = lcp_allowoptions[0].mru;
85 if (framemax < PPP_MRU) */
86 framemax = PPP_MRU;
87 framemax += PPP_HDRLEN + PPP_FCSLEN;
88 frame = malloc(framemax);
89 if (frame == NULL)
90 novm("demand frame");
91 framelen = 0;
92 pend_q = NULL;
93 escape_flag = 0;
94 flush_flag = 0;
95 fcs = PPP_INITFCS;
96
97 netif_set_mtu(0, MIN(lcp_allowoptions[0].mru, PPP_MRU));
98 if (ppp_send_config(0, PPP_MRU, (u_int32_t) 0, 0, 0) < 0
99 || ppp_recv_config(0, PPP_MRU, (u_int32_t) 0, 0, 0) < 0)
100 fatal("Couldn't set up demand-dialled PPP interface: %m");
101
102 #ifdef PPP_FILTER
103 set_filters(&pass_filter, &active_filter);
104 #endif
105
106 /*
107 * Call the demand_conf procedure for each protocol that's got one.
108 */
109 for (i = 0; (protp = protocols[i]) != NULL; ++i)
110 if (protp->enabled_flag && protp->demand_conf != NULL)
111 if (!((*protp->demand_conf)(0)))
112 die(1);
113 }
114
115
116 /*
117 * demand_block - set each network protocol to block further packets.
118 */
119 void
demand_block()120 demand_block()
121 {
122 int i;
123 struct protent *protp;
124
125 for (i = 0; (protp = protocols[i]) != NULL; ++i)
126 if (protp->enabled_flag && protp->demand_conf != NULL)
127 sifnpmode(0, protp->protocol & ~0x8000, NPMODE_QUEUE);
128 get_loop_output();
129 }
130
131 /*
132 * demand_discard - set each network protocol to discard packets
133 * with an error.
134 */
135 void
demand_discard()136 demand_discard()
137 {
138 struct packet *pkt, *nextpkt;
139 int i;
140 struct protent *protp;
141
142 for (i = 0; (protp = protocols[i]) != NULL; ++i)
143 if (protp->enabled_flag && protp->demand_conf != NULL)
144 sifnpmode(0, protp->protocol & ~0x8000, NPMODE_ERROR);
145 get_loop_output();
146
147 /* discard all saved packets */
148 for (pkt = pend_q; pkt != NULL; pkt = nextpkt) {
149 nextpkt = pkt->next;
150 free(pkt);
151 }
152 pend_q = NULL;
153 framelen = 0;
154 flush_flag = 0;
155 escape_flag = 0;
156 fcs = PPP_INITFCS;
157 }
158
159 /*
160 * demand_unblock - set each enabled network protocol to pass packets.
161 */
162 void
demand_unblock()163 demand_unblock()
164 {
165 int i;
166 struct protent *protp;
167
168 for (i = 0; (protp = protocols[i]) != NULL; ++i)
169 if (protp->enabled_flag && protp->demand_conf != NULL)
170 sifnpmode(0, protp->protocol & ~0x8000, NPMODE_PASS);
171 }
172
173 /*
174 * FCS lookup table as calculated by genfcstab.
175 */
176 static u_short fcstab[256] = {
177 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
178 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
179 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
180 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
181 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
182 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
183 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
184 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
185 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
186 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
187 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
188 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
189 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
190 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
191 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
192 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
193 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
194 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
195 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
196 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
197 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
198 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
199 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
200 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
201 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
202 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
203 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
204 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
205 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
206 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
207 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
208 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
209 };
210
211 /*
212 * loop_chars - process characters received from the loopback.
213 * Calls loop_frame when a complete frame has been accumulated.
214 * Return value is 1 if we need to bring up the link, 0 otherwise.
215 */
216 int
loop_chars(p,n)217 loop_chars(p, n)
218 unsigned char *p;
219 int n;
220 {
221 int c, rv;
222
223 rv = 0;
224 for (; n > 0; --n) {
225 c = *p++;
226 if (c == PPP_FLAG) {
227 if (!escape_flag && !flush_flag
228 && framelen > 2 && fcs == PPP_GOODFCS) {
229 framelen -= 2;
230 if (loop_frame((unsigned char *)frame, framelen))
231 rv = 1;
232 }
233 framelen = 0;
234 flush_flag = 0;
235 escape_flag = 0;
236 fcs = PPP_INITFCS;
237 continue;
238 }
239 if (flush_flag)
240 continue;
241 if (escape_flag) {
242 c ^= PPP_TRANS;
243 escape_flag = 0;
244 } else if (c == PPP_ESCAPE) {
245 escape_flag = 1;
246 continue;
247 }
248 if (framelen >= framemax) {
249 flush_flag = 1;
250 continue;
251 }
252 frame[framelen++] = c;
253 fcs = PPP_FCS(fcs, c);
254 }
255 return rv;
256 }
257
258 /*
259 * loop_frame - given a frame obtained from the loopback,
260 * decide whether to bring up the link or not, and, if we want
261 * to transmit this frame later, put it on the pending queue.
262 * Return value is 1 if we need to bring up the link, 0 otherwise.
263 * We assume that the kernel driver has already applied the
264 * pass_filter, so we won't get packets it rejected.
265 * We apply the active_filter to see if we want this packet to
266 * bring up the link.
267 */
268 int
loop_frame(frame,len)269 loop_frame(frame, len)
270 unsigned char *frame;
271 int len;
272 {
273 struct packet *pkt;
274
275 /* dbglog("from loop: %P", frame, len); */
276 if (len < PPP_HDRLEN)
277 return 0;
278 if ((PPP_PROTOCOL(frame) & 0x8000) != 0)
279 return 0; /* shouldn't get any of these anyway */
280 if (!active_packet(frame, len))
281 return 0;
282
283 pkt = (struct packet *) malloc(sizeof(struct packet) + len);
284 if (pkt != NULL) {
285 pkt->length = len;
286 pkt->next = NULL;
287 memcpy(pkt->data, frame, len);
288 if (pend_q == NULL)
289 pend_q = pkt;
290 else
291 pend_qtail->next = pkt;
292 pend_qtail = pkt;
293 }
294 return 1;
295 }
296
297 /*
298 * demand_rexmit - Resend all those frames which we got via the
299 * loopback, now that the real serial link is up.
300 */
301 void
demand_rexmit(proto)302 demand_rexmit(proto)
303 int proto;
304 {
305 struct packet *pkt, *prev, *nextpkt;
306
307 prev = NULL;
308 pkt = pend_q;
309 pend_q = NULL;
310 for (; pkt != NULL; pkt = nextpkt) {
311 nextpkt = pkt->next;
312 if (PPP_PROTOCOL(pkt->data) == proto) {
313 output(0, pkt->data, pkt->length);
314 free(pkt);
315 } else {
316 if (prev == NULL)
317 pend_q = pkt;
318 else
319 prev->next = pkt;
320 prev = pkt;
321 }
322 }
323 pend_qtail = prev;
324 if (prev != NULL)
325 prev->next = NULL;
326 }
327
328 /*
329 * Scan a packet to decide whether it is an "active" packet,
330 * that is, whether it is worth bringing up the link for.
331 */
332 static int
active_packet(p,len)333 active_packet(p, len)
334 unsigned char *p;
335 int len;
336 {
337 int proto, i;
338 struct protent *protp;
339
340 if (len < PPP_HDRLEN)
341 return 0;
342 proto = PPP_PROTOCOL(p);
343 #ifdef PPP_FILTER
344 p[0] = 1; /* outbound packet indicator */
345 if ((pass_filter.bf_len != 0
346 && bpf_filter(pass_filter.bf_insns, p, len, len) == 0)
347 || (active_filter.bf_len != 0
348 && bpf_filter(active_filter.bf_insns, p, len, len) == 0)) {
349 p[0] = 0xff;
350 return 0;
351 }
352 p[0] = 0xff;
353 #endif
354 for (i = 0; (protp = protocols[i]) != NULL; ++i) {
355 if (protp->protocol < 0xC000 && (protp->protocol & ~0x8000) == proto) {
356 if (!protp->enabled_flag)
357 return 0;
358 if (protp->active_pkt == NULL)
359 return 1;
360 return (*protp->active_pkt)(p, len);
361 }
362 }
363 return 0; /* not a supported protocol !!?? */
364 }
365