/*      $NetBSD: compat.c,v 1.2 2010/03/07 10:58:40 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: compat.c,v 1.2 2010/03/07 10:58:40 plunky Exp $");

#include <arpa/inet.h>

#include <netbt/rfcomm.h>

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

#include "sdpd.h"

/*
 * This file provides for compatibility with the old ABI. Clients send
 * a data structure and we generate a record based from that using the
 * server output buffer as temporary storage. The sdp_put functions will
 * not write invalid data or overflow the buffer which is big enough to
 * contain all these records, no need to worry about that.
 */

static bool
dun_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_dun_profile_t       *data = arg;
        uint8_t                 *first = buf->next;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_DIALUP_NETWORKING);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 12);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_DIALUP_NETWORKING);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Dialup Networking", -1);

        sdp_put_uint16(buf, SDP_ATTR_AUDIO_FEEDBACK_SUPPORT);
        sdp_put_bool(buf, data->audio_feedback_support);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
ftrn_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_ftrn_profile_t      *data = arg;
        uint8_t                 *first = buf->next;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_OBEX_FILE_TRANSFER);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 17);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_OBEX);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_OBEX_FILE_TRANSFER);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "OBEX File Transfer", -1);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
hset_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_hset_profile_t      *data = arg;
        uint8_t                 *first = buf->next;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_HEADSET_AUDIO_GATEWAY);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_GENERIC_AUDIO);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 12);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_HEADSET);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Voice Gateway", -1);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
hf_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_hf_profile_t        *data = arg;
        uint8_t                 *first = buf->next;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX
            || (data->supported_features & ~0x001f))
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_HANDSFREE);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_GENERIC_AUDIO);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 12);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_HANDSFREE);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Hands-Free unit", -1);

        sdp_put_uint16(buf, SDP_ATTR_SUPPORTED_FEATURES);
        sdp_put_uint16(buf, data->supported_features);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
irmc_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_irmc_profile_t      *data = arg;
        uint8_t                 *first = buf->next;
        int                     i;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX
            || data->supported_formats_size == 0
            || data->supported_formats_size > sizeof(data->supported_formats))
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_IR_MC_SYNC);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 17);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_OBEX);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_IR_MC_SYNC);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "IrMC Syncrhonization", -1);

        sdp_put_uint16(buf, SDP_ATTR_SUPPORTED_DATA_STORES_LIST);
        sdp_put_seq(buf, data->supported_formats_size * 2);
        for (i = 0; i < data->supported_formats_size; i++)
                sdp_put_uint8(buf, data->supported_formats[i]);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
irmc_cmd_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_irmc_command_profile_t      *data = arg;
        uint8_t                         *first = buf->next;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_IR_MC_SYNC_COMMAND);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 17);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_OBEX);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_IR_MC_SYNC_COMMAND);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Sync Command Service", -1);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
lan_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_lan_profile_t       *data = arg;
        uint8_t                 *first = buf->next;
        struct in_addr          in;
        char                    str[32];

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX
            || data->ip_subnet_radius > 32)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 12);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_AVAILABILITY);
        sdp_put_uint8(buf, data->load_factor);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "LAN Access using PPP", -1);

        in.s_addr= data->ip_subnet;
        sprintf(str, "%s/%d", inet_ntoa(in), data->ip_subnet_radius);
        sdp_put_uint16(buf, SDP_ATTR_IP_SUBNET);
        sdp_put_str(buf, str, -1);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
opush_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_opush_profile_t     *data = arg;
        uint8_t                 *first = buf->next;
        int                     i;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX
            || data->supported_formats_size == 0
            || data->supported_formats_size > sizeof(data->supported_formats))
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_OBEX_OBJECT_PUSH);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 17);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_OBEX);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_OBEX_OBJECT_PUSH);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "OBEX Object Push", -1);

        sdp_put_uint16(buf, SDP_ATTR_SUPPORTED_FORMATS_LIST);
        sdp_put_seq(buf, data->supported_formats_size * 2);
        for (i = 0; i < data->supported_formats_size; i++)
                sdp_put_uint8(buf, data->supported_formats[i]);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
sp_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_sp_profile_t        *data = arg;
        uint8_t                 *first = buf->next;

        if (len != sizeof(*data)
            || data->server_channel < RFCOMM_CHANNEL_MIN
            || data->server_channel > RFCOMM_CHANNEL_MAX)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_SERIAL_PORT);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 12);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_seq(buf, 5);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_RFCOMM);
        sdp_put_uint8(buf, data->server_channel);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_SERIAL_PORT);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Serial Port", -1);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

/* list of protocols used by PAN profiles.  */
static const uint16_t proto[] = {
        0x0800, /* IPv4 */
        0x0806, /* ARP  */
#ifdef INET6
        0x86dd, /* IPv6 */
#endif
};

static bool
nap_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_nap_profile_t       *data = arg;
        uint8_t                 *first = buf->next;
        size_t                  i;

        if (len != sizeof(*data)
            || L2CAP_PSM_INVALID(data->psm)
            || data->security_description > 0x0002)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_NAP);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 18 + 3 * __arraycount(proto));
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_uint16(buf, data->psm);
        sdp_put_seq(buf, 8 + 3 * __arraycount(proto));
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_BNEP);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */
        sdp_put_seq(buf, 3 * __arraycount(proto));
        for (i = 0; i < __arraycount(proto); i++)
                sdp_put_uint16(buf, proto[i]);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_AVAILABILITY);
        sdp_put_uint8(buf, data->load_factor);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_NAP);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Network Access Point", -1);

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_DESCRIPTION_OFFSET);
        sdp_put_str(buf, "Personal Ad-hoc Network Service", -1);

        sdp_put_uint16(buf, SDP_ATTR_SECURITY_DESCRIPTION);
        sdp_put_uint16(buf, data->security_description);

        sdp_put_uint16(buf, SDP_ATTR_NET_ACCESS_TYPE);
        sdp_put_uint16(buf, data->net_access_type);

        sdp_put_uint16(buf, SDP_ATTR_MAX_NET_ACCESS_RATE);
        sdp_put_uint32(buf, data->max_net_access_rate);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
gn_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_gn_profile_t        *data = arg;
        uint8_t                 *first = buf->next;
        size_t                  i;

        if (len != sizeof(*data)
            || L2CAP_PSM_INVALID(data->psm)
            || data->security_description > 0x0002)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_GN);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 18 + 3 * __arraycount(proto));
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_uint16(buf, data->psm);
        sdp_put_seq(buf, 8 + 3 * __arraycount(proto));
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_BNEP);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */
        sdp_put_seq(buf, 3 * __arraycount(proto));
        for (i = 0; i < __arraycount(proto); i++)
                sdp_put_uint16(buf, proto[i]);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_AVAILABILITY);
        sdp_put_uint8(buf, data->load_factor);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_GN);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Group Ad-hoc Network", -1);

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_DESCRIPTION_OFFSET);
        sdp_put_str(buf, "Personal Group Ad-hoc Network Service", -1);

        sdp_put_uint16(buf, SDP_ATTR_SECURITY_DESCRIPTION);
        sdp_put_uint16(buf, data->security_description);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static bool
panu_profile(sdp_data_t *buf, void *arg, ssize_t len)
{
        sdp_panu_profile_t      *data = arg;
        uint8_t                 *first = buf->next;
        size_t                  i;

        if (len != sizeof(*data)
            || L2CAP_PSM_INVALID(data->psm)
            || data->security_description > 0x0002)
                return false;

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_RECORD_HANDLE);
        sdp_put_uint32(buf, 0x00000000);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_CLASS_ID_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PANU);

        sdp_put_uint16(buf, SDP_ATTR_PROTOCOL_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 18 + 3 * __arraycount(proto));
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_L2CAP);
        sdp_put_uint16(buf, data->psm);
        sdp_put_seq(buf, 8 + 3 * __arraycount(proto));
        sdp_put_uuid16(buf, SDP_UUID_PROTOCOL_BNEP);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */
        sdp_put_seq(buf, 3 * __arraycount(proto));
        for (i = 0; i < __arraycount(proto); i++)
                sdp_put_uint16(buf, proto[i]);

        sdp_put_uint16(buf, SDP_ATTR_BROWSE_GROUP_LIST);
        sdp_put_seq(buf, 3);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PUBLIC_BROWSE_GROUP);

        sdp_put_uint16(buf, SDP_ATTR_LANGUAGE_BASE_ATTRIBUTE_ID_LIST);
        sdp_put_seq(buf, 9);
        sdp_put_uint16(buf, 0x656e);    /* "en" */
        sdp_put_uint16(buf, 106);       /* UTF-8 */
        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID);

        sdp_put_uint16(buf, SDP_ATTR_SERVICE_AVAILABILITY);
        sdp_put_uint8(buf, data->load_factor);

        sdp_put_uint16(buf, SDP_ATTR_BLUETOOTH_PROFILE_DESCRIPTOR_LIST);
        sdp_put_seq(buf, 8);
        sdp_put_seq(buf, 6);
        sdp_put_uuid16(buf, SDP_SERVICE_CLASS_PANU);
        sdp_put_uint16(buf, 0x0100);    /* v1.0 */

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_NAME_OFFSET);
        sdp_put_str(buf, "Personal Ad-hoc User Service", -1);

        sdp_put_uint16(buf, SDP_ATTR_PRIMARY_LANGUAGE_BASE_ID + SDP_ATTR_SERVICE_DESCRIPTION_OFFSET);
        sdp_put_str(buf, "Personal Ad-hoc User Service", -1);

        sdp_put_uint16(buf, SDP_ATTR_SECURITY_DESCRIPTION);
        sdp_put_uint16(buf, data->security_description);

        buf->end = buf->next;
        buf->next = first;
        return true;
}

static const struct {
        uint16_t        class;
        bool            (*create)(sdp_data_t *, void *, ssize_t);
} known[] = {
        { SDP_SERVICE_CLASS_DIALUP_NETWORKING,          dun_profile         },
        { SDP_SERVICE_CLASS_OBEX_FILE_TRANSFER,         ftrn_profile        },
        { SDP_SERVICE_CLASS_HEADSET_AUDIO_GATEWAY,      hset_profile        },
        { SDP_SERVICE_CLASS_HANDSFREE,                  hf_profile          },
        { SDP_SERVICE_CLASS_IR_MC_SYNC,                 irmc_profile        },
        { SDP_SERVICE_CLASS_IR_MC_SYNC_COMMAND,         irmc_cmd_profile    },
        { SDP_SERVICE_CLASS_LAN_ACCESS_USING_PPP,       lan_profile         },
        { SDP_SERVICE_CLASS_OBEX_OBJECT_PUSH,           opush_profile       },
        { SDP_SERVICE_CLASS_SERIAL_PORT,                sp_profile          },
        { SDP_SERVICE_CLASS_NAP,                        nap_profile         },
        { SDP_SERVICE_CLASS_GN,                         gn_profile          },
        { SDP_SERVICE_CLASS_PANU,                       panu_profile        },
};

uint16_t
compat_register_request(server_t *srv, int fd)
{
        sdp_data_t d, r;
        bdaddr_t bdaddr;
        uint16_t class;
        int i;

        log_debug("compat RegisterRequest by client on fd#%d", fd);

        if (!srv->fdidx[fd].control
            || !srv->fdidx[fd].priv)
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        srv->fdidx[fd].offset = 0;
        db_unselect(srv, fd);
        d.next = srv->ibuf;
        d.end = srv->ibuf + srv->pdu.len;

        if (d.next + sizeof(uint16_t) + sizeof(bdaddr_t) > d.end)
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        class = be16dec(d.next);
        d.next += sizeof(uint16_t);

        memcpy(&bdaddr, d.next, sizeof(bdaddr_t));
        d.next += sizeof(bdaddr_t);

        for (i = 0;; i++) {
                if (i == __arraycount(known))
                        return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

                if (known[i].class == class)
                        break;
        }

        r.next = srv->obuf;
        r.end = srv->obuf + srv->omtu;
        if (!(known[i].create(&r, d.next, d.end - d.next)))
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        if (!db_create(srv, fd, &bdaddr, srv->handle, &r))
                return SDP_ERROR_CODE_INSUFFICIENT_RESOURCES;

        /* successful return */
        be16enc(srv->obuf, 0x0000);
        be32enc(srv->obuf + sizeof(uint16_t), srv->handle++);
        srv->pdu.pid = SDP_PDU_ERROR_RESPONSE;
        srv->pdu.len = sizeof(uint16_t) + sizeof(uint32_t);
        return 0;
}

uint16_t
compat_change_request(server_t *srv, int fd)
{
        record_t *rec;
        sdp_data_t d, r;
        int i;

        log_debug("compat ChangeRequest by client on fd#%d", fd);

        if (!srv->fdidx[fd].control
            || !srv->fdidx[fd].priv)
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        srv->fdidx[fd].offset = 0;
        db_unselect(srv, fd);
        d.next = srv->ibuf;
        d.end = srv->ibuf + srv->pdu.len;

        if (d.next + sizeof(uint32_t) > d.end)
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        db_select_handle(srv, fd, be32dec(d.next));
        d.next += sizeof(uint32_t);

        rec = NULL;
        db_next(srv, fd, &rec);
        if (rec == NULL || rec->fd != fd)
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        /*
         * This is rather simplistic but it works. We don't keep a
         * record of the ServiceClass but we do know the format of
         * of the stored record and where it should be. If we dont
         * find it there, just give up.
         */
        r = rec->data;
        r.next += 3;            /* uint16 ServiceRecordHandle   */
        r.next += 5;            /* uint32 %handle%              */
        r.next += 3;            /* uint16 ServiceClassIDList    */
        r.next += 2;            /* seq8                         */
        for (i = 0;; i++) {
                if (i == __arraycount(known))
                        return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

                if (sdp_match_uuid16(&r, known[i].class))
                        break;
        }

        r.next = srv->obuf;
        r.end = srv->obuf + srv->omtu;
        if (!(known[i].create(&r, d.next, d.end - d.next)))
                return SDP_ERROR_CODE_INVALID_REQUEST_SYNTAX;

        if (!db_create(srv, fd, &rec->bdaddr, rec->handle, &r))
                return SDP_ERROR_CODE_INSUFFICIENT_RESOURCES;

        db_unselect(srv, fd);

        /* successful return */
        be16enc(srv->obuf, 0x0000);
        srv->pdu.pid = SDP_PDU_ERROR_RESPONSE;
        srv->pdu.len = sizeof(uint16_t);
        return 0;
}