Correct utmp handling - Robert Davidson <puttputt@iaccess.ws>
[ppp.git] / pppd / plugins / pppoe / libpppoe.c
1 /* PPPoE support library "libpppoe"
2  *
3  * Copyright 2000 Michal Ostrowski <mostrows@styx.uwaterloo.ca>,
4  *                Jamal Hadi Salim <hadi@cyberus.ca>
5  *
6  *  This program is free software; you can redistribute it and/or
7  *  modify it under the terms of the GNU General Public License
8  *  as published by the Free Software Foundation; either version
9  *  2 of the License, or (at your option) any later version.
10  */
11
12 #include "pppoe.h"
13
14 int disc_sock=-1;
15
16 int verify_packet( struct session *ses, struct pppoe_packet *p);
17
18 #define TAG_DATA(type,tag_ptr) ((type *) ((struct pppoe_tag*)tag_ptr)->tag_data)
19
20
21 /***************************************************************************
22  *
23  * Return the location where the next tag can be pu
24  *
25  **************************************************************************/
26 static  struct pppoe_tag *next_tag(struct pppoe_hdr *ph)
27 {
28     return (struct pppoe_tag *)
29         (((char *) &ph->tag) + ntohs(ph->length));
30 }
31
32 /**************************************************************************
33  *
34  * Update header to reflect the addition of a new tag
35  *
36  **************************************************************************/
37 static  void add_tag(struct pppoe_hdr *ph, struct pppoe_tag *pt)
38 {
39     int len = (ntohs(ph->length) +
40                ntohs(pt->tag_len) +
41                sizeof(struct pppoe_tag));
42
43     if (pt != next_tag(ph))
44         printf("PPPoE add_tag caller is buggy\n");
45
46     ph->length = htons(len);
47 }
48
49 /*************************************************************************
50  *
51  * Look for a tag of a specific type
52  *
53  ************************************************************************/
54 struct pppoe_tag *get_tag(struct pppoe_hdr *ph, u_int16_t idx)
55 {
56     char *end = (char *) next_tag(ph);
57     char *ptn = NULL;
58     struct pppoe_tag *pt = &ph->tag[0];
59
60     /*
61      * Keep processing tags while a tag header will still fit.
62      *
63      * This check will ensure that the entire tag header pointed
64      * to by pt will fit inside the message, and thus it will be
65      * valid to check the tag_type and tag_len fields.
66      */
67     while ((char *)(pt + 1) <= end) {
68         /*
69          * If the tag data would go past the end of the packet, abort.
70          */
71         ptn = (((char *) (pt + 1)) + ntohs(pt->tag_len));
72         if (ptn > end)
73             return NULL;
74
75         if (pt->tag_type == idx)
76             return pt;
77
78         pt = (struct pppoe_tag *) ptn;
79     }
80
81     return NULL;
82 }
83
84 /* We want to use tag names to reference into arrays  containing the tag data.
85    This takes an RFC 2516 tag identifier and maps it into a local one.
86    The reverse mapping is accomplished via the tag_map array */
87 #define UNMAP_TAG(x) case PTT_##x : return TAG_##x
88 static inline int tag_index(int tag){
89     switch(tag){
90         UNMAP_TAG(SRV_NAME);
91         UNMAP_TAG(AC_NAME);
92         UNMAP_TAG(HOST_UNIQ);
93         UNMAP_TAG(AC_COOKIE);
94         UNMAP_TAG(VENDOR);
95         UNMAP_TAG(RELAY_SID);
96         UNMAP_TAG(SRV_ERR);
97         UNMAP_TAG(SYS_ERR);
98         UNMAP_TAG(GEN_ERR);
99         UNMAP_TAG(EOL);
100     };
101     return -1;
102 }
103
104 /*************************************************************************
105  *
106  * Makes a copy of a tag into a PPPoE packe
107  *
108  ************************************************************************/
109 void copy_tag(struct pppoe_packet *dest, struct pppoe_tag *pt)
110 {
111     struct pppoe_tag *end_tag = get_tag(dest->hdr, PTT_EOL);
112     int tagid;
113     int tag_len;
114     if( !pt ) {
115         return;
116     }
117     tagid = tag_index(pt->tag_type);
118
119     tag_len = sizeof(struct pppoe_tag) + ntohs(pt->tag_len);
120
121     if( end_tag ){
122         memcpy(((char*)end_tag)+tag_len ,
123                end_tag, sizeof(struct pppoe_tag));
124
125         dest->tags[tagid]=end_tag;
126         dest->tags[TAG_EOL] = (struct pppoe_tag*)((char*)dest->tags[TAG_EOL] + tag_len);
127         memcpy(end_tag, pt, tag_len);
128         dest->hdr->length = htons(ntohs(dest->hdr->length) + tag_len);
129
130     }else{
131         memcpy(next_tag(dest->hdr),pt, tag_len);
132         dest->tags[tagid]=next_tag(dest->hdr);
133         add_tag(dest->hdr,next_tag(dest->hdr));
134     }
135
136
137 }
138
139
140 /*************************************************************************
141  *
142  * Put tags from a packet into a nice array
143  *
144  ************************************************************************/
145 static void extract_tags(struct pppoe_hdr *ph, struct pppoe_tag** buf){
146     int i=0;
147     for(;i<MAX_TAGS;++i){
148         buf[i] = get_tag(ph,tag_map[i]);
149     }
150 }
151
152
153 /*************************************************************************
154  *
155  * Verify that a packet has a tag containint a specific value
156  *
157  ************************************************************************/
158 static int verify_tag(struct session* ses,
159                       struct pppoe_packet* p,
160                       unsigned short id,
161                       char* data,
162                       int data_len)
163 {
164     int len;
165     struct pppoe_tag *pt = p->tags[id];
166
167     if( !pt ){
168         poe_info(ses,"Missing tag %d. Expected %s\n",
169                  id,data);
170         return 0;
171     }
172     len = ntohs(pt->tag_len);
173     if(len != data_len){
174         poe_info(ses,"Length mismatch on tag %d: expect: %d got: %d\n",
175                  id, data_len, len);
176         return 0;
177     }
178
179     if( 0!=memcmp(pt->tag_data,data,data_len)){
180         poe_info(ses,"Tag data mismatch on tag %d: expect: %s vs %s\n",
181                  id, data,pt->tag_data);
182         return 0;
183     }
184     return 1;
185 }
186
187
188 /*************************************************************************
189  *
190  * Verify the existence of an ethernet device.
191  * Construct an AF_PACKET address struct to match.
192  *
193  ************************************************************************/
194 int get_sockaddr_ll(const char *devnam,struct sockaddr_ll* sll){
195     struct ifreq ifr;
196     int retval;
197
198     if(disc_sock<0){
199
200         disc_sock = socket(PF_PACKET, SOCK_DGRAM, 0);
201         if( disc_sock < 0 ){
202             return -1;
203         }
204     }
205
206     strncpy(ifr.ifr_name, devnam, sizeof(ifr.ifr_name));
207
208     retval = ioctl( disc_sock , SIOCGIFINDEX, &ifr);
209
210     if( retval < 0 ){
211 //      error("Bad device name: %s  (%m)",devnam);
212         return 0;
213     }
214
215     if(sll) sll->sll_ifindex = ifr.ifr_ifindex;
216
217     retval = ioctl (disc_sock, SIOCGIFHWADDR, &ifr);
218     if( retval < 0 ){
219 //      error("Bad device name: %s  (%m)",devnam);
220         return 0;
221     }
222
223     if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
224         error("Interface %s is not Ethernet!", devnam);
225         return 0;
226     }
227     if(sll){
228         sll->sll_family = AF_PACKET;
229         sll->sll_protocol= ntohs(ETH_P_PPP_DISC);
230         sll->sll_hatype = ARPHRD_ETHER;
231         sll->sll_pkttype = PACKET_BROADCAST;
232         sll->sll_hatype = ETH_ALEN;
233         memcpy( sll->sll_addr , ifr.ifr_hwaddr.sa_data, ETH_ALEN);
234     }
235     return 1;
236 }
237
238
239
240
241 /*************************************************************************
242  *
243  * Construct and send a discovery message.
244  *
245  ************************************************************************/
246 int send_disc(struct session *ses, struct pppoe_packet *p)
247 {
248     char buf[MAX_PAYLOAD + sizeof(struct pppoe_hdr)];
249     int data_len = sizeof(struct pppoe_hdr);
250
251     struct pppoe_hdr *ph = NULL;
252     struct pppoe_tag *tag = NULL;
253     int i, error = 0;
254     int got_host_uniq = 0;
255     int got_srv_name = 0;
256     int got_ac_name = 0;
257
258     for (i = 0; i < MAX_TAGS; i++) {
259         if (!p->tags[i])
260             continue;
261
262         got_host_uniq |= (p->tags[i]->tag_type == PTT_HOST_UNIQ);
263
264         /* Relay identifiers qualify as HOST_UNIQ's:
265            we need HOST_UNIQ to uniquely identify the packet,
266            PTT_RELAY_SID is sufficient for us for outgoing packets */
267         got_host_uniq |= (p->tags[i]->tag_type == PTT_RELAY_SID);
268
269         got_srv_name |= (p->tags[i]->tag_type == PTT_SRV_NAME);
270         got_ac_name  |= (p->tags[i]->tag_type == PTT_AC_NAME);
271
272         data_len += (ntohs(p->tags[i]->tag_len) +
273                      sizeof(struct pppoe_tag));
274     }
275
276     ph = (struct pppoe_hdr *) buf;
277
278
279     memcpy(ph, p->hdr, sizeof(struct pppoe_hdr));
280     ph->length = __constant_htons(0);
281
282     /* if no HOST_UNIQ tags --- add one with process id */
283     if (!got_host_uniq){
284         data_len += (sizeof(struct pppoe_tag) +
285                      sizeof(struct session *));
286         tag = next_tag(ph);
287         tag->tag_type = PTT_HOST_UNIQ;
288         tag->tag_len = htons(sizeof(struct session *));
289         memcpy(tag->tag_data,
290                &ses,
291                sizeof(struct session *));
292
293         add_tag(ph, tag);
294     }
295
296     if( !got_srv_name ){
297         data_len += sizeof(struct pppoe_tag);
298         tag = next_tag(ph);
299         tag->tag_type = PTT_SRV_NAME;
300         tag->tag_len = 0;
301         add_tag(ph, tag);
302     }
303
304     if(!got_ac_name && ph->code==PADO_CODE){
305         data_len += sizeof(struct pppoe_tag);
306         tag = next_tag(ph);
307         tag->tag_type = PTT_AC_NAME;
308         tag->tag_len = 0;
309         add_tag(ph, tag);
310     }
311
312     for (i = 0; i < MAX_TAGS; i++) {
313         if (!p->tags[i])
314             continue;
315
316         tag = next_tag(ph);
317         memcpy(tag, p->tags[i],
318                sizeof(struct pppoe_tag) + ntohs(p->tags[i]->tag_len));
319
320         add_tag(ph, tag);
321     }
322
323     /* Now fixup the packet struct to make sure all of its pointers
324        are self-contained */
325     memcpy( p->hdr , ph, data_len );
326     extract_tags( p->hdr, p->tags);
327
328     error = sendto(disc_sock, buf, data_len, 0,
329                    (struct sockaddr*) &p->addr,
330                    sizeof(struct sockaddr_ll));
331
332     if(error < 0)
333         poe_error(ses,"sendto returned: %m\n");
334
335     return error;
336 }
337
338 /*************************************************************************
339  *
340  * Verify that a packet is legal
341  *
342  *************************************************************************/
343 int verify_packet( struct session *ses, struct pppoe_packet *p){
344     struct session * hu_val;
345
346     /* This code here should do all of the error checking and
347        validation on the incoming packet */
348
349
350     /* If we receive any error tags, abort */
351 #define CHECK_TAG(name, val)                                    \
352     if((NULL==p->tags[name])== val){                            \
353         poe_error(ses,"Tag error: " #name );                    \
354         return -1;                                              \
355     }
356
357
358
359     CHECK_TAG(TAG_SRV_ERR,0);
360     CHECK_TAG(TAG_SYS_ERR,0);
361     CHECK_TAG(TAG_GEN_ERR,0);
362
363     /* A HOST_UNIQ must be present */
364     CHECK_TAG(TAG_HOST_UNIQ,1);
365
366     hu_val = *TAG_DATA(struct session* ,p->tags[TAG_HOST_UNIQ]);
367
368     if( hu_val != ses ){
369         poe_info(ses,"HOST_UNIQ mismatch: %08x %i\n",(int)hu_val,getpid());
370         return -1;
371     }
372
373     if(ses->filt->htag &&
374        !verify_tag(ses,p,TAG_HOST_UNIQ,ses->filt->htag->tag_data,(int)ntohs(ses->filt->htag->tag_len)))
375         return -1;
376     else
377         poe_info(ses,"HOST_UNIQ successful match\n");
378
379
380     if(ses->filt->ntag &&
381        !verify_tag(ses,p,TAG_AC_NAME,ses->filt->ntag->tag_data,(int)ntohs(ses->filt->ntag->tag_len))){
382         poe_info(ses,"AC_NAME failure");
383         return -1;
384     }
385
386     if(ses->filt->stag &&
387        !verify_tag(ses,p,TAG_SRV_NAME,ses->filt->stag->tag_data,(int)ntohs(ses->filt->stag->tag_len))){
388         poe_info(ses,"SRV_NAME failure");
389         return -1;
390     }
391
392 }
393
394
395 /*************************************************************************
396  *
397  * Receive and verify an incoming packet.
398  *
399  *************************************************************************/
400 static int recv_disc( struct session *ses,
401                       struct pppoe_packet *p){
402     int error = 0;
403     unsigned int from_len = sizeof(struct sockaddr_ll);
404     struct session* hu_val;
405     struct pppoe_tag *pt;
406
407     p->hdr = (struct pppoe_hdr*)p->buf;
408
409     error = recvfrom( disc_sock, p->buf, 1500, 0,
410                       (struct sockaddr*)&p->addr, &from_len);
411
412     if(error < 0) return error;
413
414     extract_tags(p->hdr,p->tags);
415
416     return 1;
417 }
418
419
420 /*************************************************************************
421  *
422  * Send a PADT
423  *
424  *************************************************************************/
425 int session_disconnect(struct session *ses){
426     struct pppoe_packet padt;
427
428     memset(&padt,0,sizeof(struct pppoe_packet));
429     memcpy(&padt.addr, &ses->remote, sizeof(struct sockaddr_ll));
430
431     padt.hdr = (struct pppoe_hdr*) ses->curr_pkt.buf;
432     padt.hdr->ver  = 1;
433     padt.hdr->type = 1;
434     padt.hdr->code = PADT_CODE;
435     padt.hdr->sid  = ses->sp.sa_addr.pppoe.sid;
436
437     send_disc(ses,&padt);
438     ses->sp.sa_addr.pppoe.sid = 0 ;
439     ses->state = PADO_CODE;
440     return 0;
441
442 }
443
444
445 /*************************************************************************
446  *
447  * Make a connection -- behaviour depends on callbacks specified in "ses"
448  *
449  *************************************************************************/
450 int session_connect(struct session *ses)
451 {
452
453     int pkt_size=0;
454     int ret_pkt_size=0;
455     struct pppoe_tag *tags = NULL;
456     struct pppoe_packet *p_out=NULL;
457     struct pppoe_packet rcv_packet;
458     int ret;
459
460
461     if(ses->init_disc){
462         ret = (*ses->init_disc)(ses, NULL, &p_out);
463         if( ret != 0 ) return ret;
464     }
465
466     /* main discovery loop */
467
468
469     while(ses->retransmits < ses->retries || ses->retries==-1 ){
470
471         fd_set in;
472         struct timeval tv;
473         FD_ZERO(&in);
474
475         FD_SET(disc_sock,&in);
476
477         if(ses->retransmits>=0){
478             ++ses->retransmits;
479             tv.tv_sec = 1 << ses->retransmits;
480             tv.tv_usec = 0;
481             ret = select(disc_sock+1, &in, NULL, NULL, &tv);
482         }else{
483             ret = select(disc_sock+1, &in, NULL, NULL, NULL);
484         }
485
486         if( ret == 0 ){
487             if( DEB_DISC ){
488                 poe_dbglog(ses, "Re-sending ...");
489             }
490
491             if( ses->timeout ){
492                 ret = (*ses->timeout)(ses, NULL, &p_out);
493                 if( ret != 0 )
494                     return ret;
495
496             }else if(p_out){
497                 send_disc(ses,p_out);
498             }
499             continue;
500         }
501
502
503         ret = recv_disc(ses, &rcv_packet);
504
505         /* Should differentiate between system errors and
506            bad packets and the like... */
507         if( ret < 0 && errno != EINTR){
508
509             return -1;
510         }
511
512
513
514
515         switch (rcv_packet.hdr->code) {
516
517         case PADI_CODE:
518         {
519             if(ses->rcv_padi){
520                 ret = (*ses->rcv_padi)(ses,&rcv_packet,&p_out);
521
522                 if( ret != 0){
523                     return ret;
524                 }
525             }
526             break;
527         }
528
529         case PADO_CODE:         /* wait for PADO */
530         {
531             if(ses->rcv_pado){
532                 ret = (*ses->rcv_pado)(ses,&rcv_packet,&p_out);
533
534                 if( ret != 0){
535                     return ret;
536                 }
537             }
538             break;
539         }
540
541         case PADR_CODE:
542         {
543             if(ses->rcv_padr){
544                 ret = (*ses->rcv_padr)(ses,&rcv_packet,&p_out);
545
546                 if( ret != 0){
547                     return ret;
548                 }
549             }
550             break;
551         }
552
553         case PADS_CODE:
554         {
555             if(ses->rcv_pads){
556                 ret = (*ses->rcv_pads)(ses,&rcv_packet,&p_out);
557
558                 if( ret != 0){
559                     return ret;
560                 }
561             }
562             break;
563         }
564
565         case PADT_CODE:
566         {
567             if( rcv_packet.hdr->sid != ses->sp.sa_addr.pppoe.sid ){
568                 --ses->retransmits;
569                 continue;
570             }
571             if(ses->rcv_padt){
572                 ret = (*ses->rcv_padt)(ses,&rcv_packet,&p_out);
573
574                 if( ret != 0){
575                     return ret;
576                 }
577             }else{
578                 poe_error (ses,"connection terminated");
579                 return (-1);
580             }
581             break;
582         }
583         default:
584             poe_error(ses,"invalid packet %P",&rcv_packet);
585             return (-1);
586         }
587     }
588     return (0);
589 }
590
591
592 /*************************************************************************
593  *
594  * Register an ethernet address as a client of relaying services.
595  *
596  *************************************************************************/
597 int add_client(char *addr)
598 {
599     struct pppoe_con* pc = (struct pppoe_con*)malloc(sizeof(struct pppoe_con));
600     int ret;
601     if(!pc)
602         return -ENOMEM;
603
604     memset(pc, 0 , sizeof(struct pppoe_con));
605
606     memcpy(pc->client,addr, ETH_ALEN);
607     memcpy(pc->key, addr, ETH_ALEN);
608
609     pc->key_len = ETH_ALEN;
610
611     if( (ret=store_con(pc)) < 0 ){
612         free(pc);
613     }
614     return ret;
615
616 }
617
618 struct pppoe_tag *make_filter_tag(short type, short length, char* data){
619     struct pppoe_tag *pt =
620         (struct pppoe_tag* )malloc( sizeof(struct pppoe_tag) + length );
621
622     if(pt == NULL) return NULL;
623
624     pt->tag_len=htons(length);
625     pt->tag_type=type;
626
627     if(length>0 && data){
628         memcpy( pt+1, data, length);
629     }
630     return pt;
631 }