pppd: Remove unused rcsid variables
[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
49 /*
50  * Options.
51  */
52 static int setcbcp __P((char **));
53
54 static option_t cbcp_option_list[] = {
55     { "callback", o_special, (void *)setcbcp,
56       "Ask for callback", OPT_PRIO | OPT_A2STRVAL, &cbcp[0].us_number },
57     { NULL }
58 };
59
60 /*
61  * Protocol entry points.
62  */
63 static void cbcp_init      __P((int unit));
64 static void cbcp_open      __P((int unit));
65 static void cbcp_lowerup   __P((int unit));
66 static void cbcp_input     __P((int unit, u_char *pkt, int len));
67 static void cbcp_protrej   __P((int unit));
68 static int  cbcp_printpkt  __P((u_char *pkt, int len,
69                                 void (*printer) __P((void *, char *, ...)),
70                                 void *arg));
71
72 struct protent cbcp_protent = {
73     PPP_CBCP,
74     cbcp_init,
75     cbcp_input,
76     cbcp_protrej,
77     cbcp_lowerup,
78     NULL,
79     cbcp_open,
80     NULL,
81     cbcp_printpkt,
82     NULL,
83     0,
84     "CBCP",
85     NULL,
86     cbcp_option_list,
87     NULL,
88     NULL,
89     NULL
90 };
91
92 cbcp_state cbcp[NUM_PPP];       
93
94 /* internal prototypes */
95
96 static void cbcp_recvreq __P((cbcp_state *us, u_char *pckt, int len));
97 static void cbcp_resp __P((cbcp_state *us));
98 static void cbcp_up __P((cbcp_state *us));
99 static void cbcp_recvack __P((cbcp_state *us, u_char *pckt, int len));
100 static void cbcp_send __P((cbcp_state *us, int code, u_char *buf, int len));
101
102 /* option processing */
103 static int
104 setcbcp(argv)
105     char **argv;
106 {
107     lcp_wantoptions[0].neg_cbcp = 1;
108     cbcp_protent.enabled_flag = 1;
109     cbcp[0].us_number = strdup(*argv);
110     if (cbcp[0].us_number == 0)
111         novm("callback number");
112     cbcp[0].us_type |= (1 << CB_CONF_USER);
113     cbcp[0].us_type |= (1 << CB_CONF_ADMIN);
114     return (1);
115 }
116
117 /* init state */
118 static void
119 cbcp_init(iface)
120     int iface;
121 {
122     cbcp_state *us;
123
124     us = &cbcp[iface];
125     memset(us, 0, sizeof(cbcp_state));
126     us->us_unit = iface;
127     us->us_type |= (1 << CB_CONF_NO);
128 }
129
130 /* lower layer is up */
131 static void
132 cbcp_lowerup(iface)
133     int iface;
134 {
135     cbcp_state *us = &cbcp[iface];
136
137     dbglog("cbcp_lowerup");
138     dbglog("want: %d", us->us_type);
139
140     if (us->us_type == CB_CONF_USER)
141         dbglog("phone no: %s", us->us_number);
142 }
143
144 static void
145 cbcp_open(unit)
146     int unit;
147 {
148     dbglog("cbcp_open");
149 }
150
151 /* process an incomming packet */
152 static void
153 cbcp_input(unit, inpacket, pktlen)
154     int unit;
155     u_char *inpacket;
156     int pktlen;
157 {
158     u_char *inp;
159     u_char code, id;
160     u_short len;
161
162     cbcp_state *us = &cbcp[unit];
163
164     inp = inpacket;
165
166     if (pktlen < CBCP_MINLEN) {
167         if (debug)
168             dbglog("CBCP packet is too small");
169         return;
170     }
171
172     GETCHAR(code, inp);
173     GETCHAR(id, inp);
174     GETSHORT(len, inp);
175
176     if (len > pktlen || len < CBCP_MINLEN) {
177         if (debug)
178             dbglog("CBCP packet: invalid length %d", len);
179         return;
180     }
181
182     len -= CBCP_MINLEN;
183  
184     switch(code) {
185     case CBCP_REQ:
186         us->us_id = id;
187         cbcp_recvreq(us, inp, len);
188         break;
189
190     case CBCP_RESP:
191         if (debug)
192             dbglog("CBCP_RESP received");
193         break;
194
195     case CBCP_ACK:
196         if (debug && id != us->us_id)
197             dbglog("id doesn't match: expected %d recv %d",
198                    us->us_id, id);
199
200         cbcp_recvack(us, inp, len);
201         break;
202
203     default:
204         break;
205     }
206 }
207
208 /* protocol was rejected by foe */
209 void cbcp_protrej(int iface)
210 {
211 }
212
213 char *cbcp_codenames[] = {
214     "Request", "Response", "Ack"
215 };
216
217 char *cbcp_optionnames[] = {
218     "NoCallback",
219     "UserDefined",
220     "AdminDefined",
221     "List"
222 };
223
224 /* pretty print a packet */
225 static int
226 cbcp_printpkt(p, plen, printer, arg)
227     u_char *p;
228     int plen;
229     void (*printer) __P((void *, char *, ...));
230     void *arg;
231 {
232     int code, opt, id, len, olen, delay;
233     u_char *pstart;
234
235     if (plen < HEADERLEN)
236         return 0;
237     pstart = p;
238     GETCHAR(code, p);
239     GETCHAR(id, p);
240     GETSHORT(len, p);
241     if (len < HEADERLEN || len > plen)
242         return 0;
243
244     if (code >= 1 && code <= sizeof(cbcp_codenames) / sizeof(char *))
245         printer(arg, " %s", cbcp_codenames[code-1]);
246     else
247         printer(arg, " code=0x%x", code); 
248
249     printer(arg, " id=0x%x", id);
250     len -= HEADERLEN;
251
252     switch (code) {
253     case CBCP_REQ:
254     case CBCP_RESP:
255     case CBCP_ACK:
256         while(len >= 2) {
257             GETCHAR(opt, p);
258             GETCHAR(olen, p);
259
260             if (olen < 2 || olen > len) {
261                 break;
262             }
263
264             printer(arg, " <");
265             len -= olen;
266
267             if (opt >= 1 && opt <= sizeof(cbcp_optionnames) / sizeof(char *))
268                 printer(arg, " %s", cbcp_optionnames[opt-1]);
269             else
270                 printer(arg, " option=0x%x", opt); 
271
272             if (olen > 2) {
273                 GETCHAR(delay, p);
274                 printer(arg, " delay = %d", delay);
275             }
276
277             if (olen > 3) {
278                 int addrt;
279                 char str[256];
280
281                 GETCHAR(addrt, p);
282                 memcpy(str, p, olen - 4);
283                 str[olen - 4] = 0;
284                 printer(arg, " number = %s", str);
285             }
286             printer(arg, ">");
287         }
288         break;
289
290     default:
291         break;
292     }
293
294     for (; len > 0; --len) {
295         GETCHAR(code, p);
296         printer(arg, " %.2x", code);
297     }
298
299     return p - pstart;
300 }
301
302 /* received CBCP request */
303 static void
304 cbcp_recvreq(us, pckt, pcktlen)
305     cbcp_state *us;
306     u_char *pckt;
307     int pcktlen;
308 {
309     u_char type, opt_len, delay, addr_type;
310     char address[256];
311     int len = pcktlen;
312
313     address[0] = 0;
314
315     while (len >= 2) {
316         dbglog("length: %d", len);
317
318         GETCHAR(type, pckt);
319         GETCHAR(opt_len, pckt);
320         if (opt_len < 2 || opt_len > len)
321             break;
322
323         if (opt_len > 2)
324             GETCHAR(delay, pckt);
325
326         us->us_allowed |= (1 << type);
327
328         switch(type) {
329         case CB_CONF_NO:
330             dbglog("no callback allowed");
331             break;
332
333         case CB_CONF_USER:
334             dbglog("user callback allowed");
335             if (opt_len > 4) {
336                 GETCHAR(addr_type, pckt);
337                 memcpy(address, pckt, opt_len - 4);
338                 address[opt_len - 4] = 0;
339                 if (address[0])
340                     dbglog("address: %s", address);
341             }
342             break;
343
344         case CB_CONF_ADMIN:
345             dbglog("user admin defined allowed");
346             break;
347
348         case CB_CONF_LIST:
349             break;
350         }
351         len -= opt_len;
352     }
353     if (len != 0) {
354         if (debug)
355             dbglog("cbcp_recvreq: malformed packet (%d bytes left)", len);
356         return;
357     }
358
359     cbcp_resp(us);
360 }
361
362 static void
363 cbcp_resp(us)
364     cbcp_state *us;
365 {
366     u_char cb_type;
367     u_char buf[256];
368     u_char *bufp = buf;
369     int len = 0;
370     int slen;
371
372     cb_type = us->us_allowed & us->us_type;
373     dbglog("cbcp_resp cb_type=%d", cb_type);
374
375 #if 0
376     if (!cb_type)
377         lcp_down(us->us_unit);
378 #endif
379
380     if (cb_type & ( 1 << CB_CONF_USER ) ) {
381         dbglog("cbcp_resp CONF_USER");
382         slen = strlen(us->us_number);
383         if (slen > 250) {
384             warn("callback number truncated to 250 characters");
385             slen = 250;
386         }
387         PUTCHAR(CB_CONF_USER, bufp);
388         len = 3 + 1 + slen + 1;
389         PUTCHAR(len , bufp);
390         PUTCHAR(5, bufp); /* delay */
391         PUTCHAR(1, bufp);
392         BCOPY(us->us_number, bufp, slen + 1);
393         cbcp_send(us, CBCP_RESP, buf, len);
394         return;
395     }
396
397     if (cb_type & ( 1 << CB_CONF_ADMIN ) ) {
398         dbglog("cbcp_resp CONF_ADMIN");
399         PUTCHAR(CB_CONF_ADMIN, bufp);
400         len = 3;
401         PUTCHAR(len, bufp);
402         PUTCHAR(5, bufp); /* delay */
403         cbcp_send(us, CBCP_RESP, buf, len);
404         return;
405     }
406
407     if (cb_type & ( 1 << CB_CONF_NO ) ) {
408         dbglog("cbcp_resp CONF_NO");
409         PUTCHAR(CB_CONF_NO, bufp);
410         len = 2;
411         PUTCHAR(len , bufp);
412         cbcp_send(us, CBCP_RESP, buf, len);
413         start_networks(us->us_unit);
414         return;
415     }
416 }
417
418 static void
419 cbcp_send(us, code, buf, len)
420     cbcp_state *us;
421     int code;
422     u_char *buf;
423     int len;
424 {
425     u_char *outp;
426     int outlen;
427
428     outp = outpacket_buf;
429
430     outlen = 4 + len;
431     
432     MAKEHEADER(outp, PPP_CBCP);
433
434     PUTCHAR(code, outp);
435     PUTCHAR(us->us_id, outp);
436     PUTSHORT(outlen, outp);
437     
438     if (len)
439         BCOPY(buf, outp, len);
440
441     output(us->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
442 }
443
444 static void
445 cbcp_recvack(us, pckt, len)
446     cbcp_state *us;
447     u_char *pckt;
448     int len;
449 {
450     u_char type, delay, addr_type;
451     int opt_len;
452     char address[256];
453
454     if (len >= 2) {
455         GETCHAR(type, pckt);
456         GETCHAR(opt_len, pckt);
457         if (opt_len >= 2 && opt_len <= len) {
458      
459             if (opt_len > 2)
460                 GETCHAR(delay, pckt);
461
462             if (opt_len > 4) {
463                 GETCHAR(addr_type, pckt);
464                 memcpy(address, pckt, opt_len - 4);
465                 address[opt_len - 4] = 0;
466                 if (address[0])
467                     dbglog("peer will call: %s", address);
468             }
469             if (type == CB_CONF_NO)
470                 return;
471
472             cbcp_up(us);
473
474         } else if (debug)
475             dbglog("cbcp_recvack: malformed packet");
476     }
477 }
478
479 /* ok peer will do callback */
480 static void
481 cbcp_up(us)
482     cbcp_state *us;
483 {
484     persist = 0;
485     status = EXIT_CALLBACK;
486     lcp_close(0, "Call me back, please");
487 }