don't need to be group kmem any more
[ppp.git] / pppd / ccp.c
1 /*
2  * ccp.c - PPP Compression Control Protocol.
3  *
4  * Copyright (c) 1994 The Australian National University.
5  * All rights reserved.
6  *
7  * Permission to use, copy, modify, and distribute this software and its
8  * documentation is hereby granted, provided that the above copyright
9  * notice appears in all copies.  This software is provided without any
10  * warranty, express or implied. The Australian National University
11  * makes no representations about the suitability of this software for
12  * any purpose.
13  *
14  * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY
15  * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
17  * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY
18  * OF SUCH DAMAGE.
19  *
20  * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES,
21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
22  * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
23  * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO
24  * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS,
25  * OR MODIFICATIONS.
26  */
27
28 #ifndef lint
29 static char rcsid[] = "$Id: ccp.c,v 1.4 1994/09/16 02:14:31 paulus Exp $";
30 #endif
31
32 #include <syslog.h>
33 #include <sys/ioctl.h>
34
35 #include "pppd.h"
36 #include "ppp.h"
37 #include "fsm.h"
38 #include "ccp.h"
39
40 fsm ccp_fsm[NPPP];
41 ccp_options ccp_wantoptions[NPPP];      /* what to request the peer to use */
42 ccp_options ccp_gotoptions[NPPP];       /* what the peer agreed to do */
43 ccp_options ccp_allowoptions[NPPP];     /* what we'll agree to do */
44 ccp_options ccp_hisoptions[NPPP];       /* what we agreed to do */
45
46 /*
47  * Callbacks for fsm code.
48  */
49 static void ccp_resetci __ARGS((fsm *));
50 static int  ccp_cilen __ARGS((fsm *));
51 static void ccp_addci __ARGS((fsm *, u_char *, int *));
52 static int  ccp_ackci __ARGS((fsm *, u_char *, int));
53 static int  ccp_nakci __ARGS((fsm *, u_char *, int));
54 static int  ccp_rejci __ARGS((fsm *, u_char *, int));
55 static int  ccp_reqci __ARGS((fsm *, u_char *, int *, int));
56 static void ccp_up __ARGS((fsm *));
57 static void ccp_down __ARGS((fsm *));
58 static int  ccp_extcode __ARGS((fsm *, int, int, u_char *, int));
59 static void ccp_rack_timeout __ARGS(());
60
61 static fsm_callbacks ccp_callbacks = {
62     ccp_resetci,
63     ccp_cilen,
64     ccp_addci,
65     ccp_ackci,
66     ccp_nakci,
67     ccp_rejci,
68     ccp_reqci,
69     ccp_up,
70     ccp_down,
71     NULL,
72     NULL,
73     NULL,
74     NULL,
75     ccp_extcode,
76     "CCP"
77 };
78
79 /*
80  * Length of configuration options, which describe possible
81  * compression methods.
82  */
83 #define CILEN_BSD       3
84
85 /*
86  * Configuration option values for compression methods.
87  */
88 #define CI_BSD_COMPRESS 0x21
89
90 /*
91  * Information relating to BSD Compress configuration options.
92  */
93 #define BSD_NBITS(x)            ((x) & 0x1F)
94 #define BSD_VERSION(x)          ((x) >> 5)
95 #define BSD_CURRENT_VERSION     1
96 #define BSD_MAKE_OPT(v, n)      (((v) << 5) | (n))
97
98 /*
99  * Do we want / did we get any compression?
100  */
101 #define ANY_COMPRESS(opt)       ((opt).bsd_compress)
102
103 /*
104  * Local state (mainly for handling reset-reqs and reset-acks
105  */
106 static int ccp_localstate[NPPP];
107 #define RACK_PENDING    1       /* waiting for reset-ack */
108 #define RREQ_REPEAT     2       /* send another reset-req if no reset-ack */
109
110 #define RACKTIMEOUT     1       /* second */
111
112 /*
113  * ccp_init - initialize CCP.
114  */
115 void
116 ccp_init(unit)
117     int unit;
118 {
119     fsm *f = &ccp_fsm[unit];
120
121     f->unit = unit;
122     f->protocol = CCP;
123     f->callbacks = &ccp_callbacks;
124     fsm_init(f);
125
126     memset(&ccp_wantoptions[unit],  0, sizeof(ccp_options));
127     memset(&ccp_gotoptions[unit],   0, sizeof(ccp_options));
128     memset(&ccp_allowoptions[unit], 0, sizeof(ccp_options));
129     memset(&ccp_hisoptions[unit],   0, sizeof(ccp_options));
130
131     ccp_wantoptions[0].bsd_bits = 12;   /* default value */
132
133     ccp_allowoptions[0].bsd_compress = 1;
134     ccp_allowoptions[0].bsd_bits = MAX_BSD_BITS;
135 }
136
137 /*
138  * ccp_open - CCP is allowed to come up.
139  */
140 void
141 ccp_open(unit)
142     int unit;
143 {
144     fsm *f = &ccp_fsm[unit];
145
146     if (f->state != OPENED)
147         ccp_flags_set(unit, 1, 0);
148     if (!ANY_COMPRESS(ccp_wantoptions[unit]))
149         f->flags |= OPT_SILENT;
150     fsm_open(f);
151 }
152
153 /*
154  * ccp_close - Terminate CCP.
155  */
156 void
157 ccp_close(unit)
158     int unit;
159 {
160     ccp_flags_set(unit, 0, 0);
161     fsm_close(&ccp_fsm[unit]);
162 }
163
164 /*
165  * ccp_lowerup - we may now transmit CCP packets.
166  */
167 void
168 ccp_lowerup(unit)
169     int unit;
170 {
171     fsm_lowerup(&ccp_fsm[unit]);
172 }
173
174 /*
175  * ccp_lowerdown - we may not transmit CCP packets.
176  */
177 void
178 ccp_lowerdown(unit)
179     int unit;
180 {
181     fsm_lowerdown(&ccp_fsm[unit]);
182 }
183
184 /*
185  * ccp_input - process a received CCP packet.
186  */
187 void
188 ccp_input(unit, p, len)
189     int unit;
190     u_char *p;
191     int len;
192 {
193     fsm *f = &ccp_fsm[unit];
194     int oldstate;
195
196     /*
197      * Check for a terminate-request so we can print a message.
198      */
199     oldstate = f->state;
200     fsm_input(f, p, len);
201     if (oldstate == OPENED && p[0] == TERMREQ && f->state != OPENED)
202         syslog(LOG_NOTICE, "Compression disabled by peer.");
203 }
204
205 /*
206  * Handle a CCP-specific code.
207  */
208 static int
209 ccp_extcode(f, code, id, p, len)
210     fsm *f;
211     int code, id;
212     u_char *p;
213     int len;
214 {
215     switch (code) {
216     case RESETREQ:
217         if (f->state != OPENED)
218             break;
219         /* send a reset-ack, which the transmitter will see and
220            reset its compression state. */
221         fsm_sdata(f, RESETACK, id, NULL, 0);
222         break;
223
224     case RESETACK:
225         if (ccp_localstate[f->unit] & RACK_PENDING && id == f->reqid) {
226             ccp_localstate[f->unit] &= ~(RACK_PENDING | RREQ_REPEAT);
227             UNTIMEOUT(ccp_rack_timeout, (caddr_t) f);
228         }
229         break;
230
231     default:
232         return 0;
233     }
234
235     return 1;
236 }
237
238 /*
239  * ccp_protrej - peer doesn't talk CCP.
240  */
241 void
242 ccp_protrej(unit)
243     int unit;
244 {
245     ccp_flags_set(unit, 0, 0);
246     fsm_lowerdown(&ccp_fsm[unit]);
247 }
248
249 /*
250  * ccp_resetci - initialize at start of negotiation.
251  */
252 static void
253 ccp_resetci(f)
254     fsm *f;
255 {
256     ccp_options *go = &ccp_gotoptions[f->unit];
257     u_char opt_buf[16];
258
259     *go = ccp_wantoptions[f->unit];
260     if (go->bsd_compress) {
261         opt_buf[0] = CI_BSD_COMPRESS;
262         opt_buf[1] = CILEN_BSD;
263         opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
264         if (!ccp_test(f->unit, opt_buf, CILEN_BSD, 0))
265             go->bsd_compress = 0;
266     }
267 }
268
269 /*
270  * ccp_cilen - Return total length of our configuration info.
271  */
272 static int
273 ccp_cilen(f)
274     fsm *f;
275 {
276     ccp_options *go = &ccp_gotoptions[f->unit];
277
278     return (go->bsd_compress? CILEN_BSD: 0);
279 }
280
281 /*
282  * ccp_addci - put our requests in a packet.
283  */
284 static void
285 ccp_addci(f, p, lenp)
286     fsm *f;
287     u_char *p;
288     int *lenp;
289 {
290     ccp_options *go = &ccp_gotoptions[f->unit];
291     u_char *p0 = p;
292
293     if (go->bsd_compress) {
294         p[0] = CI_BSD_COMPRESS;
295         p[1] = CILEN_BSD;
296         p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits);
297         if (ccp_test(f->unit, p, CILEN_BSD, 0))
298             p += CILEN_BSD;
299         else
300             go->bsd_compress = 0;
301     }
302     *lenp = p - p0;
303 }
304
305 /*
306  * ccp_ackci - process a received configure-ack, and return
307  * 1 iff the packet was OK.
308  */
309 static int
310 ccp_ackci(f, p, len)
311     fsm *f;
312     u_char *p;
313     int len;
314 {
315     ccp_options *go = &ccp_gotoptions[f->unit];
316
317     if (go->bsd_compress) {
318         if (len < CILEN_BSD || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD
319             || p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
320             return 0;
321         p += CILEN_BSD;
322         len -= CILEN_BSD;
323     }
324     if (len != 0)
325         return 0;
326     return 1;
327 }
328
329 /*
330  * ccp_nakci - process received configure-nak.
331  * Returns 1 iff the nak was OK.
332  */
333 static int
334 ccp_nakci(f, p, len)
335     fsm *f;
336     u_char *p;
337     int len;
338 {
339     ccp_options *go = &ccp_gotoptions[f->unit];
340     ccp_options no;             /* options we've seen already */
341     ccp_options try;            /* options to ask for next time */
342
343     memset(&no, 0, sizeof(no));
344     try = *go;
345
346     if (go->bsd_compress && !no.bsd_compress && len >= CILEN_BSD
347         && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD) {
348         no.bsd_compress = 1;
349         /*
350          * Peer wants us to use a different number of bits
351          * or a different version.
352          */
353         if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION)
354             try.bsd_compress = 0;
355         else if (BSD_NBITS(p[2]) < go->bsd_bits)
356             try.bsd_bits = BSD_NBITS(p[2]);
357         p += CILEN_BSD;
358         len -= CILEN_BSD;
359     }
360
361     /*
362      * Have a look at any remaining options...???
363      */
364
365     if (len != 0)
366         return 0;
367
368     if (f->state != OPENED)
369         *go = try;
370     return 1;
371 }
372
373 /*
374  * ccp_rejci - reject some of our suggested compression methods.
375  */
376 static int
377 ccp_rejci(f, p, len)
378     fsm *f;
379     u_char *p;
380     int len;
381 {
382     ccp_options *go = &ccp_gotoptions[f->unit];
383     ccp_options try;            /* options to request next time */
384
385     try = *go;
386
387     if (go->bsd_compress && len >= CILEN_BSD
388         && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD) {
389         if (p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits))
390             return 0;
391         try.bsd_compress = 0;
392         p += CILEN_BSD;
393         len -= CILEN_BSD;
394     }
395
396     if (len != 0)
397         return 0;
398
399     if (f->state != OPENED)
400         *go = try;
401
402     return 1;
403 }
404
405 /*
406  * ccp_reqci - processed a received configure-request.
407  * Returns CONFACK, CONFNAK or CONFREJ and the packet modified
408  * appropriately.
409  */
410 static int
411 ccp_reqci(f, p, lenp, dont_nak)
412     fsm *f;
413     u_char *p;
414     int *lenp;
415     int dont_nak;
416 {
417     int ret, newret;
418     u_char *p0, *retp;
419     int len, clen, type, nb;
420     ccp_options *ho = &ccp_hisoptions[f->unit];
421     ccp_options *ao = &ccp_allowoptions[f->unit];
422
423     ret = CONFACK;
424     retp = p0 = p;
425     len = *lenp;
426
427     memset(ho, 0, sizeof(ccp_options));
428
429     while (len > 0) {
430         newret = CONFACK;
431         if (len < 2 || p[1] < 2 || p[1] > len) {
432             /* length is bad */
433             clen = len;
434             newret = CONFREJ;
435
436         } else {
437             type = p[0];
438             clen = p[1];
439
440             switch (type) {
441             case CI_BSD_COMPRESS:
442                 if (!ao->bsd_compress || clen != CILEN_BSD) {
443                     newret = CONFREJ;
444                     break;
445                 }
446
447                 ho->bsd_compress = 1;
448                 ho->bsd_bits = nb = BSD_NBITS(p[2]);
449                 if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION
450                     || nb > ao->bsd_bits) {
451                     newret = CONFNAK;
452                     nb = ao->bsd_bits;
453                 } else if (nb < MIN_BSD_BITS) {
454                     newret = CONFREJ;
455                 } else if (!ccp_test(f->unit, p, CILEN_BSD, 1)) {
456                     if (nb > MIN_BSD_BITS) {
457                         --nb;
458                         newret = CONFNAK;
459                     } else
460                         newret = CONFREJ;
461                 }
462                 if (newret == CONFNAK && !dont_nak) {
463                     p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb);
464                 }
465
466                 break;
467
468             default:
469                 newret = CONFREJ;
470             }
471         }
472
473         if (!(newret == CONFACK || newret == CONFNAK && ret == CONFREJ)) {
474             /* we're returning this option */
475             ret = newret;
476             if (p != retp)
477                 BCOPY(p, retp, clen);
478             retp += clen;
479         }
480
481         p += clen;
482         len -= clen;
483     }
484
485     if (ret != CONFACK)
486         *lenp = retp - p0;
487     return ret;
488 }
489
490 /*
491  * CCP has come up - inform the kernel driver.
492  */
493 static void
494 ccp_up(f)
495     fsm *f;
496 {
497     ccp_options *go = &ccp_gotoptions[f->unit];
498     ccp_options *ho = &ccp_hisoptions[f->unit];
499
500     ccp_flags_set(f->unit, 1, 1);
501     if (go->bsd_compress || ho->bsd_compress)
502         syslog(LOG_NOTICE, "%s enabled",
503                go->bsd_compress? ho->bsd_compress? "Compression":
504                "Receive compression": "Transmit compression");
505 }
506
507 /*
508  * CCP has gone down - inform the kernel driver.
509  */
510 static void
511 ccp_down(f)
512     fsm *f;
513 {
514     if (ccp_localstate[f->unit] & RACK_PENDING)
515         UNTIMEOUT(ccp_rack_timeout, (caddr_t) f);
516     ccp_localstate[f->unit] = 0;
517     ccp_flags_set(f->unit, 1, 0);
518 }
519
520 /*
521  * Print the contents of a CCP packet.
522  */
523 char *ccp_codenames[] = {
524     "ConfReq", "ConfAck", "ConfNak", "ConfRej",
525     "TermReq", "TermAck", "CodeRej",
526     NULL, NULL, NULL, NULL, NULL, NULL,
527     "ResetReq", "ResetAck",
528 };
529
530 int
531 ccp_printpkt(p, plen, printer, arg)
532     u_char *p;
533     int plen;
534     void (*printer) __ARGS((void *, char *, ...));
535     void *arg;
536 {
537     u_char *p0, *optend;
538     int code, id, len;
539     int optlen;
540
541     p0 = p;
542     if (plen < HEADERLEN)
543         return 0;
544     code = p[0];
545     id = p[1];
546     len = (p[2] << 8) + p[3];
547     if (len < HEADERLEN || len > plen)
548         return 0;
549
550     if (code >= 1 && code <= sizeof(ccp_codenames) / sizeof(char *)
551         && ccp_codenames[code-1] != NULL)
552         printer(arg, " %s", ccp_codenames[code-1]);
553     else
554         printer(arg, " code=0x%x", code);
555     printer(arg, " id=0x%x", id);
556     len -= HEADERLEN;
557     p += HEADERLEN;
558
559     switch (code) {
560     case CONFREQ:
561     case CONFACK:
562     case CONFNAK:
563     case CONFREJ:
564         /* print list of possible compression methods */
565         while (len >= 2) {
566             code = p[0];
567             optlen = p[1];
568             if (optlen < 2 || optlen > len)
569                 break;
570             printer(arg, " <");
571             len -= optlen;
572             optend = p + optlen;
573             switch (code) {
574             case CI_BSD_COMPRESS:
575                 if (optlen >= CILEN_BSD) {
576                     printer(arg, "bsd v%d %d", BSD_VERSION(p[2]),
577                             BSD_NBITS(p[2]));
578                     p += CILEN_BSD;
579                 }
580                 break;
581             }
582             while (p < optend)
583                 printer(arg, " %.2x", *p++);
584             printer(arg, ">");
585         }
586         break;
587     }
588
589     /* dump out the rest of the packet in hex */
590     while (--len >= 0)
591         printer(arg, " %.2x", *p++);
592
593     return p - p0;
594 }
595
596 /*
597  * We have received a packet that the decompressor failed to
598  * decompress.  Here we would expect to issue a reset-request, but
599  * Motorola has a patent on resetting the compressor as a result of
600  * detecting an error in the decompressed data after decompression.
601  * (See US patent 5,130,993; international patent publication number
602  * WO 91/10289; Australian patent 73296/91.)
603  *
604  * So we ask the kernel whether the error was detected after
605  * decompression; if it was, we take CCP down, thus disabling
606  * compression :-(, otherwise we issue the reset-request.
607  */
608 void
609 ccp_datainput(unit, pkt, len)
610     int unit;
611     u_char *pkt;
612     int len;
613 {
614     fsm *f;
615
616     f = &ccp_fsm[unit];
617     if (f->state == OPENED) {
618         if (ccp_fatal_error(unit)) {
619             /*
620              * Disable compression by taking CCP down.
621              */
622             syslog(LOG_ERR, "Lost compression sync: disabling compression");
623             ccp_close(unit);
624         } else {
625             /*
626              * Send a reset-request to reset the peer's compressor.
627              * We don't do that if we are still waiting for an
628              * acknowledgement to a previous reset-request.
629              */
630             if (!(ccp_localstate[f->unit] & RACK_PENDING)) {
631                 fsm_sdata(f, RESETREQ, f->reqid = ++f->id, NULL, 0);
632                 TIMEOUT(ccp_rack_timeout, (caddr_t) f, RACKTIMEOUT);
633                 ccp_localstate[f->unit] |= RACK_PENDING;
634             } else
635                 ccp_localstate[f->unit] |= RREQ_REPEAT;
636         }
637     }
638 }
639
640 /*
641  * Timeout waiting for reset-ack.
642  */
643 static void
644 ccp_rack_timeout(arg)
645     caddr_t arg;
646 {
647     fsm *f = (fsm *) arg;
648
649     if (f->state == OPENED && ccp_localstate[f->unit] & RREQ_REPEAT) {
650         fsm_sdata(f, RESETREQ, f->reqid, NULL, 0);
651         TIMEOUT(ccp_rack_timeout, (caddr_t) f, RACKTIMEOUT);
652         ccp_localstate[f->unit] &= ~RREQ_REPEAT;
653     } else
654         ccp_localstate[f->unit] &= ~RACK_PENDING;
655 }
656