7f2f7877cbbf4011a007441c3545d4dd2520e8dd
[ppp.git] / pppd / cbcp.c
1 /*
2  * cbcp - Call Back Configuration Protocol.
3  *
4  * Copyright (c) 1995 Pedro Roque Marques.  All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in
15  *    the documentation and/or other materials provided with the
16  *    distribution.
17  *
18  * 3. The names of the authors of this software must not be used to
19  *    endorse or promote products derived from this software without
20  *    prior written permission.
21  *
22  * 4. Redistributions of any form whatsoever must retain the following
23  *    acknowledgment:
24  *    "This product includes software developed by Pedro Roque Marques
25  *     <pedro_m@yahoo.com>"
26  *
27  * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO
28  * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
29  * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
30  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
31  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
32  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
33  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
34  */
35
36 #define RCSID   "$Id: cbcp.c,v 1.17 2006/05/22 00:04:07 paulus Exp $"
37
38 #include <stdio.h>
39 #include <string.h>
40 #include <sys/types.h>
41 #include <sys/time.h>
42
43 #include "pppd.h"
44 #include "cbcp.h"
45 #include "fsm.h"
46 #include "lcp.h"
47
48 static const char rcsid[] = RCSID;
49
50 /*
51  * Options.
52  */
53 static int setcbcp __P((char **));
54
55 static option_t cbcp_option_list[] = {
56     { "callback", o_special, (void *)setcbcp,
57       "Ask for callback", OPT_PRIO | OPT_A2STRVAL, &cbcp[0].us_number },
58     { NULL }
59 };
60
61 /*
62  * Protocol entry points.
63  */
64 static void cbcp_init      __P((int unit));
65 static void cbcp_open      __P((int unit));
66 static void cbcp_lowerup   __P((int unit));
67 static void cbcp_input     __P((int unit, u_char *pkt, int len));
68 static void cbcp_protrej   __P((int unit));
69 static int  cbcp_printpkt  __P((u_char *pkt, int len,
70                                 void (*printer) __P((void *, char *, ...)),
71                                 void *arg));
72
73 struct protent cbcp_protent = {
74     PPP_CBCP,
75     cbcp_init,
76     cbcp_input,
77     cbcp_protrej,
78     cbcp_lowerup,
79     NULL,
80     cbcp_open,
81     NULL,
82     cbcp_printpkt,
83     NULL,
84     0,
85     "CBCP",
86     NULL,
87     cbcp_option_list,
88     NULL,
89     NULL,
90     NULL
91 };
92
93 cbcp_state cbcp[NUM_PPP];       
94
95 /* internal prototypes */
96
97 static void cbcp_recvreq __P((cbcp_state *us, u_char *pckt, int len));
98 static void cbcp_resp __P((cbcp_state *us));
99 static void cbcp_up __P((cbcp_state *us));
100 static void cbcp_recvack __P((cbcp_state *us, u_char *pckt, int len));
101 static void cbcp_send __P((cbcp_state *us, int code, u_char *buf, int len));
102
103 /* option processing */
104 static int
105 setcbcp(argv)
106     char **argv;
107 {
108     lcp_wantoptions[0].neg_cbcp = 1;
109     cbcp_protent.enabled_flag = 1;
110     cbcp[0].us_number = strdup(*argv);
111     if (cbcp[0].us_number == 0)
112         novm("callback number");
113     cbcp[0].us_type |= (1 << CB_CONF_USER);
114     cbcp[0].us_type |= (1 << CB_CONF_ADMIN);
115     return (1);
116 }
117
118 /* init state */
119 static void
120 cbcp_init(iface)
121     int iface;
122 {
123     cbcp_state *us;
124
125     us = &cbcp[iface];
126     memset(us, 0, sizeof(cbcp_state));
127     us->us_unit = iface;
128     us->us_type |= (1 << CB_CONF_NO);
129 }
130
131 /* lower layer is up */
132 static void
133 cbcp_lowerup(iface)
134     int iface;
135 {
136     cbcp_state *us = &cbcp[iface];
137
138     dbglog("cbcp_lowerup");
139     dbglog("want: %d", us->us_type);
140
141     if (us->us_type == CB_CONF_USER)
142         dbglog("phone no: %s", us->us_number);
143 }
144
145 static void
146 cbcp_open(unit)
147     int unit;
148 {
149     dbglog("cbcp_open");
150 }
151
152 /* process an incomming packet */
153 static void
154 cbcp_input(unit, inpacket, pktlen)
155     int unit;
156     u_char *inpacket;
157     int pktlen;
158 {
159     u_char *inp;
160     u_char code, id;
161     u_short len;
162
163     cbcp_state *us = &cbcp[unit];
164
165     inp = inpacket;
166
167     if (pktlen < CBCP_MINLEN) {
168         if (debug)
169             dbglog("CBCP packet is too small");
170         return;
171     }
172
173     GETCHAR(code, inp);
174     GETCHAR(id, inp);
175     GETSHORT(len, inp);
176
177     if (len > pktlen || len < CBCP_MINLEN) {
178         if (debug)
179             dbglog("CBCP packet: invalid length %d", len);
180         return;
181     }
182
183     len -= CBCP_MINLEN;
184  
185     switch(code) {
186     case CBCP_REQ:
187         us->us_id = id;
188         cbcp_recvreq(us, inp, len);
189         break;
190
191     case CBCP_RESP:
192         if (debug)
193             dbglog("CBCP_RESP received");
194         break;
195
196     case CBCP_ACK:
197         if (debug && id != us->us_id)
198             dbglog("id doesn't match: expected %d recv %d",
199                    us->us_id, id);
200
201         cbcp_recvack(us, inp, len);
202         break;
203
204     default:
205         break;
206     }
207 }
208
209 /* protocol was rejected by foe */
210 void cbcp_protrej(int iface)
211 {
212 }
213
214 char *cbcp_codenames[] = {
215     "Request", "Response", "Ack"
216 };
217
218 char *cbcp_optionnames[] = {
219     "NoCallback",
220     "UserDefined",
221     "AdminDefined",
222     "List"
223 };
224
225 /* pretty print a packet */
226 static int
227 cbcp_printpkt(p, plen, printer, arg)
228     u_char *p;
229     int plen;
230     void (*printer) __P((void *, char *, ...));
231     void *arg;
232 {
233     int code, opt, id, len, olen, delay;
234     u_char *pstart;
235
236     if (plen < HEADERLEN)
237         return 0;
238     pstart = p;
239     GETCHAR(code, p);
240     GETCHAR(id, p);
241     GETSHORT(len, p);
242     if (len < HEADERLEN || len > plen)
243         return 0;
244
245     if (code >= 1 && code <= sizeof(cbcp_codenames) / sizeof(char *))
246         printer(arg, " %s", cbcp_codenames[code-1]);
247     else
248         printer(arg, " code=0x%x", code); 
249
250     printer(arg, " id=0x%x", id);
251     len -= HEADERLEN;
252
253     switch (code) {
254     case CBCP_REQ:
255     case CBCP_RESP:
256     case CBCP_ACK:
257         while(len >= 2) {
258             GETCHAR(opt, p);
259             GETCHAR(olen, p);
260
261             if (olen < 2 || olen > len) {
262                 break;
263             }
264
265             printer(arg, " <");
266             len -= olen;
267
268             if (opt >= 1 && opt <= sizeof(cbcp_optionnames) / sizeof(char *))
269                 printer(arg, " %s", cbcp_optionnames[opt-1]);
270             else
271                 printer(arg, " option=0x%x", opt); 
272
273             if (olen > 2) {
274                 GETCHAR(delay, p);
275                 printer(arg, " delay = %d", delay);
276             }
277
278             if (olen > 3) {
279                 int addrt;
280                 char str[256];
281
282                 GETCHAR(addrt, p);
283                 memcpy(str, p, olen - 4);
284                 str[olen - 4] = 0;
285                 printer(arg, " number = %s", str);
286             }
287             printer(arg, ">");
288         }
289         break;
290
291     default:
292         break;
293     }
294
295     for (; len > 0; --len) {
296         GETCHAR(code, p);
297         printer(arg, " %.2x", code);
298     }
299
300     return p - pstart;
301 }
302
303 /* received CBCP request */
304 static void
305 cbcp_recvreq(us, pckt, pcktlen)
306     cbcp_state *us;
307     u_char *pckt;
308     int pcktlen;
309 {
310     u_char type, opt_len, delay, addr_type;
311     char address[256];
312     int len = pcktlen;
313
314     address[0] = 0;
315
316     while (len >= 2) {
317         dbglog("length: %d", len);
318
319         GETCHAR(type, pckt);
320         GETCHAR(opt_len, pckt);
321         if (opt_len < 2 || opt_len > len)
322             break;
323
324         if (opt_len > 2)
325             GETCHAR(delay, pckt);
326
327         us->us_allowed |= (1 << type);
328
329         switch(type) {
330         case CB_CONF_NO:
331             dbglog("no callback allowed");
332             break;
333
334         case CB_CONF_USER:
335             dbglog("user callback allowed");
336             if (opt_len > 4) {
337                 GETCHAR(addr_type, pckt);
338                 memcpy(address, pckt, opt_len - 4);
339                 address[opt_len - 4] = 0;
340                 if (address[0])
341                     dbglog("address: %s", address);
342             }
343             break;
344
345         case CB_CONF_ADMIN:
346             dbglog("user admin defined allowed");
347             break;
348
349         case CB_CONF_LIST:
350             break;
351         }
352         len -= opt_len;
353     }
354     if (len != 0) {
355         if (debug)
356             dbglog("cbcp_recvreq: malformed packet (%d bytes left)", len);
357         return;
358     }
359
360     cbcp_resp(us);
361 }
362
363 static void
364 cbcp_resp(us)
365     cbcp_state *us;
366 {
367     u_char cb_type;
368     u_char buf[256];
369     u_char *bufp = buf;
370     int len = 0;
371     int slen;
372
373     cb_type = us->us_allowed & us->us_type;
374     dbglog("cbcp_resp cb_type=%d", cb_type);
375
376 #if 0
377     if (!cb_type)
378         lcp_down(us->us_unit);
379 #endif
380
381     if (cb_type & ( 1 << CB_CONF_USER ) ) {
382         dbglog("cbcp_resp CONF_USER");
383         slen = strlen(us->us_number);
384         if (slen > 250) {
385             warn("callback number truncated to 250 characters");
386             slen = 250;
387         }
388         PUTCHAR(CB_CONF_USER, bufp);
389         len = 3 + 1 + slen + 1;
390         PUTCHAR(len , bufp);
391         PUTCHAR(5, bufp); /* delay */
392         PUTCHAR(1, bufp);
393         BCOPY(us->us_number, bufp, slen + 1);
394         cbcp_send(us, CBCP_RESP, buf, len);
395         return;
396     }
397
398     if (cb_type & ( 1 << CB_CONF_ADMIN ) ) {
399         dbglog("cbcp_resp CONF_ADMIN");
400         PUTCHAR(CB_CONF_ADMIN, bufp);
401         len = 3;
402         PUTCHAR(len, bufp);
403         PUTCHAR(5, bufp); /* delay */
404         cbcp_send(us, CBCP_RESP, buf, len);
405         return;
406     }
407
408     if (cb_type & ( 1 << CB_CONF_NO ) ) {
409         dbglog("cbcp_resp CONF_NO");
410         PUTCHAR(CB_CONF_NO, bufp);
411         len = 2;
412         PUTCHAR(len , bufp);
413         cbcp_send(us, CBCP_RESP, buf, len);
414         start_networks(us->us_unit);
415         return;
416     }
417 }
418
419 static void
420 cbcp_send(us, code, buf, len)
421     cbcp_state *us;
422     int code;
423     u_char *buf;
424     int len;
425 {
426     u_char *outp;
427     int outlen;
428
429     outp = outpacket_buf;
430
431     outlen = 4 + len;
432     
433     MAKEHEADER(outp, PPP_CBCP);
434
435     PUTCHAR(code, outp);
436     PUTCHAR(us->us_id, outp);
437     PUTSHORT(outlen, outp);
438     
439     if (len)
440         BCOPY(buf, outp, len);
441
442     output(us->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
443 }
444
445 static void
446 cbcp_recvack(us, pckt, len)
447     cbcp_state *us;
448     u_char *pckt;
449     int len;
450 {
451     u_char type, delay, addr_type;
452     int opt_len;
453     char address[256];
454
455     if (len >= 2) {
456         GETCHAR(type, pckt);
457         GETCHAR(opt_len, pckt);
458         if (opt_len >= 2 && opt_len <= len) {
459      
460             if (opt_len > 2)
461                 GETCHAR(delay, pckt);
462
463             if (opt_len > 4) {
464                 GETCHAR(addr_type, pckt);
465                 memcpy(address, pckt, opt_len - 4);
466                 address[opt_len - 4] = 0;
467                 if (address[0])
468                     dbglog("peer will call: %s", address);
469             }
470             if (type == CB_CONF_NO)
471                 return;
472
473             cbcp_up(us);
474
475         } else if (debug)
476             dbglog("cbcp_recvack: malformed packet");
477     }
478 }
479
480 /* ok peer will do callback */
481 static void
482 cbcp_up(us)
483     cbcp_state *us;
484 {
485     persist = 0;
486     status = EXIT_CALLBACK;
487     lcp_close(0, "Call me back, please");
488 }