• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
pppoe_create(struct netif * ethif,int pd,void (* linkStatusCB)(int pd,int up),struct pppoe_softc ** scptr)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
pppoe_destroy(struct netif * ifp)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 *
pppoe_find_softc_by_session(u_int session,struct netif * rcvif)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 *
pppoe_find_softc_by_hunique(u8_t * token,size_t len,struct netif * rcvif)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
pppoe_linkstatus_up(struct pppoe_softc * sc)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
pppoe_dispatch_disc_pkt(struct netif * netif,struct pbuf * pb)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
pppoe_disc_input(struct netif * netif,struct pbuf * p)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
pppoe_data_input(struct netif * netif,struct pbuf * pb)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
pppoe_output(struct pppoe_softc * sc,struct pbuf * pb)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
pppoe_send_padi(struct pppoe_softc * sc)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
pppoe_timeout(void * arg)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
pppoe_connect(struct pppoe_softc * sc)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
pppoe_disconnect(struct pppoe_softc * sc)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
pppoe_do_disconnect(struct pppoe_softc * sc)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
pppoe_abort_connect(struct pppoe_softc * sc)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
pppoe_send_padr(struct pppoe_softc * sc)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
pppoe_send_padt(struct netif * outgoing_if,u_int session,const u8_t * dest)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
pppoe_send_pado(struct pppoe_softc * sc)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
pppoe_send_pads(struct pppoe_softc * sc)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
pppoe_xmit(struct pppoe_softc * sc,struct pbuf * pb)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
pppoe_clear_softc(struct pppoe_softc * sc,const char * message)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 
1133