DnsProxyListener.cpp

   1 /*
   2  * Copyright (C) 2010 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 <arpa/inet.h>
  18 #include <dirent.h>
  19 #include <errno.h>
  20 #include <linux/if.h>
  21 #include <netdb.h>
  22 #include <netinet/in.h>
  23 #include <stdlib.h>
  24 #include <sys/socket.h>
  25 #include <sys/types.h>
  26 #include <string.h>
  27 #include <pthread.h>
  28
  29 #define LOG_TAG "DnsProxyListener"
  30 #define DBG 0
  31
  32 #include <cutils/log.h>
  33 #include <sysutils/SocketClient.h>
  34
  35 #include "DnsProxyListener.h"
  36 #include "ResponseCode.h"
  37
  38 DnsProxyListener::DnsProxyListener() :
  39                  FrameworkListener("dnsproxyd") {
  40     registerCmd(new GetAddrInfoCmd());
  41     registerCmd(new GetHostByAddrCmd());
  42 }
  43
  44 DnsProxyListener::GetAddrInfoHandler::~GetAddrInfoHandler() {
  45     free(mHost);
  46     free(mService);
  47     free(mHints);
  48 }
  49
  50 void DnsProxyListener::GetAddrInfoHandler::start() {
  51     pthread_t thread;
  52     pthread_create(&thread, NULL,
  53                    DnsProxyListener::GetAddrInfoHandler::threadStart, this);
  54 }
  55
  56 void* DnsProxyListener::GetAddrInfoHandler::threadStart(void* obj) {
  57     GetAddrInfoHandler* handler = reinterpret_cast<GetAddrInfoHandler*>(obj);
  58     handler->run();
  59     delete handler;
  60     pthread_exit(NULL);
  61     return NULL;
  62 }
  63
  64 // Sends 4 bytes of big-endian length, followed by the data.
  65 // Returns true on success.
  66 static bool sendLenAndData(SocketClient *c, const int len, const void* data) {
  67     uint32_t len_be = htonl(len);
  68     return c->sendData(&len_be, 4) == 0 &&
  69         (len == 0 || c->sendData(data, len) == 0);
  70 }
  71
  72 void DnsProxyListener::GetAddrInfoHandler::run() {
  73     if (DBG) {
  74         ALOGD("GetAddrInfoHandler, now for %s / %s", mHost, mService);
  75     }
  76
  77     struct addrinfo* result = NULL;
  78     uint32_t rv = getaddrinfo(mHost, mService, mHints, &result);
  79     if (rv) {
  80         // getaddrinfo failed
  81         mClient->sendBinaryMsg(ResponseCode::DnsProxyOperationFailed, &rv, sizeof(rv));
  82     } else {
  83         bool success = !mClient->sendCode(ResponseCode::DnsProxyQueryResult);
  84         struct addrinfo* ai = result;
  85         while (ai && success) {
  86             success = sendLenAndData(mClient, sizeof(struct addrinfo), ai)
  87                 && sendLenAndData(mClient, ai->ai_addrlen, ai->ai_addr)
  88                 && sendLenAndData(mClient,
  89                                   ai->ai_canonname ? strlen(ai->ai_canonname) + 1 : 0,
  90                                   ai->ai_canonname);
  91             ai = ai->ai_next;
  92         }
  93         success = success && sendLenAndData(mClient, 0, "");
  94         if (!success) {
  95             ALOGW("Error writing DNS result to client");
  96         }
  97     }
  98     if (result) {
  99         freeaddrinfo(result);
 100     }
 101     mClient->decRef();
 102 }
 103
 104 DnsProxyListener::GetAddrInfoCmd::GetAddrInfoCmd() :
 105     NetdCommand("getaddrinfo") {
 106 }
 107
 108 int DnsProxyListener::GetAddrInfoCmd::runCommand(SocketClient *cli,
 109                                             int argc, char **argv) {
 110     if (DBG) {
 111         for (int i = 0; i < argc; i++) {
 112             ALOGD("argv[%i]=%s", i, argv[i]);
 113         }
 114     }
 115     if (argc != 7) {
 116         char* msg = NULL;
 117         asprintf( &msg, "Invalid number of arguments to getaddrinfo: %i", argc);
 118         ALOGW("%s", msg);
 119         cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
 120         free(msg);
 121         return -1;
 122     }
 123
 124     char* name = argv[1];
 125     if (strcmp("^", name) == 0) {
 126         name = NULL;
 127     } else {
 128         name = strdup(name);
 129     }
 130
 131     char* service = argv[2];
 132     if (strcmp("^", service) == 0) {
 133         service = NULL;
 134     } else {
 135         service = strdup(service);
 136     }
 137
 138     struct addrinfo* hints = NULL;
 139     int ai_flags = atoi(argv[3]);
 140     int ai_family = atoi(argv[4]);
 141     int ai_socktype = atoi(argv[5]);
 142     int ai_protocol = atoi(argv[6]);
 143     if (ai_flags != -1 || ai_family != -1 ||
 144         ai_socktype != -1 || ai_protocol != -1) {
 145         hints = (struct addrinfo*) calloc(1, sizeof(struct addrinfo));
 146         hints->ai_flags = ai_flags;
 147         hints->ai_family = ai_family;
 148         hints->ai_socktype = ai_socktype;
 149         hints->ai_protocol = ai_protocol;
 150     }
 151
 152     if (DBG) {
 153         ALOGD("GetAddrInfoHandler for %s / %s",
 154              name ? name : "[nullhost]",
 155              service ? service : "[nullservice]");
 156     }
 157
 158     cli->incRef();
 159     DnsProxyListener::GetAddrInfoHandler* handler =
 160         new DnsProxyListener::GetAddrInfoHandler(cli, name, service, hints);
 161     handler->start();
 162
 163     return 0;
 164 }
 165
 166 /*******************************************************
 167  *                  GetHostByAddr                       *
 168  *******************************************************/
 169 DnsProxyListener::GetHostByAddrCmd::GetHostByAddrCmd() :
 170         NetdCommand("gethostbyaddr") {
 171 }
 172
 173 int DnsProxyListener::GetHostByAddrCmd::runCommand(SocketClient *cli,
 174                                             int argc, char **argv) {
 175     if (DBG) {
 176         for (int i = 0; i < argc; i++) {
 177             ALOGD("argv[%i]=%s", i, argv[i]);
 178         }
 179     }
 180
 181     if (argc != 4) {
 182         char* msg = NULL;
 183         asprintf(&msg, "Invalid number of arguments to gethostbyaddr: %i", argc);
 184         ALOGW("%s", msg);
 185         cli->sendMsg(ResponseCode::CommandParameterError, msg, false);
 186         free(msg);
 187         return -1;
 188     }
 189
 190     char* addrStr = argv[1];
 191     int addrLen = atoi(argv[2]);
 192     int addrFamily = atoi(argv[3]);
 193
 194     void* addr = malloc(sizeof(struct in6_addr));
 195     errno = 0;
 196     int result = inet_pton(addrFamily, addrStr, addr);
 197     if (result <= 0) {
 198         char* msg = NULL;
 199         asprintf(&msg, "inet_pton(\"%s\") failed %s", addrStr, strerror(errno));
 200         ALOGW("%s", msg);
 201         cli->sendMsg(ResponseCode::OperationFailed, msg, false);
 202         free(addr);
 203         free(msg);
 204         return -1;
 205     }
 206
 207     cli->incRef();
 208     DnsProxyListener::GetHostByAddrHandler* handler =
 209             new DnsProxyListener::GetHostByAddrHandler(cli, addr, addrLen, addrFamily);
 210     handler->start();
 211
 212     return 0;
 213 }
 214
 215 DnsProxyListener::GetHostByAddrHandler::~GetHostByAddrHandler() {
 216     free(mAddress);
 217 }
 218
 219 void DnsProxyListener::GetHostByAddrHandler::start() {
 220     pthread_t thread;
 221     pthread_create(&thread, NULL,
 222                    DnsProxyListener::GetHostByAddrHandler::threadStart, this);
 223 }
 224
 225 void* DnsProxyListener::GetHostByAddrHandler::threadStart(void* obj) {
 226     GetHostByAddrHandler* handler = reinterpret_cast<GetHostByAddrHandler*>(obj);
 227     handler->run();
 228     delete handler;
 229     pthread_exit(NULL);
 230     return NULL;
 231 }
 232
 233 void DnsProxyListener::GetHostByAddrHandler::run() {
 234     if (DBG) {
 235         ALOGD("DnsProxyListener::GetHostByAddrHandler::run\n");
 236     }
 237
 238     struct hostent* hp;
 239
 240     // NOTE gethostbyaddr should take a void* but bionic thinks it should be char*
 241     hp = gethostbyaddr((char*)mAddress, mAddressLen, mAddressFamily);
 242
 243     if (DBG) {
 244         ALOGD("GetHostByAddrHandler::run gethostbyaddr errno: %s hp->h_name = %s, name_len = %d\n",
 245                 hp ? "success" : strerror(errno),
 246                 (hp && hp->h_name) ? hp->h_name: "null",
 247                 (hp && hp->h_name) ? strlen(hp->h_name)+ 1 : 0);
 248     }
 249
 250     bool failed = true;
 251     if (hp) {
 252         failed = mClient->sendBinaryMsg(ResponseCode::DnsProxyQueryResult,
 253                                         hp->h_name ? hp->h_name : "",
 254                                         hp->h_name ? strlen(hp->h_name)+ 1 : 0);
 255     } else {
 256         uint32_t error = h_errno;
 257         failed = mClient->sendBinaryMsg(ResponseCode::DnsProxyOperationFailed,
 258                                         &error, sizeof(error));
 259     }
 260
 261     if (failed) {
 262         ALOGW("GetHostByAddrHandler: Error writing DNS result to client\n");
 263     }
 264     mClient->decRef();
 265 }