aosp12/external/mtpd/mtpd.c

/*
 * 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);
}