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 (at) 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.16 2004/10/28 00:15:36 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 lcp_close(0, "Call me back, please"); 487 status = EXIT_CALLBACK; 488 } 489
