#include <hardware/bluetooth.h>
#include <hardware/bt_sock.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <pthread.h>
#include <fcntl.h>
#include <errno.h>
#include <poll.h>
#include <stdlib.h>
#include <string.h>
#include "aapiSocket.h"
#include "rfcomm.h"
#include "config.h"
#include "aapi.h"
#include "hci.h"
#include "sdp.h"
#include "log.h"
#include "sg.h"
#include "mt.h"


struct aapiSock {
    struct aapiSock *prev;
    struct aapiSock *next;
    btsock_type_t type;
    int fd, java_fd;
    struct bt_addr peer;
    union {
        struct {
            union { /* listening sockets have no rfc_conn_t */
                rfc_conn_t conn;
                uint32_t sdpHandle;
            };
            uint8_t state;
            uint8_t chNum;
            sg bufRx;
            sg bufTx;
        } rfc;
    };
};

struct appiSockListener {
    struct appiSockListener *next;
    uint32_t sdpHandle;
    uint8_t uuid[16];
};

#define RFC_SOCK_STATE_LISTENING       1
#define RFC_SOCK_STATE_AUTOACCEPTING   2 /* we allocated an instance but it is not yet openened by rfcomm */
#define RFC_SOCK_STATE_ESTABLISHED     3 /* it is open */
#define RFC_SOCK_STATE_AAPI_CLOSED     4 /* aapi closed, waiting for RFCOMM confirmation */
#define RFC_SOCK_STATE_RFC_CLOSED      5 /* rfc closed, waiting for aapi confirmation */
#define RFC_SOCK_STATE_RFC_STOP_LISTEN 6 /* someone else stopped listening for us */


#define WORKER_MSG_SOCK_ADD            0
#define WORKER_MSG_FD_CAN_RX           1 /* our user may now RX data */
#define WORKER_MSG_FD_CAN_TX           2 /* our user may now TX data */
#define WORKER_MSG_FD_CANNOT_RX        3
#define WORKER_MSG_FD_CANNOT_TX        4
#define WORKER_MSG_SOCK_DEL            5 /* delete this socket */
#define WORKER_MSG_QUIT                6 /* TODO: currently unused */

/* our state */
static struct aapiSock *mSocks = NULL;
static pthread_mutex_t mSocksLock = PTHREAD_MUTEX_INITIALIZER;
static pthread_t mWorker;
static int mWorkerPipe = -1;
static bool mSocksUp;
static bool mSocksWantUp;
static struct appiSockListener *mListeners = NULL;


/* fwd decls */
static void aapiSockFree(struct aapiSock* sock);
static void aapiSockWorkerMsgSend(uint8_t msg, void *aux);


/*
 * FUNCTION: aapiWorker
 * USE:      The worker thread for aapi.sock
 * PARAMS:   pipe - actually an int - the pipe we listen to to wake up
 * RETURN:   NONE
 * NOTES:
 */
static void *aapiSockWorker(void *pipe)
{
    uint32_t i, arrSz = 16/* a nice starting number */, arrNum = 1;
    struct aapiSock **socks = NULL;
    struct pollfd *fds = NULL;
    bool quit = false;
    uint8_t rdbuf[4096]; /* we read from java using this */

    fds = malloc(sizeof(struct pollfd) * arrSz);
    if (!fds) {
        loge("Failed to alloc fds\n");
        return NULL;
    }

    socks = malloc(sizeof(struct aapiSock*) * arrSz);
    if (!socks) {
        loge("Failed to alloc socks\n");
        free(fds);
        return NULL;
    }
    fds[0].fd = (int)(uintptr_t)pipe;
    fds[0].events = POLLIN;


    while (!quit) {
        int ret;
        for (i = 0; i < arrNum; i++)
            fds[i].revents = 0;

        do {
            ret = poll(fds, arrNum, -1);
        } while (ret == -1 && errno == EINTR);

        if (fds[0].revents & POLLIN) {
            uint8_t msg;
            struct aapiSock *sock;

            r_read(fds[0].fd, &msg, sizeof(msg));
            r_read(fds[0].fd, &sock, sizeof(sock));
            switch (msg) {
            case WORKER_MSG_SOCK_ADD:
                if (arrNum == arrSz) {
                    uint32_t newArrSz = arrSz + 16; /* we grow 16 at a time */
                    struct pollfd *newFds = realloc(fds, sizeof(struct pollfd) * newArrSz);
                    struct aapiSock **newSocks = realloc(socks, sizeof(struct aapiSock*) * newArrSz);

                    if (newFds)
                        fds = newFds;
                    if (newSocks)
                        socks = newSocks;
                    if (!newFds || !newSocks) {
                        logw("Failed to resize structs to add new sock\n");
                        break;
                    }
                    arrSz = newArrSz;
                }
                socks[arrNum] = sock;
                fds[arrNum].fd = sock->fd;
                fds[arrNum].events = POLLERR | POLLNVAL | POLLHUP;
                fds[arrNum].revents = 0;
                arrNum++;
                break;
            case WORKER_MSG_FD_CAN_RX:
            case WORKER_MSG_FD_CAN_TX:
            case WORKER_MSG_FD_CANNOT_RX:
            case WORKER_MSG_FD_CANNOT_TX:
            case WORKER_MSG_SOCK_DEL:
                for (i = 0; i < arrNum && socks[i] != sock; i++);
                if (i == arrNum) {
                    logw("worker(%u) called with unknown sock\n", msg);
                    break;
                }
                if (msg == WORKER_MSG_FD_CAN_RX)
                    fds[i].events |= POLLOUT;
                else if (msg == WORKER_MSG_FD_CAN_TX)
                    fds[i].events |= POLLIN;
                else if (msg == WORKER_MSG_FD_CANNOT_RX)
                    fds[i].events &=~ POLLOUT;
                else if (msg == WORKER_MSG_FD_CANNOT_TX)
                    fds[i].events &=~ POLLIN;
                else {
                    memcpy(fds + i, fds + arrNum - 1, sizeof(struct pollfd));
                    socks[i] = socks[arrNum - 1];
                    arrNum--;
                    pthread_mutex_lock(&mSocksLock);
                    aapiSockFree(sock);
                    pthread_mutex_unlock(&mSocksLock);
                }
                break;
            case WORKER_MSG_QUIT:
                quit = true;
                logd("AAPI.sock worker exiting\n");
                break;
            default:
                loge("Unknown AAPI.worker command %u\n", msg);
                break;
            }
        }
        for (i = 1; i < arrNum; i++) {
            uint32_t done;
            void *iter;

            if (fds[i].revents & (POLLERR | POLLNVAL | POLLHUP)) {
                logd("fd %d (sock %d) in state %u failed with error %d -> deleting\n", fds[i].fd, i, socks[i]->rfc.state, fds[i].revents);
                aapiSockWorkerMsgSend(WORKER_MSG_SOCK_DEL, socks[i]);
                continue;
            }

            if (!(fds[i].events & fds[i].revents))
                continue;

            if (fds[i].revents & POLLIN) { /* java has sent us data */
                int32_t txRet;
                while(1) {
                    ssize_t now;

                    if (sgLength(socks[i]->rfc.bufTx) >= AAPI_RFC_MAX_BUF) {
                        fds[i].events &=~ POLLIN; /* no buffer space - stop reading */
                        logd("TX throttled in socks api\n");
                        break;
                    }
                    now = read(fds[i].fd, rdbuf, sizeof(rdbuf));
                    if (now <= 0)
                        break;
                    if (!sgConcatBackCopy(socks[i]->rfc.bufTx, rdbuf, now))
                        loge("Failed to concat read data. TX data will be lost\n");
                    if (now != sizeof(rdbuf))
                        break;
                }
                txRet = rfcTx(socks[i]->rfc.conn, socks[i]->rfc.bufTx);
                if (txRet == RFC_TX_RET_ENTIRE_SENT) {
                    socks[i]->rfc.bufTx = sgNew();
                    if (!socks[i]->rfc.bufTx) {
                        loge("Failed to alloc new TX sg for conn. Closing\n");
                        aapiSockWorkerMsgSend(WORKER_MSG_SOCK_DEL, socks[i]);
                    }
                } else if (txRet == RFC_TX_RET_STOP_SENDING) {
                    fds[i].events &=~ POLLIN; /* no buffer space - stop reading */
                    logd("TX throttled in rfc\n");
                } else if (txRet == RFC_TX_RET_NO_SUCH_CONN || txRet == RFC_TX_RET_ERROR) {
                    loge("Rfc sock error %d. Closing\n", txRet);
                    aapiSockWorkerMsgSend(WORKER_MSG_SOCK_DEL, socks[i]);
                }
            }
            if (fds[i].revents & POLLOUT) { /* java is ready for data */
                pthread_mutex_lock(&mSocksLock);
                for (done = 0, iter = sgIterStart(socks[i]->rfc.bufRx); iter; iter = sgIterAdvance(iter)) {
                    ssize_t now = write(fds[i].fd, sgIterCurData(iter), sgIterCurLen(iter));
                    if (now <= 0)
                        break;
                    done += now;
                    if ((unsigned)now < sgIterCurLen(iter))
                        break;
                }
                sgTruncFront(socks[i]->rfc.bufRx, done);
                if (sgLength(socks[i]->rfc.bufRx) < AAPI_RFC_MAX_BUF)
                    rfcFlow(socks[i]->rfc.conn, false);
                if (!sgLength(socks[i]->rfc.bufRx))
                    fds[i].events &=~ POLLOUT; /* if we have no more to give, do not bother caring if java can read */
                pthread_mutex_unlock(&mSocksLock);
            }
        }
    }
    pthread_mutex_lock(&mSocksLock);
    for (i = 1; i < arrNum; i++)
        aapiSockFree(socks[i]);
    pthread_mutex_unlock(&mSocksLock);
    close((int)(uintptr_t)pipe);

    free(fds);
    free(socks);
    return NULL;
}

/*
 * FUNCTION: aapiSockDoInit
 * USE:      Init aapi.sock worker thread & pipes
 * PARAMS:   NONE
 * RETURN:   NONE
 * NOTES:
 */
static void aapiSockDoInit(void)
{
    int pipes[2];

    if (pipe(pipes))
        return;

    if (pthread_create(&mWorker, NULL, aapiSockWorker, (void*)(uintptr_t)pipes[0])) {
        close(pipes[0]);
        close(pipes[1]);
        return;
    }
    mWorkerPipe = pipes[1];
    mSocksUp = true;
    mSocksWantUp = false;
}

/*
 * FUNCTION: aapiSockWorkerMsgSend
 * USE:      Wake up aapi.sock worker with a message
 * PARAMS:   msg - the message
 *           aux - additional data for said message
 * RETURN:   NONE
 * NOTES:
 */
static void aapiSockWorkerMsgSend(uint8_t msg, void *aux)
{
    uint8_t t = msg;

    r_write(mWorkerPipe, &t, 1);
    r_write(mWorkerPipe, &aux, sizeof(void*));
}

/*
 * FUNCTION: aapiSockAlloc
 * USE:      Create a sock struct and link it into the list
 * PARAMS:   type - socket type (as per bt iface)
 *           sockType - local socket type (for linux kernel, SOCK_STREAM/SOCK_DGRAM)
 * RETURN:   sock struct or NULL on error
 * NOTES:    call with mSocksLock held
 */
static struct aapiSock* aapiSockAlloc(btsock_type_t type, int sockType)
{
    struct aapiSock *sock = calloc(1, sizeof(struct aapiSock));
    int socks[2], ret;

    if (!sock)
        return NULL;

    ret = socketpair(AF_LOCAL, sockType, 0, socks);
    if (ret) {
        free(sock);
        return NULL;
    }

    fcntl(socks[0], F_SETFL, O_NONBLOCK | fcntl(socks[0], F_GETFL));

    sock->type = type;
    sock->fd = socks[0];
    sock->java_fd = socks[1];
    sock->next = mSocks;
    if (mSocks)
        mSocks->prev = sock;
    mSocks = sock;

    return sock;
}

/*
 * FUNCTION: aapiSockAllocRfc
 * USE:      Create an RFC sock struct and link it into the list
 * PARAMS:   chNum - the chNum to save in the sock
 *           state - the state to put it into
 * RETURN:   sock struct or NULL on error
 * NOTES:    call with mSocksLock held
 */
static struct aapiSock* aapiSockAllocRfc(uint8_t chNum, uint8_t state)
{
    struct aapiSock *sock = NULL;

    sg bufTx = sgNew();
    sg bufRx = sgNew();

    if (!bufTx && ! bufRx) {
        if (bufTx)
            sgFree(bufTx);
        if (bufRx)
            sgFree(bufRx);
        return NULL;
    }

    sock = aapiSockAlloc(BTSOCK_RFCOMM, SOCK_STREAM);
    if (sock) {
        sock->rfc.chNum = chNum;
        sock->rfc.state = state;
        sock->rfc.bufTx = bufTx;
        sock->rfc.bufRx = bufRx;
    } else {
        sgFree(bufTx);
        sgFree(bufRx);
    }

    return sock;
}

/*
 * FUNCTION: aapiSockFree
 * USE:      Free a socket struct
 * PARAMS:   sock - the socket struct
 * RETURN:   NONE
 * NOTES:    call with mSocksLock held
 */
static void aapiSockFree(struct aapiSock* sock)
{
    shutdown(sock->fd, SHUT_RDWR);
    close(sock->fd);

    if (sock->java_fd != -1)
        close(sock->java_fd);

    if (sock->prev)
        sock->prev->next = sock->next;
    else
        mSocks = sock->next;
    if (sock->next)
        sock->next->prev = sock->prev;
    switch (sock->type) {
    case BTSOCK_RFCOMM:
        if (sock->rfc.bufTx)
            sgFree(sock->rfc.bufTx);
        sock->rfc.bufTx = NULL;
        if (sock->rfc.bufRx)
            sgFree(sock->rfc.bufRx);
        sock->rfc.bufTx = NULL;
        if (sock->rfc.state == RFC_SOCK_STATE_LISTENING) {
            struct appiSockListener *sl, *p = NULL;
            for (sl = mListeners; sl && sl->sdpHandle != sock->rfc.sdpHandle; p = sl, sl = sl->next);
            if (!sl)
                logw("Failed to find listener object for closed listening socket\n");
            else {
                if (p)
                    p->next = sl->next;
                else
                    mListeners = sl->next;
                free(sl);
            }
            rfcStopListen(sock->rfc.chNum);
            sdpServiceDescriptorDel(sock->rfc.sdpHandle);
        } else if (sock->rfc.state == RFC_SOCK_STATE_RFC_STOP_LISTEN) {
            /* nothing to do here */
        } else if (sock->rfc.conn)
            rfcClose(sock->rfc.conn);
        if (sock->rfc.state == RFC_SOCK_STATE_RFC_CLOSED || sock->rfc.state == RFC_SOCK_STATE_RFC_STOP_LISTEN || sock->rfc.state == RFC_SOCK_STATE_LISTENING)
            free(sock);
        else
            sock->rfc.state = RFC_SOCK_STATE_AAPI_CLOSED;
        break;
    default:
        logw("Unknown socket type %u on close\n", sock->type);
        break;
    }
}

static bool aapiSockNotifyOfConnReq(struct aapiSock *srvSock, struct aapiSock *newSock)
{
    sock_connect_signal_t sig = {.size = sizeof(sock_connect_signal_t), .channel = srvSock->rfc.chNum, .status = 0, };
    uint8_t *sigBuf  = (uint8_t*)&sig;
    char cmsgBuf[CMSG_SPACE(1)] = {0,};
    int ret, len = sizeof(sig);
    struct cmsghdr *cmsg;
    struct msghdr msg = {0,};

    memcpy(sig.bd_addr.address, newSock->peer.addr, sizeof(sig.bd_addr.address));


    msg.msg_control = cmsgBuf;
    msg.msg_controllen = sizeof(cmsgBuf);
    cmsg = CMSG_FIRSTHDR(&msg);
    cmsg->cmsg_level = SOL_SOCKET;
    cmsg->cmsg_type = SCM_RIGHTS;
    cmsg->cmsg_len = CMSG_LEN(sizeof(newSock->java_fd));
    memcpy(CMSG_DATA(cmsg), &newSock->java_fd, sizeof(newSock->java_fd));

    while (len) {
        struct iovec ovec = {0,};

        ovec.iov_base = sigBuf;
        ovec.iov_len = len;

        msg.msg_iov = &ovec;
        msg.msg_iovlen = 1;

        do {
            ret = sendmsg(srvSock->fd, &msg, MSG_NOSIGNAL);
        } while (ret < 0 && errno == EINTR);

        if (ret == -1) {
            logd("sendmsg err: %d\n", errno);
            return false;
        }

        sigBuf += ret;
        len -= ret;

        memset(&msg, 0, sizeof(msg));
    }
    close(newSock->java_fd);
    newSock->java_fd = -1;

    return true;
}

/*
 * FUNCTION: aapiSockRfcListenAlloc
 * USE:      Called when a remote device tries to connect to our listening RFC socket
 * PARAMS:   userData - our socket
 *           peerAddr - the peer address
 *           chNum - the chNum
 * RETURN:   bt_status_t
 * NOTES:
 */
static void* aapiSockRfcListenAlloc(void *userData, const struct bt_addr *peerAddr, uint8_t chNum)
{
    /* we have no way to ask user to accept or not, so we accept for the user, and sort it out later */
    struct aapiSock *srvSock = (struct aapiSock*)userData;
    struct aapiSock *newSock;

    logd("Connection to "ADDRFMT"[%u] alloc\n", ADDRCONV(*peerAddr), chNum);

    pthread_mutex_lock(&mSocksLock);
    newSock = aapiSockAllocRfc(chNum, RFC_SOCK_STATE_AUTOACCEPTING);

    if (!newSock)
        goto out;

    logd("aapi sock alloc ch %u\n", chNum);
    srvSock->rfc.chNum = chNum; /* in case we get here before aapiSockListen() finishes */

    memcpy(&newSock->peer, peerAddr, sizeof(newSock->peer));
    if (!aapiSockNotifyOfConnReq(srvSock, newSock)) {
        loge("Failed to notify of new connection - closing server socket too\n");
        aapiSockFree(newSock);
        aapiSockWorkerMsgSend(WORKER_MSG_SOCK_DEL, srvSock);
        newSock = NULL;
    }

out:
    pthread_mutex_unlock(&mSocksLock);
    return newSock;
}

/*
 * FUNCTION: aapiSockRfcListenEvt
 * USE:      Called when an even arises on an RFC connection
 * PARAMS:   userData - unused
 *           instance - our socket
 *           evt - what happened
 *           s - the data
 * RETURN:   NONE
 * NOTES:
 */
static void aapiSockRfcListenEvt(void *userData, void *instance, uint8_t evt, sg s)
{
    struct aapiSock *sock = (struct aapiSock*)instance;

    logd("aapi sock evt %u ch %u\n", evt, sock->rfc.chNum);
    pthread_mutex_lock(&mSocksLock);

    switch (evt) {
    case RFC_EVT_OPEN:
        logd("Connection to "ADDRFMT"[%u] open\n", ADDRCONV(sock->peer), sock->rfc.chNum);
        if (sock->rfc.state != RFC_SOCK_STATE_AUTOACCEPTING)
            logw("Weird socket state %u on rfc open\n", sock->rfc.state);
        sock->rfc.state = RFC_SOCK_STATE_ESTABLISHED;
        sgSerialize(s, 0, sizeof(sock->rfc.conn), &sock->rfc.conn);
        sgFree(s);
        aapiSockWorkerMsgSend(WORKER_MSG_SOCK_ADD, sock);
        aapiSockWorkerMsgSend(WORKER_MSG_FD_CAN_TX, sock);
        break;
    case RFC_EVT_RX:
        if (sock->rfc.state != RFC_SOCK_STATE_ESTABLISHED) {
            logw("Dropping data for non-established socket in state %u\n", sock->rfc.state);
            sgFree(s);
        } else {
            sgConcat(sock->rfc.bufRx, s);
            if (sgLength(sock->rfc.bufRx) >= AAPI_RFC_MAX_BUF)
                rfcFlow(sock->rfc.conn, true);
            aapiSockWorkerMsgSend(WORKER_MSG_FD_CAN_RX, sock);
        }
        break;
    case RFC_EVT_MAY_SEND:
        logd("TX unthrottled in rfc\n");
        aapiSockWorkerMsgSend(WORKER_MSG_FD_CAN_TX, sock);
        break;
    case RFC_EVT_CLOSE:
        logd("Connection to "ADDRFMT"[%u] closed\n", ADDRCONV(sock->peer), sock->rfc.chNum);
        sock->rfc.conn = 0;
        if (sock->rfc.state == RFC_SOCK_STATE_AAPI_CLOSED)
            free(sock);
        else {
            sock->rfc.state = RFC_SOCK_STATE_RFC_CLOSED;
            aapiSockWorkerMsgSend(WORKER_MSG_SOCK_DEL, sock);
        }
    }
    pthread_mutex_unlock(&mSocksLock);
}

/*
 * FUNCTION: aapiSockListen
 * USE:      Listen for connections from a peer on a socket
 * PARAMS:   type - socket type
 *           serviceName - service name to advertise
 *           serviceUuid - service uuid to advertise
 *           channel - channel number
 *           sockFdP - store socket's FD here
 *           flags - other relevant flags
 * RETURN:   bt_status_t
 * NOTES:
 */
static bt_status_t aapiSockListen(btsock_type_t type, const char* serviceName, const uint8_t* serviceUuid, int channel, int* sockFdP, int flags)
{
    bt_status_t ret = BT_STATUS_FAIL;
    struct appiSockListener *sl = NULL, *p;
    struct aapiSock* sock;
    bool linkIn = true;
    uint8_t ch;


    pthread_mutex_lock(&mSocksLock);
    if (!mSocksUp) {
        logw("Refusing sock listen when socks not up\n");
        goto out;
    }

    for (p = NULL, sl = mListeners; sl && memcmp(sl->uuid, serviceUuid, sizeof(sl->uuid)); p = sl, sl = sl->next);
    if (sl) {
        logw("Sock listen when identical listener exists -> deleting old\n");
        for (sock = mSocks; sock; sock = sock->next) {
            if (sock->rfc.state != RFC_SOCK_STATE_LISTENING)
                continue;
            if (sock->rfc.sdpHandle == sl->sdpHandle)
                break;
        }
        if (sock) {
            logd("Previous identical socket found\n");
            sock->rfc.state = RFC_SOCK_STATE_RFC_STOP_LISTEN;
            rfcStopListen(sock->rfc.chNum);
            sock->rfc.chNum = 0;
            sdpServiceDescriptorDel(sl->sdpHandle);
            sock->rfc.sdpHandle = 0;
            aapiSockWorkerMsgSend(WORKER_MSG_SOCK_DEL, sock);
        } else {
            logw("Failed to find previous listening socket. SDP likely to be leaked->auto-freeing\n");
            sdpServiceDescriptorDel(sl->sdpHandle);
        }
        linkIn = false;
    } else
        sl = malloc(sizeof(struct appiSockListener));
    if (sl)
        memcpy(sl->uuid, serviceUuid, sizeof(sl->uuid));
    else {
        loge("Failed to alloc a listener record\n");
        goto out;
    }

    logd("AAPI.sock: listen(%u,'%s',%d,%u)\n", type, serviceName, channel, flags);

    if (type != BTSOCK_RFCOMM) {
        logw("Refusing non-RFCOMM sockets for now\n");
        goto out;
    }

    if (channel == -1) /* magic number! */
        ch = RFC_CHNUM_REQ_ANY;
    else if (channel < RFC_FIRST_CHAN || channel >= RFC_NUM_CHANS + RFC_FIRST_CHAN) {
        logw("Refusing RFCOMM listen on invalid channel %d\n", channel);
        goto out;
    } else ch = channel;

    sock = aapiSockAllocRfc(ch, RFC_SOCK_STATE_LISTENING); /* yes, "ch" might be RFC_CHNUM_REQ_ANY here. this is actually ok */
    if (!sock)
        goto out;

    ch = rfcListen(ch, aapiSockRfcListenAlloc, aapiSockRfcListenEvt, sock);
    if (!ch) {
        logw("Failed to RFC listen\n");
        goto out_sockfree;
    }

    sock->rfc.chNum = ch;
    logd("RFC ch %u opened for listening with name '%s'\n", ch, serviceName);

    /* XXX: this makes me feel dirty all over, but sadly andriod api demands this be sent as an int and in native byte order... */
    channel = ch; /* send the channel ID to java */
    if (!sgConcatBackCopy(sock->rfc.bufRx, &channel ,sizeof(channel))) {
        loge("Failed to enqueue channel number for java\n");
        goto out_stoplisten;
    }

    sock->rfc.sdpHandle = rfcAddSdpRecord(serviceUuid, ch, serviceName);
    logd("sock %p has atate %u and fd %u with sdp handle 0x%08x\n", sock, sock->rfc.state, sock->fd, sock->rfc.sdpHandle);
    if (!sock->rfc.sdpHandle) {
        loge("Failed to add SDP record\n");
        goto out_stoplisten;
    }

    sl->sdpHandle = sock->rfc.sdpHandle;
    if (linkIn) {
        sl->next = mListeners;
        mListeners = sl;
    }

    *sockFdP = sock->java_fd;
    sock->java_fd = -1;
    aapiSockWorkerMsgSend(WORKER_MSG_SOCK_ADD, sock);
    aapiSockWorkerMsgSend(WORKER_MSG_FD_CAN_RX, sock);
    ret = BT_STATUS_SUCCESS;
    goto out;

out_stoplisten:
    rfcStopListen(ch);

out_sockfree:
    aapiSockFree(sock);
out:
    pthread_mutex_unlock(&mSocksLock);
    return ret;
}

/*
 * FUNCTION: aapiSockConnect
 * USE:      Try to connect to a peer's matching listening socket
 * PARAMS:   bd_addr - peer address
 *           type - socket type
 *           uuid - service uuid
 *           channel - channel number
 *           sockFdP - store socket's FD here
 *           flags - other relevant flags
 * RETURN:   bt_status_t
 * NOTES:
 */
static bt_status_t aapiSockConnect(const bt_bdaddr_t *bd_addr, btsock_type_t type, const uint8_t* uuid, int channel, int* sockFdP, int flags)
{
    bt_status_t ret = BT_STATUS_FAIL;

    logd("AAPI.sock: connect(%02X:%02X:%02X:%02X:%02X:%02X,%u,%d,%u)\n",
         bd_addr->address[5], bd_addr->address[4], bd_addr->address[3], bd_addr->address[2], bd_addr->address[1], bd_addr->address[0],
         type, channel, flags);

    pthread_mutex_lock(&mSocksLock);
    if (!mSocksUp) {
        pthread_mutex_unlock(&mSocksLock);
        logw("Refusing sock connect when socks not up\n");
        goto out;
    }
    pthread_mutex_unlock(&mSocksLock);

    if (type != BTSOCK_RFCOMM) {
        logw("Refusing non-RFCOMM sockets for now\n");
        goto out;
    }

    if (channel != -1 && (channel < RFC_FIRST_CHAN || channel >= RFC_NUM_CHANS + RFC_FIRST_CHAN)) {
        logw("Refusing RFCOMM connect on invalid channel %d\n", channel);
        goto out;
    }

    //TODO

out:
    return ret;
}


/*
 * FUNCTION: aapiGetProfileIfaceSockets
 * USE:      Try to connect to a peer's matching listening socket
 * PARAMS:   bd_addr - peer address
 *           type - socket type
 *           uuid - service uuid
 *           channel - channel number
 *           sockFdP - store socket's FD here
 *           flags - other relevant flags
 * RETURN:   bt_status_t
 * NOTES:
 */
const void* aapiGetProfileIfaceSockets(void)
{
    static const btsock_interface_t sockIface = {
        .size = sizeof(btsock_interface_t),
        .listen = aapiSockListen,
        .connect = aapiSockConnect,
    };

    pthread_mutex_lock(&mSocksLock);
    if (mSocksUp)
        logd("socks up again\n");
    else if (!aapiIsStackUp())
        mSocksWantUp = true;
    else
        aapiSockDoInit();

    pthread_mutex_unlock(&mSocksLock);

    return &sockIface;
}

/*
 * FUNCTION: aapiSocketNotifStackState
 * USE:      Stack uses this to tell us of stack up/down state changes
 * PARAMS:   up - true if stack is now up, false else
 * RETURN:   NONE
 * NOTES:
 */
void aapiSocketNotifStackState(bool up)
{
    pthread_mutex_lock(&mSocksLock);
    if (up && !mSocksUp && mSocksWantUp) {
        logd("socks coming up now\n");
        aapiSockDoInit();
        pthread_mutex_unlock(&mSocksLock);
    } else if (!up) {
        mSocksWantUp = false;
        while (mListeners) {
            struct appiSockListener *sl = mListeners;
            mListeners = mListeners->next;
            free(sl);
        }
        pthread_mutex_unlock(&mSocksLock);
        if(mSocksUp) {
            aapiSockWorkerMsgSend(WORKER_MSG_QUIT, NULL);
            pthread_join(mWorker, NULL);
            close(mWorkerPipe);
        }
        mSocksUp = false;
    }
}