开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 查看源码
ipcp.c
资源名称：LWIP+GTM900+LPC2104.rar　[点击查看]
上传用户：yyhongfa
上传日期：2013-01-18
资源大小：267k
文件大小：35k
源码类别：

嵌入式/单片机编程

开发平台：

C/C++

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