wifi/wifi_hal/netlink.cpp

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "netlink.h"

#include "log.h"
#include "netlinkmessage.h"

#include <errno.h>
#include <poll.h>
#include <string.h>
#include <linux/netlink.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>

static const size_t kControlRead = 0;
static const size_t kControlWrite = 1;

static void closeIfOpen(int* fd) {
    if (*fd != -1) {
        ::close(*fd);
        *fd = -1;
    }
}

Netlink::Netlink()
    : mNextSequenceNumber(1)
    , mSocket(-1) {
    mControlPipe[kControlRead] = -1;
    mControlPipe[kControlWrite] = -1;
}

Netlink::~Netlink() {
    closeIfOpen(&mSocket);
    closeIfOpen(&mControlPipe[kControlRead]);
    closeIfOpen(&mControlPipe[kControlWrite]);
}

bool Netlink::init() {
    if (mSocket != -1) {
        ALOGE("Netlink already initialized");
        return false;
    }

    int status = ::pipe2(mControlPipe, O_CLOEXEC);
    if (status != 0) {
        ALOGE("Failed to create control pipe: %s", strerror(errno));
        return false;
    }

    mSocket = ::socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
    if (mSocket == -1) {
        ALOGE("Failed to create netlink socket: %s", strerror(errno));
        return false;
    }

    struct sockaddr_nl addr;
    memset(&addr, 0, sizeof(addr));
    addr.nl_family = AF_NETLINK;
    status = ::bind(mSocket,
                    reinterpret_cast<struct sockaddr*>(&addr),
                    sizeof(addr));
    if (status != 0) {
        ALOGE("Failed to bind netlink socket: %s", strerror(errno));
        return false;
    }

    return true;
}

void Netlink::stop(StopHandler handler) {
    char stop = 1;
    // Set the handler before writing so that it's guaranteed to be available
    // when the event loop reads from the control pipe.
    {
        // No need to keep the lock while writing so make it scoped
        std::unique_lock<std::mutex> lock(mStopHandlerMutex);
        mStopHandler = handler;
    }
    ::write(mControlPipe[kControlWrite], &stop, sizeof(stop));
}

bool Netlink::eventLoop() {
    struct pollfd fds[2];
    memset(fds, 0, sizeof(fds));
    fds[0].fd = mSocket;
    fds[0].events = POLLIN;
    fds[1].fd = mControlPipe[kControlRead];
    fds[1].events = POLLIN;

    for (;;) {
        int status = ::poll(fds, 2, -1);
        if (status == 0) {
            // Timeout, not really supposed to happen
            ALOGW("poll encountered a timeout despite infinite timeout");
            continue;
        } else if (status < 0) {
            if (errno == EINTR) {
                continue;
            }
            ALOGE("poll encountered an error: %s", strerror(errno));
            return false;
        }
        for (auto& fd : fds) {
            if ((fd.revents & POLLIN) == 0) {
                continue;
            }
            if (fd.fd == mSocket) {
                readNetlinkMessage(fd.fd);
            } else if (fd.fd == mControlPipe[kControlRead]) {
                if (readControlMessage()) {
                    // Make a copy of the stop handler while holding the lock
                    // and then call it after releasing the lock. This prevents
                    // the potential deadlock of someone calling stop from the
                    // stop callback. The drawback of this is that if someone
                    // calls stop again with a new stop handler that new stop
                    // handler might not be called if the timing is wrong.
                    // Both of these scenarios indicate highly questionable
                    // behavior on the callers part but at least this way the
                    // event loop will terminate which seems better than a
                    // total deadlock.
                    StopHandler handler;
                    {
                        std::unique_lock<std::mutex> lock(mStopHandlerMutex);
                        handler = mStopHandler;
                    }
                    if (handler) {
                        handler();
                    }
                    return true;
                }
            }
        }
    }
}

uint32_t Netlink::getSequenceNumber() {
    return mNextSequenceNumber++;
}

bool Netlink::sendMessage(const NetlinkMessage& message,
                          ReplyHandler handler) {
    // Keep lock the entire time so that we can safely erase the handler
    // without worrying about another call to sendAsync adding a handler that
    // shouldn't be deleted.
    std::unique_lock<std::mutex> lock(mHandlersMutex);
    // Register handler before sending in case the read thread picks up the
    // response between the send thread sending and registering the handler.
    mHandlers[message.sequence()] = handler;
    for (;;) {
        int bytesSent = ::send(mSocket, message.data(), message.size(), 0);
        if (bytesSent > 0 && static_cast<size_t>(bytesSent) == message.size()) {
            return true;
        }
        if (bytesSent < 0 && errno == EINTR) {
            // We need to try again, keep the mutex locked
            continue;
        }
        // It's a failure, remove the handler and unlock the mutex
        mHandlers.erase(message.sequence());
        lock.unlock();

        if (bytesSent < 0) {
            ALOGE("Failed to send netlink message: %s", strerror(errno));
        }
        return false;
    }
}

bool Netlink::readNetlinkMessage(int fd) {
    char buffer[8 * 1024];
    for (;;) {
        int bytesReceived = ::recv(fd, buffer, sizeof(buffer), 0);
        if (bytesReceived < 0) {
            if (errno == EINTR) {
                continue;
            }
            ALOGE("recv failed to receive on netlink socket: %s",
                  strerror(errno));
            return false;
        }
        char* data = buffer;
        char* end = data + bytesReceived;
        while (data < end) {
            if (data + sizeof(nlmsghdr) > end) {
                ALOGE("received invalid netlink message, too small for header");
                return false;
            }
            auto header = reinterpret_cast<nlmsghdr*>(data);
            if (data + header->nlmsg_len > end) {
                ALOGE("received invalid netlink message, too small for data");
                return false;
            }

            if (header->nlmsg_type == NLMSG_ERROR) {
                if (data + NLMSG_HDRLEN + sizeof(nlmsgerr) <= end) {
                    auto err = reinterpret_cast<nlmsgerr*>(NLMSG_DATA(header));
                    ALOGE("Receive netlink error message: %s, sequence %u",
                          strerror(-err->error), header->nlmsg_seq);
                } else {
                    ALOGE("Received netlink error code but no error message");
                }
                return false;
            }

            notifyHandler(data, header->nlmsg_len);

            data += header->nlmsg_len;
        }
        return true;
    }
}

bool Netlink::readControlMessage() {
    char buffer[32];

    for (;;) {
        int bytesReceived = ::recv(mControlPipe[kControlRead],
                                   buffer,
                                   sizeof(buffer),
                                   0);
        if (bytesReceived < 0) {
            if (errno == EINTR) {
                continue;
            }
        } else if (bytesReceived == 0) {
            return false;
        }
        return true;
    }
}


void Netlink::notifyHandler(const char* data, size_t size) {
    NetlinkMessage message(data, size);

    ReplyHandler replyHandler;
    {
        std::unique_lock<std::mutex> lock(mHandlersMutex);
        auto handler = mHandlers.find(message.sequence());
        if (handler == mHandlers.end()) {
            // No handler found, ignore message
            return;
        }
        replyHandler = handler->second;
        mHandlers.erase(handler);
    }

    replyHandler(message);
}