Lee Kai Xuan
/
mbed-os
Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Fork of
mbed-os
by 
erkin yucel
Embed:
(wiki syntax)
Show/hide line numbers
lwip_ipcp.c
00001 /* 00002 * ipcp.c - PPP IP Control Protocol. 00003 * 00004 * Copyright (c) 1984-2000 Carnegie Mellon University. All rights reserved. 00005 * 00006 * Redistribution and use in source and binary forms, with or without 00007 * modification, are permitted provided that the following conditions 00008 * are met: 00009 * 00010 * 1. Redistributions of source code must retain the above copyright 00011 * notice, this list of conditions and the following disclaimer. 00012 * 00013 * 2. Redistributions in binary form must reproduce the above copyright 00014 * notice, this list of conditions and the following disclaimer in 00015 * the documentation and/or other materials provided with the 00016 * distribution. 00017 * 00018 * 3. The name "Carnegie Mellon University" must not be used to 00019 * endorse or promote products derived from this software without 00020 * prior written permission. For permission or any legal 00021 * details, please contact 00022 * Office of Technology Transfer 00023 * Carnegie Mellon University 00024 * 5000 Forbes Avenue 00025 * Pittsburgh, PA 15213-3890 00026 * (412) 268-4387, fax: (412) 268-7395 00027 * tech-transfer@andrew.cmu.edu 00028 * 00029 * 4. Redistributions of any form whatsoever must retain the following 00030 * acknowledgment: 00031 * "This product includes software developed by Computing Services 00032 * at Carnegie Mellon University (http://www.cmu.edu/computing/)." 00033 * 00034 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO 00035 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 00036 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE 00037 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 00038 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN 00039 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 00040 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 00041 */ 00042 00043 #include "netif/ppp/ppp_opts.h" 00044 #if PPP_SUPPORT && PPP_IPV4_SUPPORT /* don't build if not configured for use in lwipopts.h */ 00045 00046 /* 00047 * @todo: 00048 */ 00049 00050 #if 0 /* UNUSED */ 00051 #include <stdio.h> 00052 #include <string.h> 00053 #include <stdlib.h> 00054 #include <netdb.h> 00055 #include <sys/param.h> 00056 #include <sys/types.h> 00057 #include <sys/socket.h> 00058 #include <netinet/in.h> 00059 #include <arpa/inet.h> 00060 #endif /* UNUSED */ 00061 00062 #include "netif/ppp/ppp_impl.h" 00063 00064 #include "netif/ppp/fsm.h" 00065 #include "netif/ppp/ipcp.h" 00066 00067 #if 0 /* UNUSED */ 00068 /* global vars */ 00069 u32_t netmask = 0; /* IP netmask to set on interface */ 00070 #endif /* UNUSED */ 00071 00072 #if 0 /* UNUSED */ 00073 bool disable_defaultip = 0; /* Don't use hostname for default IP adrs */ 00074 #endif /* UNUSED */ 00075 00076 #if 0 /* moved to ppp_settings */ 00077 bool noremoteip = 0; /* Let him have no IP address */ 00078 #endif /* moved to ppp_setting */ 00079 00080 #if 0 /* UNUSED */ 00081 /* Hook for a plugin to know when IP protocol has come up */ 00082 void (*ip_up_hook) (void) = NULL; 00083 00084 /* Hook for a plugin to know when IP protocol has come down */ 00085 void (*ip_down_hook) (void) = NULL; 00086 00087 /* Hook for a plugin to choose the remote IP address */ 00088 void (*ip_choose_hook) (u32_t *) = NULL; 00089 #endif /* UNUSED */ 00090 00091 #if PPP_NOTIFY 00092 /* Notifiers for when IPCP goes up and down */ 00093 struct notifier *ip_up_notifier = NULL; 00094 struct notifier *ip_down_notifier = NULL; 00095 #endif /* PPP_NOTIFY */ 00096 00097 /* local vars */ 00098 #if 0 /* moved to ppp_pcb */ 00099 static int default_route_set[NUM_PPP]; /* Have set up a default route */ 00100 static int proxy_arp_set[NUM_PPP]; /* Have created proxy arp entry */ 00101 static int ipcp_is_up; /* have called np_up() */ 00102 static int ipcp_is_open; /* haven't called np_finished() */ 00103 static bool ask_for_local; /* request our address from peer */ 00104 #endif /* moved to ppp_pcb */ 00105 #if 0 /* UNUSED */ 00106 static char vj_value[8]; /* string form of vj option value */ 00107 static char netmask_str[20]; /* string form of netmask value */ 00108 #endif /* UNUSED */ 00109 00110 /* 00111 * Callbacks for fsm code. (CI = Configuration Information) 00112 */ 00113 static void ipcp_resetci(fsm *f); /* Reset our CI */ 00114 static int ipcp_cilen(fsm *f); /* Return length of our CI */ 00115 static void ipcp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI */ 00116 static int ipcp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ 00117 static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject);/* Peer nak'd our CI */ 00118 static int ipcp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ 00119 static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree); /* Rcv CI */ 00120 static void ipcp_up(fsm *f); /* We're UP */ 00121 static void ipcp_down(fsm *f); /* We're DOWN */ 00122 static void ipcp_finished(fsm *f); /* Don't need lower layer */ 00123 00124 static const fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */ 00125 ipcp_resetci, /* Reset our Configuration Information */ 00126 ipcp_cilen, /* Length of our Configuration Information */ 00127 ipcp_addci, /* Add our Configuration Information */ 00128 ipcp_ackci, /* ACK our Configuration Information */ 00129 ipcp_nakci, /* NAK our Configuration Information */ 00130 ipcp_rejci, /* Reject our Configuration Information */ 00131 ipcp_reqci, /* Request peer's Configuration Information */ 00132 ipcp_up, /* Called when fsm reaches OPENED state */ 00133 ipcp_down, /* Called when fsm leaves OPENED state */ 00134 NULL, /* Called when we want the lower layer up */ 00135 ipcp_finished, /* Called when we want the lower layer down */ 00136 NULL, /* Called when Protocol-Reject received */ 00137 NULL, /* Retransmission is necessary */ 00138 NULL, /* Called to handle protocol-specific codes */ 00139 "IPCP" /* String name of protocol */ 00140 }; 00141 00142 /* 00143 * Command-line options. 00144 */ 00145 #if PPP_OPTIONS 00146 static int setvjslots (char **); 00147 static int setdnsaddr (char **); 00148 static int setwinsaddr (char **); 00149 static int setnetmask (char **); 00150 int setipaddr (char *, char **, int); 00151 00152 static void printipaddr (option_t *, void (*)(void *, char *,...),void *); 00153 00154 static option_t ipcp_option_list[] = { 00155 { "noip", o_bool, &ipcp_protent.enabled_flag, 00156 "Disable IP and IPCP" }, 00157 { "-ip", o_bool, &ipcp_protent.enabled_flag, 00158 "Disable IP and IPCP", OPT_ALIAS }, 00159 00160 { "novj", o_bool, &ipcp_wantoptions[0].neg_vj, 00161 "Disable VJ compression", OPT_A2CLR, &ipcp_allowoptions[0].neg_vj }, 00162 { "-vj", o_bool, &ipcp_wantoptions[0].neg_vj, 00163 "Disable VJ compression", OPT_ALIAS | OPT_A2CLR, 00164 &ipcp_allowoptions[0].neg_vj }, 00165 00166 { "novjccomp", o_bool, &ipcp_wantoptions[0].cflag, 00167 "Disable VJ connection-ID compression", OPT_A2CLR, 00168 &ipcp_allowoptions[0].cflag }, 00169 { "-vjccomp", o_bool, &ipcp_wantoptions[0].cflag, 00170 "Disable VJ connection-ID compression", OPT_ALIAS | OPT_A2CLR, 00171 &ipcp_allowoptions[0].cflag }, 00172 00173 { "vj-max-slots", o_special, (void *)setvjslots, 00174 "Set maximum VJ header slots", 00175 OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, vj_value }, 00176 00177 { "ipcp-accept-local", o_bool, &ipcp_wantoptions[0].accept_local, 00178 "Accept peer's address for us", 1 }, 00179 { "ipcp-accept-remote", o_bool, &ipcp_wantoptions[0].accept_remote, 00180 "Accept peer's address for it", 1 }, 00181 00182 { "ipparam", o_string, &ipparam, 00183 "Set ip script parameter", OPT_PRIO }, 00184 00185 { "noipdefault", o_bool, &disable_defaultip, 00186 "Don't use name for default IP adrs", 1 }, 00187 00188 { "ms-dns", 1, (void *)setdnsaddr, 00189 "DNS address for the peer's use" }, 00190 { "ms-wins", 1, (void *)setwinsaddr, 00191 "Nameserver for SMB over TCP/IP for peer" }, 00192 00193 { "ipcp-restart", o_int, &ipcp_fsm[0].timeouttime, 00194 "Set timeout for IPCP", OPT_PRIO }, 00195 { "ipcp-max-terminate", o_int, &ipcp_fsm[0].maxtermtransmits, 00196 "Set max #xmits for term-reqs", OPT_PRIO }, 00197 { "ipcp-max-configure", o_int, &ipcp_fsm[0].maxconfreqtransmits, 00198 "Set max #xmits for conf-reqs", OPT_PRIO }, 00199 { "ipcp-max-failure", o_int, &ipcp_fsm[0].maxnakloops, 00200 "Set max #conf-naks for IPCP", OPT_PRIO }, 00201 00202 { "defaultroute", o_bool, &ipcp_wantoptions[0].default_route, 00203 "Add default route", OPT_ENABLE|1, &ipcp_allowoptions[0].default_route }, 00204 { "nodefaultroute", o_bool, &ipcp_allowoptions[0].default_route, 00205 "disable defaultroute option", OPT_A2CLR, 00206 &ipcp_wantoptions[0].default_route }, 00207 { "-defaultroute", o_bool, &ipcp_allowoptions[0].default_route, 00208 "disable defaultroute option", OPT_ALIAS | OPT_A2CLR, 00209 &ipcp_wantoptions[0].default_route }, 00210 00211 { "replacedefaultroute", o_bool, 00212 &ipcp_wantoptions[0].replace_default_route, 00213 "Replace default route", 1 00214 }, 00215 { "noreplacedefaultroute", o_bool, 00216 &ipcp_allowoptions[0].replace_default_route, 00217 "Never replace default route", OPT_A2COPY, 00218 &ipcp_wantoptions[0].replace_default_route }, 00219 { "proxyarp", o_bool, &ipcp_wantoptions[0].proxy_arp, 00220 "Add proxy ARP entry", OPT_ENABLE|1, &ipcp_allowoptions[0].proxy_arp }, 00221 { "noproxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp, 00222 "disable proxyarp option", OPT_A2CLR, 00223 &ipcp_wantoptions[0].proxy_arp }, 00224 { "-proxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp, 00225 "disable proxyarp option", OPT_ALIAS | OPT_A2CLR, 00226 &ipcp_wantoptions[0].proxy_arp }, 00227 00228 { "usepeerdns", o_bool, &usepeerdns, 00229 "Ask peer for DNS address(es)", 1 }, 00230 00231 { "netmask", o_special, (void *)setnetmask, 00232 "set netmask", OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, netmask_str }, 00233 00234 { "ipcp-no-addresses", o_bool, &ipcp_wantoptions[0].old_addrs, 00235 "Disable old-style IP-Addresses usage", OPT_A2CLR, 00236 &ipcp_allowoptions[0].old_addrs }, 00237 { "ipcp-no-address", o_bool, &ipcp_wantoptions[0].neg_addr, 00238 "Disable IP-Address usage", OPT_A2CLR, 00239 &ipcp_allowoptions[0].neg_addr }, 00240 00241 { "noremoteip", o_bool, &noremoteip, 00242 "Allow peer to have no IP address", 1 }, 00243 00244 { "nosendip", o_bool, &ipcp_wantoptions[0].neg_addr, 00245 "Don't send our IP address to peer", OPT_A2CLR, 00246 &ipcp_wantoptions[0].old_addrs}, 00247 00248 { "IP addresses", o_wild, (void *) &setipaddr, 00249 "set local and remote IP addresses", 00250 OPT_NOARG | OPT_A2PRINTER, (void *) &printipaddr }, 00251 00252 { NULL } 00253 }; 00254 #endif /* PPP_OPTIONS */ 00255 00256 /* 00257 * Protocol entry points from main code. 00258 */ 00259 static void ipcp_init(ppp_pcb *pcb); 00260 static void ipcp_open(ppp_pcb *pcb); 00261 static void ipcp_close(ppp_pcb *pcb, const char *reason); 00262 static void ipcp_lowerup(ppp_pcb *pcb); 00263 static void ipcp_lowerdown(ppp_pcb *pcb); 00264 static void ipcp_input(ppp_pcb *pcb, u_char *p, int len); 00265 static void ipcp_protrej(ppp_pcb *pcb); 00266 #if PRINTPKT_SUPPORT 00267 static int ipcp_printpkt(const u_char *p, int plen, 00268 void (*printer) (void *, const char *, ...), void *arg); 00269 #endif /* PRINTPKT_SUPPORT */ 00270 #if PPP_OPTIONS 00271 static void ip_check_options (void); 00272 #endif /* PPP_OPTIONS */ 00273 #if DEMAND_SUPPORT 00274 static int ip_demand_conf (int); 00275 static int ip_active_pkt (u_char *, int); 00276 #endif /* DEMAND_SUPPORT */ 00277 #if 0 /* UNUSED */ 00278 static void create_resolv (u32_t, u32_t); 00279 #endif /* UNUSED */ 00280 00281 const struct protent ipcp_protent = { 00282 PPP_IPCP, 00283 ipcp_init, 00284 ipcp_input, 00285 ipcp_protrej, 00286 ipcp_lowerup, 00287 ipcp_lowerdown, 00288 ipcp_open, 00289 ipcp_close, 00290 #if PRINTPKT_SUPPORT 00291 ipcp_printpkt, 00292 #endif /* PRINTPKT_SUPPORT */ 00293 #if PPP_DATAINPUT 00294 NULL, 00295 #endif /* PPP_DATAINPUT */ 00296 #if PRINTPKT_SUPPORT 00297 "IPCP", 00298 "IP", 00299 #endif /* PRINTPKT_SUPPORT */ 00300 #if PPP_OPTIONS 00301 ipcp_option_list, 00302 ip_check_options, 00303 #endif /* PPP_OPTIONS */ 00304 #if DEMAND_SUPPORT 00305 ip_demand_conf, 00306 ip_active_pkt 00307 #endif /* DEMAND_SUPPORT */ 00308 }; 00309 00310 static void ipcp_clear_addrs(ppp_pcb *pcb, u32_t ouraddr, u32_t hisaddr, u8_t replacedefaultroute); 00311 00312 /* 00313 * Lengths of configuration options. 00314 */ 00315 #define CILEN_VOID 2 00316 #define CILEN_COMPRESS 4 /* min length for compression protocol opt. */ 00317 #define CILEN_VJ 6 /* length for RFC1332 Van-Jacobson opt. */ 00318 #define CILEN_ADDR 6 /* new-style single address option */ 00319 #define CILEN_ADDRS 10 /* old-style dual address option */ 00320 00321 00322 #define CODENAME(x) ((x) == CONFACK ? "ACK" : \ 00323 (x) == CONFNAK ? "NAK" : "REJ") 00324 00325 #if 0 /* UNUSED, already defined by lwIP */ 00326 /* 00327 * Make a string representation of a network IP address. 00328 */ 00329 char * 00330 ip_ntoa(ipaddr) 00331 u32_t ipaddr; 00332 { 00333 static char b[64]; 00334 00335 slprintf(b, sizeof(b), "%I", ipaddr); 00336 return b; 00337 } 00338 #endif /* UNUSED, already defined by lwIP */ 00339 00340 /* 00341 * Option parsing. 00342 */ 00343 #if PPP_OPTIONS 00344 /* 00345 * setvjslots - set maximum number of connection slots for VJ compression 00346 */ 00347 static int 00348 setvjslots(argv) 00349 char **argv; 00350 { 00351 int value; 00352 00353 /* FIXME: found what int_option() did */ 00354 #if PPP_OPTIONS 00355 if (!int_option(*argv, &value)) 00356 return 0; 00357 #endif /* PPP_OPTIONS */ 00358 00359 if (value < 2 || value > 16) { 00360 option_error("vj-max-slots value must be between 2 and 16"); 00361 return 0; 00362 } 00363 ipcp_wantoptions [0].maxslotindex = 00364 ipcp_allowoptions[0].maxslotindex = value - 1; 00365 slprintf(vj_value, sizeof(vj_value), "%d", value); 00366 return 1; 00367 } 00368 00369 /* 00370 * setdnsaddr - set the dns address(es) 00371 */ 00372 static int 00373 setdnsaddr(argv) 00374 char **argv; 00375 { 00376 u32_t dns; 00377 struct hostent *hp; 00378 00379 dns = inet_addr(*argv); 00380 if (dns == (u32_t) -1) { 00381 if ((hp = gethostbyname(*argv)) == NULL) { 00382 option_error("invalid address parameter '%s' for ms-dns option", 00383 *argv); 00384 return 0; 00385 } 00386 dns = *(u32_t *)hp->h_addr; 00387 } 00388 00389 /* We take the last 2 values given, the 2nd-last as the primary 00390 and the last as the secondary. If only one is given it 00391 becomes both primary and secondary. */ 00392 if (ipcp_allowoptions[0].dnsaddr[1] == 0) 00393 ipcp_allowoptions[0].dnsaddr[0] = dns; 00394 else 00395 ipcp_allowoptions[0].dnsaddr[0] = ipcp_allowoptions[0].dnsaddr[1]; 00396 00397 /* always set the secondary address value. */ 00398 ipcp_allowoptions[0].dnsaddr[1] = dns; 00399 00400 return (1); 00401 } 00402 00403 /* 00404 * setwinsaddr - set the wins address(es) 00405 * This is primrarly used with the Samba package under UNIX or for pointing 00406 * the caller to the existing WINS server on a Windows NT platform. 00407 */ 00408 static int 00409 setwinsaddr(argv) 00410 char **argv; 00411 { 00412 u32_t wins; 00413 struct hostent *hp; 00414 00415 wins = inet_addr(*argv); 00416 if (wins == (u32_t) -1) { 00417 if ((hp = gethostbyname(*argv)) == NULL) { 00418 option_error("invalid address parameter '%s' for ms-wins option", 00419 *argv); 00420 return 0; 00421 } 00422 wins = *(u32_t *)hp->h_addr; 00423 } 00424 00425 /* We take the last 2 values given, the 2nd-last as the primary 00426 and the last as the secondary. If only one is given it 00427 becomes both primary and secondary. */ 00428 if (ipcp_allowoptions[0].winsaddr[1] == 0) 00429 ipcp_allowoptions[0].winsaddr[0] = wins; 00430 else 00431 ipcp_allowoptions[0].winsaddr[0] = ipcp_allowoptions[0].winsaddr[1]; 00432 00433 /* always set the secondary address value. */ 00434 ipcp_allowoptions[0].winsaddr[1] = wins; 00435 00436 return (1); 00437 } 00438 00439 /* 00440 * setipaddr - Set the IP address 00441 * If doit is 0, the call is to check whether this option is 00442 * potentially an IP address specification. 00443 * Not static so that plugins can call it to set the addresses 00444 */ 00445 int 00446 setipaddr(arg, argv, doit) 00447 char *arg; 00448 char **argv; 00449 int doit; 00450 { 00451 struct hostent *hp; 00452 char *colon; 00453 u32_t local, remote; 00454 ipcp_options *wo = &ipcp_wantoptions[0]; 00455 static int prio_local = 0, prio_remote = 0; 00456 00457 /* 00458 * IP address pair separated by ":". 00459 */ 00460 if ((colon = strchr(arg, ':')) == NULL) 00461 return 0; 00462 if (!doit) 00463 return 1; 00464 00465 /* 00466 * If colon first character, then no local addr. 00467 */ 00468 if (colon != arg && option_priority >= prio_local) { 00469 *colon = '\0'; 00470 if ((local = inet_addr(arg)) == (u32_t) -1) { 00471 if ((hp = gethostbyname(arg)) == NULL) { 00472 option_error("unknown host: %s", arg); 00473 return 0; 00474 } 00475 local = *(u32_t *)hp->h_addr; 00476 } 00477 if (bad_ip_adrs(local)) { 00478 option_error("bad local IP address %s", ip_ntoa(local)); 00479 return 0; 00480 } 00481 if (local != 0) 00482 wo->ouraddr = local; 00483 *colon = ':'; 00484 prio_local = option_priority; 00485 } 00486 00487 /* 00488 * If colon last character, then no remote addr. 00489 */ 00490 if (*++colon != '\0' && option_priority >= prio_remote) { 00491 if ((remote = inet_addr(colon)) == (u32_t) -1) { 00492 if ((hp = gethostbyname(colon)) == NULL) { 00493 option_error("unknown host: %s", colon); 00494 return 0; 00495 } 00496 remote = *(u32_t *)hp->h_addr; 00497 if (remote_name[0] == 0) 00498 strlcpy(remote_name, colon, sizeof(remote_name)); 00499 } 00500 if (bad_ip_adrs(remote)) { 00501 option_error("bad remote IP address %s", ip_ntoa(remote)); 00502 return 0; 00503 } 00504 if (remote != 0) 00505 wo->hisaddr = remote; 00506 prio_remote = option_priority; 00507 } 00508 00509 return 1; 00510 } 00511 00512 static void 00513 printipaddr(opt, printer, arg) 00514 option_t *opt; 00515 void (*printer) (void *, char *, ...); 00516 void *arg; 00517 { 00518 ipcp_options *wo = &ipcp_wantoptions[0]; 00519 00520 if (wo->ouraddr != 0) 00521 printer(arg, "%I", wo->ouraddr); 00522 printer(arg, ":"); 00523 if (wo->hisaddr != 0) 00524 printer(arg, "%I", wo->hisaddr); 00525 } 00526 00527 /* 00528 * setnetmask - set the netmask to be used on the interface. 00529 */ 00530 static int 00531 setnetmask(argv) 00532 char **argv; 00533 { 00534 u32_t mask; 00535 int n; 00536 char *p; 00537 00538 /* 00539 * Unfortunately, if we use inet_addr, we can't tell whether 00540 * a result of all 1s is an error or a valid 255.255.255.255. 00541 */ 00542 p = *argv; 00543 n = parse_dotted_ip(p, &mask); 00544 00545 mask = htonl(mask); 00546 00547 if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) { 00548 option_error("invalid netmask value '%s'", *argv); 00549 return 0; 00550 } 00551 00552 netmask = mask; 00553 slprintf(netmask_str, sizeof(netmask_str), "%I", mask); 00554 00555 return (1); 00556 } 00557 00558 int 00559 parse_dotted_ip(p, vp) 00560 char *p; 00561 u32_t *vp; 00562 { 00563 int n; 00564 u32_t v, b; 00565 char *endp, *p0 = p; 00566 00567 v = 0; 00568 for (n = 3;; --n) { 00569 b = strtoul(p, &endp, 0); 00570 if (endp == p) 00571 return 0; 00572 if (b > 255) { 00573 if (n < 3) 00574 return 0; 00575 /* accept e.g. 0xffffff00 */ 00576 *vp = b; 00577 return endp - p0; 00578 } 00579 v |= b << (n * 8); 00580 p = endp; 00581 if (n == 0) 00582 break; 00583 if (*p != '.') 00584 return 0; 00585 ++p; 00586 } 00587 *vp = v; 00588 return p - p0; 00589 } 00590 #endif /* PPP_OPTIONS */ 00591 00592 /* 00593 * ipcp_init - Initialize IPCP. 00594 */ 00595 static void ipcp_init(ppp_pcb *pcb) { 00596 fsm *f = &pcb->ipcp_fsm; 00597 00598 ipcp_options *wo = &pcb->ipcp_wantoptions; 00599 ipcp_options *ao = &pcb->ipcp_allowoptions; 00600 00601 f->pcb = pcb; 00602 f->protocol = PPP_IPCP; 00603 f->callbacks = &ipcp_callbacks; 00604 fsm_init(f); 00605 00606 /* 00607 * Some 3G modems use repeated IPCP NAKs as a way of stalling 00608 * until they can contact a server on the network, so we increase 00609 * the default number of NAKs we accept before we start treating 00610 * them as rejects. 00611 */ 00612 f->maxnakloops = 100; 00613 00614 #if 0 /* Not necessary, everything is cleared in ppp_new() */ 00615 memset(wo, 0, sizeof(*wo)); 00616 memset(ao, 0, sizeof(*ao)); 00617 #endif /* 0 */ 00618 00619 wo->neg_addr = wo->old_addrs = 1; 00620 #if VJ_SUPPORT 00621 wo->neg_vj = 1; 00622 wo->vj_protocol = IPCP_VJ_COMP; 00623 wo->maxslotindex = MAX_STATES - 1; /* really max index */ 00624 wo->cflag = 1; 00625 #endif /* VJ_SUPPORT */ 00626 00627 #if 0 /* UNUSED */ 00628 /* wanting default route by default */ 00629 wo->default_route = 1; 00630 #endif /* UNUSED */ 00631 00632 ao->neg_addr = ao->old_addrs = 1; 00633 #if VJ_SUPPORT 00634 /* max slots and slot-id compression are currently hardwired in */ 00635 /* ppp_if.c to 16 and 1, this needs to be changed (among other */ 00636 /* things) gmc */ 00637 00638 ao->neg_vj = 1; 00639 ao->maxslotindex = MAX_STATES - 1; 00640 ao->cflag = 1; 00641 #endif /* #if VJ_SUPPORT */ 00642 00643 #if 0 /* UNUSED */ 00644 /* 00645 * XXX These control whether the user may use the proxyarp 00646 * and defaultroute options. 00647 */ 00648 ao->proxy_arp = 1; 00649 ao->default_route = 1; 00650 #endif /* UNUSED */ 00651 } 00652 00653 00654 /* 00655 * ipcp_open - IPCP is allowed to come up. 00656 */ 00657 static void ipcp_open(ppp_pcb *pcb) { 00658 fsm *f = &pcb->ipcp_fsm; 00659 fsm_open(f); 00660 pcb->ipcp_is_open = 1; 00661 } 00662 00663 00664 /* 00665 * ipcp_close - Take IPCP down. 00666 */ 00667 static void ipcp_close(ppp_pcb *pcb, const char *reason) { 00668 fsm *f = &pcb->ipcp_fsm; 00669 fsm_close(f, reason); 00670 } 00671 00672 00673 /* 00674 * ipcp_lowerup - The lower layer is up. 00675 */ 00676 static void ipcp_lowerup(ppp_pcb *pcb) { 00677 fsm *f = &pcb->ipcp_fsm; 00678 fsm_lowerup(f); 00679 } 00680 00681 00682 /* 00683 * ipcp_lowerdown - The lower layer is down. 00684 */ 00685 static void ipcp_lowerdown(ppp_pcb *pcb) { 00686 fsm *f = &pcb->ipcp_fsm; 00687 fsm_lowerdown(f); 00688 } 00689 00690 00691 /* 00692 * ipcp_input - Input IPCP packet. 00693 */ 00694 static void ipcp_input(ppp_pcb *pcb, u_char *p, int len) { 00695 fsm *f = &pcb->ipcp_fsm; 00696 fsm_input(f, p, len); 00697 } 00698 00699 00700 /* 00701 * ipcp_protrej - A Protocol-Reject was received for IPCP. 00702 * 00703 * Pretend the lower layer went down, so we shut up. 00704 */ 00705 static void ipcp_protrej(ppp_pcb *pcb) { 00706 fsm *f = &pcb->ipcp_fsm; 00707 fsm_lowerdown(f); 00708 } 00709 00710 00711 /* 00712 * ipcp_resetci - Reset our CI. 00713 * Called by fsm_sconfreq, Send Configure Request. 00714 */ 00715 static void ipcp_resetci(fsm *f) { 00716 ppp_pcb *pcb = f->pcb; 00717 ipcp_options *wo = &pcb->ipcp_wantoptions; 00718 ipcp_options *go = &pcb->ipcp_gotoptions; 00719 ipcp_options *ao = &pcb->ipcp_allowoptions; 00720 00721 wo->req_addr = (wo->neg_addr || wo->old_addrs) && 00722 (ao->neg_addr || ao->old_addrs); 00723 if (wo->ouraddr == 0) 00724 wo->accept_local = 1; 00725 if (wo->hisaddr == 0) 00726 wo->accept_remote = 1; 00727 #if LWIP_DNS 00728 wo->req_dns1 = wo->req_dns2 = pcb->settings.usepeerdns; /* Request DNS addresses from the peer */ 00729 #endif /* LWIP_DNS */ 00730 *go = *wo; 00731 #if 0 /* UNUSED */ 00732 /* We don't need ask_for_local, this is only useful for setup which 00733 * can determine the local IP address from the system hostname. 00734 */ 00735 if (!ask_for_local) 00736 go->ouraddr = 0; 00737 #endif /* UNUSED */ 00738 #if 0 /* UNUSED */ 00739 if (ip_choose_hook) { 00740 ip_choose_hook(&wo->hisaddr); 00741 if (wo->hisaddr) { 00742 wo->accept_remote = 0; 00743 } 00744 } 00745 #endif /* UNUSED */ 00746 BZERO(&pcb->ipcp_hisoptions, sizeof(ipcp_options)); 00747 } 00748 00749 00750 /* 00751 * ipcp_cilen - Return length of our CI. 00752 * Called by fsm_sconfreq, Send Configure Request. 00753 */ 00754 static int ipcp_cilen(fsm *f) { 00755 ppp_pcb *pcb = f->pcb; 00756 ipcp_options *go = &pcb->ipcp_gotoptions; 00757 #if VJ_SUPPORT 00758 ipcp_options *wo = &pcb->ipcp_wantoptions; 00759 #endif /* VJ_SUPPORT */ 00760 ipcp_options *ho = &pcb->ipcp_hisoptions; 00761 00762 #define LENCIADDRS(neg) (neg ? CILEN_ADDRS : 0) 00763 #if VJ_SUPPORT 00764 #define LENCIVJ(neg, old) (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0) 00765 #endif /* VJ_SUPPORT */ 00766 #define LENCIADDR(neg) (neg ? CILEN_ADDR : 0) 00767 #if LWIP_DNS 00768 #define LENCIDNS(neg) LENCIADDR(neg) 00769 #endif /* LWIP_DNS */ 00770 #if 0 /* UNUSED - WINS */ 00771 #define LENCIWINS(neg) LENCIADDR(neg) 00772 #endif /* UNUSED - WINS */ 00773 00774 /* 00775 * First see if we want to change our options to the old 00776 * forms because we have received old forms from the peer. 00777 */ 00778 if (go->neg_addr && go->old_addrs && !ho->neg_addr && ho->old_addrs) 00779 go->neg_addr = 0; 00780 00781 #if VJ_SUPPORT 00782 if (wo->neg_vj && !go->neg_vj && !go->old_vj) { 00783 /* try an older style of VJ negotiation */ 00784 /* use the old style only if the peer did */ 00785 if (ho->neg_vj && ho->old_vj) { 00786 go->neg_vj = 1; 00787 go->old_vj = 1; 00788 go->vj_protocol = ho->vj_protocol; 00789 } 00790 } 00791 #endif /* VJ_SUPPORT */ 00792 00793 return (LENCIADDRS(!go->neg_addr && go->old_addrs) + 00794 #if VJ_SUPPORT 00795 LENCIVJ(go->neg_vj, go->old_vj) + 00796 #endif /* VJ_SUPPORT */ 00797 LENCIADDR(go->neg_addr) + 00798 #if LWIP_DNS 00799 LENCIDNS(go->req_dns1) + 00800 LENCIDNS(go->req_dns2) + 00801 #endif /* LWIP_DNS */ 00802 #if 0 /* UNUSED - WINS */ 00803 LENCIWINS(go->winsaddr[0]) + 00804 LENCIWINS(go->winsaddr[1]) + 00805 #endif /* UNUSED - WINS */ 00806 0); 00807 } 00808 00809 00810 /* 00811 * ipcp_addci - Add our desired CIs to a packet. 00812 * Called by fsm_sconfreq, Send Configure Request. 00813 */ 00814 static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) { 00815 ppp_pcb *pcb = f->pcb; 00816 ipcp_options *go = &pcb->ipcp_gotoptions; 00817 int len = *lenp; 00818 00819 #define ADDCIADDRS(opt, neg, val1, val2) \ 00820 if (neg) { \ 00821 if (len >= CILEN_ADDRS) { \ 00822 u32_t l; \ 00823 PUTCHAR(opt, ucp); \ 00824 PUTCHAR(CILEN_ADDRS, ucp); \ 00825 l = ntohl(val1); \ 00826 PUTLONG(l, ucp); \ 00827 l = ntohl(val2); \ 00828 PUTLONG(l, ucp); \ 00829 len -= CILEN_ADDRS; \ 00830 } else \ 00831 go->old_addrs = 0; \ 00832 } 00833 00834 #if VJ_SUPPORT 00835 #define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) \ 00836 if (neg) { \ 00837 int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \ 00838 if (len >= vjlen) { \ 00839 PUTCHAR(opt, ucp); \ 00840 PUTCHAR(vjlen, ucp); \ 00841 PUTSHORT(val, ucp); \ 00842 if (!old) { \ 00843 PUTCHAR(maxslotindex, ucp); \ 00844 PUTCHAR(cflag, ucp); \ 00845 } \ 00846 len -= vjlen; \ 00847 } else \ 00848 neg = 0; \ 00849 } 00850 #endif /* VJ_SUPPORT */ 00851 00852 #define ADDCIADDR(opt, neg, val) \ 00853 if (neg) { \ 00854 if (len >= CILEN_ADDR) { \ 00855 u32_t l; \ 00856 PUTCHAR(opt, ucp); \ 00857 PUTCHAR(CILEN_ADDR, ucp); \ 00858 l = ntohl(val); \ 00859 PUTLONG(l, ucp); \ 00860 len -= CILEN_ADDR; \ 00861 } else \ 00862 neg = 0; \ 00863 } 00864 00865 #if LWIP_DNS 00866 #define ADDCIDNS(opt, neg, addr) \ 00867 if (neg) { \ 00868 if (len >= CILEN_ADDR) { \ 00869 u32_t l; \ 00870 PUTCHAR(opt, ucp); \ 00871 PUTCHAR(CILEN_ADDR, ucp); \ 00872 l = ntohl(addr); \ 00873 PUTLONG(l, ucp); \ 00874 len -= CILEN_ADDR; \ 00875 } else \ 00876 neg = 0; \ 00877 } 00878 #endif /* LWIP_DNS */ 00879 00880 #if 0 /* UNUSED - WINS */ 00881 #define ADDCIWINS(opt, addr) \ 00882 if (addr) { \ 00883 if (len >= CILEN_ADDR) { \ 00884 u32_t l; \ 00885 PUTCHAR(opt, ucp); \ 00886 PUTCHAR(CILEN_ADDR, ucp); \ 00887 l = ntohl(addr); \ 00888 PUTLONG(l, ucp); \ 00889 len -= CILEN_ADDR; \ 00890 } else \ 00891 addr = 0; \ 00892 } 00893 #endif /* UNUSED - WINS */ 00894 00895 ADDCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, go->ouraddr, 00896 go->hisaddr); 00897 00898 #if VJ_SUPPORT 00899 ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj, 00900 go->maxslotindex, go->cflag); 00901 #endif /* VJ_SUPPORT */ 00902 00903 ADDCIADDR(CI_ADDR, go->neg_addr, go->ouraddr); 00904 00905 #if LWIP_DNS 00906 ADDCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]); 00907 00908 ADDCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]); 00909 #endif /* LWIP_DNS */ 00910 00911 #if 0 /* UNUSED - WINS */ 00912 ADDCIWINS(CI_MS_WINS1, go->winsaddr[0]); 00913 00914 ADDCIWINS(CI_MS_WINS2, go->winsaddr[1]); 00915 #endif /* UNUSED - WINS */ 00916 00917 *lenp -= len; 00918 } 00919 00920 00921 /* 00922 * ipcp_ackci - Ack our CIs. 00923 * Called by fsm_rconfack, Receive Configure ACK. 00924 * 00925 * Returns: 00926 * 0 - Ack was bad. 00927 * 1 - Ack was good. 00928 */ 00929 static int ipcp_ackci(fsm *f, u_char *p, int len) { 00930 ppp_pcb *pcb = f->pcb; 00931 ipcp_options *go = &pcb->ipcp_gotoptions; 00932 u_short cilen, citype; 00933 u32_t cilong; 00934 #if VJ_SUPPORT 00935 u_short cishort; 00936 u_char cimaxslotindex, cicflag; 00937 #endif /* VJ_SUPPORT */ 00938 00939 /* 00940 * CIs must be in exactly the same order that we sent... 00941 * Check packet length and CI length at each step. 00942 * If we find any deviations, then this packet is bad. 00943 */ 00944 00945 #define ACKCIADDRS(opt, neg, val1, val2) \ 00946 if (neg) { \ 00947 u32_t l; \ 00948 if ((len -= CILEN_ADDRS) < 0) \ 00949 goto bad; \ 00950 GETCHAR(citype, p); \ 00951 GETCHAR(cilen, p); \ 00952 if (cilen != CILEN_ADDRS || \ 00953 citype != opt) \ 00954 goto bad; \ 00955 GETLONG(l, p); \ 00956 cilong = htonl(l); \ 00957 if (val1 != cilong) \ 00958 goto bad; \ 00959 GETLONG(l, p); \ 00960 cilong = htonl(l); \ 00961 if (val2 != cilong) \ 00962 goto bad; \ 00963 } 00964 00965 #if VJ_SUPPORT 00966 #define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) \ 00967 if (neg) { \ 00968 int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \ 00969 if ((len -= vjlen) < 0) \ 00970 goto bad; \ 00971 GETCHAR(citype, p); \ 00972 GETCHAR(cilen, p); \ 00973 if (cilen != vjlen || \ 00974 citype != opt) \ 00975 goto bad; \ 00976 GETSHORT(cishort, p); \ 00977 if (cishort != val) \ 00978 goto bad; \ 00979 if (!old) { \ 00980 GETCHAR(cimaxslotindex, p); \ 00981 if (cimaxslotindex != maxslotindex) \ 00982 goto bad; \ 00983 GETCHAR(cicflag, p); \ 00984 if (cicflag != cflag) \ 00985 goto bad; \ 00986 } \ 00987 } 00988 #endif /* VJ_SUPPORT */ 00989 00990 #define ACKCIADDR(opt, neg, val) \ 00991 if (neg) { \ 00992 u32_t l; \ 00993 if ((len -= CILEN_ADDR) < 0) \ 00994 goto bad; \ 00995 GETCHAR(citype, p); \ 00996 GETCHAR(cilen, p); \ 00997 if (cilen != CILEN_ADDR || \ 00998 citype != opt) \ 00999 goto bad; \ 01000 GETLONG(l, p); \ 01001 cilong = htonl(l); \ 01002 if (val != cilong) \ 01003 goto bad; \ 01004 } 01005 01006 #if LWIP_DNS 01007 #define ACKCIDNS(opt, neg, addr) \ 01008 if (neg) { \ 01009 u32_t l; \ 01010 if ((len -= CILEN_ADDR) < 0) \ 01011 goto bad; \ 01012 GETCHAR(citype, p); \ 01013 GETCHAR(cilen, p); \ 01014 if (cilen != CILEN_ADDR || citype != opt) \ 01015 goto bad; \ 01016 GETLONG(l, p); \ 01017 cilong = htonl(l); \ 01018 if (addr != cilong) \ 01019 goto bad; \ 01020 } 01021 #endif /* LWIP_DNS */ 01022 01023 #if 0 /* UNUSED - WINS */ 01024 #define ACKCIWINS(opt, addr) \ 01025 if (addr) { \ 01026 u32_t l; \ 01027 if ((len -= CILEN_ADDR) < 0) \ 01028 goto bad; \ 01029 GETCHAR(citype, p); \ 01030 GETCHAR(cilen, p); \ 01031 if (cilen != CILEN_ADDR || citype != opt) \ 01032 goto bad; \ 01033 GETLONG(l, p); \ 01034 cilong = htonl(l); \ 01035 if (addr != cilong) \ 01036 goto bad; \ 01037 } 01038 #endif /* UNUSED - WINS */ 01039 01040 ACKCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, go->ouraddr, 01041 go->hisaddr); 01042 01043 #if VJ_SUPPORT 01044 ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj, 01045 go->maxslotindex, go->cflag); 01046 #endif /* VJ_SUPPORT */ 01047 01048 ACKCIADDR(CI_ADDR, go->neg_addr, go->ouraddr); 01049 01050 #if LWIP_DNS 01051 ACKCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]); 01052 01053 ACKCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]); 01054 #endif /* LWIP_DNS */ 01055 01056 #if 0 /* UNUSED - WINS */ 01057 ACKCIWINS(CI_MS_WINS1, go->winsaddr[0]); 01058 01059 ACKCIWINS(CI_MS_WINS2, go->winsaddr[1]); 01060 #endif /* UNUSED - WINS */ 01061 01062 /* 01063 * If there are any remaining CIs, then this packet is bad. 01064 */ 01065 if (len != 0) 01066 goto bad; 01067 return (1); 01068 01069 bad: 01070 IPCPDEBUG(("ipcp_ackci: received bad Ack!")); 01071 return (0); 01072 } 01073 01074 /* 01075 * ipcp_nakci - Peer has sent a NAK for some of our CIs. 01076 * This should not modify any state if the Nak is bad 01077 * or if IPCP is in the OPENED state. 01078 * Calback from fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. 01079 * 01080 * Returns: 01081 * 0 - Nak was bad. 01082 * 1 - Nak was good. 01083 */ 01084 static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { 01085 ppp_pcb *pcb = f->pcb; 01086 ipcp_options *go = &pcb->ipcp_gotoptions; 01087 u_char citype, cilen, *next; 01088 #if VJ_SUPPORT 01089 u_char cimaxslotindex, cicflag; 01090 u_short cishort; 01091 #endif /* VJ_SUPPORT */ 01092 u32_t ciaddr1, ciaddr2, l; 01093 #if LWIP_DNS 01094 u32_t cidnsaddr; 01095 #endif /* LWIP_DNS */ 01096 ipcp_options no; /* options we've seen Naks for */ 01097 ipcp_options try_; /* options to request next time */ 01098 01099 BZERO(&no, sizeof(no)); 01100 try_ = *go; 01101 01102 /* 01103 * Any Nak'd CIs must be in exactly the same order that we sent. 01104 * Check packet length and CI length at each step. 01105 * If we find any deviations, then this packet is bad. 01106 */ 01107 #define NAKCIADDRS(opt, neg, code) \ 01108 if ((neg) && \ 01109 (cilen = p[1]) == CILEN_ADDRS && \ 01110 len >= cilen && \ 01111 p[0] == opt) { \ 01112 len -= cilen; \ 01113 INCPTR(2, p); \ 01114 GETLONG(l, p); \ 01115 ciaddr1 = htonl(l); \ 01116 GETLONG(l, p); \ 01117 ciaddr2 = htonl(l); \ 01118 no.old_addrs = 1; \ 01119 code \ 01120 } 01121 01122 #if VJ_SUPPORT 01123 #define NAKCIVJ(opt, neg, code) \ 01124 if (go->neg && \ 01125 ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \ 01126 len >= cilen && \ 01127 p[0] == opt) { \ 01128 len -= cilen; \ 01129 INCPTR(2, p); \ 01130 GETSHORT(cishort, p); \ 01131 no.neg = 1; \ 01132 code \ 01133 } 01134 #endif /* VJ_SUPPORT */ 01135 01136 #define NAKCIADDR(opt, neg, code) \ 01137 if (go->neg && \ 01138 (cilen = p[1]) == CILEN_ADDR && \ 01139 len >= cilen && \ 01140 p[0] == opt) { \ 01141 len -= cilen; \ 01142 INCPTR(2, p); \ 01143 GETLONG(l, p); \ 01144 ciaddr1 = htonl(l); \ 01145 no.neg = 1; \ 01146 code \ 01147 } 01148 01149 #if LWIP_DNS 01150 #define NAKCIDNS(opt, neg, code) \ 01151 if (go->neg && \ 01152 ((cilen = p[1]) == CILEN_ADDR) && \ 01153 len >= cilen && \ 01154 p[0] == opt) { \ 01155 len -= cilen; \ 01156 INCPTR(2, p); \ 01157 GETLONG(l, p); \ 01158 cidnsaddr = htonl(l); \ 01159 no.neg = 1; \ 01160 code \ 01161 } 01162 #endif /* LWIP_DNS */ 01163 01164 /* 01165 * Accept the peer's idea of {our,his} address, if different 01166 * from our idea, only if the accept_{local,remote} flag is set. 01167 */ 01168 NAKCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, 01169 if (treat_as_reject) { 01170 try_.old_addrs = 0; 01171 } else { 01172 if (go->accept_local && ciaddr1) { 01173 /* take his idea of our address */ 01174 try_.ouraddr = ciaddr1; 01175 } 01176 if (go->accept_remote && ciaddr2) { 01177 /* take his idea of his address */ 01178 try_.hisaddr = ciaddr2; 01179 } 01180 } 01181 ); 01182 01183 #if VJ_SUPPORT 01184 /* 01185 * Accept the peer's value of maxslotindex provided that it 01186 * is less than what we asked for. Turn off slot-ID compression 01187 * if the peer wants. Send old-style compress-type option if 01188 * the peer wants. 01189 */ 01190 NAKCIVJ(CI_COMPRESSTYPE, neg_vj, 01191 if (treat_as_reject) { 01192 try_.neg_vj = 0; 01193 } else if (cilen == CILEN_VJ) { 01194 GETCHAR(cimaxslotindex, p); 01195 GETCHAR(cicflag, p); 01196 if (cishort == IPCP_VJ_COMP) { 01197 try_.old_vj = 0; 01198 if (cimaxslotindex < go->maxslotindex) 01199 try_.maxslotindex = cimaxslotindex; 01200 if (!cicflag) 01201 try_.cflag = 0; 01202 } else { 01203 try_.neg_vj = 0; 01204 } 01205 } else { 01206 if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) { 01207 try_.old_vj = 1; 01208 try_.vj_protocol = cishort; 01209 } else { 01210 try_.neg_vj = 0; 01211 } 01212 } 01213 ); 01214 #endif /* VJ_SUPPORT */ 01215 01216 NAKCIADDR(CI_ADDR, neg_addr, 01217 if (treat_as_reject) { 01218 try_.neg_addr = 0; 01219 try_.old_addrs = 0; 01220 } else if (go->accept_local && ciaddr1) { 01221 /* take his idea of our address */ 01222 try_.ouraddr = ciaddr1; 01223 } 01224 ); 01225 01226 #if LWIP_DNS 01227 NAKCIDNS(CI_MS_DNS1, req_dns1, 01228 if (treat_as_reject) { 01229 try_.req_dns1 = 0; 01230 } else { 01231 try_.dnsaddr[0] = cidnsaddr; 01232 } 01233 ); 01234 01235 NAKCIDNS(CI_MS_DNS2, req_dns2, 01236 if (treat_as_reject) { 01237 try_.req_dns2 = 0; 01238 } else { 01239 try_.dnsaddr[1] = cidnsaddr; 01240 } 01241 ); 01242 #endif /* #if LWIP_DNS */ 01243 01244 /* 01245 * There may be remaining CIs, if the peer is requesting negotiation 01246 * on an option that we didn't include in our request packet. 01247 * If they want to negotiate about IP addresses, we comply. 01248 * If they want us to ask for compression, we refuse. 01249 * If they want us to ask for ms-dns, we do that, since some 01250 * peers get huffy if we don't. 01251 */ 01252 while (len >= CILEN_VOID) { 01253 GETCHAR(citype, p); 01254 GETCHAR(cilen, p); 01255 if ( cilen < CILEN_VOID || (len -= cilen) < 0 ) 01256 goto bad; 01257 next = p + cilen - 2; 01258 01259 switch (citype) { 01260 #if VJ_SUPPORT 01261 case CI_COMPRESSTYPE: 01262 if (go->neg_vj || no.neg_vj || 01263 (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) 01264 goto bad; 01265 no.neg_vj = 1; 01266 break; 01267 #endif /* VJ_SUPPORT */ 01268 case CI_ADDRS: 01269 if ((!go->neg_addr && go->old_addrs) || no.old_addrs 01270 || cilen != CILEN_ADDRS) 01271 goto bad; 01272 try_.neg_addr = 0; 01273 GETLONG(l, p); 01274 ciaddr1 = htonl(l); 01275 if (ciaddr1 && go->accept_local) 01276 try_.ouraddr = ciaddr1; 01277 GETLONG(l, p); 01278 ciaddr2 = htonl(l); 01279 if (ciaddr2 && go->accept_remote) 01280 try_.hisaddr = ciaddr2; 01281 no.old_addrs = 1; 01282 break; 01283 case CI_ADDR: 01284 if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR) 01285 goto bad; 01286 try_.old_addrs = 0; 01287 GETLONG(l, p); 01288 ciaddr1 = htonl(l); 01289 if (ciaddr1 && go->accept_local) 01290 try_.ouraddr = ciaddr1; 01291 if (try_.ouraddr != 0) 01292 try_.neg_addr = 1; 01293 no.neg_addr = 1; 01294 break; 01295 #if LWIP_DNS 01296 case CI_MS_DNS1: 01297 if (go->req_dns1 || no.req_dns1 || cilen != CILEN_ADDR) 01298 goto bad; 01299 GETLONG(l, p); 01300 try_.dnsaddr[0] = htonl(l); 01301 try_.req_dns1 = 1; 01302 no.req_dns1 = 1; 01303 break; 01304 case CI_MS_DNS2: 01305 if (go->req_dns2 || no.req_dns2 || cilen != CILEN_ADDR) 01306 goto bad; 01307 GETLONG(l, p); 01308 try_.dnsaddr[1] = htonl(l); 01309 try_.req_dns2 = 1; 01310 no.req_dns2 = 1; 01311 break; 01312 #endif /* LWIP_DNS */ 01313 #if 0 /* UNUSED - WINS */ 01314 case CI_MS_WINS1: 01315 case CI_MS_WINS2: 01316 if (cilen != CILEN_ADDR) 01317 goto bad; 01318 GETLONG(l, p); 01319 ciaddr1 = htonl(l); 01320 if (ciaddr1) 01321 try_.winsaddr[citype == CI_MS_WINS2] = ciaddr1; 01322 break; 01323 #endif /* UNUSED - WINS */ 01324 default: 01325 break; 01326 } 01327 p = next; 01328 } 01329 01330 /* 01331 * OK, the Nak is good. Now we can update state. 01332 * If there are any remaining options, we ignore them. 01333 */ 01334 if (f->state != PPP_FSM_OPENED) 01335 *go = try_; 01336 01337 return 1; 01338 01339 bad: 01340 IPCPDEBUG(("ipcp_nakci: received bad Nak!")); 01341 return 0; 01342 } 01343 01344 01345 /* 01346 * ipcp_rejci - Reject some of our CIs. 01347 * Callback from fsm_rconfnakrej. 01348 */ 01349 static int ipcp_rejci(fsm *f, u_char *p, int len) { 01350 ppp_pcb *pcb = f->pcb; 01351 ipcp_options *go = &pcb->ipcp_gotoptions; 01352 u_char cilen; 01353 #if VJ_SUPPORT 01354 u_char cimaxslotindex, ciflag; 01355 u_short cishort; 01356 #endif /* VJ_SUPPORT */ 01357 u32_t cilong; 01358 ipcp_options try_; /* options to request next time */ 01359 01360 try_ = *go; 01361 /* 01362 * Any Rejected CIs must be in exactly the same order that we sent. 01363 * Check packet length and CI length at each step. 01364 * If we find any deviations, then this packet is bad. 01365 */ 01366 #define REJCIADDRS(opt, neg, val1, val2) \ 01367 if ((neg) && \ 01368 (cilen = p[1]) == CILEN_ADDRS && \ 01369 len >= cilen && \ 01370 p[0] == opt) { \ 01371 u32_t l; \ 01372 len -= cilen; \ 01373 INCPTR(2, p); \ 01374 GETLONG(l, p); \ 01375 cilong = htonl(l); \ 01376 /* Check rejected value. */ \ 01377 if (cilong != val1) \ 01378 goto bad; \ 01379 GETLONG(l, p); \ 01380 cilong = htonl(l); \ 01381 /* Check rejected value. */ \ 01382 if (cilong != val2) \ 01383 goto bad; \ 01384 try_.old_addrs = 0; \ 01385 } 01386 01387 #if VJ_SUPPORT 01388 #define REJCIVJ(opt, neg, val, old, maxslot, cflag) \ 01389 if (go->neg && \ 01390 p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && \ 01391 len >= p[1] && \ 01392 p[0] == opt) { \ 01393 len -= p[1]; \ 01394 INCPTR(2, p); \ 01395 GETSHORT(cishort, p); \ 01396 /* Check rejected value. */ \ 01397 if (cishort != val) \ 01398 goto bad; \ 01399 if (!old) { \ 01400 GETCHAR(cimaxslotindex, p); \ 01401 if (cimaxslotindex != maxslot) \ 01402 goto bad; \ 01403 GETCHAR(ciflag, p); \ 01404 if (ciflag != cflag) \ 01405 goto bad; \ 01406 } \ 01407 try_.neg = 0; \ 01408 } 01409 #endif /* VJ_SUPPORT */ 01410 01411 #define REJCIADDR(opt, neg, val) \ 01412 if (go->neg && \ 01413 (cilen = p[1]) == CILEN_ADDR && \ 01414 len >= cilen && \ 01415 p[0] == opt) { \ 01416 u32_t l; \ 01417 len -= cilen; \ 01418 INCPTR(2, p); \ 01419 GETLONG(l, p); \ 01420 cilong = htonl(l); \ 01421 /* Check rejected value. */ \ 01422 if (cilong != val) \ 01423 goto bad; \ 01424 try_.neg = 0; \ 01425 } 01426 01427 #if LWIP_DNS 01428 #define REJCIDNS(opt, neg, dnsaddr) \ 01429 if (go->neg && \ 01430 ((cilen = p[1]) == CILEN_ADDR) && \ 01431 len >= cilen && \ 01432 p[0] == opt) { \ 01433 u32_t l; \ 01434 len -= cilen; \ 01435 INCPTR(2, p); \ 01436 GETLONG(l, p); \ 01437 cilong = htonl(l); \ 01438 /* Check rejected value. */ \ 01439 if (cilong != dnsaddr) \ 01440 goto bad; \ 01441 try_.neg = 0; \ 01442 } 01443 #endif /* LWIP_DNS */ 01444 01445 #if 0 /* UNUSED - WINS */ 01446 #define REJCIWINS(opt, addr) \ 01447 if (addr && \ 01448 ((cilen = p[1]) == CILEN_ADDR) && \ 01449 len >= cilen && \ 01450 p[0] == opt) { \ 01451 u32_t l; \ 01452 len -= cilen; \ 01453 INCPTR(2, p); \ 01454 GETLONG(l, p); \ 01455 cilong = htonl(l); \ 01456 /* Check rejected value. */ \ 01457 if (cilong != addr) \ 01458 goto bad; \ 01459 try_.winsaddr[opt == CI_MS_WINS2] = 0; \ 01460 } 01461 #endif /* UNUSED - WINS */ 01462 01463 REJCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, 01464 go->ouraddr, go->hisaddr); 01465 01466 #if VJ_SUPPORT 01467 REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj, 01468 go->maxslotindex, go->cflag); 01469 #endif /* VJ_SUPPORT */ 01470 01471 REJCIADDR(CI_ADDR, neg_addr, go->ouraddr); 01472 01473 #if LWIP_DNS 01474 REJCIDNS(CI_MS_DNS1, req_dns1, go->dnsaddr[0]); 01475 01476 REJCIDNS(CI_MS_DNS2, req_dns2, go->dnsaddr[1]); 01477 #endif /* LWIP_DNS */ 01478 01479 #if 0 /* UNUSED - WINS */ 01480 REJCIWINS(CI_MS_WINS1, go->winsaddr[0]); 01481 01482 REJCIWINS(CI_MS_WINS2, go->winsaddr[1]); 01483 #endif /* UNUSED - WINS */ 01484 01485 /* 01486 * If there are any remaining CIs, then this packet is bad. 01487 */ 01488 if (len != 0) 01489 goto bad; 01490 /* 01491 * Now we can update state. 01492 */ 01493 if (f->state != PPP_FSM_OPENED) 01494 *go = try_; 01495 return 1; 01496 01497 bad: 01498 IPCPDEBUG(("ipcp_rejci: received bad Reject!")); 01499 return 0; 01500 } 01501 01502 01503 /* 01504 * ipcp_reqci - Check the peer's requested CIs and send appropriate response. 01505 * Callback from fsm_rconfreq, Receive Configure Request 01506 * 01507 * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified 01508 * appropriately. If reject_if_disagree is non-zero, doesn't return 01509 * CONFNAK; returns CONFREJ if it can't return CONFACK. 01510 * 01511 * inp = Requested CIs 01512 * len = Length of requested CIs 01513 */ 01514 static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) { 01515 ppp_pcb *pcb = f->pcb; 01516 ipcp_options *wo = &pcb->ipcp_wantoptions; 01517 ipcp_options *ho = &pcb->ipcp_hisoptions; 01518 ipcp_options *ao = &pcb->ipcp_allowoptions; 01519 u_char *cip, *next; /* Pointer to current and next CIs */ 01520 u_short cilen, citype; /* Parsed len, type */ 01521 #if VJ_SUPPORT 01522 u_short cishort; /* Parsed short value */ 01523 #endif /* VJ_SUPPORT */ 01524 u32_t tl, ciaddr1, ciaddr2;/* Parsed address values */ 01525 int rc = CONFACK; /* Final packet return code */ 01526 int orc; /* Individual option return code */ 01527 u_char *p; /* Pointer to next char to parse */ 01528 u_char *ucp = inp; /* Pointer to current output char */ 01529 int l = *len; /* Length left */ 01530 #if VJ_SUPPORT 01531 u_char maxslotindex, cflag; 01532 #endif /* VJ_SUPPORT */ 01533 #if LWIP_DNS 01534 int d; 01535 #endif /* LWIP_DNS */ 01536 01537 /* 01538 * Reset all his options. 01539 */ 01540 BZERO(ho, sizeof(*ho)); 01541 01542 /* 01543 * Process all his options. 01544 */ 01545 next = inp; 01546 while (l) { 01547 orc = CONFACK; /* Assume success */ 01548 cip = p = next; /* Remember begining of CI */ 01549 if (l < 2 || /* Not enough data for CI header or */ 01550 p[1] < 2 || /* CI length too small or */ 01551 p[1] > l) { /* CI length too big? */ 01552 IPCPDEBUG(("ipcp_reqci: bad CI length!")); 01553 orc = CONFREJ; /* Reject bad CI */ 01554 cilen = l; /* Reject till end of packet */ 01555 l = 0; /* Don't loop again */ 01556 goto endswitch; 01557 } 01558 GETCHAR(citype, p); /* Parse CI type */ 01559 GETCHAR(cilen, p); /* Parse CI length */ 01560 l -= cilen; /* Adjust remaining length */ 01561 next += cilen; /* Step to next CI */ 01562 01563 switch (citype) { /* Check CI type */ 01564 case CI_ADDRS: 01565 if (!ao->old_addrs || ho->neg_addr || 01566 cilen != CILEN_ADDRS) { /* Check CI length */ 01567 orc = CONFREJ; /* Reject CI */ 01568 break; 01569 } 01570 01571 /* 01572 * If he has no address, or if we both have his address but 01573 * disagree about it, then NAK it with our idea. 01574 * In particular, if we don't know his address, but he does, 01575 * then accept it. 01576 */ 01577 GETLONG(tl, p); /* Parse source address (his) */ 01578 ciaddr1 = htonl(tl); 01579 if (ciaddr1 != wo->hisaddr 01580 && (ciaddr1 == 0 || !wo->accept_remote)) { 01581 orc = CONFNAK; 01582 if (!reject_if_disagree) { 01583 DECPTR(sizeof(u32_t), p); 01584 tl = ntohl(wo->hisaddr); 01585 PUTLONG(tl, p); 01586 } 01587 } else if (ciaddr1 == 0 && wo->hisaddr == 0) { 01588 /* 01589 * If neither we nor he knows his address, reject the option. 01590 */ 01591 orc = CONFREJ; 01592 wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */ 01593 break; 01594 } 01595 01596 /* 01597 * If he doesn't know our address, or if we both have our address 01598 * but disagree about it, then NAK it with our idea. 01599 */ 01600 GETLONG(tl, p); /* Parse desination address (ours) */ 01601 ciaddr2 = htonl(tl); 01602 if (ciaddr2 != wo->ouraddr) { 01603 if (ciaddr2 == 0 || !wo->accept_local) { 01604 orc = CONFNAK; 01605 if (!reject_if_disagree) { 01606 DECPTR(sizeof(u32_t), p); 01607 tl = ntohl(wo->ouraddr); 01608 PUTLONG(tl, p); 01609 } 01610 } else { 01611 wo->ouraddr = ciaddr2; /* accept peer's idea */ 01612 } 01613 } 01614 01615 ho->old_addrs = 1; 01616 ho->hisaddr = ciaddr1; 01617 ho->ouraddr = ciaddr2; 01618 break; 01619 01620 case CI_ADDR: 01621 if (!ao->neg_addr || ho->old_addrs || 01622 cilen != CILEN_ADDR) { /* Check CI length */ 01623 orc = CONFREJ; /* Reject CI */ 01624 break; 01625 } 01626 01627 /* 01628 * If he has no address, or if we both have his address but 01629 * disagree about it, then NAK it with our idea. 01630 * In particular, if we don't know his address, but he does, 01631 * then accept it. 01632 */ 01633 GETLONG(tl, p); /* Parse source address (his) */ 01634 ciaddr1 = htonl(tl); 01635 if (ciaddr1 != wo->hisaddr 01636 && (ciaddr1 == 0 || !wo->accept_remote)) { 01637 orc = CONFNAK; 01638 if (!reject_if_disagree) { 01639 DECPTR(sizeof(u32_t), p); 01640 tl = ntohl(wo->hisaddr); 01641 PUTLONG(tl, p); 01642 } 01643 } else if (ciaddr1 == 0 && wo->hisaddr == 0) { 01644 /* 01645 * Don't ACK an address of 0.0.0.0 - reject it instead. 01646 */ 01647 orc = CONFREJ; 01648 wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */ 01649 break; 01650 } 01651 01652 ho->neg_addr = 1; 01653 ho->hisaddr = ciaddr1; 01654 break; 01655 01656 #if LWIP_DNS 01657 case CI_MS_DNS1: 01658 case CI_MS_DNS2: 01659 /* Microsoft primary or secondary DNS request */ 01660 d = citype == CI_MS_DNS2; 01661 01662 /* If we do not have a DNS address then we cannot send it */ 01663 if (ao->dnsaddr[d] == 0 || 01664 cilen != CILEN_ADDR) { /* Check CI length */ 01665 orc = CONFREJ; /* Reject CI */ 01666 break; 01667 } 01668 GETLONG(tl, p); 01669 if (htonl(tl) != ao->dnsaddr[d]) { 01670 DECPTR(sizeof(u32_t), p); 01671 tl = ntohl(ao->dnsaddr[d]); 01672 PUTLONG(tl, p); 01673 orc = CONFNAK; 01674 } 01675 break; 01676 #endif /* LWIP_DNS */ 01677 01678 #if 0 /* UNUSED - WINS */ 01679 case CI_MS_WINS1: 01680 case CI_MS_WINS2: 01681 /* Microsoft primary or secondary WINS request */ 01682 d = citype == CI_MS_WINS2; 01683 01684 /* If we do not have a DNS address then we cannot send it */ 01685 if (ao->winsaddr[d] == 0 || 01686 cilen != CILEN_ADDR) { /* Check CI length */ 01687 orc = CONFREJ; /* Reject CI */ 01688 break; 01689 } 01690 GETLONG(tl, p); 01691 if (htonl(tl) != ao->winsaddr[d]) { 01692 DECPTR(sizeof(u32_t), p); 01693 tl = ntohl(ao->winsaddr[d]); 01694 PUTLONG(tl, p); 01695 orc = CONFNAK; 01696 } 01697 break; 01698 #endif /* UNUSED - WINS */ 01699 01700 #if VJ_SUPPORT 01701 case CI_COMPRESSTYPE: 01702 if (!ao->neg_vj || 01703 (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) { 01704 orc = CONFREJ; 01705 break; 01706 } 01707 GETSHORT(cishort, p); 01708 01709 if (!(cishort == IPCP_VJ_COMP || 01710 (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) { 01711 orc = CONFREJ; 01712 break; 01713 } 01714 01715 ho->neg_vj = 1; 01716 ho->vj_protocol = cishort; 01717 if (cilen == CILEN_VJ) { 01718 GETCHAR(maxslotindex, p); 01719 if (maxslotindex > ao->maxslotindex) { 01720 orc = CONFNAK; 01721 if (!reject_if_disagree){ 01722 DECPTR(1, p); 01723 PUTCHAR(ao->maxslotindex, p); 01724 } 01725 } 01726 GETCHAR(cflag, p); 01727 if (cflag && !ao->cflag) { 01728 orc = CONFNAK; 01729 if (!reject_if_disagree){ 01730 DECPTR(1, p); 01731 PUTCHAR(wo->cflag, p); 01732 } 01733 } 01734 ho->maxslotindex = maxslotindex; 01735 ho->cflag = cflag; 01736 } else { 01737 ho->old_vj = 1; 01738 ho->maxslotindex = MAX_STATES - 1; 01739 ho->cflag = 1; 01740 } 01741 break; 01742 #endif /* VJ_SUPPORT */ 01743 01744 default: 01745 orc = CONFREJ; 01746 break; 01747 } 01748 endswitch: 01749 if (orc == CONFACK && /* Good CI */ 01750 rc != CONFACK) /* but prior CI wasnt? */ 01751 continue; /* Don't send this one */ 01752 01753 if (orc == CONFNAK) { /* Nak this CI? */ 01754 if (reject_if_disagree) /* Getting fed up with sending NAKs? */ 01755 orc = CONFREJ; /* Get tough if so */ 01756 else { 01757 if (rc == CONFREJ) /* Rejecting prior CI? */ 01758 continue; /* Don't send this one */ 01759 if (rc == CONFACK) { /* Ack'd all prior CIs? */ 01760 rc = CONFNAK; /* Not anymore... */ 01761 ucp = inp; /* Backup */ 01762 } 01763 } 01764 } 01765 01766 if (orc == CONFREJ && /* Reject this CI */ 01767 rc != CONFREJ) { /* but no prior ones? */ 01768 rc = CONFREJ; 01769 ucp = inp; /* Backup */ 01770 } 01771 01772 /* Need to move CI? */ 01773 if (ucp != cip) 01774 MEMCPY(ucp, cip, cilen); /* Move it */ 01775 01776 /* Update output pointer */ 01777 INCPTR(cilen, ucp); 01778 } 01779 01780 /* 01781 * If we aren't rejecting this packet, and we want to negotiate 01782 * their address, and they didn't send their address, then we 01783 * send a NAK with a CI_ADDR option appended. We assume the 01784 * input buffer is long enough that we can append the extra 01785 * option safely. 01786 */ 01787 if (rc != CONFREJ && !ho->neg_addr && !ho->old_addrs && 01788 wo->req_addr && !reject_if_disagree && !pcb->settings.noremoteip) { 01789 if (rc == CONFACK) { 01790 rc = CONFNAK; 01791 ucp = inp; /* reset pointer */ 01792 wo->req_addr = 0; /* don't ask again */ 01793 } 01794 PUTCHAR(CI_ADDR, ucp); 01795 PUTCHAR(CILEN_ADDR, ucp); 01796 tl = ntohl(wo->hisaddr); 01797 PUTLONG(tl, ucp); 01798 } 01799 01800 *len = ucp - inp; /* Compute output length */ 01801 IPCPDEBUG(("ipcp: returning Configure-%s", CODENAME(rc))); 01802 return (rc); /* Return final code */ 01803 } 01804 01805 01806 #if 0 /* UNUSED */ 01807 /* 01808 * ip_check_options - check that any IP-related options are OK, 01809 * and assign appropriate defaults. 01810 */ 01811 static void 01812 ip_check_options() 01813 { 01814 struct hostent *hp; 01815 u32_t local; 01816 ipcp_options *wo = &ipcp_wantoptions[0]; 01817 01818 /* 01819 * Default our local IP address based on our hostname. 01820 * If local IP address already given, don't bother. 01821 */ 01822 if (wo->ouraddr == 0 && !disable_defaultip) { 01823 /* 01824 * Look up our hostname (possibly with domain name appended) 01825 * and take the first IP address as our local IP address. 01826 * If there isn't an IP address for our hostname, too bad. 01827 */ 01828 wo->accept_local = 1; /* don't insist on this default value */ 01829 if ((hp = gethostbyname(hostname)) != NULL) { 01830 local = *(u32_t *)hp->h_addr; 01831 if (local != 0 && !bad_ip_adrs(local)) 01832 wo->ouraddr = local; 01833 } 01834 } 01835 ask_for_local = wo->ouraddr != 0 || !disable_defaultip; 01836 } 01837 #endif /* UNUSED */ 01838 01839 #if DEMAND_SUPPORT 01840 /* 01841 * ip_demand_conf - configure the interface as though 01842 * IPCP were up, for use with dial-on-demand. 01843 */ 01844 static int 01845 ip_demand_conf(u) 01846 int u; 01847 { 01848 ppp_pcb *pcb = &ppp_pcb_list[u]; 01849 ipcp_options *wo = &ipcp_wantoptions[u]; 01850 01851 if (wo->hisaddr == 0 && !pcb->settings.noremoteip) { 01852 /* make up an arbitrary address for the peer */ 01853 wo->hisaddr = htonl(0x0a707070 + ifunit); 01854 wo->accept_remote = 1; 01855 } 01856 if (wo->ouraddr == 0) { 01857 /* make up an arbitrary address for us */ 01858 wo->ouraddr = htonl(0x0a404040 + ifunit); 01859 wo->accept_local = 1; 01860 ask_for_local = 0; /* don't tell the peer this address */ 01861 } 01862 if (!sifaddr(pcb, wo->ouraddr, wo->hisaddr, get_mask(wo->ouraddr))) 01863 return 0; 01864 if (!sifup(pcb)) 01865 return 0; 01866 if (!sifnpmode(pcb, PPP_IP, NPMODE_QUEUE)) 01867 return 0; 01868 #if 0 /* UNUSED */ 01869 if (wo->default_route) 01870 if (sifdefaultroute(pcb, wo->ouraddr, wo->hisaddr, 01871 wo->replace_default_route)) 01872 default_route_set[u] = 1; 01873 #endif /* UNUSED */ 01874 #if 0 /* UNUSED - PROXY ARP */ 01875 if (wo->proxy_arp) 01876 if (sifproxyarp(pcb, wo->hisaddr)) 01877 proxy_arp_set[u] = 1; 01878 #endif /* UNUSED - PROXY ARP */ 01879 01880 ppp_notice("local IP address %I", wo->ouraddr); 01881 if (wo->hisaddr) 01882 ppp_notice("remote IP address %I", wo->hisaddr); 01883 01884 return 1; 01885 } 01886 #endif /* DEMAND_SUPPORT */ 01887 01888 /* 01889 * ipcp_up - IPCP has come UP. 01890 * 01891 * Configure the IP network interface appropriately and bring it up. 01892 */ 01893 static void ipcp_up(fsm *f) { 01894 ppp_pcb *pcb = f->pcb; 01895 u32_t mask; 01896 ipcp_options *ho = &pcb->ipcp_hisoptions; 01897 ipcp_options *go = &pcb->ipcp_gotoptions; 01898 ipcp_options *wo = &pcb->ipcp_wantoptions; 01899 01900 IPCPDEBUG(("ipcp: up")); 01901 01902 /* 01903 * We must have a non-zero IP address for both ends of the link. 01904 */ 01905 if (!ho->neg_addr && !ho->old_addrs) 01906 ho->hisaddr = wo->hisaddr; 01907 01908 if (!(go->neg_addr || go->old_addrs) && (wo->neg_addr || wo->old_addrs) 01909 && wo->ouraddr != 0) { 01910 ppp_error("Peer refused to agree to our IP address"); 01911 ipcp_close(f->pcb, "Refused our IP address"); 01912 return; 01913 } 01914 if (go->ouraddr == 0) { 01915 ppp_error("Could not determine local IP address"); 01916 ipcp_close(f->pcb, "Could not determine local IP address"); 01917 return; 01918 } 01919 if (ho->hisaddr == 0 && !pcb->settings.noremoteip) { 01920 ho->hisaddr = htonl(0x0a404040); 01921 ppp_warn("Could not determine remote IP address: defaulting to %I", 01922 ho->hisaddr); 01923 } 01924 #if 0 /* UNUSED */ 01925 script_setenv("IPLOCAL", ip_ntoa(go->ouraddr), 0); 01926 if (ho->hisaddr != 0) 01927 script_setenv("IPREMOTE", ip_ntoa(ho->hisaddr), 1); 01928 #endif /* UNUSED */ 01929 01930 #if LWIP_DNS 01931 if (!go->req_dns1) 01932 go->dnsaddr[0] = 0; 01933 if (!go->req_dns2) 01934 go->dnsaddr[1] = 0; 01935 #if 0 /* UNUSED */ 01936 if (go->dnsaddr[0]) 01937 script_setenv("DNS1", ip_ntoa(go->dnsaddr[0]), 0); 01938 if (go->dnsaddr[1]) 01939 script_setenv("DNS2", ip_ntoa(go->dnsaddr[1]), 0); 01940 #endif /* UNUSED */ 01941 if (pcb->settings.usepeerdns && (go->dnsaddr[0] || go->dnsaddr[1])) { 01942 sdns(pcb, go->dnsaddr[0], go->dnsaddr[1]); 01943 #if 0 /* UNUSED */ 01944 script_setenv("USEPEERDNS", "1", 0); 01945 create_resolv(go->dnsaddr[0], go->dnsaddr[1]); 01946 #endif /* UNUSED */ 01947 } 01948 #endif /* LWIP_DNS */ 01949 01950 /* FIXME: check why it fails, just to know */ 01951 #if 0 /* Unused */ 01952 /* 01953 * Check that the peer is allowed to use the IP address it wants. 01954 */ 01955 if (ho->hisaddr != 0 && !auth_ip_addr(f->unit, ho->hisaddr)) { 01956 ppp_error("Peer is not authorized to use remote address %I", ho->hisaddr); 01957 ipcp_close(f->unit, "Unauthorized remote IP address"); 01958 return; 01959 } 01960 #endif /* Unused */ 01961 01962 #if VJ_SUPPORT 01963 /* set tcp compression */ 01964 sifvjcomp(pcb, ho->neg_vj, ho->cflag, ho->maxslotindex); 01965 #endif /* VJ_SUPPORT */ 01966 01967 #if DEMAND_SUPPORT 01968 /* 01969 * If we are doing dial-on-demand, the interface is already 01970 * configured, so we put out any saved-up packets, then set the 01971 * interface to pass IP packets. 01972 */ 01973 if (demand) { 01974 if (go->ouraddr != wo->ouraddr || ho->hisaddr != wo->hisaddr) { 01975 ipcp_clear_addrs(f->unit, wo->ouraddr, wo->hisaddr, 01976 wo->replace_default_route); 01977 if (go->ouraddr != wo->ouraddr) { 01978 ppp_warn("Local IP address changed to %I", go->ouraddr); 01979 script_setenv("OLDIPLOCAL", ip_ntoa(wo->ouraddr), 0); 01980 wo->ouraddr = go->ouraddr; 01981 } else 01982 script_unsetenv("OLDIPLOCAL"); 01983 if (ho->hisaddr != wo->hisaddr && wo->hisaddr != 0) { 01984 ppp_warn("Remote IP address changed to %I", ho->hisaddr); 01985 script_setenv("OLDIPREMOTE", ip_ntoa(wo->hisaddr), 0); 01986 wo->hisaddr = ho->hisaddr; 01987 } else 01988 script_unsetenv("OLDIPREMOTE"); 01989 01990 /* Set the interface to the new addresses */ 01991 mask = get_mask(go->ouraddr); 01992 if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { 01993 #if PPP_DEBUG 01994 ppp_warn("Interface configuration failed"); 01995 #endif /* PPP_DEBUG */ 01996 ipcp_close(f->unit, "Interface configuration failed"); 01997 return; 01998 } 01999 02000 /* assign a default route through the interface if required */ 02001 if (ipcp_wantoptions[f->unit].default_route) 02002 if (sifdefaultroute(pcb, go->ouraddr, ho->hisaddr, 02003 wo->replace_default_route)) 02004 default_route_set[f->unit] = 1; 02005 02006 #if 0 /* UNUSED - PROXY ARP */ 02007 /* Make a proxy ARP entry if requested. */ 02008 if (ho->hisaddr != 0 && ipcp_wantoptions[f->unit].proxy_arp) 02009 if (sifproxyarp(pcb, ho->hisaddr)) 02010 proxy_arp_set[f->unit] = 1; 02011 #endif /* UNUSED - PROXY ARP */ 02012 02013 } 02014 demand_rexmit(PPP_IP,go->ouraddr); 02015 sifnpmode(pcb, PPP_IP, NPMODE_PASS); 02016 02017 } else 02018 #endif /* DEMAND_SUPPORT */ 02019 { 02020 /* 02021 * Set IP addresses and (if specified) netmask. 02022 */ 02023 mask = get_mask(go->ouraddr); 02024 02025 #if !(defined(SVR4) && (defined(SNI) || defined(__USLC__))) 02026 if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { 02027 #if PPP_DEBUG 02028 ppp_warn("Interface configuration failed"); 02029 #endif /* PPP_DEBUG */ 02030 ipcp_close(f->pcb, "Interface configuration failed"); 02031 return; 02032 } 02033 #endif 02034 02035 /* bring the interface up for IP */ 02036 if (!sifup(pcb)) { 02037 #if PPP_DEBUG 02038 ppp_warn("Interface failed to come up"); 02039 #endif /* PPP_DEBUG */ 02040 ipcp_close(f->pcb, "Interface configuration failed"); 02041 return; 02042 } 02043 02044 #if (defined(SVR4) && (defined(SNI) || defined(__USLC__))) 02045 if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { 02046 #if PPP_DEBUG 02047 ppp_warn("Interface configuration failed"); 02048 #endif /* PPP_DEBUG */ 02049 ipcp_close(f->unit, "Interface configuration failed"); 02050 return; 02051 } 02052 #endif 02053 #if DEMAND_SUPPORT 02054 sifnpmode(pcb, PPP_IP, NPMODE_PASS); 02055 #endif /* DEMAND_SUPPORT */ 02056 02057 #if 0 /* UNUSED */ 02058 /* assign a default route through the interface if required */ 02059 if (wo->default_route) 02060 if (sifdefaultroute(pcb, go->ouraddr, ho->hisaddr, 02061 wo->replace_default_route)) 02062 pcb->default_route_set = 1; 02063 #endif /* UNUSED */ 02064 02065 #if 0 /* UNUSED - PROXY ARP */ 02066 /* Make a proxy ARP entry if requested. */ 02067 if (ho->hisaddr != 0 && wo->proxy_arp) 02068 if (sifproxyarp(pcb, ho->hisaddr)) 02069 pcb->proxy_arp_set = 1; 02070 #endif /* UNUSED - PROXY ARP */ 02071 02072 wo->ouraddr = go->ouraddr; 02073 02074 ppp_notice("local IP address %I", go->ouraddr); 02075 if (ho->hisaddr != 0) 02076 ppp_notice("remote IP address %I", ho->hisaddr); 02077 #if LWIP_DNS 02078 if (go->dnsaddr[0]) 02079 ppp_notice("primary DNS address %I", go->dnsaddr[0]); 02080 if (go->dnsaddr[1]) 02081 ppp_notice("secondary DNS address %I", go->dnsaddr[1]); 02082 #endif /* LWIP_DNS */ 02083 } 02084 02085 #if PPP_STATS_SUPPORT 02086 reset_link_stats(f->unit); 02087 #endif /* PPP_STATS_SUPPORT */ 02088 02089 np_up(pcb, PPP_IP); 02090 pcb->ipcp_is_up = 1; 02091 02092 #if PPP_NOTIFY 02093 notify(ip_up_notifier, 0); 02094 #endif /* PPP_NOTIFY */ 02095 #if 0 /* UNUSED */ 02096 if (ip_up_hook) 02097 ip_up_hook(); 02098 #endif /* UNUSED */ 02099 } 02100 02101 02102 /* 02103 * ipcp_down - IPCP has gone DOWN. 02104 * 02105 * Take the IP network interface down, clear its addresses 02106 * and delete routes through it. 02107 */ 02108 static void ipcp_down(fsm *f) { 02109 ppp_pcb *pcb = f->pcb; 02110 ipcp_options *ho = &pcb->ipcp_hisoptions; 02111 ipcp_options *go = &pcb->ipcp_gotoptions; 02112 02113 IPCPDEBUG(("ipcp: down")); 02114 #if PPP_STATS_SUPPORT 02115 /* XXX a bit IPv4-centric here, we only need to get the stats 02116 * before the interface is marked down. */ 02117 /* XXX more correct: we must get the stats before running the notifiers, 02118 * at least for the radius plugin */ 02119 update_link_stats(f->unit); 02120 #endif /* PPP_STATS_SUPPORT */ 02121 #if PPP_NOTIFY 02122 notify(ip_down_notifier, 0); 02123 #endif /* PPP_NOTIFY */ 02124 #if 0 /* UNUSED */ 02125 if (ip_down_hook) 02126 ip_down_hook(); 02127 #endif /* UNUSED */ 02128 if (pcb->ipcp_is_up) { 02129 pcb->ipcp_is_up = 0; 02130 np_down(pcb, PPP_IP); 02131 } 02132 #if VJ_SUPPORT 02133 sifvjcomp(pcb, 0, 0, 0); 02134 #endif /* VJ_SUPPORT */ 02135 02136 #if PPP_STATS_SUPPORT 02137 print_link_stats(); /* _after_ running the notifiers and ip_down_hook(), 02138 * because print_link_stats() sets link_stats_valid 02139 * to 0 (zero) */ 02140 #endif /* PPP_STATS_SUPPORT */ 02141 02142 #if DEMAND_SUPPORT 02143 /* 02144 * If we are doing dial-on-demand, set the interface 02145 * to queue up outgoing packets (for now). 02146 */ 02147 if (demand) { 02148 sifnpmode(pcb, PPP_IP, NPMODE_QUEUE); 02149 } else 02150 #endif /* DEMAND_SUPPORT */ 02151 { 02152 #if DEMAND_SUPPORT 02153 sifnpmode(pcb, PPP_IP, NPMODE_DROP); 02154 #endif /* DEMAND_SUPPORT */ 02155 sifdown(pcb); 02156 ipcp_clear_addrs(pcb, go->ouraddr, 02157 ho->hisaddr, 0); 02158 #if LWIP_DNS 02159 cdns(pcb, go->dnsaddr[0], go->dnsaddr[1]); 02160 #endif /* LWIP_DNS */ 02161 } 02162 } 02163 02164 02165 /* 02166 * ipcp_clear_addrs() - clear the interface addresses, routes, 02167 * proxy arp entries, etc. 02168 */ 02169 static void ipcp_clear_addrs(ppp_pcb *pcb, u32_t ouraddr, u32_t hisaddr, u8_t replacedefaultroute) { 02170 LWIP_UNUSED_ARG(replacedefaultroute); 02171 02172 #if 0 /* UNUSED - PROXY ARP */ 02173 if (pcb->proxy_arp_set) { 02174 cifproxyarp(pcb, hisaddr); 02175 pcb->proxy_arp_set = 0; 02176 } 02177 #endif /* UNUSED - PROXY ARP */ 02178 #if 0 /* UNUSED */ 02179 /* If replacedefaultroute, sifdefaultroute will be called soon 02180 * with replacedefaultroute set and that will overwrite the current 02181 * default route. This is the case only when doing demand, otherwise 02182 * during demand, this cifdefaultroute would restore the old default 02183 * route which is not what we want in this case. In the non-demand 02184 * case, we'll delete the default route and restore the old if there 02185 * is one saved by an sifdefaultroute with replacedefaultroute. 02186 */ 02187 if (!replacedefaultroute && pcb->default_route_set) { 02188 cifdefaultroute(pcb, ouraddr, hisaddr); 02189 pcb->default_route_set = 0; 02190 } 02191 #endif /* UNUSED */ 02192 cifaddr(pcb, ouraddr, hisaddr); 02193 } 02194 02195 02196 /* 02197 * ipcp_finished - possibly shut down the lower layers. 02198 */ 02199 static void ipcp_finished(fsm *f) { 02200 ppp_pcb *pcb = f->pcb; 02201 if (pcb->ipcp_is_open) { 02202 pcb->ipcp_is_open = 0; 02203 np_finished(pcb, PPP_IP); 02204 } 02205 } 02206 02207 02208 #if 0 /* UNUSED */ 02209 /* 02210 * create_resolv - create the replacement resolv.conf file 02211 */ 02212 static void 02213 create_resolv(peerdns1, peerdns2) 02214 u32_t peerdns1, peerdns2; 02215 { 02216 02217 } 02218 #endif /* UNUSED */ 02219 02220 #if PRINTPKT_SUPPORT 02221 /* 02222 * ipcp_printpkt - print the contents of an IPCP packet. 02223 */ 02224 static const char* const ipcp_codenames[] = { 02225 "ConfReq", "ConfAck", "ConfNak", "ConfRej", 02226 "TermReq", "TermAck", "CodeRej" 02227 }; 02228 02229 static int ipcp_printpkt(const u_char *p, int plen, 02230 void (*printer) (void *, const char *, ...), void *arg) { 02231 int code, id, len, olen; 02232 const u_char *pstart, *optend; 02233 #if VJ_SUPPORT 02234 u_short cishort; 02235 #endif /* VJ_SUPPORT */ 02236 u32_t cilong; 02237 02238 if (plen < HEADERLEN) 02239 return 0; 02240 pstart = p; 02241 GETCHAR(code, p); 02242 GETCHAR(id, p); 02243 GETSHORT(len, p); 02244 if (len < HEADERLEN || len > plen) 02245 return 0; 02246 02247 if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ipcp_codenames)) 02248 printer(arg, " %s", ipcp_codenames[code-1]); 02249 else 02250 printer(arg, " code=0x%x", code); 02251 printer(arg, " id=0x%x", id); 02252 len -= HEADERLEN; 02253 switch (code) { 02254 case CONFREQ: 02255 case CONFACK: 02256 case CONFNAK: 02257 case CONFREJ: 02258 /* print option list */ 02259 while (len >= 2) { 02260 GETCHAR(code, p); 02261 GETCHAR(olen, p); 02262 p -= 2; 02263 if (olen < 2 || olen > len) { 02264 break; 02265 } 02266 printer(arg, " <"); 02267 len -= olen; 02268 optend = p + olen; 02269 switch (code) { 02270 case CI_ADDRS: 02271 if (olen == CILEN_ADDRS) { 02272 p += 2; 02273 GETLONG(cilong, p); 02274 printer(arg, "addrs %I", htonl(cilong)); 02275 GETLONG(cilong, p); 02276 printer(arg, " %I", htonl(cilong)); 02277 } 02278 break; 02279 #if VJ_SUPPORT 02280 case CI_COMPRESSTYPE: 02281 if (olen >= CILEN_COMPRESS) { 02282 p += 2; 02283 GETSHORT(cishort, p); 02284 printer(arg, "compress "); 02285 switch (cishort) { 02286 case IPCP_VJ_COMP: 02287 printer(arg, "VJ"); 02288 break; 02289 case IPCP_VJ_COMP_OLD: 02290 printer(arg, "old-VJ"); 02291 break; 02292 default: 02293 printer(arg, "0x%x", cishort); 02294 } 02295 } 02296 break; 02297 #endif /* VJ_SUPPORT */ 02298 case CI_ADDR: 02299 if (olen == CILEN_ADDR) { 02300 p += 2; 02301 GETLONG(cilong, p); 02302 printer(arg, "addr %I", htonl(cilong)); 02303 } 02304 break; 02305 #if LWIP_DNS 02306 case CI_MS_DNS1: 02307 case CI_MS_DNS2: 02308 p += 2; 02309 GETLONG(cilong, p); 02310 printer(arg, "ms-dns%d %I", (code == CI_MS_DNS1? 1: 2), 02311 htonl(cilong)); 02312 break; 02313 #endif /* LWIP_DNS */ 02314 #if 0 /* UNUSED - WINS */ 02315 case CI_MS_WINS1: 02316 case CI_MS_WINS2: 02317 p += 2; 02318 GETLONG(cilong, p); 02319 printer(arg, "ms-wins %I", htonl(cilong)); 02320 break; 02321 #endif /* UNUSED - WINS */ 02322 default: 02323 break; 02324 } 02325 while (p < optend) { 02326 GETCHAR(code, p); 02327 printer(arg, " %.2x", code); 02328 } 02329 printer(arg, ">"); 02330 } 02331 break; 02332 02333 case TERMACK: 02334 case TERMREQ: 02335 if (len > 0 && *p >= ' ' && *p < 0x7f) { 02336 printer(arg, " "); 02337 ppp_print_string(p, len, printer, arg); 02338 p += len; 02339 len = 0; 02340 } 02341 break; 02342 default: 02343 break; 02344 } 02345 02346 /* print the rest of the bytes in the packet */ 02347 for (; len > 0; --len) { 02348 GETCHAR(code, p); 02349 printer(arg, " %.2x", code); 02350 } 02351 02352 return p - pstart; 02353 } 02354 #endif /* PRINTPKT_SUPPORT */ 02355 02356 #if DEMAND_SUPPORT 02357 /* 02358 * ip_active_pkt - see if this IP packet is worth bringing the link up for. 02359 * We don't bring the link up for IP fragments or for TCP FIN packets 02360 * with no data. 02361 */ 02362 #define IP_HDRLEN 20 /* bytes */ 02363 #define IP_OFFMASK 0x1fff 02364 #ifndef IPPROTO_TCP 02365 #define IPPROTO_TCP 6 02366 #endif 02367 #define TCP_HDRLEN 20 02368 #define TH_FIN 0x01 02369 02370 /* 02371 * We use these macros because the IP header may be at an odd address, 02372 * and some compilers might use word loads to get th_off or ip_hl. 02373 */ 02374 02375 #define net_short(x) (((x)[0] << 8) + (x)[1]) 02376 #define get_iphl(x) (((unsigned char *)(x))[0] & 0xF) 02377 #define get_ipoff(x) net_short((unsigned char *)(x) + 6) 02378 #define get_ipproto(x) (((unsigned char *)(x))[9]) 02379 #define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4) 02380 #define get_tcpflags(x) (((unsigned char *)(x))[13]) 02381 02382 static int 02383 ip_active_pkt(pkt, len) 02384 u_char *pkt; 02385 int len; 02386 { 02387 u_char *tcp; 02388 int hlen; 02389 02390 len -= PPP_HDRLEN; 02391 pkt += PPP_HDRLEN; 02392 if (len < IP_HDRLEN) 02393 return 0; 02394 if ((get_ipoff(pkt) & IP_OFFMASK) != 0) 02395 return 0; 02396 if (get_ipproto(pkt) != IPPROTO_TCP) 02397 return 1; 02398 hlen = get_iphl(pkt) * 4; 02399 if (len < hlen + TCP_HDRLEN) 02400 return 0; 02401 tcp = pkt + hlen; 02402 if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == hlen + get_tcpoff(tcp) * 4) 02403 return 0; 02404 return 1; 02405 } 02406 #endif /* DEMAND_SUPPORT */ 02407 02408 #endif /* PPP_SUPPORT && PPP_IPV4_SUPPORT */
Generated on Tue Jul 12 2022 13:15:53 by
1.7.2