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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
ipcp.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：31k
源码类别：

VxWorks

开发平台：

C/C++

ipcp.c：源码内容
  1. /* ipcp.c - PPP IP Control Protocol */
  3. /* Copyright 1995 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7.  * Copyright (c) 1989 Carnegie Mellon University.
  8.  * All rights reserved.
  9.  *
  10.  * Redistribution and use in source and binary forms are permitted
  11.  * provided that the above copyright notice and this paragraph are
  12.  * duplicated in all such forms and that any documentation,
  13.  * advertising materials, and other materials related to such
  14.  * distribution and use acknowledge that the software was developed
  15.  * by Carnegie Mellon University.  The name of the
  16.  * University may not be used to endorse or promote products derived
  17.  * from this software without specific prior written permission.
  18.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  19.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  20.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  21.  */
  23. /*
  24. modification history
  25. --------------------
  26. 01e,16jun95,dzb  header file consolidation.
  27. 01d,08jun95,dzb  made LOG_NOTICE message printed even w/o debug option.
  28. 01c,07feb95,dab  die() if IP address reject (SPR #4038).
  29. 01b,16jan95,dab  removed ipcp_script call.  removed pathname.h inclusion.
  30. 01a,21dec94,dab  VxWorks port - first WRS version.
  31.    +dzb  added: path for ppp header files, WRS copyright.
  32. */
  34. #include <vxWorks.h>
  35. #include <stdio.h>
  36. #include <string.h>
  37. #include <sys/types.h>
  38. #include <sys/socket.h>
  39. #include <netinet/in.h>
  40. #include "pppLib.h"
  42. /*
  43.  * Callbacks for fsm code.  (CI = Configuration Information)
  44.  */
  45. static void ipcp_resetci __ARGS((fsm *)); /* Reset our CI */
  46. static int  ipcp_cilen __ARGS((fsm *));         /* Return length of our CI */
  47. static void ipcp_addci __ARGS((fsm *, u_char *, int *)); /* Add our CI */
  48. static int  ipcp_ackci __ARGS((fsm *, u_char *, int)); /* Peer ack'd our CI */
  49. static int  ipcp_nakci __ARGS((fsm *, u_char *, int)); /* Peer nak'd our CI */
  50. static int  ipcp_rejci __ARGS((fsm *, u_char *, int)); /* Peer rej'd our CI */
  51. static int  ipcp_reqci __ARGS((fsm *, u_char *, int *, int)); /* Rcv CI */
  52. static void ipcp_up __ARGS((fsm *)); /* We're UP */
  53. static void ipcp_down __ARGS((fsm *)); /* We're DOWN */
  55. static fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */
  56.     ipcp_resetci, /* Reset our Configuration Information */
  57.     ipcp_cilen, /* Length of our Configuration Information */
  58.     ipcp_addci, /* Add our Configuration Information */
  59.     ipcp_ackci, /* ACK our Configuration Information */
  60.     ipcp_nakci, /* NAK our Configuration Information */
  61.     ipcp_rejci, /* Reject our Configuration Information */
  62.     ipcp_reqci, /* Request peer's Configuration Information */
  63.     ipcp_up, /* Called when fsm reaches OPENED state */
  64.     ipcp_down, /* Called when fsm leaves OPENED state */
  65.     NULL, /* Called when we want the lower layer up */
  66.     NULL, /* Called when we want the lower layer down */
  67.     NULL, /* Called when Protocol-Reject received */
  68.     NULL, /* Retransmission is necessary */
  69.     NULL, /* Called to handle protocol-specific codes */
  70.     "IPCP" /* String name of protocol */
  71. };
  73. /*
  74.  * Lengths of configuration options.
  75.  */
  76. #define CILEN_VOID 2
  77. #define CILEN_COMPRESS 4 /* min length for compression protocol opt. */
  78. #define CILEN_VJ 6 /* length for RFC1332 Van-Jacobson opt. */
  79. #define CILEN_ADDR 6 /* new-style single address option */
  80. #define CILEN_ADDRS 10 /* old-style dual address option */
  83. #define CODENAME(x) ((x) == CONFACK ? "ACK" : 
  84.  (x) == CONFNAK ? "NAK" : "REJ")
  87. /*
  88.  * Make a string representation of a network IP address.
  89.  */
  90. char *
  91. ip_ntoa(ipaddr)
  92.     u_long ipaddr;
  93. {
  94.     static char b[64];
  96.     ipaddr = ntohl(ipaddr);
  98.     sprintf(b, "%d.%d.%d.%d",
  99.     (u_char)(ipaddr >> 24),
  100.     (u_char)(ipaddr >> 16),
  101.     (u_char)(ipaddr >> 8),
  102.     (u_char)(ipaddr));
  103.     return b;
  104. }
  107. /*
  108.  * ipcp_init - Initialize IPCP.
  109.  */
  110. void
  111. ipcp_init(unit)
  112.     int unit;
  113. {
  114.     fsm *f = &ppp_if[unit]->ipcp_fsm;
  115.     ipcp_options *wo = &ppp_if[unit]->ipcp_wantoptions;
  116.     ipcp_options *ao = &ppp_if[unit]->ipcp_allowoptions;
  118.     f->unit = unit;
  119.     f->protocol = IPCP;
  120.     f->callbacks = &ipcp_callbacks;
  121.     fsm_init(&ppp_if[unit]->ipcp_fsm);
  123.     wo->neg_addr = 1;
  124.     wo->old_addrs = 0;
  125.     wo->ouraddr = 0;
  126.     wo->hisaddr = 0;
  128.     wo->neg_vj = 1;
  129.     wo->old_vj = 0;
  130.     wo->vj_protocol = IPCP_VJ_COMP;
  131.     wo->maxslotindex = MAX_STATES - 1; /* really max index */
  132.     wo->cflag = 1;
  134.     /* max slots and slot-id compression are currently hardwired in */
  135.     /* ppp_if.c to 16 and 1, this needs to be changed (among other */
  136.     /* things) gmc */
  138.     ao->neg_addr = 1;
  139.     ao->neg_vj = 1;
  140.     ao->maxslotindex = MAX_STATES - 1;
  141.     ao->cflag = 1;
  142. }
  145. /*
  146.  * ipcp_open - IPCP is allowed to come up.
  147.  */
  148. void
  149. ipcp_open(unit)
  150.     int unit;
  151. {
  152.     fsm_open(&ppp_if[unit]->ipcp_fsm);
  153. }
  156. /*
  157.  * ipcp_close - Take IPCP down.
  158.  */
  159. void
  160. ipcp_close(unit)
  161.     int unit;
  162. {
  163.     fsm_close(&ppp_if[unit]->ipcp_fsm);
  165.     /*
  166.      * NB
  167.      * Since the only NCP supported by VxWorks is IPCP, this routine should
  168.      * also take down the entire link if IPCP is going down... Thus,
  169.      * an LCP should occur so that an LCP terminate request is sent to the
  170.      * peer.  This is *not* usual behavior, especially in regard to the
  171.      * RFC's protocol specification, but it makes sense for VxWorks.
  172.      * Users should not mind, since the link is useless without IPCP.
  173.      * -dzb
  174.      */
  176.      die(unit, 1);
  177. }
  180. /*
  181.  * ipcp_lowerup - The lower layer is up.
  182.  */
  183. void
  184. ipcp_lowerup(unit)
  185.     int unit;
  186. {
  187.     fsm_lowerup(&ppp_if[unit]->ipcp_fsm);
  188. }
  191. /*
  192.  * ipcp_lowerdown - The lower layer is down.
  193.  */
  194. void
  195. ipcp_lowerdown(unit)
  196.     int unit;
  197. {
  198.     fsm_lowerdown(&ppp_if[unit]->ipcp_fsm);
  199. }
  202. /*
  203.  * ipcp_input - Input IPCP packet.
  204.  */
  205. void
  206. ipcp_input(unit, p, len)
  207.     int unit;
  208.     u_char *p;
  209.     int len;
  210. {
  211.     fsm_input(&ppp_if[unit]->ipcp_fsm, p, len);
  212. }
  215. /*
  216.  * ipcp_protrej - A Protocol-Reject was received for IPCP.
  217.  *
  218.  * Pretend the lower layer went down, so we shut up.
  219.  */
  220. void
  221. ipcp_protrej(unit)
  222.     int unit;
  223. {
  224.     fsm_lowerdown(&ppp_if[unit]->ipcp_fsm);
  225. }
  228. /*
  229.  * ipcp_resetci - Reset our CI.
  230.  */
  231. static void
  232. ipcp_resetci(f)
  233.     fsm *f;
  234. {
  235.     ipcp_options *wo = &ppp_if[f->unit]->ipcp_wantoptions;
  237.     wo->req_addr = wo->neg_addr && ppp_if[f->unit]->ipcp_allowoptions.neg_addr;
  238.     if (wo->ouraddr == 0)
  239.         wo->accept_local = 1;
  240.     if (wo->hisaddr == 0)
  241.         wo->accept_remote = 1;
  242.     ppp_if[f->unit]->ipcp_gotoptions = *wo;
  243.     ppp_if[f->unit]->cis_received = 0;
  244. }
  247. /*
  248.  * ipcp_cilen - Return length of our CI.
  249.  */
  250. static int
  251. ipcp_cilen(f)
  252.     fsm *f;
  253. {
  254.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  256. #define LENCIVJ(neg, old) (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0)
  257. #define LENCIADDR(neg, old) (neg ? (old? CILEN_ADDRS : CILEN_ADDR) : 0)
  259.     return (LENCIADDR(go->neg_addr, go->old_addrs) +
  260.     LENCIVJ(go->neg_vj, go->old_vj));
  261. }
  264. /*
  265.  * ipcp_addci - Add our desired CIs to a packet.
  266.  */
  267. static void
  268. ipcp_addci(f, ucp, lenp)
  269.     fsm *f;
  270.     u_char *ucp;
  271.     int *lenp;
  272. {
  273.     ipcp_options *wo = &ppp_if[f->unit]->ipcp_wantoptions;
  274.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  275.     ipcp_options *ho = &ppp_if[f->unit]->ipcp_hisoptions;
  276.     int len = *lenp;
  278. #define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) 
  279.     if (neg) { 
  280. int vjlen = old? CILEN_COMPRESS : CILEN_VJ; 
  281. if (len >= vjlen) { 
  282.     PUTCHAR(opt, ucp); 
  283.     PUTCHAR(vjlen, ucp); 
  284.     PUTSHORT(val, ucp); 
  285.     if (!old) { 
  286. PUTCHAR(maxslotindex, ucp); 
  287. PUTCHAR(cflag, ucp); 
  288.     } 
  289.     len -= vjlen; 
  290. } else 
  291.     neg = 0; 
  292.     }
  294. #define ADDCIADDR(opt, neg, old, val1, val2) 
  295.     if (neg) { 
  296. int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); 
  297. if (len >= addrlen) { 
  298.     u_long l; 
  299.     PUTCHAR(opt, ucp); 
  300.     PUTCHAR(addrlen, ucp); 
  301.     l = ntohl(val1); 
  302.     PUTLONG(l, ucp); 
  303.     if (old) { 
  304. l = ntohl(val2); 
  305. PUTLONG(l, ucp); 
  306.     } 
  307.     len -= addrlen; 
  308. } else 
  309.     neg = 0; 
  310.     }
  312.     /*
  313.      * First see if we want to change our options to the old
  314.      * forms because we have received old forms from the peer.
  315.      */
  316.     if (wo->neg_addr && !go->neg_addr && !go->old_addrs) {
  317. /* use the old style of address negotiation */
  318. go->neg_addr = 1;
  319. go->old_addrs = 1;
  320.     }
  321.     if (wo->neg_vj && !go->neg_vj && !go->old_vj) {
  322. /* try an older style of VJ negotiation */
  323. if (ppp_if[f->unit]->cis_received == 0) {
  324.     /* keep trying the new style until we see some CI from the peer */
  325.     go->neg_vj = 1;
  326. } else {
  327.     /* use the old style only if the peer did */
  328.     if (ho->neg_vj && ho->old_vj) {
  329. go->neg_vj = 1;
  330. go->old_vj = 1;
  331. go->vj_protocol = ho->vj_protocol;
  332.     }
  333. }
  334.     }
  336.     ADDCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
  337.       go->old_addrs, go->ouraddr, go->hisaddr);
  339.     ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
  340.     go->maxslotindex, go->cflag);
  342.     *lenp -= len;
  343. }
  346. /*
  347.  * ipcp_ackci - Ack our CIs.
  348.  *
  349.  * Returns:
  350.  * 0 - Ack was bad.
  351.  * 1 - Ack was good.
  352.  */
  353. static int
  354. ipcp_ackci(f, p, len)
  355.     fsm *f;
  356.     u_char *p;
  357.     int len;
  358. {
  359.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  360.     u_short cilen, citype, cishort;
  361.     u_long cilong;
  362.     u_char cimaxslotindex, cicflag;
  364.     /*
  365.      * CIs must be in exactly the same order that we sent...
  366.      * Check packet length and CI length at each step.
  367.      * If we find any deviations, then this packet is bad.
  368.      */
  370. #define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) 
  371.     if (neg) { 
  372. int vjlen = old? CILEN_COMPRESS : CILEN_VJ; 
  373. if ((len -= vjlen) < 0) 
  374.     goto bad; 
  375. GETCHAR(citype, p); 
  376. GETCHAR(cilen, p); 
  377. if (cilen != vjlen || 
  378.     citype != opt)  
  379.     goto bad; 
  380. GETSHORT(cishort, p); 
  381. if (cishort != val) 
  382.     goto bad; 
  383. if (!old) { 
  384.     GETCHAR(cimaxslotindex, p); 
  385.     if (cimaxslotindex != maxslotindex) 
  386. goto bad; 
  387.     GETCHAR(cicflag, p); 
  388.     if (cicflag != cflag) 
  389. goto bad; 
  390. } 
  391.     }
  393. #define ACKCIADDR(opt, neg, old, val1, val2) 
  394.     if (neg) { 
  395. int addrlen = (old? CILEN_ADDRS: CILEN_ADDR); 
  396. u_long l; 
  397. if ((len -= addrlen) < 0) 
  398.     goto bad; 
  399. GETCHAR(citype, p); 
  400. GETCHAR(cilen, p); 
  401. if (cilen != addrlen || 
  402.     citype != opt) 
  403.     goto bad; 
  404. GETLONG(l, p); 
  405. cilong = htonl(l); 
  406. if (val1 != cilong) 
  407.     goto bad; 
  408. if (old) { 
  409.     GETLONG(l, p); 
  410.     cilong = htonl(l); 
  411.     if (val2 != cilong) 
  412. goto bad; 
  413. } 
  414.     }
  416.     ACKCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), go->neg_addr,
  417.       go->old_addrs, go->ouraddr, go->hisaddr);
  419.     ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj,
  420.     go->maxslotindex, go->cflag);
  422.     /*
  423.      * If there are any remaining CIs, then this packet is bad.
  424.      */
  425.     if (len != 0)
  426. goto bad;
  427.     return (1);
  429. bad:
  430.     IPCPDEBUG((LOG_INFO, "ipcp_ackci: received bad Ack!"));
  431.     return (0);
  432. }
  434. /*
  435.  * ipcp_nakci - Peer has sent a NAK for some of our CIs.
  436.  * This should not modify any state if the Nak is bad
  437.  * or if IPCP is in the OPENED state.
  438.  *
  439.  * Returns:
  440.  * 0 - Nak was bad.
  441.  * 1 - Nak was good.
  442.  */
  443. static int
  444. ipcp_nakci(f, p, len)
  445.     fsm *f;
  446.     u_char *p;
  447.     int len;
  448. {
  449.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  450.     u_char cimaxslotindex = 0, cicflag = 0;
  451.     u_char citype, cilen, *next;
  452.     u_short cishort;
  453.     u_long ciaddr1, ciaddr2, l;
  454.     ipcp_options no; /* options we've seen Naks for */
  455.     ipcp_options try; /* options to request next time */
  457.     BZERO((char *)&no, sizeof(no));
  458.     try = *go;
  460.     /*
  461.      * Any Nak'd CIs must be in exactly the same order that we sent.
  462.      * Check packet length and CI length at each step.
  463.      * If we find any deviations, then this packet is bad.
  464.      */
  465. #define NAKCIADDR(opt, neg, old, code) 
  466.     if (go->neg && 
  467. len >= (cilen = (old? CILEN_ADDRS: CILEN_ADDR)) && 
  468. p[1] == cilen && 
  469. p[0] == opt) { 
  470. len -= cilen; 
  471. INCPTR(2, p); 
  472. GETLONG(l, p); 
  473. ciaddr1 = htonl(l); 
  474. if (old) { 
  475.     GETLONG(l, p); 
  476.     ciaddr2 = htonl(l); 
  477.     no.old_addrs = 1; 
  478. } else 
  479.     ciaddr2 = 0; 
  480. no.neg = 1; 
  481. code 
  482.     }
  484. #define NAKCIVJ(opt, neg, code) 
  485.     if (go->neg && 
  486. ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && 
  487. len >= cilen && 
  488. p[0] == opt) { 
  489. len -= cilen; 
  490. INCPTR(2, p); 
  491. GETSHORT(cishort, p); 
  492. no.neg = 1; 
  493.         code 
  494.     }
  496.     /*
  497.      * Accept the peer's idea of {our,his} address, if different
  498.      * from our idea, only if the accept_{local,remote} flag is set.
  499.      */
  500.     NAKCIADDR(CI_ADDR, neg_addr, go->old_addrs,
  501.               if (go->accept_local && ciaddr1) { /* Do we know our address? */
  502.                   try.ouraddr = ciaddr1;
  503.                   IPCPDEBUG((LOG_INFO, "local IP address %s",
  504.                              ip_ntoa(ciaddr1)));
  505.               }
  506.               if (go->accept_remote && ciaddr2) { /* Does he know his? */
  507.                   try.hisaddr = ciaddr2;
  508.                   IPCPDEBUG((LOG_INFO, "remote IP address %s",
  509.                              ip_ntoa(ciaddr2)));
  510.               }
  511.               );
  513.     /*
  514.      * Accept the peer's value of maxslotindex provided that it
  515.      * is less than what we asked for.  Turn off slot-ID compression
  516.      * if the peer wants.  Send old-style compress-type option if
  517.      * the peer wants.
  518.      */
  519.     NAKCIVJ(CI_COMPRESSTYPE, neg_vj,
  520.     if (cilen == CILEN_VJ) {
  521.                 GETCHAR(cimaxslotindex, p);
  522.                 GETCHAR(cicflag, p);
  523. if (cishort == IPCP_VJ_COMP) {
  524.     try.old_vj = 0;
  525.     if (cimaxslotindex < go->maxslotindex)
  526. try.maxslotindex = cimaxslotindex;
  527.     if (!cicflag)
  528. try.cflag = 0;
  529. } else {
  530.     try.neg_vj = 0;
  531. }
  532.     } else {
  533. if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) {
  534.     try.old_vj = 1;
  535.     try.vj_protocol = cishort;
  536. } else {
  537.     try.neg_vj = 0;
  538. }
  539.     }
  540.     );
  542.     /*
  543.      * There may be remaining CIs, if the peer is requesting negotiation
  544.      * on an option that we didn't include in our request packet.
  545.      * If they want to negotiate about IP addresses, we comply.
  546.      * If they want us to ask for compression, we refuse.
  547.      */
  548.     while (len > CILEN_VOID) {
  549. GETCHAR(citype, p);
  550. GETCHAR(cilen, p);
  551. if( (len -= cilen) < 0 )
  552.     goto bad;
  553. next = p + cilen - 2;
  555. switch (citype) {
  556. case CI_COMPRESSTYPE:
  557.     if (go->neg_vj || no.neg_vj ||
  558. (cilen != CILEN_VJ && cilen != CILEN_COMPRESS))
  559. goto bad;
  560.     no.neg_vj = 1;
  561.     break;
  562. case CI_ADDRS:
  563.     if ((go->neg_addr && go->old_addrs) || no.old_addrs
  564. || cilen != CILEN_ADDRS)
  565. goto bad;
  566.     try.neg_addr = 1;
  567.     try.old_addrs = 1;
  568.     GETLONG(l, p);
  569.     ciaddr1 = htonl(l);
  570.     if (ciaddr1 && go->accept_local)
  571. try.ouraddr = ciaddr1;
  572.     GETLONG(l, p);
  573.     ciaddr2 = htonl(l);
  574.     if (ciaddr2 && go->accept_remote)
  575. try.hisaddr = ciaddr2;
  576.     no.old_addrs = 1;
  577.     break;
  578. case CI_ADDR:
  579.     if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR)
  580. goto bad;
  581.     try.neg_addr = 1;
  582.     try.old_addrs = 0;
  583.     GETLONG(l, p);
  584.     ciaddr1 = htonl(l);
  585.     if (ciaddr1 && go->accept_local)
  586. try.ouraddr = ciaddr1;
  587.     no.neg_addr = 1;
  588.     break;
  589. default:
  590.     goto bad;
  591. }
  592. p = next;
  593.     }
  595.     /* If there is still anything left, this packet is bad. */
  596.     if (len != 0)
  597. goto bad;
  599.     /*
  600.      * OK, the Nak is good.  Now we can update state.
  601.      */
  602.     if (f->state != OPENED)
  603. *go = try;
  605.     return 1;
  607. bad:
  608.     IPCPDEBUG((LOG_INFO, "ipcp_nakci: received bad Nak!"));
  609.     return 0;
  610. }
  613. /*
  614.  * ipcp_rejci - Reject some of our CIs.
  615.  */
  616. static int
  617. ipcp_rejci(f, p, len)
  618.     fsm *f;
  619.     u_char *p;
  620.     int len;
  621. {
  622.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  623.     u_char cimaxslotindex, ciflag, cilen;
  624.     u_short cishort;
  625.     u_long cilong;
  626.     ipcp_options try; /* options to request next time */
  628.     try = *go;
  630.     /*
  631.      * Bring down link if peer rejects the IPCP address configuration option,
  632.      * since if the IP address can't be negotiated then the link is useless.
  633.      */
  634.     /*
  635.      * Any Rejected CIs must be in exactly the same order that we sent.
  636.      * Check packet length and CI length at each step.
  637.      * If we find any deviations, then this packet is bad.
  638.      */
  639. #define REJCIADDR(opt, neg, old, val1, val2) 
  640.     if (go->neg && 
  641. len >= (cilen = old? CILEN_ADDRS: CILEN_ADDR) && 
  642. p[1] == cilen && 
  643. p[0] == opt) { 
  644. u_long l; 
  645.         die(f->unit, 1); /* not to protocol spec. see note in ipcp_close() */ 
  646. len -= cilen; 
  647. INCPTR(2, p); 
  648. GETLONG(l, p); 
  649. cilong = htonl(l); 
  650. /* Check rejected value. */ 
  651. if (cilong != val1) 
  652.     goto bad; 
  653. if (old) { 
  654.     GETLONG(l, p); 
  655.     cilong = htonl(l); 
  656.     /* Check rejected value. */ 
  657.     if (cilong != val2) 
  658. goto bad; 
  659. } 
  660. try.neg = 0; 
  661.     }
  663. #define REJCIVJ(opt, neg, val, old, maxslot, cflag) 
  664.     if (go->neg && 
  665. p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && 
  666. len >= p[1] && 
  667. p[0] == opt) { 
  668. len -= p[1]; 
  669. INCPTR(2, p); 
  670. GETSHORT(cishort, p); 
  671. /* Check rejected value. */  
  672. if (cishort != val) 
  673.     goto bad; 
  674. if (!old) { 
  675.    GETCHAR(cimaxslotindex, p); 
  676.    if (cimaxslotindex != maxslot) 
  677.      goto bad; 
  678.    GETCHAR(ciflag, p); 
  679.    if (ciflag != cflag) 
  680.      goto bad; 
  681.         } 
  682. try.neg = 0; 
  683.      }
  685.     REJCIADDR((go->old_addrs? CI_ADDRS: CI_ADDR), neg_addr,
  686.       go->old_addrs, go->ouraddr, go->hisaddr);
  688.     REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj,
  689.     go->maxslotindex, go->cflag);
  691.     /*
  692.      * If there are any remaining CIs, then this packet is bad.
  693.      */
  694.     if (len != 0)
  695. goto bad;
  696.     /*
  697.      * Now we can update state.
  698.      */
  699.     if (f->state != OPENED)
  700. *go = try;
  701.     return 1;
  703. bad:
  704.     IPCPDEBUG((LOG_INFO, "ipcp_rejci: received bad Reject!"));
  705.     return 0;
  706. }
  709. /*
  710.  * ipcp_reqci - Check the peer's requested CIs and send appropriate response.
  711.  *
  712.  * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified
  713.  * appropriately.  If reject_if_disagree is non-zero, doesn't return
  714.  * CONFNAK; returns CONFREJ if it can't return CONFACK.
  715.  */
  716. static int
  717. ipcp_reqci(f, inp, len, reject_if_disagree)
  718.     fsm *f;
  719.     u_char *inp;                /* Requested CIs */
  720.     int *len;                   /* Length of requested CIs */
  721.     int reject_if_disagree;
  722. {
  723.     ipcp_options *wo = &ppp_if[f->unit]->ipcp_wantoptions;
  724.     ipcp_options *ho = &ppp_if[f->unit]->ipcp_hisoptions;
  725.     ipcp_options *ao = &ppp_if[f->unit]->ipcp_allowoptions;
  726.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  727.     u_char *cip, *next; /* Pointer to current and next CIs */
  728.     u_short cilen, citype; /* Parsed len, type */
  729.     u_short cishort; /* Parsed short value */
  730.     u_long tl, ciaddr1, ciaddr2;/* Parsed address values */
  731.     int rc = CONFACK; /* Final packet return code */
  732.     int orc; /* Individual option return code */
  733.     u_char *p; /* Pointer to next char to parse */
  734.     u_char *ucp = inp; /* Pointer to current output char */
  735.     int l = *len; /* Length left */
  736.     u_char maxslotindex, cflag;
  738.     /*
  739.      * Reset all his options.
  740.      */
  741.     BZERO((char *)ho, sizeof(*ho));
  742.     
  743.     /*
  744.      * Process all his options.
  745.      */
  746.     next = inp;
  747.     while (l) {
  748. orc = CONFACK; /* Assume success */
  749. cip = p = next; /* Remember begining of CI */
  750. if (l < 2 || /* Not enough data for CI header or */
  751.     p[1] < 2 || /*  CI length too small or */
  752.     p[1] > l) { /*  CI length too big? */
  753.     IPCPDEBUG((LOG_INFO, "ipcp_reqci: bad CI length!"));
  754.     orc = CONFREJ; /* Reject bad CI */
  755.     cilen = l; /* Reject till end of packet */
  756.     l = 0; /* Don't loop again */
  757.     goto endswitch;
  758. }
  759. GETCHAR(citype, p); /* Parse CI type */
  760. GETCHAR(cilen, p); /* Parse CI length */
  761. l -= cilen; /* Adjust remaining length */
  762. next += cilen; /* Step to next CI */
  764. switch (citype) { /* Check CI type */
  765. case CI_ADDRS:
  766.     IPCPDEBUG((LOG_INFO, "ipcp: received ADDRS "));
  767.     if (!ao->neg_addr ||
  768. cilen != CILEN_ADDRS) { /* Check CI length */
  769. orc = CONFREJ; /* Reject CI */
  770. break;
  771.     }
  773.     /*
  774.      * If he has no address, or if we both have his address but
  775.      * disagree about it, then NAK it with our idea.
  776.      * In particular, if we don't know his address, but he does,
  777.      * then accept it.
  778.      */
  779.     GETLONG(tl, p); /* Parse source address (his) */
  780.     ciaddr1 = htonl(tl);
  781.     IPCPDEBUG((LOG_INFO, "(%s:", ip_ntoa(ciaddr1)));
  782.     if (ciaddr1 != wo->hisaddr
  783.                 && (ciaddr1 == 0 || !wo->accept_remote)) {
  784. orc = CONFNAK;
  785. if (!reject_if_disagree) {
  786.     DECPTR(sizeof (long), p);
  787.     tl = ntohl(wo->hisaddr);
  788.     PUTLONG(tl, p);
  789. }
  790.     }
  792.     /*
  793.      * If he doesn't know our address, or if we both have our address
  794.      * but disagree about it, then NAK it with our idea.
  795.      */
  796.     GETLONG(tl, p); /* Parse desination address (ours) */
  797.     ciaddr2 = htonl(tl);
  798.     IPCPDEBUG((LOG_INFO, "%s)", ip_ntoa(ciaddr2)));
  799.     if (ciaddr2 != wo->ouraddr) {
  800.                 if (ciaddr2 == 0 || !wo->accept_local) {
  801.                     orc = CONFNAK;
  802.                     if (!reject_if_disagree) {
  803.                         DECPTR(sizeof (long), p);
  804.                         tl = ntohl(wo->ouraddr);
  805.                         PUTLONG(tl, p);
  806.                     }
  807.                 } else {
  808.                     go->ouraddr = ciaddr2;      /* accept peer's idea */
  809.                 }
  810.             }
  812.     ho->neg_addr = 1;
  813.     ho->old_addrs = 1;
  814.     ho->hisaddr = ciaddr1;
  815.     ho->ouraddr = ciaddr2;
  816.     break;
  818. case CI_ADDR:
  819.     IPCPDEBUG((LOG_INFO, "ipcp: received ADDR "));
  821.     if (!ao->neg_addr ||
  822. cilen != CILEN_ADDR) { /* Check CI length */
  823. orc = CONFREJ; /* Reject CI */
  824. break;
  825.     }
  827.     /*
  828.      * If he has no address, or if we both have his address but
  829.      * disagree about it, then NAK it with our idea.
  830.      * In particular, if we don't know his address, but he does,
  831.      * then accept it.
  832.      */
  833.     GETLONG(tl, p); /* Parse source address (his) */
  834.     ciaddr1 = htonl(tl);
  835.     IPCPDEBUG((LOG_INFO, "(%s)", ip_ntoa(ciaddr1)));
  836.             if (ciaddr1 != wo->hisaddr
  837.                 && (ciaddr1 == 0 || !wo->accept_remote)) {
  838.                 orc = CONFNAK;
  839.                 if (!reject_if_disagree) {
  840.                     DECPTR(sizeof (long), p);
  841.                     tl = ntohl(wo->hisaddr);
  842.                     PUTLONG(tl, p);
  843.                 }
  844.             }
  846.     ho->neg_addr = 1;
  847.     ho->hisaddr = ciaddr1;
  848.     break;
  850. case CI_COMPRESSTYPE:
  851.     IPCPDEBUG((LOG_INFO, "ipcp: received COMPRESSTYPE "));
  852.     if (!ao->neg_vj ||
  853. (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) {
  854. orc = CONFREJ;
  855. break;
  856.     }
  857.     GETSHORT(cishort, p);
  858.     IPCPDEBUG((LOG_INFO, "(%d)", cishort));
  860.     if (!(cishort == IPCP_VJ_COMP ||
  861.   (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) {
  862. orc = CONFREJ;
  863. break;
  864.     }
  866.     ho->neg_vj = 1;
  867.     ho->vj_protocol = cishort;
  868.     if (cilen == CILEN_VJ) {
  869. GETCHAR(maxslotindex, p);
  870. if (maxslotindex > ao->maxslotindex) { 
  871.     orc = CONFNAK;
  872.     if (!reject_if_disagree){
  873. DECPTR(1, p);
  874. PUTCHAR(ao->maxslotindex, p);
  875.     }
  876. }
  877. GETCHAR(cflag, p);
  878. if (cflag && !ao->cflag) {
  879.     orc = CONFNAK;
  880.     if (!reject_if_disagree){
  881. DECPTR(1, p);
  882. PUTCHAR(wo->cflag, p);
  883.     }
  884. }
  885.                 ho->maxslotindex = maxslotindex;
  886.                 ho->cflag = wo->cflag;
  887.             } else {
  888.                 ho->old_vj = 1;
  889.                 ho->maxslotindex = MAX_STATES - 1;
  890.                 ho->cflag = 1;
  891.             }
  892.             break;
  894. default:
  895.     orc = CONFREJ;
  896.     break;
  897. }
  899. endswitch:
  900. IPCPDEBUG((LOG_INFO, " (%s)", CODENAME(orc)));
  902. if (orc == CONFACK && /* Good CI */
  903.     rc != CONFACK) /*  but prior CI wasnt? */
  904.     continue; /* Don't send this one */
  906. if (orc == CONFNAK) { /* Nak this CI? */
  907.     if (reject_if_disagree) /* Getting fed up with sending NAKs? */
  908. orc = CONFREJ; /* Get tough if so */
  909.     else {
  910. if (rc == CONFREJ) /* Rejecting prior CI? */
  911.     continue; /* Don't send this one */
  912. if (rc == CONFACK) { /* Ack'd all prior CIs? */
  913.     rc = CONFNAK; /* Not anymore... */
  914.     ucp = inp; /* Backup */
  915. }
  916.     }
  917. }
  919. if (orc == CONFREJ && /* Reject this CI */
  920.     rc != CONFREJ) { /*  but no prior ones? */
  921.     rc = CONFREJ;
  922.     ucp = inp; /* Backup */
  923. }
  925. /* Need to move CI? */
  926. if (ucp != cip)
  927.     BCOPY((char *)cip, (char *)ucp, cilen); /* Move it */
  929. /* Update output pointer */
  930. INCPTR(cilen, ucp);
  931.     }
  933.     /*
  934.      * If we aren't rejecting this packet, and we want to negotiate
  935.      * their address, and they didn't send their address, then we
  936.      * send a NAK with a CI_ADDR option appended.  We assume the
  937.      * input buffer is long enough that we can append the extra
  938.      * option safely.
  939.      */
  940.     if (rc != CONFREJ && !ho->neg_addr &&
  941. wo->req_addr && !reject_if_disagree) {
  942. if (rc == CONFACK) {
  943.     rc = CONFNAK;
  944.     ucp = inp; /* reset pointer */
  945.     wo->req_addr = 0; /* don't ask again */
  946. }
  947. PUTCHAR(CI_ADDR, ucp);
  948. PUTCHAR(CILEN_ADDR, ucp);
  949. tl = ntohl(wo->hisaddr);
  950. PUTLONG(tl, ucp);
  951.     }
  953.     *len = ucp - inp; /* Compute output length */
  954.     IPCPDEBUG((LOG_INFO, "ipcp: returning Configure-%s", CODENAME(rc)));
  955.     return (rc); /* Return final code */
  956. }
  959. /*
  960.  * ipcp_up - IPCP has come UP.
  961.  *
  962.  * Configure the IP network interface appropriately and bring it up.
  963.  */
  964. static void
  965. ipcp_up(f)
  966.     fsm *f;
  967. {
  968.     u_long mask;
  969.     ipcp_options *ho = &ppp_if[f->unit]->ipcp_hisoptions;
  970.     ipcp_options *go = &ppp_if[f->unit]->ipcp_gotoptions;
  972.     IPCPDEBUG((LOG_INFO, "ipcp: up"));
  973.     go->default_route = 0;
  974.     go->proxy_arp = 0;
  976.     /*
  977.      * We must have a non-zero IP address for both ends of the link.
  978.      */
  979.     if (!ho->neg_addr)
  980. ho->hisaddr = ppp_if[f->unit]->ipcp_wantoptions.hisaddr;
  982.     if (ho->hisaddr == 0) {
  983. syslog(LOG_ERR, "Could not determine remote IP address");
  984. ipcp_close(f->unit);
  985. return;
  986.     }
  987.     if (go->ouraddr == 0) {
  988. syslog(LOG_ERR, "Could not determine local IP address");
  989. ipcp_close(f->unit);
  990. return;
  991.     }
  993.     /*
  994.      * Check that the peer is allowed to use the IP address it wants.
  995.      */
  996.     if (!auth_ip_addr(f->unit, ho->hisaddr)) {
  997. syslog(LOG_ERR, "Peer is not authorized to use remote address %s",
  998.        ip_ntoa(ho->hisaddr));
  999. ipcp_close(f->unit);
  1000. return;
  1001.     }
  1003.     syslog (LOG_NOTICE, "local  IP address %s", ip_ntoa(go->ouraddr));
  1004.     syslog (LOG_NOTICE, "remote IP address %s", ip_ntoa(ho->hisaddr));
  1006.     /*
  1007.      * Set IP addresses and (if specified) netmask.
  1008.      */
  1009.     mask = GetMask(go->ouraddr);
  1010.     if (!sifaddr(f->unit, go->ouraddr, ho->hisaddr, mask)) {
  1011. IPCPDEBUG((LOG_WARNING, "sifaddr failed"));
  1012. ipcp_close(f->unit);
  1013. return;
  1014.     }
  1016.     /* set tcp compression */
  1017.     sifvjcomp(f->unit, ho->neg_vj, ho->cflag, ho->maxslotindex);
  1019.     /* bring the interface up for IP */
  1020.     if (!sifup(f->unit)) {
  1021. IPCPDEBUG((LOG_WARNING, "sifup failed"));
  1022. ipcp_close(f->unit);
  1023. return;
  1024.     }
  1026.     /* assign a default route through the interface if required */
  1027.     if (ppp_if[f->unit]->ipcp_wantoptions.default_route) 
  1028. if (sifdefaultroute(f->unit, ho->hisaddr))
  1029.     go->default_route = 1;
  1031.     /* Make a proxy ARP entry if requested. */
  1032.     if (ppp_if[f->unit]->ipcp_wantoptions.proxy_arp)
  1033. if (sifproxyarp(f->unit, ho->hisaddr))
  1034.     go->proxy_arp = 1;
  1035. }
  1038. /*
  1039.  * ipcp_down - IPCP has gone DOWN.
  1040.  *
  1041.  * Take the IP network interface down, clear its addresses
  1042.  * and delete routes through it.
  1043.  */
  1044. static void
  1045. ipcp_down(f)
  1046.     fsm *f;
  1047. {
  1048.     u_long ouraddr, hisaddr;
  1050.     IPCPDEBUG((LOG_INFO, "ipcp: down"));
  1052.     ouraddr = ppp_if[f->unit]->ipcp_gotoptions.ouraddr;
  1053.     hisaddr = ppp_if[f->unit]->ipcp_hisoptions.hisaddr;
  1054.     if (ppp_if[f->unit]->ipcp_gotoptions.proxy_arp)
  1055. cifproxyarp(f->unit, hisaddr);
  1056.     if (ppp_if[f->unit]->ipcp_gotoptions.default_route) 
  1057. cifdefaultroute(f->unit, hisaddr);
  1058.     sifdown(f->unit);
  1059.     cifaddr(f->unit, ouraddr, hisaddr);
  1060. }
  1062. #ifdef notyet
  1063. /*
  1064.  * ipcp_script - Execute a script with arguments
  1065.  * interface-name tty-name speed local-IP remote-IP.
  1066.  */
  1067. static void
  1068. ipcp_script(f, script)
  1069.     fsm *f;
  1070.     char *script;
  1071. {
  1072.     char strspeed[32], strlocal[32], strremote[32];
  1073.     char *argv[8];
  1075.     sprintf(strspeed, "%d", ppp_if[f->unit]->baud_rate);
  1076.     strcpy(strlocal, ip_ntoa(ppp_if[f->unit]->ipcp_gotoptions.ouraddr));
  1077.     strcpy(strremote, ip_ntoa(ppp_if[f->unit]->ipcp_hisoptions.hisaddr));
  1079.     argv[0] = script;
  1080.     argv[1] = ppp_if[f->unit]->ifname;
  1081.     argv[2] = ppp_if[f->unit]->devname;
  1082.     argv[3] = strspeed;
  1083.     argv[4] = strlocal;
  1084.     argv[5] = strremote;
  1085.     argv[6] = NULL;
  1086.     run_program(script, argv, 0);
  1087. }
  1088. #endif /* notyet */
  1090. /*
  1091.  * ipcp_printpkt - print the contents of an IPCP packet.
  1092.  */
  1093. char *ipcp_codenames[] = {
  1094.     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
  1095.     "TermReq", "TermAck", "CodeRej"
  1096. };
  1098. int
  1099. ipcp_printpkt(p, plen, printer, arg)
  1100.     u_char *p;
  1101.     int plen;
  1102.     void (*printer)();
  1103.     void *arg;
  1104. {
  1105.     int code, id, len, olen;
  1106.     u_char *pstart, *optend;
  1107.     u_short cishort;
  1108.     u_long cilong;
  1110.     if (plen < HEADERLEN)
  1111.         return 0;
  1112.     pstart = p;
  1113.     GETCHAR(code, p);
  1114.     GETCHAR(id, p);
  1115.     GETSHORT(len, p);
  1116.     if (len < HEADERLEN || len > plen)
  1117.         return 0;
  1119.     if (code >= 1 && code <= sizeof(ipcp_codenames) / sizeof(char *))
  1120.         printer(arg, " %s", ipcp_codenames[code-1]);
  1121.     else
  1122.         printer(arg, " code=0x%x", code);
  1123.     printer(arg, " id=0x%x", id);
  1124.     len -= HEADERLEN;
  1125.     switch (code) {
  1126.     case CONFREQ:
  1127.     case CONFACK:
  1128.     case CONFNAK:
  1129.     case CONFREJ:
  1130.         /* print option list */
  1131.         while (len >= 2) {
  1132.             GETCHAR(code, p);
  1133.             GETCHAR(olen, p);
  1134.             p -= 2;
  1135.             if (olen < 2 || olen > len) {
  1136.                 break;
  1137.             }
  1138.             printer(arg, " <");
  1139.             len -= olen;
  1140.             optend = p + olen;
  1141.             switch (code) {
  1142.             case CI_ADDRS:
  1143.                 if (olen == CILEN_ADDRS) {
  1144.                     p += 2;
  1145.                     GETLONG(cilong, p);
  1146.                     printer(arg, "addrs %s", ip_ntoa(htonl(cilong)));
  1147.                     GETLONG(cilong, p);
  1148.                     printer(arg, " %s", ip_ntoa(htonl(cilong)));
  1149.                 }
  1150.                 break;
  1151.             case CI_COMPRESSTYPE:
  1152.                 if (olen >= CILEN_COMPRESS) {
  1153.                     p += 2;
  1154.                     GETSHORT(cishort, p);
  1155.                     printer(arg, "compress ");
  1156.                     switch (cishort) {
  1157.                     case IPCP_VJ_COMP:
  1158.                         printer(arg, "VJ");
  1159.                         break;
  1160.                     case IPCP_VJ_COMP_OLD:
  1161.                         printer(arg, "old-VJ");
  1162.                         break;
  1163.                     default:
  1164.                         printer(arg, "0x%x", cishort);
  1165.                     }
  1166.                 }
  1167.                 break;
  1168.             case CI_ADDR:
  1169.                 if (olen == CILEN_ADDR) {
  1170.                     p += 2;
  1171.                     GETLONG(cilong, p);
  1172.                     printer(arg, "addr %s", ip_ntoa(htonl(cilong)));
  1173.                 }
  1174.                 break;
  1175.             }
  1176.             while (p < optend) {
  1177.                 GETCHAR(code, p);
  1178.                 printer(arg, " %.2x", code);
  1179.             }
  1180.             printer(arg, ">");
  1181.         }
  1182.         break;
  1183.     }
  1185.     /* print the rest of the bytes in the packet */
  1186.     for (; len > 0; --len) {
  1187.         GETCHAR(code, p);
  1188.         printer(arg, " %.2x", code);
  1189.     }
  1191.     return p - pstart;
  1192. }