/*      $NetBSD: sdp_session.c,v 1.3 2010/11/13 19:43:56 plunky Exp $   */

/*-
 * Copyright (c) 2009 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Iain Hibbert.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: sdp_session.c,v 1.3 2010/11/13 19:43:56 plunky Exp $");

#include <sys/socket.h>
#include <sys/un.h>

#include <errno.h>
#include <sdp.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "sdp-int.h"

/*
 * open session with remote Bluetooth SDP server
 */
struct sdp_session *
_sdp_open(const bdaddr_t *laddr, const bdaddr_t *raddr)
{
        struct sdp_session *    ss;
        struct sockaddr_bt      sa;
        struct linger           li;
        socklen_t               len;

        ss = calloc(1, sizeof(struct sdp_session));
        if (ss == NULL)
                goto fail;

        ss->s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_L2CAP);
        if (ss->s == -1)
                goto fail;

        memset(&li, 0, sizeof(li));
        li.l_onoff = 1;
        li.l_linger = 5;
        if (setsockopt(ss->s, SOL_SOCKET, SO_LINGER, &li, sizeof(li)) == -1)
                goto fail;

        if (laddr == NULL)
                laddr = BDADDR_ANY;

        memset(&sa, 0, sizeof(sa));
        sa.bt_len = sizeof(sa);
        sa.bt_family = AF_BLUETOOTH;
        bdaddr_copy(&sa.bt_bdaddr, laddr);
        if (bind(ss->s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
                goto fail;

        sa.bt_psm = L2CAP_PSM_SDP;
        bdaddr_copy(&sa.bt_bdaddr, raddr);
        if (connect(ss->s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
                goto fail;

        len = sizeof(ss->imtu);
        if (getsockopt(ss->s, BTPROTO_L2CAP, SO_L2CAP_IMTU, &ss->imtu, &len) == -1)
                goto fail;

        ss->ibuf = malloc((size_t)(ss->imtu));
        if (ss->ibuf == NULL)
                goto fail;

        return ss;

fail:
        _sdp_close(ss);
        return NULL;
}

/*
 * open session with local SDP server
 */
struct sdp_session *
_sdp_open_local(const char *control)
{
        struct sdp_session *    ss;
        struct sockaddr_un      sa;

        ss = calloc(1, sizeof(struct sdp_session));
        if (ss == NULL)
                goto fail;

        ss->s = socket(PF_LOCAL, SOCK_STREAM, 0);
        if (ss->s == -1)
                goto fail;

        if (control == NULL)
                control = SDP_LOCAL_PATH;

        memset(&sa, 0, sizeof(sa));
        sa.sun_len = sizeof(sa);
        sa.sun_family = AF_LOCAL;
        strlcpy(sa.sun_path, control, sizeof(sa.sun_path));
        if (connect(ss->s, (struct sockaddr *)&sa, sizeof(sa)) == -1)
                goto fail;

        ss->imtu = L2CAP_MTU_DEFAULT;

        ss->ibuf = malloc((size_t)(ss->imtu));
        if (ss->ibuf == NULL)
                goto fail;

        return ss;

fail:
        _sdp_close(ss);
        return NULL;
}

/*
 * close session and release all resources
 */
void
_sdp_close(struct sdp_session *ss)
{

        if (ss == NULL)
                return;

        if (ss->s != -1)
                close(ss->s);

        if (ss->ibuf != NULL)
                free(ss->ibuf);

        if (ss->rbuf != NULL)
                free(ss->rbuf);

        free(ss);
}

/*
 * internal function; send a PDU on session
 *
 * caller provides an iovec array with an empty slot at the beginning for
 * PDU header, num is total iovec count.
 */
bool
_sdp_send_pdu(struct sdp_session *ss, uint8_t pid, struct iovec *iov, int num)
{
        sdp_pdu_t       pdu;
        ssize_t         len, nw;
        int             i;

        for (len = 0, i = 1; i < num; i++)
                len += iov[i].iov_len;

        if (len > UINT16_MAX) {
                errno = EMSGSIZE;
                return false;
        }

        ss->tid += 1;

        pdu.pid = pid;
        pdu.tid = htobe16(ss->tid);
        pdu.len = htobe16(len);

        iov[0].iov_base = &pdu;
        iov[0].iov_len = sizeof(pdu);

        do {
                nw = writev(ss->s, iov, num);
        } while (nw == -1 && errno == EINTR);

        if ((size_t)nw != sizeof(pdu) + len) {
                errno = EIO;
                return false;
        }

        return true;
}

/*
 * internal function; receive a PDU on session
 *
 * validate the PDU and transaction IDs and data length, stores
 * received data in the session incoming buffer.
 */
ssize_t
_sdp_recv_pdu(struct sdp_session *ss, uint8_t pid)
{
        struct iovec    iov[2];
        sdp_pdu_t       pdu;
        ssize_t         nr;

        iov[0].iov_base = &pdu;
        iov[0].iov_len = sizeof(pdu);

        iov[1].iov_base = ss->ibuf;
        iov[1].iov_len = ss->imtu;

        do {
                nr = readv(ss->s, iov, __arraycount(iov));
        } while (nr == -1 && errno == EINTR);

        if (nr == -1)
                return -1;

        if ((size_t)nr < sizeof(pdu)) {
                errno = EIO;
                return -1;
        }

        pdu.tid = be16toh(pdu.tid);
        pdu.len = be16toh(pdu.len);

        if (pid != pdu.pid
            || ss->tid != pdu.tid
            || (size_t)nr != sizeof(pdu) + pdu.len) {
                if (pdu.pid == SDP_PDU_ERROR_RESPONSE
                    && pdu.len == sizeof(uint16_t))
                        errno = _sdp_errno(be16dec(ss->ibuf));
                else
                        errno = EIO;

                return -1;
        }

        return pdu.len;
}

/*
 * translate ErrorCode to errno
 */
int
_sdp_errno(uint16_t ec)
{

        switch (ec) {
        case SDP_ERROR_CODE_INVALID_SERVICE_RECORD_HANDLE:
                return ENOATTR;

        case SDP_ERROR_CODE_INVALID_SDP_VERSION:
        case SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX:
        case SDP_ERROR_CODE_INVALID_PDU_SIZE:
        case SDP_ERROR_CODE_INVALID_CONTINUATION_STATE:
        case SDP_ERROR_CODE_INSUFFICIENT_RESOURCES:
        default:
                return EIO;
        }
}