1/*
2 * Copyright (C) 2012 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 <fcntl.h>
18#include <string.h>
19#include <sys/wait.h>
20
21#define LOG_TAG "Netd"
22
23#include <cutils/log.h>
24#include <logwrap/logwrap.h>
25
26#include "NetdConstants.h"
27
28const char * const OEM_SCRIPT_PATH = "/system/bin/oem-iptables-init.sh";
29const char * const IPTABLES_PATH = "/system/bin/iptables";
30const char * const IP6TABLES_PATH = "/system/bin/ip6tables";
31const char * const TC_PATH = "/system/bin/tc";
32const char * const IP_PATH = "/system/bin/ip";
33const char * const ADD = "add";
34const char * const DEL = "del";
35
36static void logExecError(const char* argv[], int res, int status) {
37    const char** argp = argv;
38    std::string args = "";
39    while (*argp) {
40        args += *argp;
41        args += ' ';
42        argp++;
43    }
44    ALOGE("exec() res=%d, status=%d for %s", res, status, args.c_str());
45}
46
47static int execIptablesCommand(int argc, const char *argv[], bool silent) {
48    int res;
49    int status;
50
51    res = android_fork_execvp(argc, (char **)argv, &status, false,
52        !silent);
53    if (res || !WIFEXITED(status) || WEXITSTATUS(status)) {
54        if (!silent) {
55            logExecError(argv, res, status);
56        }
57        if (res)
58            return res;
59        if (!WIFEXITED(status))
60            return ECHILD;
61    }
62    return WEXITSTATUS(status);
63}
64
65static int execIptables(IptablesTarget target, bool silent, va_list args) {
66    /* Read arguments from incoming va_list; we expect the list to be NULL terminated. */
67    std::list<const char*> argsList;
68    argsList.push_back(NULL);
69    const char* arg;
70    do {
71        arg = va_arg(args, const char *);
72        argsList.push_back(arg);
73    } while (arg);
74
75    int i = 0;
76    const char* argv[argsList.size()];
77    std::list<const char*>::iterator it;
78    for (it = argsList.begin(); it != argsList.end(); it++, i++) {
79        argv[i] = *it;
80    }
81
82    int res = 0;
83    if (target == V4 || target == V4V6) {
84        argv[0] = IPTABLES_PATH;
85        res |= execIptablesCommand(argsList.size(), argv, silent);
86    }
87    if (target == V6 || target == V4V6) {
88        argv[0] = IP6TABLES_PATH;
89        res |= execIptablesCommand(argsList.size(), argv, silent);
90    }
91    return res;
92}
93
94int execIptables(IptablesTarget target, ...) {
95    va_list args;
96    va_start(args, target);
97    int res = execIptables(target, false, args);
98    va_end(args);
99    return res;
100}
101
102int execIptablesSilently(IptablesTarget target, ...) {
103    va_list args;
104    va_start(args, target);
105    int res = execIptables(target, true, args);
106    va_end(args);
107    return res;
108}
109
110int writeFile(const char *path, const char *value, int size) {
111    int fd = open(path, O_WRONLY);
112    if (fd < 0) {
113        ALOGE("Failed to open %s: %s", path, strerror(errno));
114        return -1;
115    }
116
117    if (write(fd, value, size) != size) {
118        ALOGE("Failed to write %s: %s", path, strerror(errno));
119        close(fd);
120        return -1;
121    }
122    close(fd);
123    return 0;
124}
125
126int readFile(const char *path, char *buf, int *sizep)
127{
128    int fd = open(path, O_RDONLY);
129    int size;
130
131    if (fd < 0) {
132        ALOGE("Failed to open %s: %s", path, strerror(errno));
133        return -1;
134    }
135
136    size = read(fd, buf, *sizep);
137    if (size < 0) {
138        ALOGE("Failed to write %s: %s", path, strerror(errno));
139        close(fd);
140        return -1;
141    }
142    *sizep = size;
143    close(fd);
144    return 0;
145}
146