Home | History | Annotate | Download | only in mtpd 
      1 /*
      2  * Copyright (C) 2009 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <stdio.h>
     18 #include <stdlib.h>
     19 #include <stdarg.h>
     20 #include <string.h>
     21 #include <errno.h>
     22 #include <sys/types.h>
     23 #include <sys/socket.h>
     24 #include <sys/poll.h>
     25 #include <sys/wait.h>
     26 #include <netdb.h>
     27 #include <signal.h>
     28 #include <unistd.h>
     29 #include <fcntl.h>
     30 #include <time.h>
     31 
     32 #ifdef ANDROID_CHANGES
     33 #include <android/log.h>
     34 #include <cutils/sockets.h>
     35 #endif
     36 
     37 #include "mtpd.h"
     38 
     39 int the_socket = -1;
     40 
     41 extern struct protocol l2tp;
     42 extern struct protocol pptp;
     43 static struct protocol *protocols[] = {&l2tp, &pptp, NULL};
     44 static struct protocol *the_protocol;
     45 
     46 static char *interface;
     47 static int pppd_argc;
     48 static char **pppd_argv;
     49 static pid_t pppd_pid;
     50 
     51 /* We redirect signals to a pipe in order to prevent race conditions. */
     52 static int signals[2];
     53 
     54 static void interrupt(int signal)
     55 {
     56     write(signals[1], &signal, sizeof(int));
     57 }
     58 
     59 static int initialize(int argc, char **argv)
     60 {
     61     int i;
     62 
     63     for (i = 0; protocols[i]; ++i) {
     64         struct protocol *p = protocols[i];
     65         if (argc - 3 >= p->arguments && !strcmp(argv[2], p->name)) {
     66             log_print(INFO, "Using protocol %s", p->name);
     67             the_protocol = p;
     68             break;
     69         }
     70     }
     71 
     72     if (!the_protocol) {
     73         printf("Usages:\n");
     74         for (i = 0; protocols[i]; ++i) {
     75             struct protocol *p = protocols[i];
     76             printf("  %s interface %s %s pppd-arguments\n",
     77                     argv[0], p->name, p->usage);
     78         }
     79         exit(0);
     80     }
     81 
     82     interface = argv[1];
     83     pppd_argc = argc - 3 - the_protocol->arguments;
     84     pppd_argv = &argv[3 + the_protocol->arguments];
     85     return the_protocol->connect(&argv[3]);
     86 }
     87 
     88 static void stop_pppd()
     89 {
     90     if (pppd_pid) {
     91         int status;
     92         log_print(INFO, "Sending signal to pppd (pid = %d)", pppd_pid);
     93         kill(pppd_pid, SIGTERM);
     94         waitpid(pppd_pid, &status, 0);
     95         pppd_pid = 0;
     96     }
     97 }
     98 
     99 #ifdef ANDROID_CHANGES
    100 
    101 static int android_get_control_and_arguments(int *argc, char ***argv)
    102 {
    103     static char *args[32];
    104     int control;
    105     int i;
    106 
    107     if ((i = android_get_control_socket("mtpd")) == -1) {
    108         return -1;
    109     }
    110     log_print(DEBUG, "Waiting for control socket");
    111     if (listen(i, 1) == -1 || (control = accept(i, NULL, 0)) == -1) {
    112         log_print(FATAL, "Cannot get control socket");
    113         exit(SYSTEM_ERROR);
    114     }
    115     close(i);
    116     fcntl(control, F_SETFD, FD_CLOEXEC);
    117 
    118     args[0] = (*argv)[0];
    119     for (i = 1; i < 32; ++i) {
    120         unsigned char bytes[2];
    121         if (recv(control, &bytes[0], 1, 0) != 1 ||
    122                 recv(control, &bytes[1], 1, 0) != 1) {
    123             log_print(FATAL, "Cannot get argument length");
    124             exit(SYSTEM_ERROR);
    125         } else {
    126             int length = bytes[0] << 8 | bytes[1];
    127             int offset = 0;
    128 
    129             if (length == 0xFFFF) {
    130                 break;
    131             }
    132             args[i] = malloc(length + 1);
    133             while (offset < length) {
    134                 int n = recv(control, &args[i][offset], length - offset, 0);
    135                 if (n > 0) {
    136                     offset += n;
    137                 } else {
    138                     log_print(FATAL, "Cannot get argument value");
    139                     exit(SYSTEM_ERROR);
    140                 }
    141             }
    142             args[i][length] = 0;
    143         }
    144     }
    145     log_print(DEBUG, "Received %d arguments", i - 1);
    146 
    147     *argc = i;
    148     *argv = args;
    149     return control;
    150 }
    151 
    152 #endif
    153 
    154 int main(int argc, char **argv)
    155 {
    156     struct pollfd pollfds[3];
    157     int control = -1;
    158     int timeout;
    159     int status;
    160 
    161 #ifdef ANDROID_CHANGES
    162     control = android_get_control_and_arguments(&argc, &argv);
    163     shutdown(control, SHUT_WR);
    164 #endif
    165 
    166     srandom(time(NULL));
    167 
    168     if (pipe(signals) == -1) {
    169         log_print(FATAL, "Pipe() %s", strerror(errno));
    170         exit(SYSTEM_ERROR);
    171     }
    172     fcntl(signals[0], F_SETFD, FD_CLOEXEC);
    173     fcntl(signals[1], F_SETFD, FD_CLOEXEC);
    174 
    175     timeout = initialize(argc, argv);
    176 
    177     signal(SIGHUP, interrupt);
    178     signal(SIGINT, interrupt);
    179     signal(SIGTERM, interrupt);
    180     signal(SIGCHLD, interrupt);
    181     signal(SIGPIPE, SIG_IGN);
    182     atexit(stop_pppd);
    183 
    184     pollfds[0].fd = the_socket;
    185     pollfds[0].events = POLLIN;
    186     pollfds[1].fd = signals[0];
    187     pollfds[1].events = POLLIN;
    188     pollfds[2].fd = control;
    189     pollfds[2].events = 0;
    190 
    191     while (timeout >= 0) {
    192         if (poll(pollfds, 3, timeout ? timeout : -1) == -1 && errno != EINTR) {
    193             log_print(FATAL, "Poll() %s", strerror(errno));
    194             exit(SYSTEM_ERROR);
    195         }
    196         if (pollfds[1].revents) {
    197             break;
    198         }
    199         if (pollfds[2].revents) {
    200             interrupt(SIGTERM);
    201         }
    202         timeout = pollfds[0].revents ?
    203                 the_protocol->process() : the_protocol->timeout();
    204 #ifdef ANDROID_CHANGES
    205         if (!access("/data/misc/vpn/abort", F_OK)) {
    206             interrupt(SIGTERM);
    207         }
    208         if (!timeout) {
    209             timeout = 5000;
    210         }
    211 #endif
    212     }
    213 
    214     if (timeout < 0) {
    215         status = -timeout;
    216     } else {
    217         int signal;
    218         read(signals[0], &signal, sizeof(int));
    219         log_print(INFO, "Received signal %d", signal);
    220         if (signal == SIGCHLD && waitpid(pppd_pid, &status, WNOHANG) == pppd_pid
    221                 && WIFEXITED(status)) {
    222             status = WEXITSTATUS(status);
    223             log_print(INFO, "Pppd is terminated (status = %d)", status);
    224             status += PPPD_EXITED;
    225             pppd_pid = 0;
    226         } else {
    227             status = USER_REQUESTED;
    228         }
    229     }
    230 
    231     stop_pppd();
    232     the_protocol->shutdown();
    233     log_print(INFO, "Mtpd is terminated (status = %d)", status);
    234     return status;
    235 }
    236 
    237 void log_print(int level, char *format, ...)
    238 {
    239     if (level >= 0 && level <= LOG_MAX) {
    240 #ifdef ANDROID_CHANGES
    241         static int levels[5] = {
    242             ANDROID_LOG_DEBUG, ANDROID_LOG_INFO, ANDROID_LOG_WARN,
    243             ANDROID_LOG_ERROR, ANDROID_LOG_FATAL
    244         };
    245         va_list ap;
    246         va_start(ap, format);
    247         __android_log_vprint(levels[level], "mtpd", format, ap);
    248         va_end(ap);
    249 #else
    250         static char *levels = "DIWEF";
    251         va_list ap;
    252         fprintf(stderr, "%c: ", levels[level]);
    253         va_start(ap, format);
    254         vfprintf(stderr, format, ap);
    255         va_end(ap);
    256         fputc('\n', stderr);
    257 #endif
    258     }
    259 }
    260 
    261 void create_socket(int family, int type, char *server, char *port)
    262 {
    263     struct addrinfo hints = {
    264         .ai_flags = AI_NUMERICSERV,
    265         .ai_family = family,
    266         .ai_socktype = type,
    267     };
    268     struct addrinfo *records;
    269     struct addrinfo *r;
    270     int error;
    271 
    272     log_print(INFO, "Connecting to %s port %s via %s", server, port, interface);
    273 
    274     error = getaddrinfo(server, port, &hints, &records);
    275     if (error) {
    276         log_print(FATAL, "Getaddrinfo() %s", (error == EAI_SYSTEM) ?
    277                 strerror(errno) : gai_strerror(error));
    278         exit(NETWORK_ERROR);
    279     }
    280 
    281     for (r = records; r; r = r->ai_next) {
    282         int s = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
    283         if (!setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, interface,
    284                 strlen(interface)) && !connect(s, r->ai_addr, r->ai_addrlen)) {
    285             the_socket = s;
    286             break;
    287         }
    288         close(s);
    289     }
    290 
    291     freeaddrinfo(records);
    292 
    293     if (the_socket == -1) {
    294         log_print(FATAL, "Connect() %s", strerror(errno));
    295         exit(NETWORK_ERROR);
    296     }
    297 
    298     fcntl(the_socket, F_SETFD, FD_CLOEXEC);
    299     log_print(INFO, "Connection established (socket = %d)", the_socket);
    300 }
    301 
    302 void start_pppd(int pppox)
    303 {
    304     if (pppd_pid) {
    305         log_print(WARNING, "Pppd is already started (pid = %d)", pppd_pid);
    306         close(pppox);
    307         return;
    308     }
    309 
    310     log_print(INFO, "Starting pppd (pppox = %d)", pppox);
    311 
    312     pppd_pid = fork();
    313     if (pppd_pid < 0) {
    314         log_print(FATAL, "Fork() %s", strerror(errno));
    315         exit(SYSTEM_ERROR);
    316     }
    317 
    318     if (!pppd_pid) {
    319         char *args[pppd_argc + 5];
    320         char number[12];
    321 
    322         sprintf(number, "%d", pppox);
    323         args[0] = "pppd";
    324         args[1] = "nodetach";
    325         args[2] = "pppox";
    326         args[3] = number;
    327         memcpy(&args[4], pppd_argv, sizeof(char *) * pppd_argc);
    328         args[4 + pppd_argc] = NULL;
    329 
    330 #ifdef ANDROID_CHANGES
    331         {
    332             char envargs[65536];
    333             char *tail = envargs;
    334             int i;
    335             /* Hex encode the arguments using [A-P] instead of [0-9A-F]. */
    336             for (i = 0; args[i]; ++i) {
    337                 char *p = args[i];
    338                 do {
    339                     *tail++ = 'A' + ((*p >> 4) & 0x0F);
    340                     *tail++ = 'A' + (*p & 0x0F);
    341                 } while (*p++);
    342             }
    343             *tail = 0;
    344             setenv("envargs", envargs, 1);
    345             args[1] = NULL;
    346         }
    347 #endif
    348         execvp("pppd", args);
    349         log_print(FATAL, "Exec() %s", strerror(errno));
    350         exit(1); /* Pretending a fatal error in pppd. */
    351     }
    352 
    353     log_print(INFO, "Pppd started (pid = %d)", pppd_pid);
    354     close(pppox);
    355 }
    356