lib/liblwip/netif/ppp/ppp_oe.c

   1 /*****************************************************************************
   2 * ppp_oe.c - PPP Over Ethernet implementation for lwIP.
   3 *
   4 * Copyright (c) 2006 by Marc Boucher, Services Informatiques (MBSI) inc.
   5 *
   6 * The authors hereby grant permission to use, copy, modify, distribute,
   7 * and license this software and its documentation for any purpose, provided
   8 * that existing copyright notices are retained in all copies and that this
   9 * notice and the following disclaimer are included verbatim in any
  10 * distributions. No written agreement, license, or royalty fee is required
  11 * for any of the authorized uses.
  12 *
  13 * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
  14 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16 * IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  17 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23 *
  24 ******************************************************************************
  25 * REVISION HISTORY
  26 *
  27 * 06-01-01 Marc Boucher <marc@mbsi.ca>
  28 *   Ported to lwIP.
  29 *****************************************************************************/
  30
  31
  32
  33 /* based on NetBSD: if_pppoe.c,v 1.64 2006/01/31 23:50:15 martin Exp */
  34
  35 /*-
  36  * Copyright (c) 2002 The NetBSD Foundation, Inc.
  37  * All rights reserved.
  38  *
  39  * This code is derived from software contributed to The NetBSD Foundation
  40  * by Martin Husemann <martin@NetBSD.org>.
  41  *
  42  * Redistribution and use in source and binary forms, with or without
  43  * modification, are permitted provided that the following conditions
  44  * are met:
  45  * 1. Redistributions of source code must retain the above copyright
  46  *    notice, this list of conditions and the following disclaimer.
  47  * 2. Redistributions in binary form must reproduce the above copyright
  48  *    notice, this list of conditions and the following disclaimer in the
  49  *    documentation and/or other materials provided with the distribution.
  50  * 3. All advertising materials mentioning features or use of this software
  51  *    must display the following acknowledgement:
  52  *        This product includes software developed by the NetBSD
  53  *        Foundation, Inc. and its contributors.
  54  * 4. Neither the name of The NetBSD Foundation nor the names of its
  55  *    contributors may be used to endorse or promote products derived
  56  *    from this software without specific prior written permission.
  57  *
  58  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  59  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  60  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  61  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  62  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  63  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  64  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  65  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  66  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  67  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  68  * POSSIBILITY OF SUCH DAMAGE.
  69  */
  70
  71 #include "lwip/opt.h"
  72
  73 #if PPPOE_SUPPORT /* don't build if not configured for use in lwipopts.h */
  74
  75 #include "netif/ppp_oe.h"
  76
  77 #include "ppp.h"
  78 #include "pppdebug.h"
  79
  80 #include "lwip/timers.h"
  81 #include "lwip/memp.h"
  82
  83 #include <string.h>
  84 #include <stdio.h>
  85
  86
  87 /* Add a 16 bit unsigned value to a buffer pointed to by PTR */
  88 #define PPPOE_ADD_16(PTR, VAL) \
  89     *(PTR)++ = (u8_t)((VAL) / 256);    \
  90     *(PTR)++ = (u8_t)((VAL) % 256)
  91
  92 /* Add a complete PPPoE header to the buffer pointed to by PTR */
  93 #define PPPOE_ADD_HEADER(PTR, CODE, SESS, LEN)  \
  94     *(PTR)++ = PPPOE_VERTYPE;  \
  95     *(PTR)++ = (CODE);         \
  96     PPPOE_ADD_16(PTR, SESS);   \
  97     PPPOE_ADD_16(PTR, LEN)
  98
  99 #define PPPOE_DISC_TIMEOUT (5*1000)  /* base for quick timeout calculation */
 100 #define PPPOE_SLOW_RETRY   (60*1000) /* persistent retry interval */
 101 #define PPPOE_DISC_MAXPADI  4        /* retry PADI four times (quickly) */
 102 #define PPPOE_DISC_MAXPADR  2        /* retry PADR twice */
 103
 104 #ifdef PPPOE_SERVER
 105 #error "PPPOE_SERVER is not yet supported under lwIP!"
 106 /* from if_spppsubr.c */
 107 #define IFF_PASSIVE IFF_LINK0 /* wait passively for connection */
 108 #endif
 109
 110 #ifndef PPPOE_ERRORSTRING_LEN
 111 #define PPPOE_ERRORSTRING_LEN     64
 112 #endif
 113 static char pppoe_error_tmp[PPPOE_ERRORSTRING_LEN];
 114
 115
 116 /* input routines */
 117 static void pppoe_dispatch_disc_pkt(struct netif *, struct pbuf *);
 118
 119 /* management routines */
 120 static int pppoe_do_disconnect(struct pppoe_softc *);
 121 static void pppoe_abort_connect(struct pppoe_softc *);
 122 static void pppoe_clear_softc(struct pppoe_softc *, const char *);
 123
 124 /* internal timeout handling */
 125 static void pppoe_timeout(void *);
 126
 127 /* sending actual protocol controll packets */
 128 static err_t pppoe_send_padi(struct pppoe_softc *);
 129 static err_t pppoe_send_padr(struct pppoe_softc *);
 130 #ifdef PPPOE_SERVER
 131 static err_t pppoe_send_pado(struct pppoe_softc *);
 132 static err_t pppoe_send_pads(struct pppoe_softc *);
 133 #endif
 134 static err_t pppoe_send_padt(struct netif *, u_int, const u8_t *);
 135
 136 /* internal helper functions */
 137 static struct pppoe_softc * pppoe_find_softc_by_session(u_int, struct netif *);
 138 static struct pppoe_softc * pppoe_find_softc_by_hunique(u8_t *, size_t, struct netif *);
 139
 140 /** linked list of created pppoe interfaces */
 141 static struct pppoe_softc *pppoe_softc_list;
 142
 143 err_t
 144 pppoe_create(struct netif *ethif, int pd, void (*linkStatusCB)(int pd, int up), struct pppoe_softc **scptr)
 145 {
 146   struct pppoe_softc *sc;
 147
 148   sc = (struct pppoe_softc *)memp_malloc(MEMP_PPPOE_IF);
 149   if (sc == NULL) {
 150     *scptr = NULL;
 151     return ERR_MEM;
 152   }
 153   memset(sc, 0, sizeof(struct pppoe_softc));
 154
 155   /* changed to real address later */
 156   MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest));
 157
 158   sc->sc_pd = pd;
 159   sc->sc_linkStatusCB = linkStatusCB;
 160   sc->sc_ethif = ethif;
 161
 162   /* put the new interface at the head of the list */
 163   sc->next = pppoe_softc_list;
 164   pppoe_softc_list = sc;
 165
 166   *scptr = sc;
 167
 168   return ERR_OK;
 169 }
 170
 171 err_t
 172 pppoe_destroy(struct netif *ifp)
 173 {
 174   struct pppoe_softc *sc, *prev = NULL;
 175
 176   for (sc = pppoe_softc_list; sc != NULL; prev = sc, sc = sc->next) {
 177     if (sc->sc_ethif == ifp) {
 178       break;
 179     }
 180   }
 181
 182   if(!(sc && (sc->sc_ethif == ifp))) {
 183     return ERR_IF;
 184   }
 185
 186   sys_untimeout(pppoe_timeout, sc);
 187   if (prev == NULL) {
 188     /* remove sc from the head of the list */
 189     pppoe_softc_list = sc->next;
 190   } else {
 191     /* remove sc from the list */
 192     prev->next = sc->next;
 193   }
 194
 195 #ifdef PPPOE_TODO
 196   if (sc->sc_concentrator_name) {
 197     mem_free(sc->sc_concentrator_name);
 198   }
 199   if (sc->sc_service_name) {
 200     mem_free(sc->sc_service_name);
 201   }
 202 #endif /* PPPOE_TODO */
 203   memp_free(MEMP_PPPOE_IF, sc);
 204
 205   return ERR_OK;
 206 }
 207
 208 /*
 209  * Find the interface handling the specified session.
 210  * Note: O(number of sessions open), this is a client-side only, mean
 211  * and lean implementation, so number of open sessions typically should
 212  * be 1.
 213  */
 214 static struct pppoe_softc *
 215 pppoe_find_softc_by_session(u_int session, struct netif *rcvif)
 216 {
 217   struct pppoe_softc *sc;
 218
 219   if (session == 0) {
 220     return NULL;
 221   }
 222
 223   for (sc = pppoe_softc_list; sc != NULL; sc = sc->next) {
 224     if (sc->sc_state == PPPOE_STATE_SESSION
 225         && sc->sc_session == session) {
 226       if (sc->sc_ethif == rcvif) {
 227         return sc;
 228       } else {
 229         return NULL;
 230       }
 231     }
 232   }
 233   return NULL;
 234 }
 235
 236 /* Check host unique token passed and return appropriate softc pointer,
 237  * or NULL if token is bogus. */
 238 static struct pppoe_softc *
 239 pppoe_find_softc_by_hunique(u8_t *token, size_t len, struct netif *rcvif)
 240 {
 241   struct pppoe_softc *sc, *t;
 242
 243   if (pppoe_softc_list == NULL) {
 244     return NULL;
 245   }
 246
 247   if (len != sizeof sc) {
 248     return NULL;
 249   }
 250   MEMCPY(&t, token, len);
 251
 252   for (sc = pppoe_softc_list; sc != NULL; sc = sc->next) {
 253     if (sc == t) {
 254       break;
 255     }
 256   }
 257
 258   if (sc == NULL) {
 259     PPPDEBUG(LOG_DEBUG, ("pppoe: alien host unique tag, no session found\n"));
 260     return NULL;
 261   }
 262
 263   /* should be safe to access *sc now */
 264   if (sc->sc_state < PPPOE_STATE_PADI_SENT || sc->sc_state >= PPPOE_STATE_SESSION) {
 265     printf("%c%c%"U16_F": host unique tag found, but it belongs to a connection in state %d\n",
 266       sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, sc->sc_state);
 267     return NULL;
 268   }
 269   if (sc->sc_ethif != rcvif) {
 270     printf("%c%c%"U16_F": wrong interface, not accepting host unique\n",
 271       sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num);
 272     return NULL;
 273   }
 274   return sc;
 275 }
 276
 277 static void
 278 pppoe_linkstatus_up(struct pppoe_softc *sc)
 279 {
 280   sc->sc_linkStatusCB(sc->sc_pd, 1);
 281 }
 282
 283 /* analyze and handle a single received packet while not in session state */
 284 static void
 285 pppoe_dispatch_disc_pkt(struct netif *netif, struct pbuf *pb)
 286 {
 287   u16_t tag, len;
 288   u16_t session, plen;
 289   struct pppoe_softc *sc;
 290   const char *err_msg;
 291   char devname[6];
 292   u8_t *ac_cookie;
 293   u16_t ac_cookie_len;
 294 #ifdef PPPOE_SERVER
 295   u8_t *hunique;
 296   size_t hunique_len;
 297 #endif
 298   struct pppoehdr *ph;
 299   struct pppoetag pt;
 300   int off, err, errortag;
 301   struct eth_hdr *ethhdr;
 302
 303   pb = pppSingleBuf(pb);
 304
 305   strcpy(devname, "pppoe");  /* as long as we don't know which instance */
 306   err_msg = NULL;
 307   errortag = 0;
 308   if (pb->len < sizeof(*ethhdr)) {
 309     goto done;
 310   }
 311   ethhdr = (struct eth_hdr *)pb->payload;
 312   off = sizeof(*ethhdr);
 313
 314   ac_cookie = NULL;
 315   ac_cookie_len = 0;
 316 #ifdef PPPOE_SERVER
 317   hunique = NULL;
 318   hunique_len = 0;
 319 #endif
 320   session = 0;
 321   if (pb->len - off < PPPOE_HEADERLEN) {
 322     printf("pppoe: packet too short: %d\n", pb->len);
 323     goto done;
 324   }
 325
 326   ph = (struct pppoehdr *) (ethhdr + 1);
 327   if (ph->vertype != PPPOE_VERTYPE) {
 328     printf("pppoe: unknown version/type packet: 0x%x\n", ph->vertype);
 329     goto done;
 330   }
 331   session = ntohs(ph->session);
 332   plen = ntohs(ph->plen);
 333   off += sizeof(*ph);
 334
 335   if (plen + off > pb->len) {
 336     printf("pppoe: packet content does not fit: data available = %d, packet size = %u\n",
 337         pb->len - off, plen);
 338     goto done;
 339   }
 340   if(pb->tot_len == pb->len) {
 341     pb->tot_len = pb->len = (u16_t)off + plen; /* ignore trailing garbage */
 342   }
 343   tag = 0;
 344   len = 0;
 345   sc = NULL;
 346   while (off + sizeof(pt) <= pb->len) {
 347     MEMCPY(&pt, (u8_t*)pb->payload + off, sizeof(pt));
 348     tag = ntohs(pt.tag);
 349     len = ntohs(pt.len);
 350     if (off + sizeof(pt) + len > pb->len) {
 351       printf("pppoe: tag 0x%x len 0x%x is too long\n", tag, len);
 352       goto done;
 353     }
 354     switch (tag) {
 355       case PPPOE_TAG_EOL:
 356         goto breakbreak;
 357       case PPPOE_TAG_SNAME:
 358         break;  /* ignored */
 359       case PPPOE_TAG_ACNAME:
 360         break;  /* ignored */
 361       case PPPOE_TAG_HUNIQUE:
 362         if (sc != NULL) {
 363           break;
 364         }
 365 #ifdef PPPOE_SERVER
 366         hunique = (u8_t*)pb->payload + off + sizeof(pt);
 367         hunique_len = len;
 368 #endif
 369         sc = pppoe_find_softc_by_hunique((u8_t*)pb->payload + off + sizeof(pt), len, netif);
 370         if (sc != NULL) {
 371           snprintf(devname, sizeof(devname), "%c%c%"U16_F, sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num);
 372         }
 373         break;
 374       case PPPOE_TAG_ACCOOKIE:
 375         if (ac_cookie == NULL) {
 376           ac_cookie = (u8_t*)pb->payload + off + sizeof(pt);
 377           ac_cookie_len = len;
 378         }
 379         break;
 380       case PPPOE_TAG_SNAME_ERR:
 381         err_msg = "SERVICE NAME ERROR";
 382         errortag = 1;
 383         break;
 384       case PPPOE_TAG_ACSYS_ERR:
 385         err_msg = "AC SYSTEM ERROR";
 386         errortag = 1;
 387         break;
 388       case PPPOE_TAG_GENERIC_ERR:
 389         err_msg = "GENERIC ERROR";
 390         errortag = 1;
 391         break;
 392     }
 393     if (err_msg) {
 394       if (errortag && len) {
 395         u16_t error_len = LWIP_MIN(len, sizeof(pppoe_error_tmp)-1);
 396         strncpy(pppoe_error_tmp, (char*)pb->payload + off + sizeof(pt), error_len);
 397         pppoe_error_tmp[error_len-1] = '\0';
 398         printf("%s: %s: %s\n", devname, err_msg, pppoe_error_tmp);
 399       } else {
 400         printf("%s: %s\n", devname, err_msg);
 401       }
 402       if (errortag) {
 403         goto done;
 404       }
 405     }
 406     off += sizeof(pt) + len;
 407   }
 408
 409 breakbreak:;
 410   switch (ph->code) {
 411     case PPPOE_CODE_PADI:
 412 #ifdef PPPOE_SERVER
 413       /*
 414        * got service name, concentrator name, and/or host unique.
 415        * ignore if we have no interfaces with IFF_PASSIVE|IFF_UP.
 416        */
 417       if (LIST_EMPTY(&pppoe_softc_list)) {
 418         goto done;
 419       }
 420       LIST_FOREACH(sc, &pppoe_softc_list, sc_list) {
 421         if (!(sc->sc_sppp.pp_if.if_flags & IFF_UP)) {
 422           continue;
 423         }
 424         if (!(sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE)) {
 425           continue;
 426         }
 427         if (sc->sc_state == PPPOE_STATE_INITIAL) {
 428           break;
 429         }
 430       }
 431       if (sc == NULL) {
 432         /* printf("pppoe: free passive interface is not found\n"); */
 433         goto done;
 434       }
 435       if (hunique) {
 436         if (sc->sc_hunique) {
 437           mem_free(sc->sc_hunique);
 438         }
 439         sc->sc_hunique = mem_malloc(hunique_len);
 440         if (sc->sc_hunique == NULL) {
 441           goto done;
 442         }
 443         sc->sc_hunique_len = hunique_len;
 444         MEMCPY(sc->sc_hunique, hunique, hunique_len);
 445       }
 446       MEMCPY(&sc->sc_dest, eh->ether_shost, sizeof sc->sc_dest);
 447       sc->sc_state = PPPOE_STATE_PADO_SENT;
 448       pppoe_send_pado(sc);
 449       break;
 450 #endif /* PPPOE_SERVER */
 451     case PPPOE_CODE_PADR:
 452 #ifdef PPPOE_SERVER
 453       /*
 454        * get sc from ac_cookie if IFF_PASSIVE
 455        */
 456       if (ac_cookie == NULL) {
 457         /* be quiet if there is not a single pppoe instance */
 458         printf("pppoe: received PADR but not includes ac_cookie\n");
 459         goto done;
 460       }
 461       sc = pppoe_find_softc_by_hunique(ac_cookie, ac_cookie_len, netif);
 462       if (sc == NULL) {
 463         /* be quiet if there is not a single pppoe instance */
 464         if (!LIST_EMPTY(&pppoe_softc_list)) {
 465           printf("pppoe: received PADR but could not find request for it\n");
 466         }
 467         goto done;
 468       }
 469       if (sc->sc_state != PPPOE_STATE_PADO_SENT) {
 470         printf("%c%c%"U16_F": received unexpected PADR\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num);
 471         goto done;
 472       }
 473       if (hunique) {
 474         if (sc->sc_hunique) {
 475           mem_free(sc->sc_hunique);
 476         }
 477         sc->sc_hunique = mem_malloc(hunique_len);
 478         if (sc->sc_hunique == NULL) {
 479           goto done;
 480         }
 481         sc->sc_hunique_len = hunique_len;
 482         MEMCPY(sc->sc_hunique, hunique, hunique_len);
 483       }
 484       pppoe_send_pads(sc);
 485       sc->sc_state = PPPOE_STATE_SESSION;
 486       pppoe_linkstatus_up(sc); /* notify upper layers */
 487       break;
 488 #else
 489       /* ignore, we are no access concentrator */
 490       goto done;
 491 #endif /* PPPOE_SERVER */
 492     case PPPOE_CODE_PADO:
 493       if (sc == NULL) {
 494         /* be quiet if there is not a single pppoe instance */
 495         if (pppoe_softc_list != NULL) {
 496           printf("pppoe: received PADO but could not find request for it\n");
 497         }
 498         goto done;
 499       }
 500       if (sc->sc_state != PPPOE_STATE_PADI_SENT) {
 501         printf("%c%c%"U16_F": received unexpected PADO\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num);
 502         goto done;
 503       }
 504       if (ac_cookie) {
 505         sc->sc_ac_cookie_len = ac_cookie_len;
 506         MEMCPY(sc->sc_ac_cookie, ac_cookie, ac_cookie_len);
 507       }
 508       MEMCPY(&sc->sc_dest, ethhdr->src.addr, sizeof(sc->sc_dest.addr));
 509       sys_untimeout(pppoe_timeout, sc);
 510       sc->sc_padr_retried = 0;
 511       sc->sc_state = PPPOE_STATE_PADR_SENT;
 512       if ((err = pppoe_send_padr(sc)) != 0) {
 513         PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADR, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err));
 514       }
 515       sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried), pppoe_timeout, sc);
 516       break;
 517     case PPPOE_CODE_PADS:
 518       if (sc == NULL) {
 519         goto done;
 520       }
 521       sc->sc_session = session;
 522       sys_untimeout(pppoe_timeout, sc);
 523       PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": session 0x%x connected\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, session));
 524       sc->sc_state = PPPOE_STATE_SESSION;
 525       pppoe_linkstatus_up(sc); /* notify upper layers */
 526       break;
 527     case PPPOE_CODE_PADT:
 528       if (sc == NULL) {
 529         goto done;
 530       }
 531       pppoe_clear_softc(sc, "received PADT");
 532       break;
 533     default:
 534       if(sc) {
 535         printf("%c%c%"U16_F": unknown code (0x%"X16_F") session = 0x%"X16_F"\n",
 536             sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num,
 537             (u16_t)ph->code, session);
 538       } else {
 539         printf("pppoe: unknown code (0x%"X16_F") session = 0x%"X16_F"\n", (u16_t)ph->code, session);
 540       }
 541       break;
 542   }
 543
 544 done:
 545   pbuf_free(pb);
 546   return;
 547 }
 548
 549 void
 550 pppoe_disc_input(struct netif *netif, struct pbuf *p)
 551 {
 552   /* avoid error messages if there is not a single pppoe instance */
 553   if (pppoe_softc_list != NULL) {
 554     pppoe_dispatch_disc_pkt(netif, p);
 555   } else {
 556     pbuf_free(p);
 557   }
 558 }
 559
 560 void
 561 pppoe_data_input(struct netif *netif, struct pbuf *pb)
 562 {
 563   u16_t session, plen;
 564   struct pppoe_softc *sc;
 565   struct pppoehdr *ph;
 566 #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
 567   u8_t shost[ETHER_ADDR_LEN];
 568 #endif
 569
 570 #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
 571   MEMCPY(shost, ((struct eth_hdr *)pb->payload)->src.addr, sizeof(shost));
 572 #endif
 573   if (pbuf_header(pb, -(int)sizeof(struct eth_hdr)) != 0) {
 574     /* bail out */
 575     PPPDEBUG(LOG_ERR, ("pppoe_data_input: pbuf_header failed\n"));
 576     LINK_STATS_INC(link.lenerr);
 577     goto drop;
 578   }
 579
 580   pb = pppSingleBuf (pb);
 581
 582   if (pb->len <= PPPOE_HEADERLEN) {
 583     printf("pppoe (data): dropping too short packet: %d bytes\n", pb->len);
 584     goto drop;
 585   }
 586
 587   if (pb->len < sizeof(*ph)) {
 588     printf("pppoe_data_input: could not get PPPoE header\n");
 589     goto drop;
 590   }
 591   ph = (struct pppoehdr *)pb->payload;
 592
 593   if (ph->vertype != PPPOE_VERTYPE) {
 594     printf("pppoe (data): unknown version/type packet: 0x%x\n", ph->vertype);
 595     goto drop;
 596   }
 597   if (ph->code != 0) {
 598     goto drop;
 599   }
 600
 601   session = ntohs(ph->session);
 602   sc = pppoe_find_softc_by_session(session, netif);
 603   if (sc == NULL) {
 604 #ifdef PPPOE_TERM_UNKNOWN_SESSIONS
 605     printf("pppoe: input for unknown session 0x%x, sending PADT\n", session);
 606     pppoe_send_padt(netif, session, shost);
 607 #endif
 608     goto drop;
 609   }
 610
 611   plen = ntohs(ph->plen);
 612
 613   if (pbuf_header(pb, -(int)(PPPOE_HEADERLEN)) != 0) {
 614     /* bail out */
 615     PPPDEBUG(LOG_ERR, ("pppoe_data_input: pbuf_header PPPOE_HEADERLEN failed\n"));
 616     LINK_STATS_INC(link.lenerr);
 617     goto drop;
 618   }
 619
 620   PPPDEBUG(LOG_DEBUG, ("pppoe_data_input: %c%c%"U16_F": pkthdr.len=%d, pppoe.len=%d\n",
 621         sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num,
 622         pb->len, plen));
 623
 624   if (pb->len < plen) {
 625     goto drop;
 626   }
 627
 628   pppInProcOverEthernet(sc->sc_pd, pb);
 629
 630   return;
 631
 632 drop:
 633   pbuf_free(pb);
 634 }
 635
 636 static err_t
 637 pppoe_output(struct pppoe_softc *sc, struct pbuf *pb)
 638 {
 639   struct eth_hdr *ethhdr;
 640   u16_t etype;
 641   err_t res;
 642
 643   if (!sc->sc_ethif) {
 644     pbuf_free(pb);
 645     return ERR_IF;
 646   }
 647
 648   ethhdr = (struct eth_hdr *)pb->payload;
 649   etype = sc->sc_state == PPPOE_STATE_SESSION ? ETHTYPE_PPPOE : ETHTYPE_PPPOEDISC;
 650   ethhdr->type = htons(etype);
 651   MEMCPY(ethhdr->dest.addr, sc->sc_dest.addr, sizeof(ethhdr->dest.addr));
 652   MEMCPY(ethhdr->src.addr, ((struct eth_addr *)sc->sc_ethif->hwaddr)->addr, sizeof(ethhdr->src.addr));
 653
 654   PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F" (%x) state=%d, session=0x%x output -> %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F", len=%d\n",
 655       sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, etype,
 656       sc->sc_state, sc->sc_session,
 657       sc->sc_dest.addr[0], sc->sc_dest.addr[1], sc->sc_dest.addr[2], sc->sc_dest.addr[3], sc->sc_dest.addr[4], sc->sc_dest.addr[5],
 658       pb->tot_len));
 659
 660   res = sc->sc_ethif->linkoutput(sc->sc_ethif, pb);
 661
 662   pbuf_free(pb);
 663
 664   return res;
 665 }
 666
 667 static err_t
 668 pppoe_send_padi(struct pppoe_softc *sc)
 669 {
 670   struct pbuf *pb;
 671   u8_t *p;
 672   int len;
 673 #ifdef PPPOE_TODO
 674   int l1 = 0, l2 = 0; /* XXX: gcc */
 675 #endif /* PPPOE_TODO */
 676
 677   if (sc->sc_state >PPPOE_STATE_PADI_SENT) {
 678     PPPDEBUG(LOG_ERR, ("ERROR: pppoe_send_padi in state %d", sc->sc_state));
 679   }
 680
 681   /* calculate length of frame (excluding ethernet header + pppoe header) */
 682   len = 2 + 2 + 2 + 2 + sizeof sc;  /* service name tag is required, host unique is send too */
 683 #ifdef PPPOE_TODO
 684   if (sc->sc_service_name != NULL) {
 685     l1 = (int)strlen(sc->sc_service_name);
 686     len += l1;
 687   }
 688   if (sc->sc_concentrator_name != NULL) {
 689     l2 = (int)strlen(sc->sc_concentrator_name);
 690     len += 2 + 2 + l2;
 691   }
 692 #endif /* PPPOE_TODO */
 693   LWIP_ASSERT("sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff",
 694     sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff);
 695
 696   /* allocate a buffer */
 697   pb = pbuf_alloc(PBUF_LINK, (u16_t)(sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len), PBUF_RAM);
 698   if (!pb) {
 699     return ERR_MEM;
 700   }
 701   LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len);
 702
 703   p = (u8_t*)pb->payload + sizeof (struct eth_hdr);
 704   /* fill in pkt */
 705   PPPOE_ADD_HEADER(p, PPPOE_CODE_PADI, 0, (u16_t)len);
 706   PPPOE_ADD_16(p, PPPOE_TAG_SNAME);
 707 #ifdef PPPOE_TODO
 708   if (sc->sc_service_name != NULL) {
 709     PPPOE_ADD_16(p, l1);
 710     MEMCPY(p, sc->sc_service_name, l1);
 711     p += l1;
 712   } else
 713 #endif /* PPPOE_TODO */
 714   {
 715     PPPOE_ADD_16(p, 0);
 716   }
 717 #ifdef PPPOE_TODO
 718   if (sc->sc_concentrator_name != NULL) {
 719     PPPOE_ADD_16(p, PPPOE_TAG_ACNAME);
 720     PPPOE_ADD_16(p, l2);
 721     MEMCPY(p, sc->sc_concentrator_name, l2);
 722     p += l2;
 723   }
 724 #endif /* PPPOE_TODO */
 725   PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
 726   PPPOE_ADD_16(p, sizeof(sc));
 727   MEMCPY(p, &sc, sizeof sc);
 728
 729   /* send pkt */
 730   return pppoe_output(sc, pb);
 731 }
 732
 733 static void
 734 pppoe_timeout(void *arg)
 735 {
 736   int retry_wait, err;
 737   struct pppoe_softc *sc = (struct pppoe_softc*)arg;
 738
 739   PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": timeout\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num));
 740
 741   switch (sc->sc_state) {
 742     case PPPOE_STATE_PADI_SENT:
 743       /*
 744        * We have two basic ways of retrying:
 745        *  - Quick retry mode: try a few times in short sequence
 746        *  - Slow retry mode: we already had a connection successfully
 747        *    established and will try infinitely (without user
 748        *    intervention)
 749        * We only enter slow retry mode if IFF_LINK1 (aka autodial)
 750        * is not set.
 751        */
 752
 753       /* initialize for quick retry mode */
 754       retry_wait = PPPOE_DISC_TIMEOUT * (1 + sc->sc_padi_retried);
 755
 756       sc->sc_padi_retried++;
 757       if (sc->sc_padi_retried >= PPPOE_DISC_MAXPADI) {
 758 #if 0
 759         if ((sc->sc_sppp.pp_if.if_flags & IFF_LINK1) == 0) {
 760           /* slow retry mode */
 761           retry_wait = PPPOE_SLOW_RETRY;
 762         } else
 763 #endif
 764         {
 765           pppoe_abort_connect(sc);
 766           return;
 767         }
 768       }
 769       if ((err = pppoe_send_padi(sc)) != 0) {
 770         sc->sc_padi_retried--;
 771         PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to transmit PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err));
 772       }
 773       sys_timeout(retry_wait, pppoe_timeout, sc);
 774       break;
 775
 776     case PPPOE_STATE_PADR_SENT:
 777       sc->sc_padr_retried++;
 778       if (sc->sc_padr_retried >= PPPOE_DISC_MAXPADR) {
 779         MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest));
 780         sc->sc_state = PPPOE_STATE_PADI_SENT;
 781         sc->sc_padr_retried = 0;
 782         if ((err = pppoe_send_padi(sc)) != 0) {
 783           PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err));
 784         }
 785         sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padi_retried), pppoe_timeout, sc);
 786         return;
 787       }
 788       if ((err = pppoe_send_padr(sc)) != 0) {
 789         sc->sc_padr_retried--;
 790         PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADR, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err));
 791       }
 792       sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried), pppoe_timeout, sc);
 793       break;
 794     case PPPOE_STATE_CLOSING:
 795       pppoe_do_disconnect(sc);
 796       break;
 797     default:
 798       return;  /* all done, work in peace */
 799   }
 800 }
 801
 802 /* Start a connection (i.e. initiate discovery phase) */
 803 int
 804 pppoe_connect(struct pppoe_softc *sc)
 805 {
 806   int err;
 807
 808   if (sc->sc_state != PPPOE_STATE_INITIAL) {
 809     return EBUSY;
 810   }
 811
 812 #ifdef PPPOE_SERVER
 813   /* wait PADI if IFF_PASSIVE */
 814   if ((sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE)) {
 815     return 0;
 816   }
 817 #endif
 818   /* save state, in case we fail to send PADI */
 819   sc->sc_state = PPPOE_STATE_PADI_SENT;
 820   sc->sc_padr_retried = 0;
 821   err = pppoe_send_padi(sc);
 822   PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err));
 823   sys_timeout(PPPOE_DISC_TIMEOUT, pppoe_timeout, sc);
 824   return err;
 825 }
 826
 827 /* disconnect */
 828 void
 829 pppoe_disconnect(struct pppoe_softc *sc)
 830 {
 831   if (sc->sc_state < PPPOE_STATE_SESSION) {
 832     return;
 833   }
 834   /*
 835    * Do not call pppoe_disconnect here, the upper layer state
 836    * machine gets confused by this. We must return from this
 837    * function and defer disconnecting to the timeout handler.
 838    */
 839   sc->sc_state = PPPOE_STATE_CLOSING;
 840   sys_timeout(20, pppoe_timeout, sc);
 841 }
 842
 843 static int
 844 pppoe_do_disconnect(struct pppoe_softc *sc)
 845 {
 846   int err;
 847
 848   if (sc->sc_state < PPPOE_STATE_SESSION) {
 849     err = EBUSY;
 850   } else {
 851     PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": disconnecting\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num));
 852     err = pppoe_send_padt(sc->sc_ethif, sc->sc_session, (const u8_t *)&sc->sc_dest);
 853   }
 854
 855   /* cleanup softc */
 856   sc->sc_state = PPPOE_STATE_INITIAL;
 857   MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest));
 858   sc->sc_ac_cookie_len = 0;
 859 #ifdef PPPOE_SERVER
 860   if (sc->sc_hunique) {
 861     mem_free(sc->sc_hunique);
 862     sc->sc_hunique = NULL;
 863   }
 864   sc->sc_hunique_len = 0;
 865 #endif
 866   sc->sc_session = 0;
 867
 868   sc->sc_linkStatusCB(sc->sc_pd, 0); /* notify upper layers */
 869
 870   return err;
 871 }
 872
 873 /* Connection attempt aborted */
 874 static void
 875 pppoe_abort_connect(struct pppoe_softc *sc)
 876 {
 877   printf("%c%c%"U16_F": could not establish connection\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num);
 878   sc->sc_state = PPPOE_STATE_CLOSING;
 879
 880   sc->sc_linkStatusCB(sc->sc_pd, 0); /* notify upper layers */
 881
 882   /* clear connection state */
 883   MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest));
 884   sc->sc_state = PPPOE_STATE_INITIAL;
 885 }
 886
 887 /* Send a PADR packet */
 888 static err_t
 889 pppoe_send_padr(struct pppoe_softc *sc)
 890 {
 891   struct pbuf *pb;
 892   u8_t *p;
 893   size_t len;
 894 #ifdef PPPOE_TODO
 895   size_t l1 = 0; /* XXX: gcc */
 896 #endif /* PPPOE_TODO */
 897
 898   if (sc->sc_state != PPPOE_STATE_PADR_SENT) {
 899     return ERR_CONN;
 900   }
 901
 902   len = 2 + 2 + 2 + 2 + sizeof(sc);    /* service name, host unique */
 903 #ifdef PPPOE_TODO
 904   if (sc->sc_service_name != NULL) {    /* service name tag maybe empty */
 905     l1 = strlen(sc->sc_service_name);
 906     len += l1;
 907   }
 908 #endif /* PPPOE_TODO */
 909   if (sc->sc_ac_cookie_len > 0) {
 910     len += 2 + 2 + sc->sc_ac_cookie_len;  /* AC cookie */
 911   }
 912   LWIP_ASSERT("sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff",
 913     sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff);
 914   pb = pbuf_alloc(PBUF_LINK, (u16_t)(sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len), PBUF_RAM);
 915   if (!pb) {
 916     return ERR_MEM;
 917   }
 918   LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len);
 919   p = (u8_t*)pb->payload + sizeof (struct eth_hdr);
 920   PPPOE_ADD_HEADER(p, PPPOE_CODE_PADR, 0, len);
 921   PPPOE_ADD_16(p, PPPOE_TAG_SNAME);
 922 #ifdef PPPOE_TODO
 923   if (sc->sc_service_name != NULL) {
 924     PPPOE_ADD_16(p, l1);
 925     MEMCPY(p, sc->sc_service_name, l1);
 926     p += l1;
 927   } else
 928 #endif /* PPPOE_TODO */
 929   {
 930     PPPOE_ADD_16(p, 0);
 931   }
 932   if (sc->sc_ac_cookie_len > 0) {
 933     PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE);
 934     PPPOE_ADD_16(p, sc->sc_ac_cookie_len);
 935     MEMCPY(p, sc->sc_ac_cookie, sc->sc_ac_cookie_len);
 936     p += sc->sc_ac_cookie_len;
 937   }
 938   PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
 939   PPPOE_ADD_16(p, sizeof(sc));
 940   MEMCPY(p, &sc, sizeof sc);
 941
 942   return pppoe_output(sc, pb);
 943 }
 944
 945 /* send a PADT packet */
 946 static err_t
 947 pppoe_send_padt(struct netif *outgoing_if, u_int session, const u8_t *dest)
 948 {
 949   struct pbuf *pb;
 950   struct eth_hdr *ethhdr;
 951   err_t res;
 952   u8_t *p;
 953
 954   pb = pbuf_alloc(PBUF_LINK, sizeof(struct eth_hdr) + PPPOE_HEADERLEN, PBUF_RAM);
 955   if (!pb) {
 956     return ERR_MEM;
 957   }
 958   LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len);
 959
 960   ethhdr = (struct eth_hdr *)pb->payload;
 961   ethhdr->type = PP_HTONS(ETHTYPE_PPPOEDISC);
 962   MEMCPY(ethhdr->dest.addr, dest, sizeof(ethhdr->dest.addr));
 963   MEMCPY(ethhdr->src.addr, ((struct eth_addr *)outgoing_if->hwaddr)->addr, sizeof(ethhdr->src.addr));
 964
 965   p = (u8_t*)(ethhdr + 1);
 966   PPPOE_ADD_HEADER(p, PPPOE_CODE_PADT, session, 0);
 967
 968   res = outgoing_if->linkoutput(outgoing_if, pb);
 969
 970   pbuf_free(pb);
 971
 972   return res;
 973 }
 974
 975 #ifdef PPPOE_SERVER
 976 static err_t
 977 pppoe_send_pado(struct pppoe_softc *sc)
 978 {
 979   struct pbuf *pb;
 980   u8_t *p;
 981   size_t len;
 982
 983   if (sc->sc_state != PPPOE_STATE_PADO_SENT) {
 984     return ERR_CONN;
 985   }
 986
 987   /* calc length */
 988   len = 0;
 989   /* include ac_cookie */
 990   len += 2 + 2 + sizeof(sc);
 991   /* include hunique */
 992   len += 2 + 2 + sc->sc_hunique_len;
 993   pb = pbuf_alloc(PBUF_LINK, sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len, PBUF_RAM);
 994   if (!pb) {
 995     return ERR_MEM;
 996   }
 997   LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len);
 998   p = (u8_t*)pb->payload + sizeof (struct eth_hdr);
 999   PPPOE_ADD_HEADER(p, PPPOE_CODE_PADO, 0, len);
1000   PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE);
1001   PPPOE_ADD_16(p, sizeof(sc));
1002   MEMCPY(p, &sc, sizeof(sc));
1003   p += sizeof(sc);
1004   PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
1005   PPPOE_ADD_16(p, sc->sc_hunique_len);
1006   MEMCPY(p, sc->sc_hunique, sc->sc_hunique_len);
1007   return pppoe_output(sc, pb);
1008 }
1009
1010 static err_t
1011 pppoe_send_pads(struct pppoe_softc *sc)
1012 {
1013   struct pbuf *pb;
1014   u8_t *p;
1015   size_t len, l1 = 0;  /* XXX: gcc */
1016
1017   if (sc->sc_state != PPPOE_STATE_PADO_SENT) {
1018     return ERR_CONN;
1019   }
1020
1021   sc->sc_session = mono_time.tv_sec % 0xff + 1;
1022   /* calc length */
1023   len = 0;
1024   /* include hunique */
1025   len += 2 + 2 + 2 + 2 + sc->sc_hunique_len;  /* service name, host unique*/
1026   if (sc->sc_service_name != NULL) {    /* service name tag maybe empty */
1027     l1 = strlen(sc->sc_service_name);
1028     len += l1;
1029   }
1030   pb = pbuf_alloc(PBUF_LINK, sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len, PBUF_RAM);
1031   if (!pb) {
1032     return ERR_MEM;
1033   }
1034   LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len);
1035   p = (u8_t*)pb->payload + sizeof (struct eth_hdr);
1036   PPPOE_ADD_HEADER(p, PPPOE_CODE_PADS, sc->sc_session, len);
1037   PPPOE_ADD_16(p, PPPOE_TAG_SNAME);
1038   if (sc->sc_service_name != NULL) {
1039     PPPOE_ADD_16(p, l1);
1040     MEMCPY(p, sc->sc_service_name, l1);
1041     p += l1;
1042   } else {
1043     PPPOE_ADD_16(p, 0);
1044   }
1045   PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE);
1046   PPPOE_ADD_16(p, sc->sc_hunique_len);
1047   MEMCPY(p, sc->sc_hunique, sc->sc_hunique_len);
1048   return pppoe_output(sc, pb);
1049 }
1050 #endif
1051
1052 err_t
1053 pppoe_xmit(struct pppoe_softc *sc, struct pbuf *pb)
1054 {
1055   u8_t *p;
1056   size_t len;
1057
1058   /* are we ready to process data yet? */
1059   if (sc->sc_state < PPPOE_STATE_SESSION) {
1060     /*sppp_flush(&sc->sc_sppp.pp_if);*/
1061     pbuf_free(pb);
1062     return ERR_CONN;
1063   }
1064
1065   len = pb->tot_len;
1066
1067   /* make room for Ethernet header - should not fail */
1068   if (pbuf_header(pb, sizeof(struct eth_hdr) + PPPOE_HEADERLEN) != 0) {
1069     /* bail out */
1070     PPPDEBUG(LOG_ERR, ("pppoe: %c%c%"U16_F": pppoe_xmit: could not allocate room for header\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num));
1071     LINK_STATS_INC(link.lenerr);
1072     pbuf_free(pb);
1073     return ERR_BUF;
1074   }
1075
1076   p = (u8_t*)pb->payload + sizeof(struct eth_hdr);
1077   PPPOE_ADD_HEADER(p, 0, sc->sc_session, len);
1078
1079   return pppoe_output(sc, pb);
1080 }
1081
1082 #if 0 /*def PFIL_HOOKS*/
1083 static int
1084 pppoe_ifattach_hook(void *arg, struct pbuf **mp, struct netif *ifp, int dir)
1085 {
1086   struct pppoe_softc *sc;
1087   int s;
1088
1089   if (mp != (struct pbuf **)PFIL_IFNET_DETACH) {
1090     return 0;
1091   }
1092
1093   LIST_FOREACH(sc, &pppoe_softc_list, sc_list) {
1094     if (sc->sc_ethif != ifp) {
1095       continue;
1096     }
1097     if (sc->sc_sppp.pp_if.if_flags & IFF_UP) {
1098       sc->sc_sppp.pp_if.if_flags &= ~(IFF_UP|IFF_RUNNING);
1099       printf("%c%c%"U16_F": ethernet interface detached, going down\n",
1100           sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num);
1101     }
1102     sc->sc_ethif = NULL;
1103     pppoe_clear_softc(sc, "ethernet interface detached");
1104   }
1105
1106   return 0;
1107 }
1108 #endif
1109
1110 static void
1111 pppoe_clear_softc(struct pppoe_softc *sc, const char *message)
1112 {
1113   LWIP_UNUSED_ARG(message);
1114
1115   /* stop timer */
1116   sys_untimeout(pppoe_timeout, sc);
1117   PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": session 0x%x terminated, %s\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, sc->sc_session, message));
1118
1119   /* fix our state */
1120   sc->sc_state = PPPOE_STATE_INITIAL;
1121
1122   /* notify upper layers */
1123   sc->sc_linkStatusCB(sc->sc_pd, 0);
1124
1125   /* clean up softc */
1126   MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest));
1127   sc->sc_ac_cookie_len = 0;
1128   sc->sc_session = 0;
1129 }
1130
1131 #endif /* PPPOE_SUPPORT */
1132