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 #ifdef ANDROID_CHANGES
    203         if (!access("/data/misc/vpn/abort", F_OK)) {
    204             interrupt(SIGTERM);
    205         }
    206 #endif
    207         timeout = pollfds[0].revents ?
    208                 the_protocol->process() : the_protocol->timeout();
    209     }
    210 
    211     if (timeout < 0) {
    212         status = -timeout;
    213     } else {
    214         int signal;
    215         read(signals[0], &signal, sizeof(int));
    216         log_print(INFO, "Received signal %d", signal);
    217         if (signal == SIGCHLD && waitpid(pppd_pid, &status, WNOHANG) == pppd_pid
    218                 && WIFEXITED(status)) {
    219             status = WEXITSTATUS(status);
    220             log_print(INFO, "Pppd is terminated (status = %d)", status);
    221             status += PPPD_EXITED;
    222             pppd_pid = 0;
    223         } else {
    224             status = USER_REQUESTED;
    225         }
    226     }
    227 
    228     stop_pppd();
    229     the_protocol->shutdown();
    230     log_print(INFO, "Mtpd is terminated (status = %d)", status);
    231     return status;
    232 }
    233 
    234 void log_print(int level, char *format, ...)
    235 {
    236     if (level >= 0 && level <= LOG_MAX) {
    237 #ifdef ANDROID_CHANGES
    238         static int levels[5] = {
    239             ANDROID_LOG_DEBUG, ANDROID_LOG_INFO, ANDROID_LOG_WARN,
    240             ANDROID_LOG_ERROR, ANDROID_LOG_FATAL
    241         };
    242         va_list ap;
    243         va_start(ap, format);
    244         __android_log_vprint(levels[level], "mtpd", format, ap);
    245         va_end(ap);
    246 #else
    247         static char *levels = "DIWEF";
    248         va_list ap;
    249         fprintf(stderr, "%c: ", levels[level]);
    250         va_start(ap, format);
    251         vfprintf(stderr, format, ap);
    252         va_end(ap);
    253         fputc('\n', stderr);
    254 #endif
    255     }
    256 }
    257 
    258 void create_socket(int family, int type, char *server, char *port)
    259 {
    260     struct addrinfo hints = {
    261         .ai_flags = AI_NUMERICSERV,
    262         .ai_family = family,
    263         .ai_socktype = type,
    264     };
    265     struct addrinfo *records;
    266     struct addrinfo *r;
    267     int error;
    268 
    269     log_print(INFO, "Connecting to %s port %s via %s", server, port, interface);
    270 
    271     error = getaddrinfo(server, port, &hints, &records);
    272     if (error) {
    273         log_print(FATAL, "Getaddrinfo() %s", (error == EAI_SYSTEM) ?
    274                 strerror(errno) : gai_strerror(error));
    275         exit(NETWORK_ERROR);
    276     }
    277 
    278     for (r = records; r; r = r->ai_next) {
    279         int s = socket(r->ai_family, r->ai_socktype, r->ai_protocol);
    280         if (!setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, interface,
    281                 strlen(interface)) && !connect(s, r->ai_addr, r->ai_addrlen)) {
    282             the_socket = s;
    283             break;
    284         }
    285         close(s);
    286     }
    287 
    288     freeaddrinfo(records);
    289 
    290     if (the_socket == -1) {
    291         log_print(FATAL, "Connect() %s", strerror(errno));
    292         exit(NETWORK_ERROR);
    293     }
    294 
    295     fcntl(the_socket, F_SETFD, FD_CLOEXEC);
    296     log_print(INFO, "Connection established (socket = %d)", the_socket);
    297 }
    298 
    299 void start_pppd(int pppox)
    300 {
    301     if (pppd_pid) {
    302         log_print(WARNING, "Pppd is already started (pid = %d)", pppd_pid);
    303         close(pppox);
    304         return;
    305     }
    306 
    307     log_print(INFO, "Starting pppd (pppox = %d)", pppox);
    308 
    309     pppd_pid = fork();
    310     if (pppd_pid < 0) {
    311         log_print(FATAL, "Fork() %s", strerror(errno));
    312         exit(SYSTEM_ERROR);
    313     }
    314 
    315     if (!pppd_pid) {
    316         char *args[pppd_argc + 5];
    317         char number[12];
    318 
    319         sprintf(number, "%d", pppox);
    320         args[0] = "pppd";
    321         args[1] = "nodetach";
    322         args[2] = "pppox";
    323         args[3] = number;
    324         memcpy(&args[4], pppd_argv, sizeof(char *) * pppd_argc);
    325         args[4 + pppd_argc] = NULL;
    326 
    327 #ifdef ANDROID_CHANGES
    328         {
    329             char envargs[65536];
    330             char *tail = envargs;
    331             int i;
    332             /* Hex encode the arguments using [A-P] instead of [0-9A-F]. */
    333             for (i = 0; args[i]; ++i) {
    334                 char *p = args[i];
    335                 do {
    336                     *tail++ = 'A' + ((*p >> 4) & 0x0F);
    337                     *tail++ = 'A' + (*p & 0x0F);
    338                 } while (*p++);
    339             }
    340             *tail = 0;
    341             setenv("envargs", envargs, 1);
    342             args[1] = NULL;
    343         }
    344 #endif
    345         execvp("pppd", args);
    346         log_print(FATAL, "Exec() %s", strerror(errno));
    347         exit(1); /* Pretending a fatal error in pppd. */
    348     }
    349 
    350     log_print(INFO, "Pppd started (pid = %d)", pppd_pid);
    351     close(pppox);
    352 }
    353