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 (at) 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 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 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 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 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 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 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 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 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
