1 /*
2  * cbcp - Call Back Configuration Protocol.
3  *
4  * Copyright (c) 2000 by Sun Microsystems, Inc.
5  * All rights reserved.
6  *
7  * Copyright (c) 1995 Pedro Roque Marques
8  * All rights reserved.
9  *
10  * Redistribution and use in source and binary forms are permitted
11  * provided that the above copyright notice and this paragraph are
12  * duplicated in all such forms and that any documentation,
13  * advertising materials, and other materials related to such
14  * distribution and use acknowledge that the software was developed
15  * by Pedro Roque Marques.  The name of the author may not be used to
16  * endorse or promote products derived from this software without
17  * specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
20  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
21  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22  */
23 
24 #include <stdio.h>
25 #include <string.h>
26 #include <sys/types.h>
27 #include <sys/time.h>
28 
29 #include "pppd.h"
30 #include "cbcp.h"
31 #include "fsm.h"
32 #include "lcp.h"
33 
34 /*
35  * Options.
36  */
37 static int setcbcp __P((char **, option_t *));
38 
39 static option_t cbcp_option_list[] = {
40     { "callback", o_special, (void *)setcbcp,
41       "Ask for callback" },
42     { NULL }
43 };
44 
45 /*
46  * Protocol entry points.
47  */
48 static void cbcp_init      __P((int unit));
49 static void cbcp_lowerup   __P((int unit));
50 static void cbcp_input     __P((int unit, u_char *pkt, int len));
51 static void cbcp_protrej   __P((int unit));
52 static int  cbcp_printpkt  __P((u_char *pkt, int len,
53     void (*printer) __P((void *, const char *, ...)),
54     void *arg));
55 
56 struct protent cbcp_protent = {
57     PPP_CBCP,			/* PPP protocol number */
58     cbcp_init,			/* Initialization procedure */
59     cbcp_input,			/* Process a received packet */
60     cbcp_protrej,		/* Process a received protocol-reject */
61     cbcp_lowerup,		/* Lower layer has come up */
62     NULL,			/* Lower layer has gone down */
63     NULL,			/* Open the protocol */
64     NULL,			/* Close the protocol */
65     cbcp_printpkt,		/* Print a packet in readable form */
66     NULL,			/* Process a received data packet */
67     0,				/* 0 iff protocol is disabled */
68     "CBCP",			/* Text name of protocol */
69     NULL,			/* Text name of corresponding data protocol */
70     cbcp_option_list,		/* List of command-line options */
71     NULL,			/* Check requested options, assign defaults */
72     NULL,			/* Configure interface for demand-dial */
73     NULL			/* Say whether to bring up link for this pkt */
74 };
75 
76 /* Not static'd for plug-ins */
77 cbcp_state cbcp[NUM_PPP];
78 
79 /* internal prototypes */
80 
81 static void cbcp_recvreq __P((cbcp_state *us, u_char *pckt, int len));
82 static void cbcp_recvack __P((cbcp_state *us, u_char *pckt, int len));
83 static void cbcp_send __P((cbcp_state *us, int code, u_char *buf, int len));
84 
85 /* option processing */
86 /*ARGSUSED*/
87 static int
88 setcbcp(argv, opt)
89     char **argv;
90     option_t *opt;
91 {
92     lcp_wantoptions[0].neg_cbcp = 1;
93     cbcp_protent.enabled_flag = 1;
94     cbcp[0].us_number = strdup(*argv);
95     if (cbcp[0].us_number == NULL)
96 	novm("callback number");
97     cbcp[0].us_type |= (1 << CB_CONF_USER);
98     cbcp[0].us_type |= (1 << CB_CONF_ADMIN);
99     return (1);
100 }
101 
102 /* init state */
103 static void
104 cbcp_init(unit)
105     int unit;
106 {
107     cbcp_state *us;
108 
109     us = &cbcp[unit];
110     BZERO(us, sizeof(cbcp_state));
111     us->us_unit = unit;
112     us->us_type |= (1 << CB_CONF_NO);
113 }
114 
115 /* lower layer is up */
116 static void
117 cbcp_lowerup(unit)
118     int unit;
119 {
120     cbcp_state *us = &cbcp[unit];
121 
122     if (debug) {
123 	dbglog("cbcp_lowerup: want: %d", us->us_type);
124 
125 	if (us->us_type == CB_CONF_USER)
126 	    dbglog("phone no: %s", us->us_number);
127     }
128 }
129 
130 /* process an incoming packet */
131 static void
132 cbcp_input(unit, inpacket, pktlen)
133     int unit;
134     u_char *inpacket;
135     int pktlen;
136 {
137     u_char *inp;
138     u_char code, id;
139     u_short len;
140 
141     cbcp_state *us = &cbcp[unit];
142 
143     inp = inpacket;
144 
145     if (pktlen < CBCP_MINLEN) {
146         error("CBCP packet is too small (%d < %d)", pktlen, CBCP_MINLEN);
147 	return;
148     }
149 
150     GETCHAR(code, inp);
151     GETCHAR(id, inp);
152     GETSHORT(len, inp);
153 
154     if (len > pktlen) {
155         error("CBCP packet: invalid length (%d > %d)", len, pktlen);
156         return;
157     }
158 
159     len -= CBCP_MINLEN;
160 
161     switch (code) {
162     case CBCP_REQ:
163         us->us_id = id;
164 	cbcp_recvreq(us, inp, len);
165 	break;
166 
167     case CBCP_RESP:
168 	if (debug)
169 	    dbglog("CBCP Response received; no request sent");
170 	break;
171 
172     case CBCP_ACK:
173 	if (id != us->us_id) {
174 	    if (debug)
175 		dbglog("CBCP Ack ID %d doesn't match expected %d", id,
176 		    us->us_id);
177 	    break;
178 	}
179 
180 	cbcp_recvack(us, inp, len);
181 	break;
182 
183     default:
184 	if (debug)
185 	    dbglog("Unknown CBCP code number %d", code);
186 	break;
187     }
188 }
189 
190 /* protocol was rejected by foe */
191 /*ARGSUSED*/
192 static void
193 cbcp_protrej(int unit)
194 {
195     start_networks();
196 }
197 
198 static char *cbcp_codenames[] = {
199     "Request", "Response", "Ack"
200 };
201 
202 static char *cbcp_optionnames[] = {
203     "NoCallback",
204     "UserDefined",
205     "AdminDefined",
206     "List"
207 };
208 
209 /*
210  * Pretty print a packet.  Return value is number of bytes parsed out
211  * of the packet and printed in some way.  Caller (in util.c) will
212  * print the remainder of the packet.
213  */
214 static int
215 cbcp_printpkt(p, plen, printer, arg)
216     u_char *p;
217     int plen;
218     void (*printer) __P((void *, const char *, ...));
219     void *arg;
220 {
221     int code, id, len, olen, alen;
222     u_char *pstart, cichar;
223 
224     if (plen < HEADERLEN) {
225 	printer(arg, "too short (%d<%d)", plen, HEADERLEN);
226 	return (0);
227     }
228     pstart = p;
229     GETCHAR(code, p);
230     GETCHAR(id, p);
231     GETSHORT(len, p);
232 
233     if (code >= 1 && code <= Dim(cbcp_codenames))
234 	printer(arg, " %s", cbcp_codenames[code-1]);
235     else
236 	printer(arg, " code=0x%x", code);
237 
238     printer(arg, " id=0x%x", id);
239 
240     if (len < HEADERLEN) {
241 	printer(arg, " header length %d<%d", len, HEADERLEN);
242 	return (HEADERLEN);
243     }
244     if (len > plen) {
245 	printer(arg, " truncated (%d>%d)", len, plen);
246 	len = plen;
247     }
248     len -= HEADERLEN;
249 
250     switch (code) {
251     case CBCP_REQ:
252     case CBCP_RESP:
253     case CBCP_ACK:
254         while (len >= 2) {
255 	    GETCHAR(cichar, p);
256 	    GETCHAR(olen, p);
257 
258 	    if (olen < 2)
259 		break;
260 
261 	    printer(arg, " <");
262 
263 	    if (olen > len) {
264 		printer(arg, "trunc[%d>%d] ", olen, len);
265 	        olen = len;
266 	    }
267 	    len -= olen;
268 	    olen -= 2;
269 
270 	    if (cichar >= 1 && cichar <= Dim(cbcp_optionnames))
271 	    	printer(arg, " %s", cbcp_optionnames[cichar-1]);
272 	    else
273 	        printer(arg, " option=0x%x", cichar);
274 
275 	    if (olen > 0) {
276 	        GETCHAR(cichar, p);
277 		olen--;
278 		printer(arg, " delay=%d", cichar);
279 	    }
280 
281 	    while (olen > 0) {
282 		GETCHAR(cichar, p);
283 		olen--;
284 		if (cichar != 1)
285 		    printer(arg, " (type %d?)", cichar);
286 		alen = strllen((const char *)p, olen);
287 		if (olen > 0 && alen > 0)
288 		    printer(arg, " '%.*s'", alen, p);
289 		else
290 		    printer(arg, " null");
291 		p += alen + 1;
292 		olen -= alen + 1;
293 	    }
294 	    printer(arg, ">");
295 	}
296 
297     default:
298 	break;
299     }
300 
301     if (len > 0) {
302 	if (len > 8)
303 	    printer(arg, "%8B ...", p);
304 	else
305 	    printer(arg, "%.*B", len, p);
306     }
307     p += len;
308 
309     return p - pstart;
310 }
311 
312 /*
313  * received CBCP request.
314  * No reason to print packet contents in detail here, since enabling
315  * debug mode will cause the print routine above to be invoked.
316  */
317 static void
318 cbcp_recvreq(us, pckt, pcktlen)
319     cbcp_state *us;
320     u_char *pckt;
321     int pcktlen;
322 {
323     u_char type, opt_len;
324     int len = pcktlen;
325     u_char cb_type;
326     u_char buf[256];
327     u_char *bufp = buf;
328 
329     us->us_allowed = 0;
330     while (len > 0) {
331 	GETCHAR(type, pckt);
332 	GETCHAR(opt_len, pckt);
333 
334 	if (opt_len > 2) {
335 	    pckt++;	/* ignore the delay time */
336 	}
337 
338 	len -= opt_len;
339 
340 	/*
341 	 * Careful; don't use left-shift operator on numbers that are
342 	 * too big.
343 	 */
344 	if (type > CB_CONF_LIST) {
345 	    if (debug)
346 		dbglog("CBCP: ignoring unknown type %d", type);
347 	    continue;
348 	}
349 
350 	us->us_allowed |= (1 << type);
351 
352 	switch (type) {
353 	case CB_CONF_NO:
354 	    if (debug)
355 		dbglog("CBCP: operation without callback allowed");
356 	    break;
357 
358 	case CB_CONF_USER:
359 	    if (debug)
360 		dbglog("callback to user-specified number allowed");
361 	    break;
362 
363 	case CB_CONF_ADMIN:
364 	    if (debug)
365 		dbglog("CBCP: callback to admin-defined address allowed");
366 	    break;
367 
368 	case CB_CONF_LIST:
369 	    if (debug)
370 		dbglog("CBCP: callback to one out of list allowed");
371 	    break;
372 	}
373     }
374 
375     /* Now generate the response */
376     len = 0;
377     cb_type = us->us_allowed & us->us_type;
378 
379     if (cb_type & ( 1 << CB_CONF_USER ) ) {
380 	if (debug)
381 	    dbglog("CBCP Response: selecting user-specified number");
382 	PUTCHAR(CB_CONF_USER, bufp);
383 	len = 3 + 1 + strlen(us->us_number) + 1;
384 	PUTCHAR(len , bufp);
385 	PUTCHAR(5, bufp); /* delay */
386 	PUTCHAR(1, bufp);
387 	BCOPY(us->us_number, bufp, strlen(us->us_number) + 1);
388 	cbcp_send(us, CBCP_RESP, buf, len);
389 	return;
390     }
391 
392     if (cb_type & ( 1 << CB_CONF_ADMIN ) ) {
393 	if (debug)
394 	    dbglog("CBCP Response: selecting admin-specified number");
395         PUTCHAR(CB_CONF_ADMIN, bufp);
396 	len = 3;
397 	PUTCHAR(len, bufp);
398 	PUTCHAR(5, bufp); /* delay */
399 	cbcp_send(us, CBCP_RESP, buf, len);
400 	return;
401     }
402 
403     if (cb_type & ( 1 << CB_CONF_NO ) ) {
404 	if (debug)
405 	    dbglog("CBCP Response: selecting no-callback mode");
406 	PUTCHAR(CB_CONF_NO, bufp);
407 	len = 3;
408 	PUTCHAR(len , bufp);
409 	PUTCHAR(0, bufp);
410 	cbcp_send(us, CBCP_RESP, buf, len);
411 	start_networks();
412 	return;
413     }
414 
415     if (debug)
416 	dbglog("CBCP:  no callback types in common");
417     lcp_close(us->us_unit, "No CBCP callback options available");
418 }
419 
420 static void
421 cbcp_send(us, code, buf, len)
422     cbcp_state *us;
423     int code;
424     u_char *buf;
425     int len;
426 {
427     u_char *outp;
428     int outlen;
429 
430     outp = outpacket_buf;
431 
432     outlen = 4 + len;
433 
434     MAKEHEADER(outp, PPP_CBCP);
435 
436     PUTCHAR(code, outp);
437     PUTCHAR(us->us_id, outp);
438     PUTSHORT(outlen, outp);
439 
440     if (len > 0)
441         BCOPY(buf, outp, len);
442 
443     output(us->us_unit, outpacket_buf, outlen + PPP_HDRLEN);
444 }
445 
446 /*
447  * Received CBCP Acknowledgment message.
448  */
449 static void
450 cbcp_recvack(us, pckt, len)
451     cbcp_state *us;
452     u_char *pckt;
453     int len;
454 {
455     u_char type, addr_type;
456     int opt_len;
457 
458     if (len > 0) {
459         GETCHAR(type, pckt);
460 	GETCHAR(opt_len, pckt);
461 
462 	if (type == CB_CONF_NO) {
463 	    if (debug)
464 		dbglog("CBCP: proceeding without callback");
465 	    return;
466 	}
467 
468 	/* just ignore the delay time */
469 	pckt++;
470 
471 	if (opt_len > 4) {
472 	    GETCHAR(addr_type, pckt);
473 	    if (addr_type != 1)
474 		warn("CBCP: unknown callback address type %d", addr_type);
475 	}
476 	if (debug && opt_len > 5)
477 	    dbglog("CBCP: peer will call %.*s", pckt, opt_len - 4);
478     }
479 
480     persist = 0;
481     lcp_close(us->us_unit, "Call me back, please");
482     status = EXIT_CALLBACK;
483 }
484