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 }