usr.sbin/bluetooth/rfcomm_pppd/rfcomm_pppd.c

   1 /*
   2  * rfcomm_pppd.c
   3  */
   4
   5 /*-
   6  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   7  *
   8  * Copyright (c) 2001-2008 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  * $Id: rfcomm_pppd.c,v 1.5 2003/09/07 18:32:11 max Exp $
  33  * $FreeBSD$
  34  */
  35 #define L2CAP_SOCKET_CHECKED
  36 #include <bluetooth.h>
  37 #include <ctype.h>
  38 #include <err.h>
  39 #include <errno.h>
  40 #include <fcntl.h>
  41 #include <sdp.h>
  42 #include <signal.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <syslog.h>
  48 #include <unistd.h>
  49
  50 #define RFCOMM_PPPD     "rfcomm_pppd"
  51
  52 int             rfcomm_channel_lookup   (bdaddr_t const *local,
  53                                          bdaddr_t const *remote,
  54                                          int service, int *channel, int *error);
  55
  56 static void     exec_ppp        (int s, char *unit, char *label);
  57 static void     sighandler      (int s);
  58 static void     usage           (void);
  59
  60 static int      done;
  61
  62 /* Main */
  63 int
  64 main(int argc, char *argv[])
  65 {
  66         struct sockaddr_rfcomm   sock_addr;
  67         char                    *label = NULL, *unit = NULL, *ep = NULL;
  68         bdaddr_t                 addr;
  69         int                      s, channel, detach, server, service,
  70                                  regdun, regsp;
  71         pid_t                    pid;
  72
  73         memcpy(&addr, NG_HCI_BDADDR_ANY, sizeof(addr));
  74         channel = 0;
  75         detach = 1;
  76         server = 0;
  77         service = 0;
  78         regdun = 0;
  79         regsp = 0;
  80
  81         /* Parse command line arguments */
  82         while ((s = getopt(argc, argv, "a:cC:dDhl:sSu:")) != -1) {
  83                 switch (s) {
  84                 case 'a': /* BDADDR */
  85                         if (!bt_aton(optarg, &addr)) {
  86                                 struct hostent  *he = NULL;
  87
  88                                 if ((he = bt_gethostbyname(optarg)) == NULL)
  89                                         errx(1, "%s: %s", optarg, hstrerror(h_errno));
  90
  91                                 memcpy(&addr, he->h_addr, sizeof(addr));
  92                         }
  93                         break;
  94
  95                 case 'c': /* client */
  96                         server = 0;
  97                         break;
  98
  99                 case 'C': /* RFCOMM channel */
 100                         channel = strtoul(optarg, &ep, 10);
 101                         if (*ep != '\0') {
 102                                 channel = 0;
 103                                 switch (tolower(optarg[0])) {
 104                                 case 'd': /* DialUp Networking */
 105                                         service = SDP_SERVICE_CLASS_DIALUP_NETWORKING;
 106                                         break;
 107
 108                                 case 'l': /* LAN Access Using PPP */
 109                                         service = SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP;
 110                                         break;
 111                                 }
 112                         }
 113                         break;
 114
 115                 case 'd': /* do not detach */
 116                         detach = 0;
 117                         break;
 118
 119                 case 'D': /* Register DUN service as well as LAN service */
 120                         regdun = 1;
 121                         break;
 122
 123                 case 'l': /* PPP label */
 124                         label = optarg;
 125                         break;
 126
 127                 case 's': /* server */
 128                         server = 1;
 129                         break;
 130
 131                 case 'S': /* Register SP service as well as LAN service */
 132                         regsp = 1;
 133                         break;
 134
 135                 case 'u': /* PPP -unit option */
 136                         strtoul(optarg, &ep, 10);
 137                         if (*ep != '\0')
 138                                 usage();
 139                                 /* NOT REACHED */
 140
 141                         unit = optarg;
 142                         break;
 143
 144                 case 'h':
 145                 default:
 146                         usage();
 147                         /* NOT REACHED */
 148                 }
 149         }
 150
 151         /* Check if we got everything we wanted */
 152         if (label == NULL)
 153                 errx(1, "Must specify PPP label");
 154
 155         if (!server) {
 156                 if (memcmp(&addr, NG_HCI_BDADDR_ANY, sizeof(addr)) == 0)
 157                         errx(1, "Must specify server BD_ADDR");
 158
 159                 /* Check channel, if was not set then obtain it via SDP */
 160                 if (channel == 0 && service != 0)
 161                         if (rfcomm_channel_lookup(NULL, &addr, service,
 162                                                         &channel, &s) != 0)
 163                                 errc(1, s, "Could not obtain RFCOMM channel");
 164         }
 165
 166         if (channel <= 0 || channel > 30)
 167                 errx(1, "Invalid RFCOMM channel number %d", channel);
 168
 169         openlog(RFCOMM_PPPD, LOG_PID | LOG_PERROR | LOG_NDELAY, LOG_USER);
 170
 171         if (detach && daemon(0, 0) < 0) {
 172                 syslog(LOG_ERR, "Could not daemon(0, 0). %s (%d)",
 173                         strerror(errno), errno);
 174                 exit(1);
 175         }
 176
 177         s = socket(PF_BLUETOOTH, SOCK_STREAM, BLUETOOTH_PROTO_RFCOMM);
 178         if (s < 0) {
 179                 syslog(LOG_ERR, "Could not create socket. %s (%d)",
 180                         strerror(errno), errno);
 181                 exit(1);
 182         }
 183
 184         if (server) {
 185                 struct sigaction         sa;
 186                 void                    *ss = NULL;
 187                 sdp_lan_profile_t        lan;
 188
 189                 /* Install signal handler */
 190                 memset(&sa, 0, sizeof(sa));
 191                 sa.sa_handler = sighandler;
 192
 193                 if (sigaction(SIGTERM, &sa, NULL) < 0) {
 194                         syslog(LOG_ERR, "Could not sigaction(SIGTERM). %s (%d)",
 195                                 strerror(errno), errno);
 196                         exit(1);
 197                 }
 198
 199                 if (sigaction(SIGHUP, &sa, NULL) < 0) {
 200                         syslog(LOG_ERR, "Could not sigaction(SIGHUP). %s (%d)",
 201                                 strerror(errno), errno);
 202                         exit(1);
 203                 }
 204
 205                 if (sigaction(SIGINT, &sa, NULL) < 0) {
 206                         syslog(LOG_ERR, "Could not sigaction(SIGINT). %s (%d)",
 207                                 strerror(errno), errno);
 208                         exit(1);
 209                 }
 210
 211                 sa.sa_handler = SIG_IGN;
 212                 sa.sa_flags = SA_NOCLDWAIT;
 213
 214                 if (sigaction(SIGCHLD, &sa, NULL) < 0) {
 215                         syslog(LOG_ERR, "Could not sigaction(SIGCHLD). %s (%d)",
 216                                 strerror(errno), errno);
 217                         exit(1);
 218                 }
 219
 220                 /* bind socket and listen for incoming connections */
 221                 sock_addr.rfcomm_len = sizeof(sock_addr);
 222                 sock_addr.rfcomm_family = AF_BLUETOOTH;
 223                 memcpy(&sock_addr.rfcomm_bdaddr, &addr,
 224                         sizeof(sock_addr.rfcomm_bdaddr));
 225                 sock_addr.rfcomm_channel = channel;
 226
 227                 if (bind(s, (struct sockaddr *) &sock_addr,
 228                                 sizeof(sock_addr)) < 0) {
 229                         syslog(LOG_ERR, "Could not bind socket. %s (%d)",
 230                                 strerror(errno), errno);
 231                         exit(1);
 232                 }
 233
 234                 if (listen(s, 10) < 0) {
 235                         syslog(LOG_ERR, "Could not listen on socket. %s (%d)",
 236                                 strerror(errno), errno);
 237                         exit(1);
 238                 }
 239
 240                 ss = sdp_open_local(NULL);
 241                 if (ss == NULL) {
 242                         syslog(LOG_ERR, "Unable to create local SDP session");
 243                         exit(1);
 244                 }
 245
 246                 if (sdp_error(ss) != 0) {
 247                         syslog(LOG_ERR, "Unable to open local SDP session. " \
 248                                 "%s (%d)", strerror(sdp_error(ss)),
 249                                 sdp_error(ss));
 250                         exit(1);
 251                 }
 252
 253                 memset(&lan, 0, sizeof(lan));
 254                 lan.server_channel = channel;
 255
 256                 if (sdp_register_service(ss,
 257                                 SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP,
 258                                 &addr, (void *) &lan, sizeof(lan), NULL) != 0) {
 259                         syslog(LOG_ERR, "Unable to register LAN service with " \
 260                                 "local SDP daemon. %s (%d)",
 261                                 strerror(sdp_error(ss)), sdp_error(ss));
 262                         exit(1);
 263                 }
 264
 265                 /*
 266                  * Register DUN (Dial-Up Networking) service on the same
 267                  * RFCOMM channel if requested. There is really no good reason
 268                  * to not to support this. AT-command exchange can be faked
 269                  * with chat script in ppp.conf
 270                  */
 271
 272                 if (regdun) {
 273                         sdp_dun_profile_t       dun;
 274
 275                         memset(&dun, 0, sizeof(dun));
 276                         dun.server_channel = channel;
 277
 278                         if (sdp_register_service(ss,
 279                                         SDP_SERVICE_CLASS_DIALUP_NETWORKING,
 280                                         &addr, (void *) &dun, sizeof(dun),
 281                                         NULL) != 0) {
 282                                 syslog(LOG_ERR, "Unable to register DUN " \
 283                                         "service with local SDP daemon. " \
 284                                         "%s (%d)", strerror(sdp_error(ss)),
 285                                         sdp_error(ss));
 286                                 exit(1);
 287                         }
 288                 }
 289
 290                 /*
 291                  * Register SP (Serial Port) service on the same RFCOMM channel
 292                  * if requested. It appears that some cell phones are using so
 293                  * called "callback mechanism". In this scenario user is trying
 294                  * to connect his cell phone to the Internet, and, user's host
 295                  * computer is acting as the gateway server. It seems that it
 296                  * is not possible to tell the phone to just connect and start
 297                  * using the LAN service. Instead the user's host computer must
 298                  * "jump start" the phone by connecting to the phone's SP
 299                  * service. What happens next is the phone kills the existing
 300                  * connection and opens another connection back to the user's
 301                  * host computer. The phone really wants to use LAN service,
 302                  * but for whatever reason it looks for SP service on the
 303                  * user's host computer. This brain damaged behavior was
 304                  * reported for Nokia 6600 and Sony/Ericsson P900. Both phones
 305                  * are Symbian-based phones. Perhaps this is a Symbian problem?
 306                  */
 307
 308                 if (regsp) {
 309                         sdp_sp_profile_t        sp;
 310
 311                         memset(&sp, 0, sizeof(sp));
 312                         sp.server_channel = channel;
 313
 314                         if (sdp_register_service(ss,
 315                                         SDP_SERVICE_CLASS_SERIAL_PORT,
 316                                         &addr, (void *) &sp, sizeof(sp),
 317                                         NULL) != 0) {
 318                                 syslog(LOG_ERR, "Unable to register SP " \
 319                                         "service with local SDP daemon. " \
 320                                         "%s (%d)", strerror(sdp_error(ss)),
 321                                         sdp_error(ss));
 322                                 exit(1);
 323                         }
 324                 }
 325
 326                 for (done = 0; !done; ) {
 327                         socklen_t       len = sizeof(sock_addr);
 328                         int             s1 = accept(s, (struct sockaddr *) &sock_addr, &len);
 329
 330                         if (s1 < 0) {
 331                                 syslog(LOG_ERR, "Could not accept connection " \
 332                                         "on socket. %s (%d)", strerror(errno),
 333                                         errno);
 334                                 exit(1);
 335                         }
 336
 337                         pid = fork();
 338                         if (pid == (pid_t) -1) {
 339                                 syslog(LOG_ERR, "Could not fork(). %s (%d)",
 340                                         strerror(errno), errno);
 341                                 exit(1);
 342                         }
 343
 344                         if (pid == 0) {
 345                                 sdp_close(ss);
 346                                 close(s);
 347
 348                                 /* Reset signal handler */
 349                                 memset(&sa, 0, sizeof(sa));
 350                                 sa.sa_handler = SIG_DFL;
 351
 352                                 sigaction(SIGTERM, &sa, NULL);
 353                                 sigaction(SIGHUP, &sa, NULL);
 354                                 sigaction(SIGINT, &sa, NULL);
 355                                 sigaction(SIGCHLD, &sa, NULL);
 356
 357                                 /* Become daemon */
 358                                 daemon(0, 0);
 359
 360                                 /*
 361                                  * XXX Make sure user does not shoot himself
 362                                  * in the foot. Do not pass unit option to the
 363                                  * PPP when operating in the server mode.
 364                                  */
 365
 366                                 exec_ppp(s1, NULL, label);
 367                         } else
 368                                 close(s1);
 369                 }
 370         } else {
 371                 sock_addr.rfcomm_len = sizeof(sock_addr);
 372                 sock_addr.rfcomm_family = AF_BLUETOOTH;
 373                 memcpy(&sock_addr.rfcomm_bdaddr, NG_HCI_BDADDR_ANY,
 374                         sizeof(sock_addr.rfcomm_bdaddr));
 375                 sock_addr.rfcomm_channel = 0;
 376
 377                 if (bind(s, (struct sockaddr *) &sock_addr,
 378                                 sizeof(sock_addr)) < 0) {
 379                         syslog(LOG_ERR, "Could not bind socket. %s (%d)",
 380                                 strerror(errno), errno);
 381                         exit(1);
 382                 }
 383
 384                 memcpy(&sock_addr.rfcomm_bdaddr, &addr,
 385                         sizeof(sock_addr.rfcomm_bdaddr));
 386                 sock_addr.rfcomm_channel = channel;
 387
 388                 if (connect(s, (struct sockaddr *) &sock_addr,
 389                                 sizeof(sock_addr)) < 0) {
 390                         syslog(LOG_ERR, "Could not connect socket. %s (%d)",
 391                                 strerror(errno), errno);
 392                         exit(1);
 393                 }
 394
 395                 exec_ppp(s, unit, label);
 396         }
 397
 398         exit(0);
 399 } /* main */
 400
 401 /*
 402  * Redirects stdin/stdout to s, stderr to /dev/null and exec
 403  * 'ppp -direct -quiet [-unit N] label'. Never returns.
 404  */
 405
 406 static void
 407 exec_ppp(int s, char *unit, char *label)
 408 {
 409         char     ppp[] = "/usr/sbin/ppp";
 410         char    *ppp_args[] = { ppp,  "-direct", "-quiet",
 411                                 NULL, NULL,      NULL,     NULL };
 412
 413         close(0);
 414         if (dup(s) < 0) {
 415                 syslog(LOG_ERR, "Could not dup(0). %s (%d)",
 416                         strerror(errno), errno);
 417                 exit(1);
 418         }
 419
 420         close(1);
 421         if (dup(s) < 0) {
 422                 syslog(LOG_ERR, "Could not dup(1). %s (%d)",
 423                         strerror(errno), errno);
 424                 exit(1);
 425         }
 426
 427         close(2);
 428         open("/dev/null", O_RDWR);
 429
 430         if (unit != NULL) {
 431                 ppp_args[3] = "-unit";
 432                 ppp_args[4] = unit;
 433                 ppp_args[5] = label;
 434         } else
 435                 ppp_args[3] = label;
 436
 437         if (execv(ppp, ppp_args) < 0) {
 438                 syslog(LOG_ERR, "Could not exec(%s -direct -quiet%s%s %s). " \
 439                         "%s (%d)", ppp, (unit != NULL)? " -unit " : "",
 440                         (unit != NULL)? unit : "", label,
 441                         strerror(errno), errno);
 442                 exit(1);
 443         }
 444 } /* run_ppp */
 445
 446 /* Signal handler */
 447 static void
 448 sighandler(int s)
 449 {
 450         done = 1;
 451 } /* sighandler */
 452
 453 /* Display usage and exit */
 454 static void
 455 usage(void)
 456 {
 457         fprintf(stdout,
 458 "Usage: %s options\n" \
 459 "Where options are:\n" \
 460 "\t-a address   Address to listen on or connect to (required for client)\n" \
 461 "\t-c           Act as a clinet (default)\n" \
 462 "\t-C channel   RFCOMM channel to listen on or connect to (required)\n" \
 463 "\t-d           Run in foreground\n" \
 464 "\t-D           Register Dial-Up Networking service (server mode only)\n" \
 465 "\t-l label     Use PPP label (required)\n" \
 466 "\t-s           Act as a server\n" \
 467 "\t-S           Register Serial Port service (server mode only)\n" \
 468 "\t-u N         Tell PPP to operate on /dev/tunN (client mode only)\n" \
 469 "\t-h           Display this message\n", RFCOMM_PPPD);
 470
 471         exit(255);
 472 } /* usage */
 473