ReactOS  0.4.15-dev-1150-g593bcce
ipcp.c
Go to the documentation of this file.
1 
3 /*****************************************************************************
4 * ipcp.c - Network PPP IP Control Protocol program file.
5 *
6 * Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc.
7 * portions Copyright (c) 1997 by Global Election Systems Inc.
8 *
9 * The authors hereby grant permission to use, copy, modify, distribute,
10 * and license this software and its documentation for any purpose, provided
11 * that existing copyright notices are retained in all copies and that this
12 * notice and the following disclaimer are included verbatim in any
13 * distributions. No written agreement, license, or royalty fee is required
14 * for any of the authorized uses.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 ******************************************************************************
28 * REVISION HISTORY
29 *
30 * 03-01-01 Marc Boucher <marc@mbsi.ca>
31 * Ported to lwIP.
32 * 97-12-08 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
33 * Original.
34 *****************************************************************************/
35 /*
36  * ipcp.c - PPP IP Control Protocol.
37  *
38  * Copyright (c) 1989 Carnegie Mellon University.
39  * All rights reserved.
40  *
41  * Redistribution and use in source and binary forms are permitted
42  * provided that the above copyright notice and this paragraph are
43  * duplicated in all such forms and that any documentation,
44  * advertising materials, and other materials related to such
45  * distribution and use acknowledge that the software was developed
46  * by Carnegie Mellon University. The name of the
47  * University may not be used to endorse or promote products derived
48  * from this software without specific prior written permission.
49  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
50  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
51  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
52  */
53 
54 #include "lwip/opt.h"
55 
56 #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
57 
58 #include "ppp_impl.h"
59 #include "pppdebug.h"
60 
61 #include "auth.h"
62 #include "fsm.h"
63 #include "vj.h"
64 #include "ipcp.h"
65 
66 #include "lwip/inet.h"
67 
68 #include <string.h>
69 
70 /* #define OLD_CI_ADDRS 1 */ /* Support deprecated address negotiation. */
71 
72 /* global vars */
73 ipcp_options ipcp_wantoptions[NUM_PPP]; /* Options that we want to request */
74 ipcp_options ipcp_gotoptions[NUM_PPP]; /* Options that peer ack'd */
75 ipcp_options ipcp_allowoptions[NUM_PPP]; /* Options we allow peer to request */
76 ipcp_options ipcp_hisoptions[NUM_PPP]; /* Options that we ack'd */
77 
78 /* local vars */
79 static int default_route_set[NUM_PPP]; /* Have set up a default route */
80 static int cis_received[NUM_PPP]; /* # Conf-Reqs received */
81 
82 
83 /*
84  * Callbacks for fsm code. (CI = Configuration Information)
85  */
86 static void ipcp_resetci (fsm *); /* Reset our CI */
87 static int ipcp_cilen (fsm *); /* Return length of our CI */
88 static void ipcp_addci (fsm *, u_char *, int *); /* Add our CI */
89 static int ipcp_ackci (fsm *, u_char *, int); /* Peer ack'd our CI */
90 static int ipcp_nakci (fsm *, u_char *, int); /* Peer nak'd our CI */
91 static int ipcp_rejci (fsm *, u_char *, int); /* Peer rej'd our CI */
92 static int ipcp_reqci (fsm *, u_char *, int *, int); /* Rcv CI */
93 static void ipcp_up (fsm *); /* We're UP */
94 static void ipcp_down (fsm *); /* We're DOWN */
95 #if PPP_ADDITIONAL_CALLBACKS
96 static void ipcp_script (fsm *, char *); /* Run an up/down script */
97 #endif
98 static void ipcp_finished (fsm *); /* Don't need lower layer */
99 
100 
101 fsm ipcp_fsm[NUM_PPP]; /* IPCP fsm structure */
102 
103 
104 static fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */
105  ipcp_resetci, /* Reset our Configuration Information */
106  ipcp_cilen, /* Length of our Configuration Information */
107  ipcp_addci, /* Add our Configuration Information */
108  ipcp_ackci, /* ACK our Configuration Information */
109  ipcp_nakci, /* NAK our Configuration Information */
110  ipcp_rejci, /* Reject our Configuration Information */
111  ipcp_reqci, /* Request peer's Configuration Information */
112  ipcp_up, /* Called when fsm reaches LS_OPENED state */
113  ipcp_down, /* Called when fsm leaves LS_OPENED state */
114  NULL, /* Called when we want the lower layer up */
115  ipcp_finished, /* Called when we want the lower layer down */
116  NULL, /* Called when Protocol-Reject received */
117  NULL, /* Retransmission is necessary */
118  NULL, /* Called to handle protocol-specific codes */
119  "IPCP" /* String name of protocol */
120 };
121 
122 /*
123  * Protocol entry points from main code.
124  */
125 static void ipcp_init (int);
126 static void ipcp_open (int);
127 static void ipcp_close (int, char *);
128 static void ipcp_lowerup (int);
129 static void ipcp_lowerdown (int);
130 static void ipcp_input (int, u_char *, int);
131 static void ipcp_protrej (int);
132 
133 
134 struct protent ipcp_protent = {
135  PPP_IPCP,
136  ipcp_init,
137  ipcp_input,
138  ipcp_protrej,
139  ipcp_lowerup,
140  ipcp_lowerdown,
141  ipcp_open,
142  ipcp_close,
143 #if PPP_ADDITIONAL_CALLBACKS
144  ipcp_printpkt,
145  NULL,
146 #endif /* PPP_ADDITIONAL_CALLBACKS */
147  1,
148  "IPCP",
149 #if PPP_ADDITIONAL_CALLBACKS
150  ip_check_options,
151  NULL,
152  ip_active_pkt
153 #endif /* PPP_ADDITIONAL_CALLBACKS */
154 };
155 
156 static void ipcp_clear_addrs (int);
157 
158 /*
159  * Lengths of configuration options.
160  */
161 #define CILEN_VOID 2
162 #define CILEN_COMPRESS 4 /* min length for compression protocol opt. */
163 #define CILEN_VJ 6 /* length for RFC1332 Van-Jacobson opt. */
164 #define CILEN_ADDR 6 /* new-style single address option */
165 #define CILEN_ADDRS 10 /* old-style dual address option */
166 
167 
168 #define CODENAME(x) ((x) == CONFACK ? "ACK" : \
169  (x) == CONFNAK ? "NAK" : "REJ")
170 
171 
172 /*
173  * ipcp_init - Initialize IPCP.
174  */
175 static void
176 ipcp_init(int unit)
177 {
178  fsm *f = &ipcp_fsm[unit];
181 
182  f->unit = unit;
183  f->protocol = PPP_IPCP;
184  f->callbacks = &ipcp_callbacks;
186 
187  memset(wo, 0, sizeof(*wo));
188  memset(ao, 0, sizeof(*ao));
189 
190  wo->neg_addr = 1;
191  wo->ouraddr = 0;
192 #if VJ_SUPPORT
193  wo->neg_vj = 1;
194 #else /* VJ_SUPPORT */
195  wo->neg_vj = 0;
196 #endif /* VJ_SUPPORT */
198  wo->maxslotindex = MAX_SLOTS - 1;
199  wo->cflag = 0;
200  wo->default_route = 1;
201 
202  ao->neg_addr = 1;
203 #if VJ_SUPPORT
204  ao->neg_vj = 1;
205 #else /* VJ_SUPPORT */
206  ao->neg_vj = 0;
207 #endif /* VJ_SUPPORT */
208  ao->maxslotindex = MAX_SLOTS - 1;
209  ao->cflag = 1;
210  ao->default_route = 1;
211 }
212 
213 
214 /*
215  * ipcp_open - IPCP is allowed to come up.
216  */
217 static void
218 ipcp_open(int unit)
219 {
221 }
222 
223 
224 /*
225  * ipcp_close - Take IPCP down.
226  */
227 static void
228 ipcp_close(int unit, char *reason)
229 {
231 }
232 
233 
234 /*
235  * ipcp_lowerup - The lower layer is up.
236  */
237 static void
238 ipcp_lowerup(int unit)
239 {
241 }
242 
243 
244 /*
245  * ipcp_lowerdown - The lower layer is down.
246  */
247 static void
248 ipcp_lowerdown(int unit)
249 {
251 }
252 
253 
254 /*
255  * ipcp_input - Input IPCP packet.
256  */
257 static void
258 ipcp_input(int unit, u_char *p, int len)
259 {
260  fsm_input(&ipcp_fsm[unit], p, len);
261 }
262 
263 
264 /*
265  * ipcp_protrej - A Protocol-Reject was received for IPCP.
266  *
267  * Pretend the lower layer went down, so we shut up.
268  */
269 static void
270 ipcp_protrej(int unit)
271 {
273 }
274 
275 
276 /*
277  * ipcp_resetci - Reset our CI.
278  */
279 static void
280 ipcp_resetci(fsm *f)
281 {
282  ipcp_options *wo = &ipcp_wantoptions[f->unit];
283 
284  wo->req_addr = wo->neg_addr && ipcp_allowoptions[f->unit].neg_addr;
285  if (wo->ouraddr == 0) {
286  wo->accept_local = 1;
287  }
288  if (wo->hisaddr == 0) {
289  wo->accept_remote = 1;
290  }
291  /* Request DNS addresses from the peer */
292  wo->req_dns1 = ppp_settings.usepeerdns;
293  wo->req_dns2 = ppp_settings.usepeerdns;
294  ipcp_gotoptions[f->unit] = *wo;
295  cis_received[f->unit] = 0;
296 }
297 
298 
299 /*
300  * ipcp_cilen - Return length of our CI.
301  */
302 static int
303 ipcp_cilen(fsm *f)
304 {
305  ipcp_options *go = &ipcp_gotoptions[f->unit];
306  ipcp_options *wo = &ipcp_wantoptions[f->unit];
307  ipcp_options *ho = &ipcp_hisoptions[f->unit];
308 
309 #define LENCIVJ(neg, old) (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0)
310 #define LENCIADDR(neg, old) (neg ? (old? CILEN_ADDRS : CILEN_ADDR) : 0)
311 #define LENCIDNS(neg) (neg ? (CILEN_ADDR) : 0)
312 
313  /*
314  * First see if we want to change our options to the old
315  * forms because we have received old forms from the peer.
316  */
317  if (wo->neg_addr && !go->neg_addr && !go->old_addrs) {
318  /* use the old style of address negotiation */
319  go->neg_addr = 1;
320  go->old_addrs = 1;
321  }
322  if (wo->neg_vj && !go->neg_vj && !go->old_vj) {
323  /* try an older style of VJ negotiation */
324  if (cis_received[f->unit] == 0) {
325  /* keep trying the new style until we see some CI from the peer */
326  go->neg_vj = 1;
327  } else {
328  /* use the old style only if the peer did */
329  if (ho->neg_vj && ho->old_vj) {
330  go->neg_vj = 1;
331  go->old_vj = 1;
332  go->vj_protocol = ho->vj_protocol;
333  }
334  }
335  }
336 
337  return (LENCIADDR(go->neg_addr, go->old_addrs) +
338  LENCIVJ(go->neg_vj, go->old_vj) +
339  LENCIDNS(go->req_dns1) +
340  LENCIDNS(go->req_dns2));
341 }
342 
343 
344 /*
345  * ipcp_addci - Add our desired CIs to a packet.
346  */
347 static void
348 ipcp_addci(fsm *f, u_char *ucp, int *lenp)
349 {
350  ipcp_options *go = &ipcp_gotoptions[f->unit];
351  int len = *lenp;
352 
353 #define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) \
354  if (neg) { \
355  int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \
356  if (len >= vjlen) { \
357  PUTCHAR(opt, ucp); \
358  PUTCHAR(vjlen, ucp); \
359  PUTSHORT(val, ucp); \
360  if (!old) { \
361  PUTCHAR(maxslotindex, ucp); \
362  PUTCHAR(cflag, ucp); \
363  } \
364  len -= vjlen; \
365  } else { \
366  neg = 0; \
367  } \
368  }
369 
370 #define ADDCIADDR(opt, neg, old, val1, val2) \
371  if (neg) { \
372  int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); \
373  if (len >= addrlen) { \
374  u32_t l; \
375  PUTCHAR(opt, ucp); \
376  PUTCHAR(addrlen, ucp); \
377  l = ntohl(val1); \
378  PUTLONG(l, ucp); \
379  if (old) { \
380  l = ntohl(val2); \
381  PUTLONG(l, ucp); \
382  } \
383  len -= addrlen; \
384  } else { \
385  neg = 0; \
386  } \
387  }
388 
389 #define ADDCIDNS(opt, neg, addr) \
390  if (neg) { \
391  if (len >= CILEN_ADDR) { \
392  u32_t l; \
393  PUTCHAR(opt, ucp); \
394  PUTCHAR(CILEN_ADDR, ucp); \
395  l = ntohl(addr); \
396  PUTLONG(l, ucp); \
397  len -= CILEN_ADDR; \
398  } else { \
399  neg = 0; \
400  } \
401  }
402 
403  ADDCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
404  go->old_addrs, go->ouraddr, go->hisaddr);
405 
406  ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
407  go->maxslotindex, go->cflag);
408 
409  ADDCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]);
410 
411  ADDCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]);
412 
413  *lenp -= len;
414 }
415 
416 
417 /*
418  * ipcp_ackci - Ack our CIs.
419  *
420  * Returns:
421  * 0 - Ack was bad.
422  * 1 - Ack was good.
423  */
424 static int
425 ipcp_ackci(fsm *f, u_char *p, int len)
426 {
427  ipcp_options *go = &ipcp_gotoptions[f->unit];
428  u_short cilen, citype, cishort;
429  u32_t cilong;
430  u_char cimaxslotindex, cicflag;
431 
432  /*
433  * CIs must be in exactly the same order that we sent...
434  * Check packet length and CI length at each step.
435  * If we find any deviations, then this packet is bad.
436  */
437 
438 #define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) \
439  if (neg) { \
440  int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \
441  if ((len -= vjlen) < 0) { \
442  goto bad; \
443  } \
444  GETCHAR(citype, p); \
445  GETCHAR(cilen, p); \
446  if (cilen != vjlen || \
447  citype != opt) { \
448  goto bad; \
449  } \
450  GETSHORT(cishort, p); \
451  if (cishort != val) { \
452  goto bad; \
453  } \
454  if (!old) { \
455  GETCHAR(cimaxslotindex, p); \
456  if (cimaxslotindex != maxslotindex) { \
457  goto bad; \
458  } \
459  GETCHAR(cicflag, p); \
460  if (cicflag != cflag) { \
461  goto bad; \
462  } \
463  } \
464  }
465 
466 #define ACKCIADDR(opt, neg, old, val1, val2) \
467  if (neg) { \
468  int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); \
469  u32_t l; \
470  if ((len -= addrlen) < 0) { \
471  goto bad; \
472  } \
473  GETCHAR(citype, p); \
474  GETCHAR(cilen, p); \
475  if (cilen != addrlen || \
476  citype != opt) { \
477  goto bad; \
478  } \
479  GETLONG(l, p); \
480  cilong = htonl(l); \
481  if (val1 != cilong) { \
482  goto bad; \
483  } \
484  if (old) { \
485  GETLONG(l, p); \
486  cilong = htonl(l); \
487  if (val2 != cilong) { \
488  goto bad; \
489  } \
490  } \
491  }
492 
493 #define ACKCIDNS(opt, neg, addr) \
494  if (neg) { \
495  u32_t l; \
496  if ((len -= CILEN_ADDR) < 0) { \
497  goto bad; \
498  } \
499  GETCHAR(citype, p); \
500  GETCHAR(cilen, p); \
501  if (cilen != CILEN_ADDR || \
502  citype != opt) { \
503  goto bad; \
504  } \
505  GETLONG(l, p); \
506  cilong = htonl(l); \
507  if (addr != cilong) { \
508  goto bad; \
509  } \
510  }
511 
512  ACKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
513  go->old_addrs, go->ouraddr, go->hisaddr);
514 
515  ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
516  go->maxslotindex, go->cflag);
517 
518  ACKCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]);
519 
520  ACKCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]);
521 
522  /*
523  * If there are any remaining CIs, then this packet is bad.
524  */
525  if (len != 0) {
526  goto bad;
527  }
528  return (1);
529 
530 bad:
531  IPCPDEBUG(LOG_INFO, ("ipcp_ackci: received bad Ack!\n"));
532  return (0);
533 }
534 
535 /*
536  * ipcp_nakci - Peer has sent a NAK for some of our CIs.
537  * This should not modify any state if the Nak is bad
538  * or if IPCP is in the LS_OPENED state.
539  *
540  * Returns:
541  * 0 - Nak was bad.
542  * 1 - Nak was good.
543  */
544 static int
545 ipcp_nakci(fsm *f, u_char *p, int len)
546 {
547  ipcp_options *go = &ipcp_gotoptions[f->unit];
548  u_char cimaxslotindex, cicflag;
549  u_char citype, cilen, *next;
550  u_short cishort;
551  u32_t ciaddr1, ciaddr2, l, cidnsaddr;
552  ipcp_options no; /* options we've seen Naks for */
553  ipcp_options try; /* options to request next time */
554 
555  BZERO(&no, sizeof(no));
556  try = *go;
557 
558  /*
559  * Any Nak'd CIs must be in exactly the same order that we sent.
560  * Check packet length and CI length at each step.
561  * If we find any deviations, then this packet is bad.
562  */
563 #define NAKCIADDR(opt, neg, old, code) \
564  if (go->neg && \
565  len >= (cilen = (old? CILEN_ADDRS: CILEN_ADDR)) && \
566  p[1] == cilen && \
567  p[0] == opt) { \
568  len -= cilen; \
569  INCPTR(2, p); \
570  GETLONG(l, p); \
571  ciaddr1 = htonl(l); \
572  if (old) { \
573  GETLONG(l, p); \
574  ciaddr2 = htonl(l); \
575  no.old_addrs = 1; \
576  } else { \
577  ciaddr2 = 0; \
578  } \
579  no.neg = 1; \
580  code \
581  }
582 
583 #define NAKCIVJ(opt, neg, code) \
584  if (go->neg && \
585  ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \
586  len >= cilen && \
587  p[0] == opt) { \
588  len -= cilen; \
589  INCPTR(2, p); \
590  GETSHORT(cishort, p); \
591  no.neg = 1; \
592  code \
593  }
594 
595 #define NAKCIDNS(opt, neg, code) \
596  if (go->neg && \
597  ((cilen = p[1]) == CILEN_ADDR) && \
598  len >= cilen && \
599  p[0] == opt) { \
600  len -= cilen; \
601  INCPTR(2, p); \
602  GETLONG(l, p); \
603  cidnsaddr = htonl(l); \
604  no.neg = 1; \
605  code \
606  }
607 
608  /*
609  * Accept the peer's idea of {our,his} address, if different
610  * from our idea, only if the accept_{local,remote} flag is set.
611  */
612  NAKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr, go->old_addrs,
613  if (go->accept_local && ciaddr1) { /* Do we know our address? */
614  try.ouraddr = ciaddr1;
615  IPCPDEBUG(LOG_INFO, ("local IP address %s\n",
616  inet_ntoa(ciaddr1)));
617  }
618  if (go->accept_remote && ciaddr2) { /* Does he know his? */
619  try.hisaddr = ciaddr2;
620  IPCPDEBUG(LOG_INFO, ("remote IP address %s\n",
621  inet_ntoa(ciaddr2)));
622  }
623  );
624 
625  /*
626  * Accept the peer's value of maxslotindex provided that it
627  * is less than what we asked for. Turn off slot-ID compression
628  * if the peer wants. Send old-style compress-type option if
629  * the peer wants.
630  */
631  NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
632  if (cilen == CILEN_VJ) {
633  GETCHAR(cimaxslotindex, p);
634  GETCHAR(cicflag, p);
635  if (cishort == IPCP_VJ_COMP) {
636  try.old_vj = 0;
637  if (cimaxslotindex < go->maxslotindex) {
638  try.maxslotindex = cimaxslotindex;
639  }
640  if (!cicflag) {
641  try.cflag = 0;
642  }
643  } else {
644  try.neg_vj = 0;
645  }
646  } else {
647  if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) {
648  try.old_vj = 1;
649  try.vj_protocol = cishort;
650  } else {
651  try.neg_vj = 0;
652  }
653  }
654  );
655 
656  NAKCIDNS(CI_MS_DNS1, req_dns1,
657  try.dnsaddr[0] = cidnsaddr;
658  IPCPDEBUG(LOG_INFO, ("primary DNS address %s\n", inet_ntoa(cidnsaddr)));
659  );
660 
661  NAKCIDNS(CI_MS_DNS2, req_dns2,
662  try.dnsaddr[1] = cidnsaddr;
663  IPCPDEBUG(LOG_INFO, ("secondary DNS address %s\n", inet_ntoa(cidnsaddr)));
664  );
665 
666  /*
667  * There may be remaining CIs, if the peer is requesting negotiation
668  * on an option that we didn't include in our request packet.
669  * If they want to negotiate about IP addresses, we comply.
670  * If they want us to ask for compression, we refuse.
671  */
672  while (len > CILEN_VOID) {
673  GETCHAR(citype, p);
674  GETCHAR(cilen, p);
675  if( (len -= cilen) < 0 ) {
676  goto bad;
677  }
678  next = p + cilen - 2;
679 
680  switch (citype) {
681  case CI_COMPRESSTYPE:
682  if (go->neg_vj || no.neg_vj ||
683  (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) {
684  goto bad;
685  }
686  no.neg_vj = 1;
687  break;
688  case CI_ADDRS:
689  if ((go->neg_addr && go->old_addrs) || no.old_addrs
690  || cilen != CILEN_ADDRS) {
691  goto bad;
692  }
693  try.neg_addr = 1;
694  try.old_addrs = 1;
695  GETLONG(l, p);
696  ciaddr1 = htonl(l);
697  if (ciaddr1 && go->accept_local) {
698  try.ouraddr = ciaddr1;
699  }
700  GETLONG(l, p);
701  ciaddr2 = htonl(l);
702  if (ciaddr2 && go->accept_remote) {
703  try.hisaddr = ciaddr2;
704  }
705  no.old_addrs = 1;
706  break;
707  case CI_ADDR:
708  if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR) {
709  goto bad;
710  }
711  try.old_addrs = 0;
712  GETLONG(l, p);
713  ciaddr1 = htonl(l);
714  if (ciaddr1 && go->accept_local) {
715  try.ouraddr = ciaddr1;
716  }
717  if (try.ouraddr != 0) {
718  try.neg_addr = 1;
719  }
720  no.neg_addr = 1;
721  break;
722  }
723  p = next;
724  }
725 
726  /* If there is still anything left, this packet is bad. */
727  if (len != 0) {
728  goto bad;
729  }
730 
731  /*
732  * OK, the Nak is good. Now we can update state.
733  */
734  if (f->state != LS_OPENED) {
735  *go = try;
736  }
737 
738  return 1;
739 
740 bad:
741  IPCPDEBUG(LOG_INFO, ("ipcp_nakci: received bad Nak!\n"));
742  return 0;
743 }
744 
745 
746 /*
747  * ipcp_rejci - Reject some of our CIs.
748  */
749 static int
750 ipcp_rejci(fsm *f, u_char *p, int len)
751 {
752  ipcp_options *go = &ipcp_gotoptions[f->unit];
753  u_char cimaxslotindex, ciflag, cilen;
754  u_short cishort;
755  u32_t cilong;
756  ipcp_options try; /* options to request next time */
757 
758  try = *go;
759  /*
760  * Any Rejected CIs must be in exactly the same order that we sent.
761  * Check packet length and CI length at each step.
762  * If we find any deviations, then this packet is bad.
763  */
764 #define REJCIADDR(opt, neg, old, val1, val2) \
765  if (go->neg && \
766  len >= (cilen = old? CILEN_ADDRS: CILEN_ADDR) && \
767  p[1] == cilen && \
768  p[0] == opt) { \
769  u32_t l; \
770  len -= cilen; \
771  INCPTR(2, p); \
772  GETLONG(l, p); \
773  cilong = htonl(l); \
774  /* Check rejected value. */ \
775  if (cilong != val1) { \
776  goto bad; \
777  } \
778  if (old) { \
779  GETLONG(l, p); \
780  cilong = htonl(l); \
781  /* Check rejected value. */ \
782  if (cilong != val2) { \
783  goto bad; \
784  } \
785  } \
786  try.neg = 0; \
787  }
788 
789 #define REJCIVJ(opt, neg, val, old, maxslot, cflag) \
790  if (go->neg && \
791  p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && \
792  len >= p[1] && \
793  p[0] == opt) { \
794  len -= p[1]; \
795  INCPTR(2, p); \
796  GETSHORT(cishort, p); \
797  /* Check rejected value. */ \
798  if (cishort != val) { \
799  goto bad; \
800  } \
801  if (!old) { \
802  GETCHAR(cimaxslotindex, p); \
803  if (cimaxslotindex != maxslot) { \
804  goto bad; \
805  } \
806  GETCHAR(ciflag, p); \
807  if (ciflag != cflag) { \
808  goto bad; \
809  } \
810  } \
811  try.neg = 0; \
812  }
813 
814 #define REJCIDNS(opt, neg, dnsaddr) \
815  if (go->neg && \
816  ((cilen = p[1]) == CILEN_ADDR) && \
817  len >= cilen && \
818  p[0] == opt) { \
819  u32_t l; \
820  len -= cilen; \
821  INCPTR(2, p); \
822  GETLONG(l, p); \
823  cilong = htonl(l); \
824  /* Check rejected value. */ \
825  if (cilong != dnsaddr) { \
826  goto bad; \
827  } \
828  try.neg = 0; \
829  }
830 
831  REJCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr,
832  go->old_addrs, go->ouraddr, go->hisaddr);
833 
834  REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj,
835  go->maxslotindex, go->cflag);
836 
837  REJCIDNS(CI_MS_DNS1, req_dns1, go->dnsaddr[0]);
838 
839  REJCIDNS(CI_MS_DNS2, req_dns2, go->dnsaddr[1]);
840 
841  /*
842  * If there are any remaining CIs, then this packet is bad.
843  */
844  if (len != 0) {
845  goto bad;
846  }
847  /*
848  * Now we can update state.
849  */
850  if (f->state != LS_OPENED) {
851  *go = try;
852  }
853  return 1;
854 
855 bad:
856  IPCPDEBUG(LOG_INFO, ("ipcp_rejci: received bad Reject!\n"));
857  return 0;
858 }
859 
860 
861 /*
862  * ipcp_reqci - Check the peer's requested CIs and send appropriate response.
863  *
864  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
865  * appropriately. If reject_if_disagree is non-zero, doesn't return
866  * CONFNAK; returns CONFREJ if it can't return CONFACK.
867  */
868 static int
869 ipcp_reqci(fsm *f, u_char *inp/* Requested CIs */,int *len/* Length of requested CIs */,int reject_if_disagree)
870 {
871  ipcp_options *wo = &ipcp_wantoptions[f->unit];
872  ipcp_options *ho = &ipcp_hisoptions[f->unit];
873  ipcp_options *ao = &ipcp_allowoptions[f->unit];
874 #ifdef OLD_CI_ADDRS
875  ipcp_options *go = &ipcp_gotoptions[f->unit];
876 #endif
877  u_char *cip, *next; /* Pointer to current and next CIs */
878  u_short cilen, citype; /* Parsed len, type */
879  u_short cishort; /* Parsed short value */
880  u32_t tl, ciaddr1; /* Parsed address values */
881 #ifdef OLD_CI_ADDRS
882  u32_t ciaddr2; /* Parsed address values */
883 #endif
884  int rc = CONFACK; /* Final packet return code */
885  int orc; /* Individual option return code */
886  u_char *p; /* Pointer to next char to parse */
887  u_char *ucp = inp; /* Pointer to current output char */
888  int l = *len; /* Length left */
889  u_char maxslotindex, cflag;
890  int d;
891 
892  cis_received[f->unit] = 1;
893 
894  /*
895  * Reset all his options.
896  */
897  BZERO(ho, sizeof(*ho));
898 
899  /*
900  * Process all his options.
901  */
902  next = inp;
903  while (l) {
904  orc = CONFACK; /* Assume success */
905  cip = p = next; /* Remember begining of CI */
906  if (l < 2 || /* Not enough data for CI header or */
907  p[1] < 2 || /* CI length too small or */
908  p[1] > l) { /* CI length too big? */
909  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: bad CI length!\n"));
910  orc = CONFREJ; /* Reject bad CI */
911  cilen = (u_short)l;/* Reject till end of packet */
912  l = 0; /* Don't loop again */
913  goto endswitch;
914  }
915  GETCHAR(citype, p); /* Parse CI type */
916  GETCHAR(cilen, p); /* Parse CI length */
917  l -= cilen; /* Adjust remaining length */
918  next += cilen; /* Step to next CI */
919 
920  switch (citype) { /* Check CI type */
921 #ifdef OLD_CI_ADDRS /* Need to save space... */
922  case CI_ADDRS:
923  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: received ADDRS\n"));
924  if (!ao->neg_addr ||
925  cilen != CILEN_ADDRS) { /* Check CI length */
926  orc = CONFREJ; /* Reject CI */
927  break;
928  }
929 
930  /*
931  * If he has no address, or if we both have his address but
932  * disagree about it, then NAK it with our idea.
933  * In particular, if we don't know his address, but he does,
934  * then accept it.
935  */
936  GETLONG(tl, p); /* Parse source address (his) */
937  ciaddr1 = htonl(tl);
938  IPCPDEBUG(LOG_INFO, ("his addr %s\n", inet_ntoa(ciaddr1)));
939  if (ciaddr1 != wo->hisaddr
940  && (ciaddr1 == 0 || !wo->accept_remote)) {
941  orc = CONFNAK;
942  if (!reject_if_disagree) {
943  DECPTR(sizeof(u32_t), p);
944  tl = ntohl(wo->hisaddr);
945  PUTLONG(tl, p);
946  }
947  } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
948  /*
949  * If neither we nor he knows his address, reject the option.
950  */
951  orc = CONFREJ;
952  wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */
953  break;
954  }
955 
956  /*
957  * If he doesn't know our address, or if we both have our address
958  * but disagree about it, then NAK it with our idea.
959  */
960  GETLONG(tl, p); /* Parse desination address (ours) */
961  ciaddr2 = htonl(tl);
962  IPCPDEBUG(LOG_INFO, ("our addr %s\n", inet_ntoa(ciaddr2)));
963  if (ciaddr2 != wo->ouraddr) {
964  if (ciaddr2 == 0 || !wo->accept_local) {
965  orc = CONFNAK;
966  if (!reject_if_disagree) {
967  DECPTR(sizeof(u32_t), p);
968  tl = ntohl(wo->ouraddr);
969  PUTLONG(tl, p);
970  }
971  } else {
972  go->ouraddr = ciaddr2; /* accept peer's idea */
973  }
974  }
975 
976  ho->neg_addr = 1;
977  ho->old_addrs = 1;
978  ho->hisaddr = ciaddr1;
979  ho->ouraddr = ciaddr2;
980  break;
981 #endif
982 
983  case CI_ADDR:
984  if (!ao->neg_addr) {
985  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Reject ADDR not allowed\n"));
986  orc = CONFREJ; /* Reject CI */
987  break;
988  } else if (cilen != CILEN_ADDR) { /* Check CI length */
989  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Reject ADDR bad len\n"));
990  orc = CONFREJ; /* Reject CI */
991  break;
992  }
993 
994  /*
995  * If he has no address, or if we both have his address but
996  * disagree about it, then NAK it with our idea.
997  * In particular, if we don't know his address, but he does,
998  * then accept it.
999  */
1000  GETLONG(tl, p); /* Parse source address (his) */
1001  ciaddr1 = htonl(tl);
1002  if (ciaddr1 != wo->hisaddr
1003  && (ciaddr1 == 0 || !wo->accept_remote)) {
1004  orc = CONFNAK;
1005  if (!reject_if_disagree) {
1006  DECPTR(sizeof(u32_t), p);
1007  tl = ntohl(wo->hisaddr);
1008  PUTLONG(tl, p);
1009  }
1010  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Nak ADDR %s\n", inet_ntoa(ciaddr1)));
1011  } else if (ciaddr1 == 0 && wo->hisaddr == 0) {
1012  /*
1013  * Don't ACK an address of 0.0.0.0 - reject it instead.
1014  */
1015  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Reject ADDR %s\n", inet_ntoa(ciaddr1)));
1016  orc = CONFREJ;
1017  wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */
1018  break;
1019  }
1020 
1021  ho->neg_addr = 1;
1022  ho->hisaddr = ciaddr1;
1023  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: ADDR %s\n", inet_ntoa(ciaddr1)));
1024  break;
1025 
1026  case CI_MS_DNS1:
1027  case CI_MS_DNS2:
1028  /* Microsoft primary or secondary DNS request */
1029  d = citype == CI_MS_DNS2;
1030 
1031  /* If we do not have a DNS address then we cannot send it */
1032  if (ao->dnsaddr[d] == 0 ||
1033  cilen != CILEN_ADDR) { /* Check CI length */
1034  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Rejecting DNS%d Request\n", d+1));
1035  orc = CONFREJ; /* Reject CI */
1036  break;
1037  }
1038  GETLONG(tl, p);
1039  if (htonl(tl) != ao->dnsaddr[d]) {
1040  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Naking DNS%d Request %s\n",
1041  d+1, inet_ntoa(tl)));
1042  DECPTR(sizeof(u32_t), p);
1043  tl = ntohl(ao->dnsaddr[d]);
1044  PUTLONG(tl, p);
1045  orc = CONFNAK;
1046  }
1047  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: received DNS%d Request\n", d+1));
1048  break;
1049 
1050  case CI_MS_WINS1:
1051  case CI_MS_WINS2:
1052  /* Microsoft primary or secondary WINS request */
1053  d = citype == CI_MS_WINS2;
1054  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: received WINS%d Request\n", d+1));
1055 
1056  /* If we do not have a DNS address then we cannot send it */
1057  if (ao->winsaddr[d] == 0 ||
1058  cilen != CILEN_ADDR) { /* Check CI length */
1059  orc = CONFREJ; /* Reject CI */
1060  break;
1061  }
1062  GETLONG(tl, p);
1063  if (htonl(tl) != ao->winsaddr[d]) {
1064  DECPTR(sizeof(u32_t), p);
1065  tl = ntohl(ao->winsaddr[d]);
1066  PUTLONG(tl, p);
1067  orc = CONFNAK;
1068  }
1069  break;
1070 
1071  case CI_COMPRESSTYPE:
1072  if (!ao->neg_vj) {
1073  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Rejecting COMPRESSTYPE not allowed\n"));
1074  orc = CONFREJ;
1075  break;
1076  } else if (cilen != CILEN_VJ && cilen != CILEN_COMPRESS) {
1077  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Rejecting COMPRESSTYPE len=%d\n", cilen));
1078  orc = CONFREJ;
1079  break;
1080  }
1081  GETSHORT(cishort, p);
1082 
1083  if (!(cishort == IPCP_VJ_COMP ||
1084  (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) {
1085  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Rejecting COMPRESSTYPE %d\n", cishort));
1086  orc = CONFREJ;
1087  break;
1088  }
1089 
1090  ho->neg_vj = 1;
1091  ho->vj_protocol = cishort;
1092  if (cilen == CILEN_VJ) {
1093  GETCHAR(maxslotindex, p);
1094  if (maxslotindex > ao->maxslotindex) {
1095  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Naking VJ max slot %d\n", maxslotindex));
1096  orc = CONFNAK;
1097  if (!reject_if_disagree) {
1098  DECPTR(1, p);
1099  PUTCHAR(ao->maxslotindex, p);
1100  }
1101  }
1102  GETCHAR(cflag, p);
1103  if (cflag && !ao->cflag) {
1104  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Naking VJ cflag %d\n", cflag));
1105  orc = CONFNAK;
1106  if (!reject_if_disagree) {
1107  DECPTR(1, p);
1108  PUTCHAR(wo->cflag, p);
1109  }
1110  }
1111  ho->maxslotindex = maxslotindex;
1112  ho->cflag = cflag;
1113  } else {
1114  ho->old_vj = 1;
1115  ho->maxslotindex = MAX_SLOTS - 1;
1116  ho->cflag = 1;
1117  }
1118  IPCPDEBUG(LOG_INFO, (
1119  "ipcp_reqci: received COMPRESSTYPE p=%d old=%d maxslot=%d cflag=%d\n",
1120  ho->vj_protocol, ho->old_vj, ho->maxslotindex, ho->cflag));
1121  break;
1122 
1123  default:
1124  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Rejecting unknown CI type %d\n", citype));
1125  orc = CONFREJ;
1126  break;
1127  }
1128 
1129 endswitch:
1130  if (orc == CONFACK && /* Good CI */
1131  rc != CONFACK) { /* but prior CI wasnt? */
1132  continue; /* Don't send this one */
1133  }
1134 
1135  if (orc == CONFNAK) { /* Nak this CI? */
1136  if (reject_if_disagree) { /* Getting fed up with sending NAKs? */
1137  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Rejecting too many naks\n"));
1138  orc = CONFREJ; /* Get tough if so */
1139  } else {
1140  if (rc == CONFREJ) { /* Rejecting prior CI? */
1141  continue; /* Don't send this one */
1142  }
1143  if (rc == CONFACK) { /* Ack'd all prior CIs? */
1144  rc = CONFNAK; /* Not anymore... */
1145  ucp = inp; /* Backup */
1146  }
1147  }
1148  }
1149 
1150  if (orc == CONFREJ && /* Reject this CI */
1151  rc != CONFREJ) { /* but no prior ones? */
1152  rc = CONFREJ;
1153  ucp = inp; /* Backup */
1154  }
1155 
1156  /* Need to move CI? */
1157  if (ucp != cip) {
1158  BCOPY(cip, ucp, cilen); /* Move it */
1159  }
1160 
1161  /* Update output pointer */
1162  INCPTR(cilen, ucp);
1163  }
1164 
1165  /*
1166  * If we aren't rejecting this packet, and we want to negotiate
1167  * their address, and they didn't send their address, then we
1168  * send a NAK with a CI_ADDR option appended. We assume the
1169  * input buffer is long enough that we can append the extra
1170  * option safely.
1171  */
1172  if (rc != CONFREJ && !ho->neg_addr &&
1173  wo->req_addr && !reject_if_disagree) {
1174  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: Requesting peer address\n"));
1175  if (rc == CONFACK) {
1176  rc = CONFNAK;
1177  ucp = inp; /* reset pointer */
1178  wo->req_addr = 0; /* don't ask again */
1179  }
1180  PUTCHAR(CI_ADDR, ucp);
1181  PUTCHAR(CILEN_ADDR, ucp);
1182  tl = ntohl(wo->hisaddr);
1183  PUTLONG(tl, ucp);
1184  }
1185 
1186  *len = (int)(ucp - inp); /* Compute output length */
1187  IPCPDEBUG(LOG_INFO, ("ipcp_reqci: returning Configure-%s\n", CODENAME(rc)));
1188  return (rc); /* Return final code */
1189 }
1190 
1191 
1192 #if 0
1193 /*
1194  * ip_check_options - check that any IP-related options are OK,
1195  * and assign appropriate defaults.
1196  */
1197 static void
1198 ip_check_options(u_long localAddr)
1199 {
1200  ipcp_options *wo = &ipcp_wantoptions[0];
1201 
1202  /*
1203  * Load our default IP address but allow the remote host to give us
1204  * a new address.
1205  */
1206  if (wo->ouraddr == 0 && !ppp_settings.disable_defaultip) {
1207  wo->accept_local = 1; /* don't insist on this default value */
1208  wo->ouraddr = htonl(localAddr);
1209  }
1210 }
1211 #endif
1212 
1213 
1214 /*
1215  * ipcp_up - IPCP has come UP.
1216  *
1217  * Configure the IP network interface appropriately and bring it up.
1218  */
1219 static void
1220 ipcp_up(fsm *f)
1221 {
1222  u32_t mask;
1223  ipcp_options *ho = &ipcp_hisoptions[f->unit];
1224  ipcp_options *go = &ipcp_gotoptions[f->unit];
1225  ipcp_options *wo = &ipcp_wantoptions[f->unit];
1226 
1227  np_up(f->unit, PPP_IP);
1228  IPCPDEBUG(LOG_INFO, ("ipcp: up\n"));
1229 
1230  /*
1231  * We must have a non-zero IP address for both ends of the link.
1232  */
1233  if (!ho->neg_addr) {
1234  ho->hisaddr = wo->hisaddr;
1235  }
1236 
1237  if (ho->hisaddr == 0) {
1238  IPCPDEBUG(LOG_ERR, ("Could not determine remote IP address\n"));
1239  ipcp_close(f->unit, "Could not determine remote IP address");
1240  return;
1241  }
1242  if (go->ouraddr == 0) {
1243  IPCPDEBUG(LOG_ERR, ("Could not determine local IP address\n"));
1244  ipcp_close(f->unit, "Could not determine local IP address");
1245  return;
1246  }
1247 
1248  if (ppp_settings.usepeerdns && (go->dnsaddr[0] || go->dnsaddr[1])) {
1249  /*pppGotDNSAddrs(go->dnsaddr[0], go->dnsaddr[1]);*/
1250  }
1251 
1252  /*
1253  * Check that the peer is allowed to use the IP address it wants.
1254  */
1255  if (!auth_ip_addr(f->unit, ho->hisaddr)) {
1256  IPCPDEBUG(LOG_ERR, ("Peer is not authorized to use remote address %s\n",
1257  inet_ntoa(ho->hisaddr)));
1258  ipcp_close(f->unit, "Unauthorized remote IP address");
1259  return;
1260  }
1261 
1262  /* set tcp compression */
1263  sifvjcomp(f->unit, ho->neg_vj, ho->cflag, ho->maxslotindex);
1264 
1265  /*
1266  * Set IP addresses and (if specified) netmask.
1267  */
1268  mask = GetMask(go->ouraddr);
1269 
1270  if (!sifaddr(f->unit, go->ouraddr, ho->hisaddr, mask, go->dnsaddr[0], go->dnsaddr[1])) {
1271  IPCPDEBUG(LOG_WARNING, ("sifaddr failed\n"));
1272  ipcp_close(f->unit, "Interface configuration failed");
1273  return;
1274  }
1275 
1276  /* bring the interface up for IP */
1277  if (!sifup(f->unit)) {
1278  IPCPDEBUG(LOG_WARNING, ("sifup failed\n"));
1279  ipcp_close(f->unit, "Interface configuration failed");
1280  return;
1281  }
1282 
1283  sifnpmode(f->unit, PPP_IP, NPMODE_PASS);
1284 
1285  /* assign a default route through the interface if required */
1286  if (ipcp_wantoptions[f->unit].default_route) {
1287  if (sifdefaultroute(f->unit, go->ouraddr, ho->hisaddr)) {
1288  default_route_set[f->unit] = 1;
1289  }
1290  }
1291 
1292  IPCPDEBUG(LOG_NOTICE, ("local IP address %s\n", inet_ntoa(go->ouraddr)));
1293  IPCPDEBUG(LOG_NOTICE, ("remote IP address %s\n", inet_ntoa(ho->hisaddr)));
1294  if (go->dnsaddr[0]) {
1295  IPCPDEBUG(LOG_NOTICE, ("primary DNS address %s\n", inet_ntoa(go->dnsaddr[0])));
1296  }
1297  if (go->dnsaddr[1]) {
1298  IPCPDEBUG(LOG_NOTICE, ("secondary DNS address %s\n", inet_ntoa(go->dnsaddr[1])));
1299  }
1300 }
1301 
1302 
1303 /*
1304  * ipcp_down - IPCP has gone DOWN.
1305  *
1306  * Take the IP network interface down, clear its addresses
1307  * and delete routes through it.
1308  */
1309 static void
1310 ipcp_down(fsm *f)
1311 {
1312  IPCPDEBUG(LOG_INFO, ("ipcp: down\n"));
1313  np_down(f->unit, PPP_IP);
1314  sifvjcomp(f->unit, 0, 0, 0);
1315 
1316  sifdown(f->unit);
1317  ipcp_clear_addrs(f->unit);
1318 }
1319 
1320 
1321 /*
1322  * ipcp_clear_addrs() - clear the interface addresses, routes, etc.
1323  */
1324 static void
1325 ipcp_clear_addrs(int unit)
1326 {
1327  u32_t ouraddr, hisaddr;
1328 
1329  ouraddr = ipcp_gotoptions[unit].ouraddr;
1330  hisaddr = ipcp_hisoptions[unit].hisaddr;
1331  if (default_route_set[unit]) {
1332  cifdefaultroute(unit, ouraddr, hisaddr);
1333  default_route_set[unit] = 0;
1334  }
1335  cifaddr(unit, ouraddr, hisaddr);
1336 }
1337 
1338 
1339 /*
1340  * ipcp_finished - possibly shut down the lower layers.
1341  */
1342 static void
1343 ipcp_finished(fsm *f)
1344 {
1345  np_finished(f->unit, PPP_IP);
1346 }
1347 
1348 #if PPP_ADDITIONAL_CALLBACKS
1349 static int
1350 ipcp_printpkt(u_char *p, int plen, void (*printer) (void *, char *, ...), void *arg)
1351 {
1352  LWIP_UNUSED_ARG(p);
1353  LWIP_UNUSED_ARG(plen);
1354  LWIP_UNUSED_ARG(printer);
1356  return 0;
1357 }
1358 
1359 /*
1360  * ip_active_pkt - see if this IP packet is worth bringing the link up for.
1361  * We don't bring the link up for IP fragments or for TCP FIN packets
1362  * with no data.
1363  */
1364 #define IP_HDRLEN 20 /* bytes */
1365 #define IP_OFFMASK 0x1fff
1366 #define IPPROTO_TCP 6
1367 #define TCP_HDRLEN 20
1368 #define TH_FIN 0x01
1369 
1370 /*
1371  * We use these macros because the IP header may be at an odd address,
1372  * and some compilers might use word loads to get th_off or ip_hl.
1373  */
1374 
1375 #define net_short(x) (((x)[0] << 8) + (x)[1])
1376 #define get_iphl(x) (((unsigned char *)(x))[0] & 0xF)
1377 #define get_ipoff(x) net_short((unsigned char *)(x) + 6)
1378 #define get_ipproto(x) (((unsigned char *)(x))[9])
1379 #define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4)
1380 #define get_tcpflags(x) (((unsigned char *)(x))[13])
1381 
1382 static int
1383 ip_active_pkt(u_char *pkt, int len)
1384 {
1385  u_char *tcp;
1386  int hlen;
1387 
1388  len -= PPP_HDRLEN;
1389  pkt += PPP_HDRLEN;
1390  if (len < IP_HDRLEN) {
1391  return 0;
1392  }
1393  if ((get_ipoff(pkt) & IP_OFFMASK) != 0) {
1394  return 0;
1395  }
1396  if (get_ipproto(pkt) != IPPROTO_TCP) {
1397  return 1;
1398  }
1399  hlen = get_iphl(pkt) * 4;
1400  if (len < hlen + TCP_HDRLEN) {
1401  return 0;
1402  }
1403  tcp = pkt + hlen;
1404  if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == hlen + get_tcpoff(tcp) * 4) {
1405  return 0;
1406  }
1407  return 1;
1408 }
1409 #endif /* PPP_ADDITIONAL_CALLBACKS */
1410 
1411 #endif /* PPP_SUPPORT */
Definition: fsm.h:78
u_int neg_vj
Definition: ipcp.h:84
u_int accept_remote
Definition: ipcp.h:87
ipcp_options ipcp_wantoptions[]
void np_up(int, u16_t)
void np_down(int, u16_t)
#define MAX_SLOTS
Definition: vj.h:31
unsigned long u_long
Definition: linux.h:269
u_int neg_addr
Definition: ipcp.h:79
#define LOG_WARNING
Definition: syslog.h:49
#define CI_ADDR
Definition: ipcp.h:62
#define htonl(x)
Definition: module.h:212
u_int accept_local
Definition: ipcp.h:86
u32_t dnsaddr[2]
Definition: ipcp.h:94
u32_t winsaddr[2]
Definition: ipcp.h:95
#define CONFACK
Definition: fsm.h:67
u_int req_dns1
Definition: ipcp.h:88
u_short vj_protocol
Definition: ipcp.h:90
fsm ipcp_fsm[]
void fsm_close(fsm *, char *)
#define CI_MS_DNS2
Definition: ipcp.h:66
u_int default_route
Definition: ipcp.h:82
GLenum GLint GLuint mask
Definition: glext.h:6028
u_int req_dns2
Definition: ipcp.h:89
u_int old_vj
Definition: ipcp.h:85
u32_t ouraddr
Definition: ipcp.h:93
png_const_structrp png_const_inforp int * unit
Definition: png.h:2161
#define CI_MS_WINS1
Definition: ipcp.h:65
smooth NULL
Definition: ftsmooth.c:416
struct protent ipcp_protent
#define inet_ntoa(addr)
Definition: inet.h:100
r l[0]
Definition: byte_order.h:167
u_char cflag
Definition: ipcp.h:92
void fsm_lowerdown(fsm *)
GLfloat f
Definition: glext.h:7540
static WCHAR no[MAX_STRING_RESOURCE_LEN]
Definition: object.c:2340
void fsm_input(fsm *, u_char *, int)
#define d
Definition: ke_i.h:81
void np_finished(int, u16_t)
if(!(yy_init))
Definition: macro.lex.yy.c:714
void fsm_open(fsm *)
unsigned long u32_t
Definition: cc.h:25
#define LS_OPENED
Definition: fsm.h:129
void fsm_init(fsm *)
#define CI_MS_DNS1
Definition: ipcp.h:64
#define LOG_ERR
Definition: syslog.h:48
unsigned short u_short
Definition: types.h:81
#define IPCPDEBUG(a, b)
Definition: pppdebug.h:64
ipcp_options ipcp_hisoptions[]
#define IPCP_VJ_COMP_OLD
Definition: ipcp.h:75
static WCHAR reason[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1904
#define IPCP_VJ_COMP
Definition: ipcp.h:74
#define LOG_NOTICE
Definition: syslog.h:50
#define CI_ADDRS
Definition: ipcp.h:60
GLenum GLsizei len
Definition: glext.h:6722
u32_t hisaddr
Definition: ipcp.h:93
static unsigned __int64 next
Definition: rand_nt.c:6
u_int old_addrs
Definition: ipcp.h:80
#define CI_MS_WINS2
Definition: ipcp.h:67
#define TH_FIN
Definition: netiodef.h:349
u_char maxslotindex
Definition: ipcp.h:91
#define CI_COMPRESSTYPE
Definition: ipcp.h:61
#define CONFNAK
Definition: fsm.h:68
ipcp_options ipcp_allowoptions[]
u_int req_addr
Definition: ipcp.h:81
ipcp_options ipcp_gotoptions[]
#define IP_OFFMASK
Definition: dhcpd.h:72
GLfloat GLfloat p
Definition: glext.h:8902
UCHAR u_char
Definition: types.h:80
int auth_ip_addr(int, u32_t)
#define memset(x, y, z)
Definition: compat.h:39
#define LWIP_UNUSED_ARG(x)
Definition: arch.h:73
#define LOG_INFO
Definition: syslog.h:51
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
void fsm_lowerup(fsm *)
#define CONFREJ
Definition: fsm.h:69
#define ntohl(x)
Definition: module.h:203