main.cpp

   1 /*
   2  * Copyright (C) 2008 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 <signal.h>
  20 #include <errno.h>
  21 #include <string.h>
  22 #include <sys/stat.h>
  23 #include <sys/types.h>
  24 #include <sys/wait.h>
  25
  26 #include <fcntl.h>
  27 #include <dirent.h>
  28
  29 #define LOG_TAG "Netd"
  30
  31 #include "cutils/log.h"
  32
  33 #include "CommandListener.h"
  34 #include "NetlinkManager.h"
  35 #include "DnsProxyListener.h"
  36 #include "MDnsSdListener.h"
  37
  38 static void coldboot(const char *path);
  39 static void sigchld_handler(int sig);
  40 static void blockSigpipe();
  41
  42 int main() {
  43
  44     CommandListener *cl;
  45     NetlinkManager *nm;
  46     DnsProxyListener *dpl;
  47     MDnsSdListener *mdnsl;
  48
  49     ALOGI("Netd 1.0 starting");
  50
  51 //    signal(SIGCHLD, sigchld_handler);
  52     blockSigpipe();
  53
  54     if (!(nm = NetlinkManager::Instance())) {
  55         ALOGE("Unable to create NetlinkManager");
  56         exit(1);
  57     };
  58
  59     cl = new CommandListener();
  60     nm->setBroadcaster((SocketListener *) cl);
  61
  62     if (nm->start()) {
  63         ALOGE("Unable to start NetlinkManager (%s)", strerror(errno));
  64         exit(1);
  65     }
  66
  67     // Set local DNS mode, to prevent bionic from proxying
  68     // back to this service, recursively.
  69     setenv("ANDROID_DNS_MODE", "local", 1);
  70     dpl = new DnsProxyListener(CommandListener::sNetCtrl);
  71     if (dpl->startListener()) {
  72         ALOGE("Unable to start DnsProxyListener (%s)", strerror(errno));
  73         exit(1);
  74     }
  75
  76     mdnsl = new MDnsSdListener();
  77     if (mdnsl->startListener()) {
  78         ALOGE("Unable to start MDnsSdListener (%s)", strerror(errno));
  79         exit(1);
  80     }
  81     /*
  82      * Now that we're up, we can respond to commands
  83      */
  84     if (cl->startListener()) {
  85         ALOGE("Unable to start CommandListener (%s)", strerror(errno));
  86         exit(1);
  87     }
  88
  89     // Eventually we'll become the monitoring thread
  90     while(1) {
  91         sleep(1000);
  92     }
  93
  94     ALOGI("Netd exiting");
  95     exit(0);
  96 }
  97
  98 static void do_coldboot(DIR *d, int lvl)
  99 {
 100     struct dirent *de;
 101     int dfd, fd;
 102
 103     dfd = dirfd(d);
 104
 105     fd = openat(dfd, "uevent", O_WRONLY);
 106     if(fd >= 0) {
 107         write(fd, "add\n", 4);
 108         close(fd);
 109     }
 110
 111     while((de = readdir(d))) {
 112         DIR *d2;
 113
 114         if (de->d_name[0] == '.')
 115             continue;
 116
 117         if (de->d_type != DT_DIR && lvl > 0)
 118             continue;
 119
 120         fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY);
 121         if(fd < 0)
 122             continue;
 123
 124         d2 = fdopendir(fd);
 125         if(d2 == 0)
 126             close(fd);
 127         else {
 128             do_coldboot(d2, lvl + 1);
 129             closedir(d2);
 130         }
 131     }
 132 }
 133
 134 static void coldboot(const char *path)
 135 {
 136     DIR *d = opendir(path);
 137     if(d) {
 138         do_coldboot(d, 0);
 139         closedir(d);
 140     }
 141 }
 142
 143 static void sigchld_handler(int sig) {
 144     pid_t pid = wait(NULL);
 145     ALOGD("Child process %d exited", pid);
 146 }
 147
 148 static void blockSigpipe()
 149 {
 150     sigset_t mask;
 151
 152     sigemptyset(&mask);
 153     sigaddset(&mask, SIGPIPE);
 154     if (sigprocmask(SIG_BLOCK, &mask, NULL) != 0)
 155         ALOGW("WARNING: SIGPIPE not blocked\n");
 156 }