NetdConstants.cpp

   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
  28 const char * const OEM_SCRIPT_PATH = "/system/bin/oem-iptables-init.sh";
  29 const char * const IPTABLES_PATH = "/system/bin/iptables";
  30 const char * const IP6TABLES_PATH = "/system/bin/ip6tables";
  31 const char * const TC_PATH = "/system/bin/tc";
  32 const char * const IP_PATH = "/system/bin/ip";
  33 const char * const ADD = "add";
  34 const char * const DEL = "del";
  35
  36 static 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
  47 static 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
  65 static 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
  94 int 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
 102 int 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
 110 int 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
 126 int 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 }