Merge "qtaguid.cpp - improvements"

#include <dlfcn.h>

#include <errno.h>

#include <fcntl.h>

#include <inttypes.h>

#include <stdio.h>

#include <string.h>

#include <unistd.h>

#include <log/log.h>

class netdHandler {

  public:

struct netdHandler {

    int (*netdTagSocket)(int, uint32_t, uid_t);

    int (*netdUntagSocket)(int);

};

int stubTagSocket(int, uint32_t, uid_t) {

static int stubTagSocket(int, uint32_t, uid_t) {

    return -EREMOTEIO;

}

int stubUntagSocket(int) {

static int stubUntagSocket(int) {

    return -EREMOTEIO;

}

netdHandler initHandler(void) {

    netdHandler handler = {stubTagSocket, stubUntagSocket};

static netdHandler initHandler(void) {

    const netdHandler stubHandler = { stubTagSocket, stubUntagSocket };

    void* netdClientHandle = dlopen("libnetd_client.so", RTLD_NOW);

    if (!netdClientHandle) {

        ALOGE("Failed to open libnetd_client.so: %s", dlerror());

        return handler;

        return stubHandler;

    }

    netdHandler handler;

    handler.netdTagSocket = (int (*)(int, uint32_t, uid_t))dlsym(netdClientHandle, "tagSocket");

    if (!handler.netdTagSocket) {

        ALOGE("load netdTagSocket handler failed: %s", dlerror());

        return stubHandler;

    }

    handler.netdUntagSocket = (int (*)(int))dlsym(netdClientHandle, "untagSocket");

    if (!handler.netdUntagSocket) {

        ALOGE("load netdUntagSocket handler failed: %s", dlerror());

        return stubHandler;

    }

    return handler;

}

// The language guarantees that this object will be initialized in a thread-safe way.

static netdHandler& getHandler() {

    static netdHandler instance = initHandler();

static const netdHandler& getHandler() {

    static const netdHandler instance = initHandler();

    return instance;

}

int qtaguid_tagSocket(int sockfd, int tag, uid_t uid) {

    // Check the socket fd passed to us is still valid before we load the netd

    // client. Pass a already closed socket fd to netd client may let netd open

    // the unix socket with the same fd number and pass it to server for

    // tagging.

    // TODO: move the check into netdTagSocket.

    int res = fcntl(sockfd, F_GETFD);

    if (res < 0) return res;

    ALOGV("Tagging socket %d with tag %u for uid %d", sockfd, tag, uid);

    return getHandler().netdTagSocket(sockfd, tag, uid);

}

int qtaguid_untagSocket(int sockfd) {

    // Similiar to tag socket. We need a check before untag to make sure untag a closed socket fail

    // as expected.

    // TODO: move the check into netdTagSocket.

    int res = fcntl(sockfd, F_GETFD);

    if (res < 0) return res;

    ALOGV("Untagging socket %d", sockfd);

    return getHandler().netdUntagSocket(sockfd);

}