minix/lib/liblwip/dist/src/netif/ppp/ppp.c

   1 /*****************************************************************************
   2 * ppp.c - Network Point to Point 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-11-05 Guy Lancaster <lancasterg@acm.org>, Global Election Systems Inc.
  31 *   Original.
  32 *****************************************************************************/
  33
  34 /*
  35  * ppp_defs.h - PPP definitions.
  36  *
  37  * if_pppvar.h - private structures and declarations for PPP.
  38  *
  39  * Copyright (c) 1994 The Australian National University.
  40  * All rights reserved.
  41  *
  42  * Permission to use, copy, modify, and distribute this software and its
  43  * documentation is hereby granted, provided that the above copyright
  44  * notice appears in all copies.  This software is provided without any
  45  * warranty, express or implied. The Australian National University
  46  * makes no representations about the suitability of this software for
  47  * any purpose.
  48  *
  49  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
  50  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  51  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
  52  * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
  53  * OF SUCH DAMAGE.
  54  *
  55  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  56  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  57  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  58  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
  59  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
  60  * OR MODIFICATIONS.
  61  */
  62
  63 /*
  64  * if_ppp.h - Point-to-Point Protocol definitions.
  65  *
  66  * Copyright (c) 1989 Carnegie Mellon University.
  67  * All rights reserved.
  68  *
  69  * Redistribution and use in source and binary forms are permitted
  70  * provided that the above copyright notice and this paragraph are
  71  * duplicated in all such forms and that any documentation,
  72  * advertising materials, and other materials related to such
  73  * distribution and use acknowledge that the software was developed
  74  * by Carnegie Mellon University.  The name of the
  75  * University may not be used to endorse or promote products derived
  76  * from this software without specific prior written permission.
  77  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  78  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  79  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  80  */
  81
  82 /**
  83  * @defgroup ppp PPP netif
  84  * @ingroup addons
  85  * @verbinclude "ppp.txt"
  86  */
  87
  88 #include "netif/ppp/ppp_opts.h"
  89 #if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */
  90
  91 #include "lwip/pbuf.h"
  92 #include "lwip/stats.h"
  93 #include "lwip/sys.h"
  94 #include "lwip/tcpip.h"
  95 #include "lwip/api.h"
  96 #include "lwip/snmp.h"
  97 #include "lwip/ip4.h" /* for ip4_input() */
  98 #if PPP_IPV6_SUPPORT
  99 #include "lwip/ip6.h" /* for ip6_input() */
 100 #endif /* PPP_IPV6_SUPPORT */
 101 #include "lwip/dns.h"
 102
 103 #include "netif/ppp/ppp_impl.h"
 104 #include "netif/ppp/pppos.h"
 105
 106 #include "netif/ppp/fsm.h"
 107 #include "netif/ppp/lcp.h"
 108 #include "netif/ppp/magic.h"
 109
 110 #if PAP_SUPPORT
 111 #include "netif/ppp/upap.h"
 112 #endif /* PAP_SUPPORT */
 113 #if CHAP_SUPPORT
 114 #include "netif/ppp/chap-new.h"
 115 #endif /* CHAP_SUPPORT */
 116 #if EAP_SUPPORT
 117 #include "netif/ppp/eap.h"
 118 #endif /* EAP_SUPPORT */
 119 #if CCP_SUPPORT
 120 #include "netif/ppp/ccp.h"
 121 #endif /* CCP_SUPPORT */
 122 #if MPPE_SUPPORT
 123 #include "netif/ppp/mppe.h"
 124 #endif /* MPPE_SUPPORT */
 125 #if ECP_SUPPORT
 126 #include "netif/ppp/ecp.h"
 127 #endif /* EAP_SUPPORT */
 128 #if VJ_SUPPORT
 129 #include "netif/ppp/vj.h"
 130 #endif /* VJ_SUPPORT */
 131 #if PPP_IPV4_SUPPORT
 132 #include "netif/ppp/ipcp.h"
 133 #endif /* PPP_IPV4_SUPPORT */
 134 #if PPP_IPV6_SUPPORT
 135 #include "netif/ppp/ipv6cp.h"
 136 #endif /* PPP_IPV6_SUPPORT */
 137
 138 /*************************/
 139 /*** LOCAL DEFINITIONS ***/
 140 /*************************/
 141
 142 /* Memory pools */
 143 #if PPPOS_SUPPORT
 144 LWIP_MEMPOOL_PROTOTYPE(PPPOS_PCB);
 145 #endif
 146 #if PPPOE_SUPPORT
 147 LWIP_MEMPOOL_PROTOTYPE(PPPOE_IF);
 148 #endif
 149 #if PPPOL2TP_SUPPORT
 150 LWIP_MEMPOOL_PROTOTYPE(PPPOL2TP_PCB);
 151 #endif
 152 #if LWIP_PPP_API && LWIP_MPU_COMPATIBLE
 153 LWIP_MEMPOOL_PROTOTYPE(PPPAPI_MSG);
 154 #endif
 155 LWIP_MEMPOOL_DECLARE(PPP_PCB, MEMP_NUM_PPP_PCB, sizeof(ppp_pcb), "PPP_PCB")
 156
 157 /* FIXME: add stats per PPP session */
 158 #if PPP_STATS_SUPPORT
 159 static struct timeval start_time; /* Time when link was started. */
 160 static struct pppd_stats old_link_stats;
 161 struct pppd_stats link_stats;
 162 unsigned link_connect_time;
 163 int link_stats_valid;
 164 #endif /* PPP_STATS_SUPPORT */
 165
 166 /*
 167  * PPP Data Link Layer "protocol" table.
 168  * One entry per supported protocol.
 169  * The last entry must be NULL.
 170  */
 171 const struct protent* const protocols[] = {
 172     &lcp_protent,
 173 #if PAP_SUPPORT
 174     &pap_protent,
 175 #endif /* PAP_SUPPORT */
 176 #if CHAP_SUPPORT
 177     &chap_protent,
 178 #endif /* CHAP_SUPPORT */
 179 #if CBCP_SUPPORT
 180     &cbcp_protent,
 181 #endif /* CBCP_SUPPORT */
 182 #if PPP_IPV4_SUPPORT
 183     &ipcp_protent,
 184 #endif /* PPP_IPV4_SUPPORT */
 185 #if PPP_IPV6_SUPPORT
 186     &ipv6cp_protent,
 187 #endif /* PPP_IPV6_SUPPORT */
 188 #if CCP_SUPPORT
 189     &ccp_protent,
 190 #endif /* CCP_SUPPORT */
 191 #if ECP_SUPPORT
 192     &ecp_protent,
 193 #endif /* ECP_SUPPORT */
 194 #ifdef AT_CHANGE
 195     &atcp_protent,
 196 #endif /* AT_CHANGE */
 197 #if EAP_SUPPORT
 198     &eap_protent,
 199 #endif /* EAP_SUPPORT */
 200     NULL
 201 };
 202
 203 /* Prototypes for procedures local to this file. */
 204 static void ppp_do_connect(void *arg);
 205 static err_t ppp_netif_init_cb(struct netif *netif);
 206 #if LWIP_IPV4
 207 static err_t ppp_netif_output_ip4(struct netif *netif, struct pbuf *pb, const ip4_addr_t *ipaddr);
 208 #endif /* LWIP_IPV4 */
 209 #if PPP_IPV6_SUPPORT
 210 static err_t ppp_netif_output_ip6(struct netif *netif, struct pbuf *pb, const ip6_addr_t *ipaddr);
 211 #endif /* PPP_IPV6_SUPPORT */
 212 static err_t ppp_netif_output(struct netif *netif, struct pbuf *pb, u16_t protocol);
 213
 214 /***********************************/
 215 /*** PUBLIC FUNCTION DEFINITIONS ***/
 216 /***********************************/
 217 #if PPP_AUTH_SUPPORT
 218 void ppp_set_auth(ppp_pcb *pcb, u8_t authtype, const char *user, const char *passwd) {
 219 #if PAP_SUPPORT
 220   pcb->settings.refuse_pap = !(authtype & PPPAUTHTYPE_PAP);
 221 #endif /* PAP_SUPPORT */
 222 #if CHAP_SUPPORT
 223   pcb->settings.refuse_chap = !(authtype & PPPAUTHTYPE_CHAP);
 224 #if MSCHAP_SUPPORT
 225   pcb->settings.refuse_mschap = !(authtype & PPPAUTHTYPE_MSCHAP);
 226   pcb->settings.refuse_mschap_v2 = !(authtype & PPPAUTHTYPE_MSCHAP_V2);
 227 #endif /* MSCHAP_SUPPORT */
 228 #endif /* CHAP_SUPPORT */
 229 #if EAP_SUPPORT
 230   pcb->settings.refuse_eap = !(authtype & PPPAUTHTYPE_EAP);
 231 #endif /* EAP_SUPPORT */
 232   pcb->settings.user = user;
 233   pcb->settings.passwd = passwd;
 234 }
 235 #endif /* PPP_AUTH_SUPPORT */
 236
 237 #if MPPE_SUPPORT
 238 /* Set MPPE configuration */
 239 void ppp_set_mppe(ppp_pcb *pcb, u8_t flags) {
 240   if (flags == PPP_MPPE_DISABLE) {
 241     pcb->settings.require_mppe = 0;
 242     return;
 243   }
 244
 245   pcb->settings.require_mppe = 1;
 246   pcb->settings.refuse_mppe_stateful = !(flags & PPP_MPPE_ALLOW_STATEFUL);
 247   pcb->settings.refuse_mppe_40 = !!(flags & PPP_MPPE_REFUSE_40);
 248   pcb->settings.refuse_mppe_128 = !!(flags & PPP_MPPE_REFUSE_128);
 249 }
 250 #endif /* MPPE_SUPPORT */
 251
 252 #if PPP_NOTIFY_PHASE
 253 void ppp_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb) {
 254   pcb->notify_phase_cb = notify_phase_cb;
 255   notify_phase_cb(pcb, pcb->phase, pcb->ctx_cb);
 256 }
 257 #endif /* PPP_NOTIFY_PHASE */
 258
 259 /*
 260  * Initiate a PPP connection.
 261  *
 262  * This can only be called if PPP is in the dead phase.
 263  *
 264  * Holdoff is the time to wait (in seconds) before initiating
 265  * the connection.
 266  *
 267  * If this port connects to a modem, the modem connection must be
 268  * established before calling this.
 269  */
 270 err_t ppp_connect(ppp_pcb *pcb, u16_t holdoff) {
 271   if (pcb->phase != PPP_PHASE_DEAD) {
 272     return ERR_ALREADY;
 273   }
 274
 275   PPPDEBUG(LOG_DEBUG, ("ppp_connect[%d]: holdoff=%d\n", pcb->netif->num, holdoff));
 276
 277   if (holdoff == 0) {
 278     ppp_do_connect(pcb);
 279     return ERR_OK;
 280   }
 281
 282   new_phase(pcb, PPP_PHASE_HOLDOFF);
 283   sys_timeout((u32_t)(holdoff*1000), ppp_do_connect, pcb);
 284   return ERR_OK;
 285 }
 286
 287 #if PPP_SERVER
 288 /*
 289  * Listen for an incoming PPP connection.
 290  *
 291  * This can only be called if PPP is in the dead phase.
 292  *
 293  * If this port connects to a modem, the modem connection must be
 294  * established before calling this.
 295  */
 296 err_t ppp_listen(ppp_pcb *pcb) {
 297   if (pcb->phase != PPP_PHASE_DEAD) {
 298     return ERR_ALREADY;
 299   }
 300
 301   PPPDEBUG(LOG_DEBUG, ("ppp_listen[%d]\n", pcb->netif->num));
 302
 303   if (pcb->link_cb->listen) {
 304     new_phase(pcb, PPP_PHASE_INITIALIZE);
 305     pcb->link_cb->listen(pcb, pcb->link_ctx_cb);
 306     return ERR_OK;
 307   }
 308   return ERR_IF;
 309 }
 310 #endif /* PPP_SERVER */
 311
 312 /*
 313  * Initiate the end of a PPP connection.
 314  * Any outstanding packets in the queues are dropped.
 315  *
 316  * Setting nocarrier to 1 close the PPP connection without initiating the
 317  * shutdown procedure. Always using nocarrier = 0 is still recommended,
 318  * this is going to take a little longer time if your link is down, but
 319  * is a safer choice for the PPP state machine.
 320  *
 321  * Return 0 on success, an error code on failure.
 322  */
 323 err_t
 324 ppp_close(ppp_pcb *pcb, u8_t nocarrier)
 325 {
 326   pcb->err_code = PPPERR_USER;
 327
 328   /* holdoff phase, cancel the reconnection */
 329   if (pcb->phase == PPP_PHASE_HOLDOFF) {
 330     sys_untimeout(ppp_do_connect, pcb);
 331     new_phase(pcb, PPP_PHASE_DEAD);
 332   }
 333
 334   /* dead phase, nothing to do, call the status callback to be consistent */
 335   if (pcb->phase == PPP_PHASE_DEAD) {
 336     pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb);
 337     return ERR_OK;
 338   }
 339
 340   /* Already terminating, nothing to do */
 341   if (pcb->phase >= PPP_PHASE_TERMINATE) {
 342     return ERR_INPROGRESS;
 343   }
 344
 345   /* LCP not open, close link protocol */
 346   if (pcb->phase < PPP_PHASE_ESTABLISH) {
 347     new_phase(pcb, PPP_PHASE_DISCONNECT);
 348     ppp_link_terminated(pcb);
 349     return ERR_OK;
 350   }
 351
 352   /*
 353    * Only accept carrier lost signal on the stable running phase in order
 354    * to prevent changing the PPP phase FSM in transition phases.
 355    *
 356    * Always using nocarrier = 0 is still recommended, this is going to
 357    * take a little longer time, but is a safer choice from FSM point of view.
 358    */
 359   if (nocarrier && pcb->phase == PPP_PHASE_RUNNING) {
 360     PPPDEBUG(LOG_DEBUG, ("ppp_close[%d]: carrier lost -> lcp_lowerdown\n", pcb->netif->num));
 361     lcp_lowerdown(pcb);
 362     /* forced link termination, this will force link protocol to disconnect. */
 363     link_terminated(pcb);
 364     return ERR_OK;
 365   }
 366
 367   /* Disconnect */
 368   PPPDEBUG(LOG_DEBUG, ("ppp_close[%d]: kill_link -> lcp_close\n", pcb->netif->num));
 369   /* LCP soft close request. */
 370   lcp_close(pcb, "User request");
 371   return ERR_OK;
 372 }
 373
 374 /*
 375  * Release the control block.
 376  *
 377  * This can only be called if PPP is in the dead phase.
 378  *
 379  * You must use ppp_close() before if you wish to terminate
 380  * an established PPP session.
 381  *
 382  * Return 0 on success, an error code on failure.
 383  */
 384 err_t ppp_free(ppp_pcb *pcb) {
 385   err_t err;
 386   if (pcb->phase != PPP_PHASE_DEAD) {
 387     return ERR_CONN;
 388   }
 389
 390   PPPDEBUG(LOG_DEBUG, ("ppp_free[%d]\n", pcb->netif->num));
 391
 392   netif_remove(pcb->netif);
 393
 394   err = pcb->link_cb->free(pcb, pcb->link_ctx_cb);
 395
 396   LWIP_MEMPOOL_FREE(PPP_PCB, pcb);
 397   return err;
 398 }
 399
 400 /* Get and set parameters for the given connection.
 401  * Return 0 on success, an error code on failure. */
 402 err_t
 403 ppp_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg)
 404 {
 405   if (pcb == NULL) {
 406     return ERR_VAL;
 407   }
 408
 409   switch(cmd) {
 410     case PPPCTLG_UPSTATUS:      /* Get the PPP up status. */
 411       if (!arg) {
 412         goto fail;
 413       }
 414       *(int *)arg = (int)(0
 415 #if PPP_IPV4_SUPPORT
 416            || pcb->if4_up
 417 #endif /* PPP_IPV4_SUPPORT */
 418 #if PPP_IPV6_SUPPORT
 419            || pcb->if6_up
 420 #endif /* PPP_IPV6_SUPPORT */
 421            );
 422       return ERR_OK;
 423
 424     case PPPCTLG_ERRCODE:       /* Get the PPP error code. */
 425       if (!arg) {
 426         goto fail;
 427       }
 428       *(int *)arg = (int)(pcb->err_code);
 429       return ERR_OK;
 430
 431     default:
 432       goto fail;
 433   }
 434
 435 fail:
 436   return ERR_VAL;
 437 }
 438
 439
 440 /**********************************/
 441 /*** LOCAL FUNCTION DEFINITIONS ***/
 442 /**********************************/
 443
 444 static void ppp_do_connect(void *arg) {
 445   ppp_pcb *pcb = (ppp_pcb*)arg;
 446
 447   LWIP_ASSERT("pcb->phase == PPP_PHASE_DEAD || pcb->phase == PPP_PHASE_HOLDOFF", pcb->phase == PPP_PHASE_DEAD || pcb->phase == PPP_PHASE_HOLDOFF);
 448
 449   new_phase(pcb, PPP_PHASE_INITIALIZE);
 450   pcb->link_cb->connect(pcb, pcb->link_ctx_cb);
 451 }
 452
 453 /*
 454  * ppp_netif_init_cb - netif init callback
 455  */
 456 static err_t ppp_netif_init_cb(struct netif *netif) {
 457   netif->name[0] = 'p';
 458   netif->name[1] = 'p';
 459 #if LWIP_IPV4
 460   /* FIXME: change that when netif_null_output_ip4() will materialize */
 461   netif->output = ppp_netif_output_ip4;
 462 #endif /* LWIP_IPV4 */
 463 #if PPP_IPV6_SUPPORT
 464   netif->output_ip6 = ppp_netif_output_ip6;
 465 #endif /* PPP_IPV6_SUPPORT */
 466   netif->flags = NETIF_FLAG_UP;
 467 #if LWIP_NETIF_HOSTNAME
 468   /* @todo: Initialize interface hostname */
 469   /* netif_set_hostname(netif, "lwip"); */
 470 #endif /* LWIP_NETIF_HOSTNAME */
 471   return ERR_OK;
 472 }
 473
 474 #if LWIP_IPV4
 475 /*
 476  * Send an IPv4 packet on the given connection.
 477  */
 478 static err_t ppp_netif_output_ip4(struct netif *netif, struct pbuf *pb, const ip4_addr_t *ipaddr) {
 479   LWIP_UNUSED_ARG(ipaddr);
 480 #if PPP_IPV4_SUPPORT
 481   return ppp_netif_output(netif, pb, PPP_IP);
 482 #else /* PPP_IPV4_SUPPORT */
 483   LWIP_UNUSED_ARG(netif);
 484   LWIP_UNUSED_ARG(pb);
 485   return ERR_IF;
 486 #endif /* PPP_IPV4_SUPPORT */
 487 }
 488 #endif /* LWIP_IPV4 */
 489
 490 #if PPP_IPV6_SUPPORT
 491 /*
 492  * Send an IPv6 packet on the given connection.
 493  */
 494 static err_t ppp_netif_output_ip6(struct netif *netif, struct pbuf *pb, const ip6_addr_t *ipaddr) {
 495   LWIP_UNUSED_ARG(ipaddr);
 496   return ppp_netif_output(netif, pb, PPP_IPV6);
 497 }
 498 #endif /* PPP_IPV6_SUPPORT */
 499
 500 static err_t ppp_netif_output(struct netif *netif, struct pbuf *pb, u16_t protocol) {
 501   ppp_pcb *pcb = (ppp_pcb*)netif->state;
 502   err_t err;
 503   struct pbuf *fpb = NULL;
 504
 505   /* Check that the link is up. */
 506   if (0
 507 #if PPP_IPV4_SUPPORT
 508       || (protocol == PPP_IP && !pcb->if4_up)
 509 #endif /* PPP_IPV4_SUPPORT */
 510 #if PPP_IPV6_SUPPORT
 511       || (protocol == PPP_IPV6 && !pcb->if6_up)
 512 #endif /* PPP_IPV6_SUPPORT */
 513       ) {
 514     PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: link not up\n", pcb->netif->num));
 515     goto err_rte_drop;
 516   }
 517
 518 #if MPPE_SUPPORT
 519   /* If MPPE is required, refuse any IP packet until we are able to crypt them. */
 520   if (pcb->settings.require_mppe && pcb->ccp_transmit_method != CI_MPPE) {
 521     PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: MPPE required, not up\n", pcb->netif->num));
 522     goto err_rte_drop;
 523   }
 524 #endif /* MPPE_SUPPORT */
 525
 526 #if VJ_SUPPORT
 527   /*
 528    * Attempt Van Jacobson header compression if VJ is configured and
 529    * this is an IP packet.
 530    */
 531   if (protocol == PPP_IP && pcb->vj_enabled) {
 532     switch (vj_compress_tcp(&pcb->vj_comp, &pb)) {
 533       case TYPE_IP:
 534         /* No change...
 535            protocol = PPP_IP; */
 536         break;
 537       case TYPE_COMPRESSED_TCP:
 538         /* vj_compress_tcp() returns a new allocated pbuf, indicate we should free
 539          * our duplicated pbuf later */
 540         fpb = pb;
 541         protocol = PPP_VJC_COMP;
 542         break;
 543       case TYPE_UNCOMPRESSED_TCP:
 544         /* vj_compress_tcp() returns a new allocated pbuf, indicate we should free
 545          * our duplicated pbuf later */
 546         fpb = pb;
 547         protocol = PPP_VJC_UNCOMP;
 548         break;
 549       default:
 550         PPPDEBUG(LOG_WARNING, ("ppp_netif_output[%d]: bad IP packet\n", pcb->netif->num));
 551         LINK_STATS_INC(link.proterr);
 552         LINK_STATS_INC(link.drop);
 553         MIB2_STATS_NETIF_INC(pcb->netif, ifoutdiscards);
 554         return ERR_VAL;
 555     }
 556   }
 557 #endif /* VJ_SUPPORT */
 558
 559 #if CCP_SUPPORT
 560   switch (pcb->ccp_transmit_method) {
 561   case 0:
 562     break; /* Don't compress */
 563 #if MPPE_SUPPORT
 564   case CI_MPPE:
 565     if ((err = mppe_compress(pcb, &pcb->mppe_comp, &pb, protocol)) != ERR_OK) {
 566       LINK_STATS_INC(link.memerr);
 567       LINK_STATS_INC(link.drop);
 568       MIB2_STATS_NETIF_INC(netif, ifoutdiscards);
 569       goto err;
 570     }
 571     /* if VJ compressor returned a new allocated pbuf, free it */
 572     if (fpb) {
 573       pbuf_free(fpb);
 574     }
 575     /* mppe_compress() returns a new allocated pbuf, indicate we should free
 576      * our duplicated pbuf later */
 577     fpb = pb;
 578     protocol = PPP_COMP;
 579     break;
 580 #endif /* MPPE_SUPPORT */
 581   default:
 582     PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: bad CCP transmit method\n", pcb->netif->num));
 583     goto err_rte_drop; /* Cannot really happen, we only negotiate what we are able to do */
 584   }
 585 #endif /* CCP_SUPPORT */
 586
 587   err = pcb->link_cb->netif_output(pcb, pcb->link_ctx_cb, pb, protocol);
 588   goto err;
 589
 590 err_rte_drop:
 591   err = ERR_RTE;
 592   LINK_STATS_INC(link.rterr);
 593   LINK_STATS_INC(link.drop);
 594   MIB2_STATS_NETIF_INC(netif, ifoutdiscards);
 595 err:
 596   if (fpb) {
 597     pbuf_free(fpb);
 598   }
 599   return err;
 600 }
 601
 602 /************************************/
 603 /*** PRIVATE FUNCTION DEFINITIONS ***/
 604 /************************************/
 605
 606 /* Initialize the PPP subsystem. */
 607 int ppp_init(void)
 608 {
 609 #if PPPOS_SUPPORT
 610   LWIP_MEMPOOL_INIT(PPPOS_PCB);
 611 #endif
 612 #if PPPOE_SUPPORT
 613   LWIP_MEMPOOL_INIT(PPPOE_IF);
 614 #endif
 615 #if PPPOL2TP_SUPPORT
 616   LWIP_MEMPOOL_INIT(PPPOL2TP_PCB);
 617 #endif
 618 #if LWIP_PPP_API && LWIP_MPU_COMPATIBLE
 619   LWIP_MEMPOOL_INIT(PPPAPI_MSG);
 620 #endif
 621
 622   LWIP_MEMPOOL_INIT(PPP_PCB);
 623
 624   /*
 625    * Initialize magic number generator now so that protocols may
 626    * use magic numbers in initialization.
 627    */
 628   magic_init();
 629
 630   return 0;
 631 }
 632
 633 /*
 634  * Create a new PPP control block.
 635  *
 636  * This initializes the PPP control block but does not
 637  * attempt to negotiate the LCP session.
 638  *
 639  * Return a new PPP connection control block pointer
 640  * on success or a null pointer on failure.
 641  */
 642 ppp_pcb *ppp_new(struct netif *pppif, const struct link_callbacks *callbacks, void *link_ctx_cb, ppp_link_status_cb_fn link_status_cb, void *ctx_cb) {
 643   ppp_pcb *pcb;
 644   const struct protent *protp;
 645   int i;
 646
 647   /* PPP is single-threaded: without a callback,
 648    * there is no way to know when the link is up. */
 649   if (link_status_cb == NULL) {
 650     return NULL;
 651   }
 652
 653   pcb = (ppp_pcb*)LWIP_MEMPOOL_ALLOC(PPP_PCB);
 654   if (pcb == NULL) {
 655     return NULL;
 656   }
 657
 658   memset(pcb, 0, sizeof(ppp_pcb));
 659
 660   /* default configuration */
 661 #if PAP_SUPPORT
 662   pcb->settings.pap_timeout_time = UPAP_DEFTIMEOUT;
 663   pcb->settings.pap_max_transmits = UPAP_DEFTRANSMITS;
 664 #if PPP_SERVER
 665   pcb->settings.pap_req_timeout = UPAP_DEFREQTIME;
 666 #endif /* PPP_SERVER */
 667 #endif /* PAP_SUPPORT */
 668
 669 #if CHAP_SUPPORT
 670   pcb->settings.chap_timeout_time = CHAP_DEFTIMEOUT;
 671   pcb->settings.chap_max_transmits = CHAP_DEFTRANSMITS;
 672 #if PPP_SERVER
 673   pcb->settings.chap_rechallenge_time = CHAP_DEFRECHALLENGETIME;
 674 #endif /* PPP_SERVER */
 675 #endif /* CHAP_SUPPPORT */
 676
 677 #if EAP_SUPPORT
 678   pcb->settings.eap_req_time = EAP_DEFREQTIME;
 679   pcb->settings.eap_allow_req = EAP_DEFALLOWREQ;
 680 #if PPP_SERVER
 681   pcb->settings.eap_timeout_time = EAP_DEFTIMEOUT;
 682   pcb->settings.eap_max_transmits = EAP_DEFTRANSMITS;
 683 #endif /* PPP_SERVER */
 684 #endif /* EAP_SUPPORT */
 685
 686   pcb->settings.lcp_loopbackfail = LCP_DEFLOOPBACKFAIL;
 687   pcb->settings.lcp_echo_interval = LCP_ECHOINTERVAL;
 688   pcb->settings.lcp_echo_fails = LCP_MAXECHOFAILS;
 689
 690   pcb->settings.fsm_timeout_time = FSM_DEFTIMEOUT;
 691   pcb->settings.fsm_max_conf_req_transmits = FSM_DEFMAXCONFREQS;
 692   pcb->settings.fsm_max_term_transmits = FSM_DEFMAXTERMREQS;
 693   pcb->settings.fsm_max_nak_loops = FSM_DEFMAXNAKLOOPS;
 694
 695   pcb->netif = pppif;
 696   MIB2_INIT_NETIF(pppif, snmp_ifType_ppp, 0);
 697   if (!netif_add(pcb->netif,
 698 #if LWIP_IPV4
 699                  IP4_ADDR_ANY4, IP4_ADDR_BROADCAST, IP4_ADDR_ANY4,
 700 #endif /* LWIP_IPV4 */
 701                  (void *)pcb, ppp_netif_init_cb, NULL)) {
 702     LWIP_MEMPOOL_FREE(PPP_PCB, pcb);
 703     PPPDEBUG(LOG_ERR, ("ppp_new: netif_add failed\n"));
 704     return NULL;
 705   }
 706
 707   pcb->link_cb = callbacks;
 708   pcb->link_ctx_cb = link_ctx_cb;
 709   pcb->link_status_cb = link_status_cb;
 710   pcb->ctx_cb = ctx_cb;
 711
 712   /*
 713    * Initialize each protocol.
 714    */
 715   for (i = 0; (protp = protocols[i]) != NULL; ++i) {
 716       (*protp->init)(pcb);
 717   }
 718
 719   new_phase(pcb, PPP_PHASE_DEAD);
 720   return pcb;
 721 }
 722
 723 /** Initiate LCP open request */
 724 void ppp_start(ppp_pcb *pcb) {
 725   PPPDEBUG(LOG_DEBUG, ("ppp_start[%d]\n", pcb->netif->num));
 726
 727   /* Clean data not taken care by anything else, mostly shared data. */
 728 #if PPP_STATS_SUPPORT
 729   link_stats_valid = 0;
 730 #endif /* PPP_STATS_SUPPORT */
 731 #if MPPE_SUPPORT
 732   pcb->mppe_keys_set = 0;
 733   memset(&pcb->mppe_comp, 0, sizeof(pcb->mppe_comp));
 734   memset(&pcb->mppe_decomp, 0, sizeof(pcb->mppe_decomp));
 735 #endif /* MPPE_SUPPORT */
 736 #if VJ_SUPPORT
 737   vj_compress_init(&pcb->vj_comp);
 738 #endif /* VJ_SUPPORT */
 739
 740   /* Start protocol */
 741   new_phase(pcb, PPP_PHASE_ESTABLISH);
 742   lcp_open(pcb);
 743   lcp_lowerup(pcb);
 744   PPPDEBUG(LOG_DEBUG, ("ppp_start[%d]: finished\n", pcb->netif->num));
 745 }
 746
 747 /** Called when link failed to setup */
 748 void ppp_link_failed(ppp_pcb *pcb) {
 749   PPPDEBUG(LOG_DEBUG, ("ppp_link_failed[%d]\n", pcb->netif->num));
 750   new_phase(pcb, PPP_PHASE_DEAD);
 751   pcb->err_code = PPPERR_OPEN;
 752   pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb);
 753 }
 754
 755 /** Called when link is normally down (i.e. it was asked to end) */
 756 void ppp_link_end(ppp_pcb *pcb) {
 757   PPPDEBUG(LOG_DEBUG, ("ppp_link_end[%d]\n", pcb->netif->num));
 758   new_phase(pcb, PPP_PHASE_DEAD);
 759   if (pcb->err_code == PPPERR_NONE) {
 760     pcb->err_code = PPPERR_CONNECT;
 761   }
 762   pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb);
 763 }
 764
 765 /*
 766  * Pass the processed input packet to the appropriate handler.
 767  * This function and all handlers run in the context of the tcpip_thread
 768  */
 769 void ppp_input(ppp_pcb *pcb, struct pbuf *pb) {
 770   u16_t protocol;
 771 #if PPP_DEBUG && PPP_PROTOCOLNAME
 772     const char *pname;
 773 #endif /* PPP_DEBUG && PPP_PROTOCOLNAME */
 774
 775   magic_randomize();
 776
 777   if (pb->len < 2) {
 778     PPPDEBUG(LOG_ERR, ("ppp_input[%d]: packet too short\n", pcb->netif->num));
 779     goto drop;
 780   }
 781   protocol = (((u8_t *)pb->payload)[0] << 8) | ((u8_t*)pb->payload)[1];
 782
 783 #if PRINTPKT_SUPPORT
 784   ppp_dump_packet(pcb, "rcvd", (unsigned char *)pb->payload, pb->len);
 785 #endif /* PRINTPKT_SUPPORT */
 786
 787   pbuf_header(pb, -(s16_t)sizeof(protocol));
 788
 789   LINK_STATS_INC(link.recv);
 790   MIB2_STATS_NETIF_INC(pcb->netif, ifinucastpkts);
 791   MIB2_STATS_NETIF_ADD(pcb->netif, ifinoctets, pb->tot_len);
 792
 793   /*
 794    * Toss all non-LCP packets unless LCP is OPEN.
 795    */
 796   if (protocol != PPP_LCP && pcb->lcp_fsm.state != PPP_FSM_OPENED) {
 797     ppp_dbglog("Discarded non-LCP packet when LCP not open");
 798     goto drop;
 799   }
 800
 801   /*
 802    * Until we get past the authentication phase, toss all packets
 803    * except LCP, LQR and authentication packets.
 804    */
 805   if (pcb->phase <= PPP_PHASE_AUTHENTICATE
 806    && !(protocol == PPP_LCP
 807 #if LQR_SUPPORT
 808    || protocol == PPP_LQR
 809 #endif /* LQR_SUPPORT */
 810 #if PAP_SUPPORT
 811    || protocol == PPP_PAP
 812 #endif /* PAP_SUPPORT */
 813 #if CHAP_SUPPORT
 814    || protocol == PPP_CHAP
 815 #endif /* CHAP_SUPPORT */
 816 #if EAP_SUPPORT
 817    || protocol == PPP_EAP
 818 #endif /* EAP_SUPPORT */
 819    )) {
 820     ppp_dbglog("discarding proto 0x%x in phase %d", protocol, pcb->phase);
 821     goto drop;
 822   }
 823
 824 #if CCP_SUPPORT
 825 #if MPPE_SUPPORT
 826   /*
 827    * MPPE is required and unencrypted data has arrived (this
 828    * should never happen!). We should probably drop the link if
 829    * the protocol is in the range of what should be encrypted.
 830    * At the least, we drop this packet.
 831    */
 832   if (pcb->settings.require_mppe && protocol != PPP_COMP && protocol < 0x8000) {
 833     PPPDEBUG(LOG_ERR, ("ppp_input[%d]: MPPE required, received unencrypted data!\n", pcb->netif->num));
 834     goto drop;
 835   }
 836 #endif /* MPPE_SUPPORT */
 837
 838   if (protocol == PPP_COMP) {
 839     u8_t *pl;
 840
 841     switch (pcb->ccp_receive_method) {
 842 #if MPPE_SUPPORT
 843     case CI_MPPE:
 844       if (mppe_decompress(pcb, &pcb->mppe_decomp, &pb) != ERR_OK) {
 845         goto drop;
 846       }
 847       break;
 848 #endif /* MPPE_SUPPORT */
 849     default:
 850       PPPDEBUG(LOG_ERR, ("ppp_input[%d]: bad CCP receive method\n", pcb->netif->num));
 851       goto drop; /* Cannot really happen, we only negotiate what we are able to do */
 852     }
 853
 854     /* Assume no PFC */
 855     if (pb->len < 2) {
 856       goto drop;
 857     }
 858
 859     /* Extract and hide protocol (do PFC decompression if necessary) */
 860     pl = (u8_t*)pb->payload;
 861     if (pl[0] & 0x01) {
 862       protocol = pl[0];
 863       pbuf_header(pb, -(s16_t)1);
 864     } else {
 865       protocol = (pl[0] << 8) | pl[1];
 866       pbuf_header(pb, -(s16_t)2);
 867     }
 868   }
 869 #endif /* CCP_SUPPORT */
 870
 871   switch(protocol) {
 872
 873 #if PPP_IPV4_SUPPORT
 874     case PPP_IP:            /* Internet Protocol */
 875       PPPDEBUG(LOG_INFO, ("ppp_input[%d]: ip in pbuf len=%d\n", pcb->netif->num, pb->tot_len));
 876       ip4_input(pb, pcb->netif);
 877       return;
 878 #endif /* PPP_IPV4_SUPPORT */
 879
 880 #if PPP_IPV6_SUPPORT
 881     case PPP_IPV6:          /* Internet Protocol Version 6 */
 882       PPPDEBUG(LOG_INFO, ("ppp_input[%d]: ip6 in pbuf len=%d\n", pcb->netif->num, pb->tot_len));
 883       ip6_input(pb, pcb->netif);
 884       return;
 885 #endif /* PPP_IPV6_SUPPORT */
 886
 887 #if VJ_SUPPORT
 888     case PPP_VJC_COMP:      /* VJ compressed TCP */
 889       /*
 890        * Clip off the VJ header and prepend the rebuilt TCP/IP header and
 891        * pass the result to IP.
 892        */
 893       PPPDEBUG(LOG_INFO, ("ppp_input[%d]: vj_comp in pbuf len=%d\n", pcb->netif->num, pb->tot_len));
 894       if (pcb->vj_enabled && vj_uncompress_tcp(&pb, &pcb->vj_comp) >= 0) {
 895         ip4_input(pb, pcb->netif);
 896         return;
 897       }
 898       /* Something's wrong so drop it. */
 899       PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping VJ compressed\n", pcb->netif->num));
 900       break;
 901
 902     case PPP_VJC_UNCOMP:    /* VJ uncompressed TCP */
 903       /*
 904        * Process the TCP/IP header for VJ header compression and then pass
 905        * the packet to IP.
 906        */
 907       PPPDEBUG(LOG_INFO, ("ppp_input[%d]: vj_un in pbuf len=%d\n", pcb->netif->num, pb->tot_len));
 908       if (pcb->vj_enabled && vj_uncompress_uncomp(pb, &pcb->vj_comp) >= 0) {
 909         ip4_input(pb, pcb->netif);
 910         return;
 911       }
 912       /* Something's wrong so drop it. */
 913       PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping VJ uncompressed\n", pcb->netif->num));
 914       break;
 915 #endif /* VJ_SUPPORT */
 916
 917     default: {
 918       int i;
 919       const struct protent *protp;
 920
 921       /*
 922        * Upcall the proper protocol input routine.
 923        */
 924       for (i = 0; (protp = protocols[i]) != NULL; ++i) {
 925         if (protp->protocol == protocol) {
 926           pb = ppp_singlebuf(pb);
 927           (*protp->input)(pcb, (u8_t*)pb->payload, pb->len);
 928           goto out;
 929         }
 930 #if 0   /* UNUSED
 931          *
 932          * This is actually a (hacked?) way for the Linux kernel to pass a data
 933          * packet to pppd. pppd in normal condition only do signaling
 934          * (LCP, PAP, CHAP, IPCP, ...) and does not handle any data packet at all.
 935          *
 936          * We don't even need this interface, which is only there because of PPP
 937          * interface limitation between Linux kernel and pppd. For MPPE, which uses
 938          * CCP to negotiate although it is not really a (de)compressor, we added
 939          * ccp_resetrequest() in CCP and MPPE input data flow is calling either
 940          * ccp_resetrequest() or lcp_close() if the issue is, respectively, non-fatal
 941          * or fatal, this is what ccp_datainput() really do.
 942          */
 943         if (protocol == (protp->protocol & ~0x8000)
 944           && protp->datainput != NULL) {
 945           (*protp->datainput)(pcb, pb->payload, pb->len);
 946           goto out;
 947         }
 948 #endif /* UNUSED */
 949       }
 950
 951 #if PPP_DEBUG
 952 #if PPP_PROTOCOLNAME
 953       pname = protocol_name(protocol);
 954       if (pname != NULL) {
 955         ppp_warn("Unsupported protocol '%s' (0x%x) received", pname, protocol);
 956       } else
 957 #endif /* PPP_PROTOCOLNAME */
 958         ppp_warn("Unsupported protocol 0x%x received", protocol);
 959 #endif /* PPP_DEBUG */
 960         pbuf_header(pb, (s16_t)sizeof(protocol));
 961         lcp_sprotrej(pcb, (u8_t*)pb->payload, pb->len);
 962       }
 963       break;
 964   }
 965
 966 drop:
 967   LINK_STATS_INC(link.drop);
 968   MIB2_STATS_NETIF_INC(pcb->netif, ifindiscards);
 969
 970 out:
 971   pbuf_free(pb);
 972 }
 973
 974 /* merge a pbuf chain into one pbuf */
 975 struct pbuf *ppp_singlebuf(struct pbuf *p) {
 976   struct pbuf *q, *b;
 977   u8_t *pl;
 978
 979   if(p->tot_len == p->len) {
 980     return p;
 981   }
 982
 983   q = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM);
 984   if(!q) {
 985     PPPDEBUG(LOG_ERR,
 986              ("ppp_singlebuf: unable to alloc new buf (%d)\n", p->tot_len));
 987     return p; /* live dangerously */
 988   }
 989
 990   for(b = p, pl = (u8_t*)q->payload; b != NULL; b = b->next) {
 991     MEMCPY(pl, b->payload, b->len);
 992     pl += b->len;
 993   }
 994
 995   pbuf_free(p);
 996
 997   return q;
 998 }
 999
1000 /*
1001  * Write a pbuf to a ppp link, only used from PPP functions
1002  * to send PPP packets.
1003  *
1004  * IPv4 and IPv6 packets from lwIP are sent, respectively,
1005  * with ppp_netif_output_ip4() and ppp_netif_output_ip6()
1006  * functions (which are callbacks of the netif PPP interface).
1007  */
1008 err_t ppp_write(ppp_pcb *pcb, struct pbuf *p) {
1009 #if PRINTPKT_SUPPORT
1010   ppp_dump_packet(pcb, "sent", (unsigned char *)p->payload+2, p->len-2);
1011 #endif /* PRINTPKT_SUPPORT */
1012   return pcb->link_cb->write(pcb, pcb->link_ctx_cb, p);
1013 }
1014
1015 void ppp_link_terminated(ppp_pcb *pcb) {
1016   PPPDEBUG(LOG_DEBUG, ("ppp_link_terminated[%d]\n", pcb->netif->num));
1017   pcb->link_cb->disconnect(pcb, pcb->link_ctx_cb);
1018   PPPDEBUG(LOG_DEBUG, ("ppp_link_terminated[%d]: finished.\n", pcb->netif->num));
1019 }
1020
1021
1022 /************************************************************************
1023  * Functions called by various PPP subsystems to configure
1024  * the PPP interface or change the PPP phase.
1025  */
1026
1027 /*
1028  * new_phase - signal the start of a new phase of pppd's operation.
1029  */
1030 void new_phase(ppp_pcb *pcb, int p) {
1031   pcb->phase = p;
1032   PPPDEBUG(LOG_DEBUG, ("ppp phase changed[%d]: phase=%d\n", pcb->netif->num, pcb->phase));
1033 #if PPP_NOTIFY_PHASE
1034   if (pcb->notify_phase_cb != NULL) {
1035     pcb->notify_phase_cb(pcb, p, pcb->ctx_cb);
1036   }
1037 #endif /* PPP_NOTIFY_PHASE */
1038 }
1039
1040 /*
1041  * ppp_send_config - configure the transmit-side characteristics of
1042  * the ppp interface.
1043  */
1044 int ppp_send_config(ppp_pcb *pcb, int mtu, u32_t accm, int pcomp, int accomp) {
1045   LWIP_UNUSED_ARG(mtu);
1046   /* pcb->mtu = mtu; -- set correctly with netif_set_mtu */
1047
1048   if (pcb->link_cb->send_config) {
1049     pcb->link_cb->send_config(pcb, pcb->link_ctx_cb, accm, pcomp, accomp);
1050   }
1051
1052   PPPDEBUG(LOG_INFO, ("ppp_send_config[%d]\n", pcb->netif->num) );
1053   return 0;
1054 }
1055
1056 /*
1057  * ppp_recv_config - configure the receive-side characteristics of
1058  * the ppp interface.
1059  */
1060 int ppp_recv_config(ppp_pcb *pcb, int mru, u32_t accm, int pcomp, int accomp) {
1061   LWIP_UNUSED_ARG(mru);
1062
1063   if (pcb->link_cb->recv_config) {
1064     pcb->link_cb->recv_config(pcb, pcb->link_ctx_cb, accm, pcomp, accomp);
1065   }
1066
1067   PPPDEBUG(LOG_INFO, ("ppp_recv_config[%d]\n", pcb->netif->num));
1068   return 0;
1069 }
1070
1071 #if PPP_IPV4_SUPPORT
1072 /*
1073  * sifaddr - Config the interface IP addresses and netmask.
1074  */
1075 int sifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr, u32_t netmask) {
1076   ip4_addr_t ip, nm, gw;
1077
1078   ip4_addr_set_u32(&ip, our_adr);
1079   ip4_addr_set_u32(&nm, netmask);
1080   ip4_addr_set_u32(&gw, his_adr);
1081   netif_set_addr(pcb->netif, &ip, &nm, &gw);
1082   return 1;
1083 }
1084
1085 /********************************************************************
1086  *
1087  * cifaddr - Clear the interface IP addresses, and delete routes
1088  * through the interface if possible.
1089  */
1090 int cifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr) {
1091   LWIP_UNUSED_ARG(our_adr);
1092   LWIP_UNUSED_ARG(his_adr);
1093
1094   netif_set_addr(pcb->netif, IP4_ADDR_ANY4, IP4_ADDR_BROADCAST, IP4_ADDR_ANY4);
1095   return 1;
1096 }
1097
1098 #if 0 /* UNUSED - PROXY ARP */
1099 /********************************************************************
1100  *
1101  * sifproxyarp - Make a proxy ARP entry for the peer.
1102  */
1103
1104 int sifproxyarp(ppp_pcb *pcb, u32_t his_adr) {
1105   LWIP_UNUSED_ARG(pcb);
1106   LWIP_UNUSED_ARG(his_adr);
1107   return 0;
1108 }
1109
1110 /********************************************************************
1111  *
1112  * cifproxyarp - Delete the proxy ARP entry for the peer.
1113  */
1114
1115 int cifproxyarp(ppp_pcb *pcb, u32_t his_adr) {
1116   LWIP_UNUSED_ARG(pcb);
1117   LWIP_UNUSED_ARG(his_adr);
1118   return 0;
1119 }
1120 #endif /* UNUSED - PROXY ARP */
1121
1122 #if LWIP_DNS
1123 /*
1124  * sdns - Config the DNS servers
1125  */
1126 int sdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2) {
1127   ip_addr_t ns;
1128   LWIP_UNUSED_ARG(pcb);
1129
1130   ip_addr_set_ip4_u32(&ns, ns1);
1131   dns_setserver(0, &ns);
1132   ip_addr_set_ip4_u32(&ns, ns2);
1133   dns_setserver(1, &ns);
1134   return 1;
1135 }
1136
1137 /********************************************************************
1138  *
1139  * cdns - Clear the DNS servers
1140  */
1141 int cdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2) {
1142   const ip_addr_t *nsa;
1143   ip_addr_t nsb;
1144   LWIP_UNUSED_ARG(pcb);
1145
1146   nsa = dns_getserver(0);
1147   ip_addr_set_ip4_u32(&nsb, ns1);
1148   if (ip_addr_cmp(nsa, &nsb)) {
1149     dns_setserver(0, IP_ADDR_ANY);
1150   }
1151   nsa = dns_getserver(1);
1152   ip_addr_set_ip4_u32(&nsb, ns2);
1153   if (ip_addr_cmp(nsa, &nsb)) {
1154     dns_setserver(1, IP_ADDR_ANY);
1155   }
1156   return 1;
1157 }
1158 #endif /* LWIP_DNS */
1159
1160 #if VJ_SUPPORT
1161 /********************************************************************
1162  *
1163  * sifvjcomp - config tcp header compression
1164  */
1165 int sifvjcomp(ppp_pcb *pcb, int vjcomp, int cidcomp, int maxcid) {
1166   pcb->vj_enabled = vjcomp;
1167   pcb->vj_comp.compressSlot = cidcomp;
1168   pcb->vj_comp.maxSlotIndex = maxcid;
1169   PPPDEBUG(LOG_INFO, ("sifvjcomp[%d]: VJ compress enable=%d slot=%d max slot=%d\n",
1170             pcb->netif->num, vjcomp, cidcomp, maxcid));
1171   return 0;
1172 }
1173 #endif /* VJ_SUPPORT */
1174
1175 /*
1176  * sifup - Config the interface up and enable IP packets to pass.
1177  */
1178 int sifup(ppp_pcb *pcb) {
1179   pcb->if4_up = 1;
1180   pcb->err_code = PPPERR_NONE;
1181   netif_set_link_up(pcb->netif);
1182
1183   PPPDEBUG(LOG_DEBUG, ("sifup[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code));
1184   pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb);
1185   return 1;
1186 }
1187
1188 /********************************************************************
1189  *
1190  * sifdown - Disable the indicated protocol and config the interface
1191  *           down if there are no remaining protocols.
1192  */
1193 int sifdown(ppp_pcb *pcb) {
1194
1195   pcb->if4_up = 0;
1196
1197   if (1
1198 #if PPP_IPV6_SUPPORT
1199    /* set the interface down if IPv6 is down as well */
1200    && !pcb->if6_up
1201 #endif /* PPP_IPV6_SUPPORT */
1202   ) {
1203     /* make sure the netif link callback is called */
1204     netif_set_link_down(pcb->netif);
1205   }
1206   PPPDEBUG(LOG_DEBUG, ("sifdown[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code));
1207   return 1;
1208 }
1209
1210 /********************************************************************
1211  *
1212  * Return user specified netmask, modified by any mask we might determine
1213  * for address `addr' (in network byte order).
1214  * Here we scan through the system's list of interfaces, looking for
1215  * any non-point-to-point interfaces which might appear to be on the same
1216  * network as `addr'.  If we find any, we OR in their netmask to the
1217  * user-specified netmask.
1218  */
1219 u32_t get_mask(u32_t addr) {
1220 #if 0
1221   u32_t mask, nmask;
1222
1223   addr = lwip_htonl(addr);
1224   if (IP_CLASSA(addr)) { /* determine network mask for address class */
1225     nmask = IP_CLASSA_NET;
1226   } else if (IP_CLASSB(addr)) {
1227     nmask = IP_CLASSB_NET;
1228   } else {
1229     nmask = IP_CLASSC_NET;
1230   }
1231
1232   /* class D nets are disallowed by bad_ip_adrs */
1233   mask = PP_HTONL(0xffffff00UL) | lwip_htonl(nmask);
1234
1235   /* XXX
1236    * Scan through the system's network interfaces.
1237    * Get each netmask and OR them into our mask.
1238    */
1239   /* return mask; */
1240   return mask;
1241 #endif /* 0 */
1242   LWIP_UNUSED_ARG(addr);
1243   return IPADDR_BROADCAST;
1244 }
1245 #endif /* PPP_IPV4_SUPPORT */
1246
1247 #if PPP_IPV6_SUPPORT
1248 #define IN6_LLADDR_FROM_EUI64(ip6, eui64) do {    \
1249   ip6.addr[0] = PP_HTONL(0xfe800000);             \
1250   ip6.addr[1] = 0;                                \
1251   eui64_copy(eui64, ip6.addr[2]);                 \
1252   } while (0)
1253
1254 /********************************************************************
1255  *
1256  * sif6addr - Config the interface with an IPv6 link-local address
1257  */
1258 int sif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64) {
1259   ip6_addr_t ip6;
1260   LWIP_UNUSED_ARG(his_eui64);
1261
1262   IN6_LLADDR_FROM_EUI64(ip6, our_eui64);
1263   netif_ip6_addr_set(pcb->netif, 0, &ip6);
1264   netif_ip6_addr_set_state(pcb->netif, 0, IP6_ADDR_PREFERRED);
1265   /* FIXME: should we add an IPv6 static neighbor using his_eui64 ? */
1266   return 1;
1267 }
1268
1269 /********************************************************************
1270  *
1271  * cif6addr - Remove IPv6 address from interface
1272  */
1273 int cif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64) {
1274   LWIP_UNUSED_ARG(our_eui64);
1275   LWIP_UNUSED_ARG(his_eui64);
1276
1277   netif_ip6_addr_set_state(pcb->netif, 0, IP6_ADDR_INVALID);
1278   netif_ip6_addr_set(pcb->netif, 0, IP6_ADDR_ANY6);
1279   return 1;
1280 }
1281
1282 /*
1283  * sif6up - Config the interface up and enable IPv6 packets to pass.
1284  */
1285 int sif6up(ppp_pcb *pcb) {
1286
1287   pcb->if6_up = 1;
1288   pcb->err_code = PPPERR_NONE;
1289   netif_set_link_up(pcb->netif);
1290
1291   PPPDEBUG(LOG_DEBUG, ("sif6up[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code));
1292   pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb);
1293   return 1;
1294 }
1295
1296 /********************************************************************
1297  *
1298  * sif6down - Disable the indicated protocol and config the interface
1299  *            down if there are no remaining protocols.
1300  */
1301 int sif6down(ppp_pcb *pcb) {
1302
1303   pcb->if6_up = 0;
1304
1305   if (1
1306 #if PPP_IPV4_SUPPORT
1307    /* set the interface down if IPv4 is down as well */
1308    && !pcb->if4_up
1309 #endif /* PPP_IPV4_SUPPORT */
1310   ) {
1311     /* make sure the netif link callback is called */
1312     netif_set_link_down(pcb->netif);
1313   }
1314   PPPDEBUG(LOG_DEBUG, ("sif6down[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code));
1315   return 1;
1316 }
1317 #endif /* PPP_IPV6_SUPPORT */
1318
1319 #if DEMAND_SUPPORT
1320 /*
1321  * sifnpmode - Set the mode for handling packets for a given NP.
1322  */
1323 int sifnpmode(ppp_pcb *pcb, int proto, enum NPmode mode) {
1324   LWIP_UNUSED_ARG(pcb);
1325   LWIP_UNUSED_ARG(proto);
1326   LWIP_UNUSED_ARG(mode);
1327   return 0;
1328 }
1329 #endif /* DEMAND_SUPPORT */
1330
1331 /*
1332  * netif_set_mtu - set the MTU on the PPP network interface.
1333  */
1334 void netif_set_mtu(ppp_pcb *pcb, int mtu) {
1335
1336   pcb->netif->mtu = mtu;
1337   PPPDEBUG(LOG_INFO, ("netif_set_mtu[%d]: mtu=%d\n", pcb->netif->num, mtu));
1338 }
1339
1340 /*
1341  * netif_get_mtu - get PPP interface MTU
1342  */
1343 int netif_get_mtu(ppp_pcb *pcb) {
1344
1345   return pcb->netif->mtu;
1346 }
1347
1348 #if CCP_SUPPORT
1349 #if 0 /* unused */
1350 /*
1351  * ccp_test - whether a given compression method is acceptable for use.
1352  */
1353 int
1354 ccp_test(ppp_pcb *pcb, u_char *opt_ptr, int opt_len, int for_transmit)
1355 {
1356   LWIP_UNUSED_ARG(pcb);
1357   LWIP_UNUSED_ARG(opt_ptr);
1358   LWIP_UNUSED_ARG(opt_len);
1359   LWIP_UNUSED_ARG(for_transmit);
1360   return -1;
1361 }
1362 #endif /* unused */
1363
1364 /*
1365  * ccp_set - inform about the current state of CCP.
1366  */
1367 void
1368 ccp_set(ppp_pcb *pcb, u8_t isopen, u8_t isup, u8_t receive_method, u8_t transmit_method)
1369 {
1370   LWIP_UNUSED_ARG(isopen);
1371   LWIP_UNUSED_ARG(isup);
1372   pcb->ccp_receive_method = receive_method;
1373   pcb->ccp_transmit_method = transmit_method;
1374   PPPDEBUG(LOG_DEBUG, ("ccp_set[%d]: is_open=%d, is_up=%d, receive_method=%u, transmit_method=%u\n",
1375            pcb->netif->num, isopen, isup, receive_method, transmit_method));
1376 }
1377
1378 void
1379 ccp_reset_comp(ppp_pcb *pcb)
1380 {
1381   switch (pcb->ccp_transmit_method) {
1382 #if MPPE_SUPPORT
1383   case CI_MPPE:
1384     mppe_comp_reset(pcb, &pcb->mppe_comp);
1385     break;
1386 #endif /* MPPE_SUPPORT */
1387   default:
1388     break;
1389   }
1390 }
1391
1392 void
1393 ccp_reset_decomp(ppp_pcb *pcb)
1394 {
1395   switch (pcb->ccp_receive_method) {
1396 #if MPPE_SUPPORT
1397   case CI_MPPE:
1398     mppe_decomp_reset(pcb, &pcb->mppe_decomp);
1399     break;
1400 #endif /* MPPE_SUPPORT */
1401   default:
1402     break;
1403   }
1404 }
1405
1406 #if 0 /* unused */
1407 /*
1408  * ccp_fatal_error - returns 1 if decompression was disabled as a
1409  * result of an error detected after decompression of a packet,
1410  * 0 otherwise.  This is necessary because of patent nonsense.
1411  */
1412 int
1413 ccp_fatal_error(ppp_pcb *pcb)
1414 {
1415   LWIP_UNUSED_ARG(pcb);
1416   return 1;
1417 }
1418 #endif /* unused */
1419 #endif /* CCP_SUPPORT */
1420
1421 #if PPP_IDLETIMELIMIT
1422 /********************************************************************
1423  *
1424  * get_idle_time - return how long the link has been idle.
1425  */
1426 int get_idle_time(ppp_pcb *pcb, struct ppp_idle *ip) {
1427   /* FIXME: add idle time support and make it optional */
1428   LWIP_UNUSED_ARG(pcb);
1429   LWIP_UNUSED_ARG(ip);
1430   return 1;
1431 }
1432 #endif /* PPP_IDLETIMELIMIT */
1433
1434 #if DEMAND_SUPPORT
1435 /********************************************************************
1436  *
1437  * get_loop_output - get outgoing packets from the ppp device,
1438  * and detect when we want to bring the real link up.
1439  * Return value is 1 if we need to bring up the link, 0 otherwise.
1440  */
1441 int get_loop_output(void) {
1442   return 0;
1443 }
1444 #endif /* DEMAND_SUPPORT */
1445
1446 #if PPP_PROTOCOLNAME
1447 /* List of protocol names, to make our messages a little more informative. */
1448 struct protocol_list {
1449   u_short proto;
1450   const char *name;
1451 } const protocol_list[] = {
1452   { 0x21, "IP" },
1453   { 0x23, "OSI Network Layer" },
1454   { 0x25, "Xerox NS IDP" },
1455   { 0x27, "DECnet Phase IV" },
1456   { 0x29, "Appletalk" },
1457   { 0x2b, "Novell IPX" },
1458   { 0x2d, "VJ compressed TCP/IP" },
1459   { 0x2f, "VJ uncompressed TCP/IP" },
1460   { 0x31, "Bridging PDU" },
1461   { 0x33, "Stream Protocol ST-II" },
1462   { 0x35, "Banyan Vines" },
1463   { 0x39, "AppleTalk EDDP" },
1464   { 0x3b, "AppleTalk SmartBuffered" },
1465   { 0x3d, "Multi-Link" },
1466   { 0x3f, "NETBIOS Framing" },
1467   { 0x41, "Cisco Systems" },
1468   { 0x43, "Ascom Timeplex" },
1469   { 0x45, "Fujitsu Link Backup and Load Balancing (LBLB)" },
1470   { 0x47, "DCA Remote Lan" },
1471   { 0x49, "Serial Data Transport Protocol (PPP-SDTP)" },
1472   { 0x4b, "SNA over 802.2" },
1473   { 0x4d, "SNA" },
1474   { 0x4f, "IP6 Header Compression" },
1475   { 0x51, "KNX Bridging Data" },
1476   { 0x53, "Encryption" },
1477   { 0x55, "Individual Link Encryption" },
1478   { 0x57, "IPv6" },
1479   { 0x59, "PPP Muxing" },
1480   { 0x5b, "Vendor-Specific Network Protocol" },
1481   { 0x61, "RTP IPHC Full Header" },
1482   { 0x63, "RTP IPHC Compressed TCP" },
1483   { 0x65, "RTP IPHC Compressed non-TCP" },
1484   { 0x67, "RTP IPHC Compressed UDP 8" },
1485   { 0x69, "RTP IPHC Compressed RTP 8" },
1486   { 0x6f, "Stampede Bridging" },
1487   { 0x73, "MP+" },
1488   { 0xc1, "NTCITS IPI" },
1489   { 0xfb, "single-link compression" },
1490   { 0xfd, "Compressed Datagram" },
1491   { 0x0201, "802.1d Hello Packets" },
1492   { 0x0203, "IBM Source Routing BPDU" },
1493   { 0x0205, "DEC LANBridge100 Spanning Tree" },
1494   { 0x0207, "Cisco Discovery Protocol" },
1495   { 0x0209, "Netcs Twin Routing" },
1496   { 0x020b, "STP - Scheduled Transfer Protocol" },
1497   { 0x020d, "EDP - Extreme Discovery Protocol" },
1498   { 0x0211, "Optical Supervisory Channel Protocol" },
1499   { 0x0213, "Optical Supervisory Channel Protocol" },
1500   { 0x0231, "Luxcom" },
1501   { 0x0233, "Sigma Network Systems" },
1502   { 0x0235, "Apple Client Server Protocol" },
1503   { 0x0281, "MPLS Unicast" },
1504   { 0x0283, "MPLS Multicast" },
1505   { 0x0285, "IEEE p1284.4 standard - data packets" },
1506   { 0x0287, "ETSI TETRA Network Protocol Type 1" },
1507   { 0x0289, "Multichannel Flow Treatment Protocol" },
1508   { 0x2063, "RTP IPHC Compressed TCP No Delta" },
1509   { 0x2065, "RTP IPHC Context State" },
1510   { 0x2067, "RTP IPHC Compressed UDP 16" },
1511   { 0x2069, "RTP IPHC Compressed RTP 16" },
1512   { 0x4001, "Cray Communications Control Protocol" },
1513   { 0x4003, "CDPD Mobile Network Registration Protocol" },
1514   { 0x4005, "Expand accelerator protocol" },
1515   { 0x4007, "ODSICP NCP" },
1516   { 0x4009, "DOCSIS DLL" },
1517   { 0x400B, "Cetacean Network Detection Protocol" },
1518   { 0x4021, "Stacker LZS" },
1519   { 0x4023, "RefTek Protocol" },
1520   { 0x4025, "Fibre Channel" },
1521   { 0x4027, "EMIT Protocols" },
1522   { 0x405b, "Vendor-Specific Protocol (VSP)" },
1523   { 0x8021, "Internet Protocol Control Protocol" },
1524   { 0x8023, "OSI Network Layer Control Protocol" },
1525   { 0x8025, "Xerox NS IDP Control Protocol" },
1526   { 0x8027, "DECnet Phase IV Control Protocol" },
1527   { 0x8029, "Appletalk Control Protocol" },
1528   { 0x802b, "Novell IPX Control Protocol" },
1529   { 0x8031, "Bridging NCP" },
1530   { 0x8033, "Stream Protocol Control Protocol" },
1531   { 0x8035, "Banyan Vines Control Protocol" },
1532   { 0x803d, "Multi-Link Control Protocol" },
1533   { 0x803f, "NETBIOS Framing Control Protocol" },
1534   { 0x8041, "Cisco Systems Control Protocol" },
1535   { 0x8043, "Ascom Timeplex" },
1536   { 0x8045, "Fujitsu LBLB Control Protocol" },
1537   { 0x8047, "DCA Remote Lan Network Control Protocol (RLNCP)" },
1538   { 0x8049, "Serial Data Control Protocol (PPP-SDCP)" },
1539   { 0x804b, "SNA over 802.2 Control Protocol" },
1540   { 0x804d, "SNA Control Protocol" },
1541   { 0x804f, "IP6 Header Compression Control Protocol" },
1542   { 0x8051, "KNX Bridging Control Protocol" },
1543   { 0x8053, "Encryption Control Protocol" },
1544   { 0x8055, "Individual Link Encryption Control Protocol" },
1545   { 0x8057, "IPv6 Control Protocol" },
1546   { 0x8059, "PPP Muxing Control Protocol" },
1547   { 0x805b, "Vendor-Specific Network Control Protocol (VSNCP)" },
1548   { 0x806f, "Stampede Bridging Control Protocol" },
1549   { 0x8073, "MP+ Control Protocol" },
1550   { 0x80c1, "NTCITS IPI Control Protocol" },
1551   { 0x80fb, "Single Link Compression Control Protocol" },
1552   { 0x80fd, "Compression Control Protocol" },
1553   { 0x8207, "Cisco Discovery Protocol Control" },
1554   { 0x8209, "Netcs Twin Routing" },
1555   { 0x820b, "STP - Control Protocol" },
1556   { 0x820d, "EDPCP - Extreme Discovery Protocol Ctrl Prtcl" },
1557   { 0x8235, "Apple Client Server Protocol Control" },
1558   { 0x8281, "MPLSCP" },
1559   { 0x8285, "IEEE p1284.4 standard - Protocol Control" },
1560   { 0x8287, "ETSI TETRA TNP1 Control Protocol" },
1561   { 0x8289, "Multichannel Flow Treatment Protocol" },
1562   { 0xc021, "Link Control Protocol" },
1563   { 0xc023, "Password Authentication Protocol" },
1564   { 0xc025, "Link Quality Report" },
1565   { 0xc027, "Shiva Password Authentication Protocol" },
1566   { 0xc029, "CallBack Control Protocol (CBCP)" },
1567   { 0xc02b, "BACP Bandwidth Allocation Control Protocol" },
1568   { 0xc02d, "BAP" },
1569   { 0xc05b, "Vendor-Specific Authentication Protocol (VSAP)" },
1570   { 0xc081, "Container Control Protocol" },
1571   { 0xc223, "Challenge Handshake Authentication Protocol" },
1572   { 0xc225, "RSA Authentication Protocol" },
1573   { 0xc227, "Extensible Authentication Protocol" },
1574   { 0xc229, "Mitsubishi Security Info Exch Ptcl (SIEP)" },
1575   { 0xc26f, "Stampede Bridging Authorization Protocol" },
1576   { 0xc281, "Proprietary Authentication Protocol" },
1577   { 0xc283, "Proprietary Authentication Protocol" },
1578   { 0xc481, "Proprietary Node ID Authentication Protocol" },
1579   { 0, NULL },
1580 };
1581
1582 /*
1583  * protocol_name - find a name for a PPP protocol.
1584  */
1585 const char * protocol_name(int proto) {
1586   const struct protocol_list *lp;
1587
1588   for (lp = protocol_list; lp->proto != 0; ++lp) {
1589     if (proto == lp->proto) {
1590       return lp->name;
1591     }
1592   }
1593   return NULL;
1594 }
1595 #endif /* PPP_PROTOCOLNAME */
1596
1597 #if PPP_STATS_SUPPORT
1598
1599 /* ---- Note on PPP Stats support ----
1600  *
1601  * The one willing link stats support should add the get_ppp_stats()
1602  * to fetch statistics from lwIP.
1603  */
1604
1605 /*
1606  * reset_link_stats - "reset" stats when link goes up.
1607  */
1608 void reset_link_stats(int u) {
1609   if (!get_ppp_stats(u, &old_link_stats)) {
1610     return;
1611   }
1612   gettimeofday(&start_time, NULL);
1613 }
1614
1615 /*
1616  * update_link_stats - get stats at link termination.
1617  */
1618 void update_link_stats(int u) {
1619   struct timeval now;
1620   char numbuf[32];
1621
1622   if (!get_ppp_stats(u, &link_stats) || gettimeofday(&now, NULL) < 0) {
1623     return;
1624   }
1625   link_connect_time = now.tv_sec - start_time.tv_sec;
1626   link_stats_valid = 1;
1627
1628   link_stats.bytes_in  -= old_link_stats.bytes_in;
1629   link_stats.bytes_out -= old_link_stats.bytes_out;
1630   link_stats.pkts_in   -= old_link_stats.pkts_in;
1631   link_stats.pkts_out  -= old_link_stats.pkts_out;
1632 }
1633
1634 void print_link_stats() {
1635   /*
1636    * Print connect time and statistics.
1637    */
1638   if (link_stats_valid) {
1639     int t = (link_connect_time + 5) / 6;    /* 1/10ths of minutes */
1640     info("Connect time %d.%d minutes.", t/10, t%10);
1641     info("Sent %u bytes, received %u bytes.", link_stats.bytes_out, link_stats.bytes_in);
1642     link_stats_valid = 0;
1643   }
1644 }
1645 #endif /* PPP_STATS_SUPPORT */
1646
1647 #endif /* PPP_SUPPORT */