/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <stdio.h> #include <stdlib.h> #include <stdarg.h> #include <string.h> #include <errno.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/poll.h> #include <sys/wait.h> #include <netdb.h> #include <signal.h> #include <unistd.h> #include <fcntl.h> #include <time.h> #include <limits.h> #ifdef ANDROID_CHANGES #include <android/log.h> #include <cutils/sockets.h> #endif #include "mtpd.h" #include "NetdClient.h" #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) /* Characters count in string with max value of unsigned type t */ #define TYPE_STRLEN_U(t) ((((sizeof(t) * CHAR_BIT) * 1233) >> 12) + 1) /* Length of string with max file descriptor value */ #define FD_MAX_LEN TYPE_STRLEN_U(int) int the_socket = -1; extern struct protocol l2tp; extern struct protocol pptp; static struct protocol *protocols[] = {&l2tp, &pptp, NULL}; static struct protocol *the_protocol; static char *interface; static int pppd_argc; static char **pppd_argv; static pid_t pppd_pid; /* We redirect signals to a pipe in order to prevent race conditions. */ static int signals[2]; static void interrupt(int signal) { write(signals[1], &signal, sizeof(int)); } static int initialize(int argc, char **argv) { int i; for (i = 0; protocols[i]; ++i) { struct protocol *p = protocols[i]; if (argc - 3 >= p->arguments && !strcmp(argv[2], p->name)) { log_print(INFO, "Using protocol %s", p->name); the_protocol = p; break; } } if (!the_protocol) { printf("Usages:\n"); for (i = 0; protocols[i]; ++i) { struct protocol *p = protocols[i]; printf(" %s interface %s %s pppd-arguments\n", argv[0], p->name, p->usage); } exit(0); } interface = argv[1]; pppd_argc = argc - 3 - the_protocol->arguments; pppd_argv = &argv[3 + the_protocol->arguments]; return the_protocol->connect(&argv[3]); } static void stop_pppd() { if (pppd_pid) { int status; log_print(INFO, "Sending signal to pppd (pid = %d)", pppd_pid); kill(pppd_pid, SIGTERM); waitpid(pppd_pid, &status, 0); pppd_pid = 0; } } #ifdef ANDROID_CHANGES static int android_get_control_and_arguments(int *argc, char ***argv) { static char *args[32]; int control; int i; if ((i = android_get_control_socket("mtpd")) == -1) { return -1; } log_print(DEBUG, "Waiting for control socket"); if (listen(i, 1) == -1 || (control = accept(i, NULL, 0)) == -1) { log_print(FATAL, "Cannot get control socket"); exit(SYSTEM_ERROR); } close(i); fcntl(control, F_SETFD, FD_CLOEXEC); args[0] = (*argv)[0]; for (i = 1; i < 32; ++i) { unsigned char bytes[2]; if (recv(control, &bytes[0], 1, 0) != 1 || recv(control, &bytes[1], 1, 0) != 1) { log_print(FATAL, "Cannot get argument length"); exit(SYSTEM_ERROR); } else { int length = bytes[0] << 8 | bytes[1]; int offset = 0; if (length == 0xFFFF) { break; } args[i] = malloc(length + 1); while (offset < length) { int n = recv(control, &args[i][offset], length - offset, 0); if (n > 0) { offset += n; } else { log_print(FATAL, "Cannot get argument value"); exit(SYSTEM_ERROR); } } args[i][length] = 0; } } log_print(DEBUG, "Received %d arguments", i - 1); *argc = i; *argv = args; return control; } #endif int main(int argc, char **argv) { struct pollfd pollfds[3]; int control = -1; int timeout; int status; #ifdef ANDROID_CHANGES control = android_get_control_and_arguments(&argc, &argv); shutdown(control, SHUT_WR); #endif srandom(time(NULL)); if (pipe(signals) == -1) { log_print(FATAL, "Pipe() %s", strerror(errno)); exit(SYSTEM_ERROR); } fcntl(signals[0], F_SETFD, FD_CLOEXEC); fcntl(signals[1], F_SETFD, FD_CLOEXEC); timeout = initialize(argc, argv); signal(SIGHUP, interrupt); signal(SIGINT, interrupt); signal(SIGTERM, interrupt); signal(SIGCHLD, interrupt); signal(SIGPIPE, SIG_IGN); atexit(stop_pppd); pollfds[0].fd = the_socket; pollfds[0].events = POLLIN; pollfds[1].fd = signals[0]; pollfds[1].events = POLLIN; pollfds[2].fd = control; pollfds[2].events = 0; while (timeout >= 0) { if (poll(pollfds, 3, timeout ? timeout : -1) == -1 && errno != EINTR) { log_print(FATAL, "Poll() %s", strerror(errno)); exit(SYSTEM_ERROR); } if (pollfds[1].revents) { break; } if (pollfds[2].revents) { interrupt(SIGTERM); } timeout = pollfds[0].revents ? the_protocol->process() : the_protocol->timeout(); #ifdef ANDROID_CHANGES if (!access("/data/misc/vpn/abort", F_OK)) { interrupt(SIGTERM); } if (!timeout) { timeout = 5000; } #endif } if (timeout < 0) { status = -timeout; } else { int signal; read(signals[0], &signal, sizeof(int)); log_print(INFO, "Received signal %d", signal); if (signal == SIGCHLD && waitpid(pppd_pid, &status, WNOHANG) == pppd_pid && WIFEXITED(status)) { status = WEXITSTATUS(status); log_print(INFO, "Pppd is terminated (status = %d)", status); status += PPPD_EXITED; pppd_pid = 0; } else { status = USER_REQUESTED; } } stop_pppd(); the_protocol->shutdown(); log_print(INFO, "Mtpd is terminated (status = %d)", status); return status; } void log_print(int level, char *format, ...) { if (level >= 0 && level <= LOG_MAX) { #ifdef ANDROID_CHANGES static int levels[5] = { ANDROID_LOG_DEBUG, ANDROID_LOG_INFO, ANDROID_LOG_WARN, ANDROID_LOG_ERROR, ANDROID_LOG_FATAL }; va_list ap; va_start(ap, format); __android_log_vprint(levels[level], "mtpd", format, ap); va_end(ap); #else static char *levels = "DIWEF"; va_list ap; fprintf(stderr, "%c: ", levels[level]); va_start(ap, format); vfprintf(stderr, format, ap); va_end(ap); fputc('\n', stderr); #endif } } void create_socket(int family, int type, char *server, char *port) { struct addrinfo hints = { .ai_flags = AI_NUMERICSERV, .ai_family = family, .ai_socktype = type, }; struct addrinfo *records; struct addrinfo *r; int error; log_print(INFO, "Connecting to %s port %s via %s", server, port, interface); error = getaddrinfo(server, port, &hints, &records); if (error) { log_print(FATAL, "Getaddrinfo() %s", (error == EAI_SYSTEM) ? strerror(errno) : gai_strerror(error)); exit(NETWORK_ERROR); } for (r = records; r; r = r->ai_next) { int s = socket(r->ai_family, r->ai_socktype, r->ai_protocol); if (!setsockopt(s, SOL_SOCKET, SO_BINDTODEVICE, interface, strlen(interface)) && !connect(s, r->ai_addr, r->ai_addrlen)) { the_socket = s; break; } close(s); } freeaddrinfo(records); if (the_socket == -1) { log_print(FATAL, "Connect() %s", strerror(errno)); exit(NETWORK_ERROR); } #ifdef ANDROID_CHANGES protectFromVpn(the_socket); #endif fcntl(the_socket, F_SETFD, FD_CLOEXEC); log_print(INFO, "Connection established (socket = %d)", the_socket); } void start_pppd(int pppox) { if (pppd_pid) { log_print(WARNING, "Pppd is already started (pid = %d)", pppd_pid); close(pppox); return; } log_print(INFO, "Starting pppd (pppox = %d)", pppox); pppd_pid = fork(); if (pppd_pid < 0) { log_print(FATAL, "Fork() %s", strerror(errno)); exit(SYSTEM_ERROR); } if (!pppd_pid) { char *args[pppd_argc + 5]; char number[FD_MAX_LEN + 1]; snprintf(number, FD_MAX_LEN + 1, "%d", pppox); args[0] = "pppd"; args[1] = "nodetach"; args[2] = "pppox"; args[3] = number; memcpy(&args[4], pppd_argv, sizeof(char *) * pppd_argc); args[4 + pppd_argc] = NULL; execvp("pppd", args); log_print(FATAL, "Exec() %s", strerror(errno)); exit(SYSTEM_ERROR); /* Pretending a fatal error in pppd. */ } log_print(INFO, "Pppd started (pid = %d)", pppd_pid); close(pppox); } /** * Start pppd daemon with pppol2tp-android plugin. * * @param tunnel_fd Tunnel socket file descriptor * @param session_fd Session socket file descriptor * @param tunnel_id Tunnel ID; must be in host byte order * @param session_id Session ID; must be in host byte order */ void start_pppd_ol2tp(int tunnel_fd, int session_fd, int tunnel_id, int session_id) { if (pppd_pid) { log_print(WARNING, "Pppd is already started (pid = %d)", pppd_pid); goto ret; } log_print(INFO, "Starting pppd (tunnel_fd = %d, session_fd = %d)", tunnel_fd, session_fd); pppd_pid = fork(); if (pppd_pid < 0) { log_print(FATAL, "Fork() %s", strerror(errno)); exit(SYSTEM_ERROR); } if (!pppd_pid) { char tunnel_fd_str[FD_MAX_LEN + 1]; char session_fd_str[FD_MAX_LEN + 1]; char tunnel_id_str[FD_MAX_LEN + 1]; char session_id_str[FD_MAX_LEN + 1]; snprintf(tunnel_fd_str, FD_MAX_LEN + 1, "%d", tunnel_fd); snprintf(session_fd_str, FD_MAX_LEN + 1, "%d", session_fd); snprintf(tunnel_id_str, FD_MAX_LEN + 1, "%d", tunnel_id); snprintf(session_id_str, FD_MAX_LEN + 1, "%d", session_id); const char *l2tp_args[] = { "pppd", "nodetach", "plugin", "pppol2tp-android.so", "session_fd", session_fd_str, "tunnel_fd", tunnel_fd_str, "session_id", session_id_str, "tunnel_id", tunnel_id_str, }; const size_t args_len = ARRAY_SIZE(l2tp_args) + pppd_argc + 1; char *args[args_len]; /* Populate args[] from l2tp_args[] and pppd_argv[] */ memcpy(args, l2tp_args, sizeof(l2tp_args)); memcpy(args + ARRAY_SIZE(l2tp_args), pppd_argv, sizeof(char *) * pppd_argc); args[args_len - 1] = NULL; execvp("pppd", args); log_print(FATAL, "Exec() %s", strerror(errno)); exit(SYSTEM_ERROR); /* Pretending a fatal error in pppd. */ } log_print(INFO, "Pppd started (pid = %d)", pppd_pid); ret: close(session_fd); close(tunnel_fd); } /** * Start pppd daemon with pppopptp-android plugin. * * @param pptp_fd PPTP socket file descriptor */ void start_pppd_pptp(int pptp_fd) { if (pppd_pid) { log_print(WARNING, "Pppd is already started (pid = %d)", pppd_pid); goto ret; } log_print(INFO, "Starting pppd (pptp_fd = %d)", pptp_fd); pppd_pid = fork(); if (pppd_pid < 0) { log_print(FATAL, "Fork() %s", strerror(errno)); exit(SYSTEM_ERROR); } if (!pppd_pid) { char pptp_fd_str[FD_MAX_LEN + 1]; snprintf(pptp_fd_str, FD_MAX_LEN + 1, "%d", pptp_fd); const char *pptp_args[] = { "pppd", "nodetach", "plugin", "pppopptp-android.so", "pptp_socket", pptp_fd_str, }; const size_t args_len = ARRAY_SIZE(pptp_args) + pppd_argc + 1; char *args[args_len]; /* Populate args[] from pptp_args[] and pppd_argv[] */ memcpy(args, pptp_args, sizeof(pptp_args)); memcpy(args + ARRAY_SIZE(pptp_args), pppd_argv, sizeof(char *) * pppd_argc); args[args_len - 1] = NULL; execvp("pppd", args); log_print(FATAL, "Exec() %s", strerror(errno)); exit(SYSTEM_ERROR); /* Pretending a fatal error in pppd. */ } log_print(INFO, "Pppd started (pid = %d)", pppd_pid); ret: close(pptp_fd); }