/* $NetBSD$ */

/*-
 * Copyright (c) 2015-2016 Nathanial Sloss <nathanialsloss@yahoo.com.au>
 * Copyright (c) 2016-2019 Hans Petter Selasky <hps@selasky.org>
 * Copyright (c) 2019 Google LLC, written by Richard Kralovic <riso@google.com>
 *
 *              This software is dedicated to the memory of -
 *         Baron James Anlezark (Barry) - 1 Jan 1949 - 13 May 2012.
 *
 *              Barry was a man who loved his music.
 *
 * 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/uio.h>

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

#include "avdtp_signal.h"
#include "bt.h"

#define DPRINTF(...) printf("backend_bt: " __VA_ARGS__)

struct avdtpGetPacketInfo {
        uint8_t buffer_data[512];
        uint16_t buffer_len;
        uint8_t trans;
        uint8_t signalID;
};

static int avdtpAutoConfig(struct bt_config *);

/* Return received message type if success, < 0 if failure. */
static int
avdtpGetPacket(int fd, struct avdtpGetPacketInfo *info)
{
        uint8_t *pos = info->buffer_data;
        uint8_t *end = info->buffer_data + sizeof(info->buffer_data);
        uint8_t message_type;
        int len;

        memset(info, 0, sizeof(*info));

        /* Handle fragmented packets */
        for (int remaining = 1; remaining > 0; --remaining) {
                len = read(fd, pos, end - pos);

                if (len < AVDTP_LEN_SUCCESS)
                        return (-1);
                if (len == (int)(end - pos))
                        return (-1);    /* buffer too small */

                uint8_t trans = (pos[0] & TRANSACTIONLABEL) >> TRANSACTIONLABEL_S;
                uint8_t packet_type = (pos[0] & PACKETTYPE) >> PACKETTYPE_S;
                uint8_t current_message_type = (info->buffer_data[0] & MESSAGETYPE);
                uint8_t shift;
                if (pos == info->buffer_data) {
                        info->trans = trans;
                        message_type = current_message_type;
                        if (packet_type == singlePacket) {
                                info->signalID = (pos[1] & SIGNALID_MASK);
                                shift = 2;
                        } else {
                                if (packet_type != startPacket)
                                        return (-1);
                                remaining = pos[1];
                                info->signalID = (pos[2] & SIGNALID_MASK);
                                shift = 3;
                        }
                } else {
                        if (info->trans != trans ||
                            message_type != current_message_type ||
                            (remaining == 1 && packet_type != endPacket) ||
                            (remaining > 1 && packet_type != continuePacket)) {
                                return (-1);
                        }
                        shift = 1;
                }
                memmove(pos, pos + shift, len);
                pos += len;
        }
        info->buffer_len = pos - info->buffer_data;
        return (message_type);
}

/* Returns 0 on success, < 0 on failure. */
static int
avdtpSendPacket(int fd, uint8_t command, uint8_t trans, uint8_t type,
    uint8_t * data0, int datasize0, uint8_t * data1,
    int datasize1)
{
        struct iovec iov[3];
        uint8_t header[2];
        int retval;

        /* fill out command header */
        header[0] = (trans << 4) | (type & 3);
        if (command != 0)
                header[1] = command & 0x3f;
        else
                header[1] = 3;

        iov[0].iov_base = header;
        iov[0].iov_len = 2;
        iov[1].iov_base = data0;
        iov[1].iov_len = datasize0;
        iov[2].iov_base = data1;
        iov[2].iov_len = datasize1;

        retval = writev(fd, iov, 3);
        if (retval != (2 + datasize0 + datasize1))
                return (-EINVAL);
        else
                return (0);
}

/* Returns 0 on success, < 0 on failure. */
static int
avdtpSendSyncCommand(int fd, struct avdtpGetPacketInfo *info,
    uint8_t command, uint8_t type, uint8_t * data0,
    int datasize0, uint8_t * data1, int datasize1)
{
        static uint8_t transLabel;
        uint8_t trans;
        int retval;

        alarm(8);                       /* set timeout */

        trans = (transLabel++) & 0xF;

        retval = avdtpSendPacket(fd, command, trans, type,
            data0, datasize0, data1, datasize1);
        if (retval)
                goto done;
retry:
        switch (avdtpGetPacket(fd, info)) {
        case RESPONSEACCEPT:
                if (info->trans != trans)
                        goto retry;
                retval = 0;
                break;
        case RESPONSEREJECT:
                if (info->trans != trans)
                        goto retry;
                retval = -EINVAL;
                break;
        case COMMAND:
                retval = avdtpSendReject(fd, info->trans, info->signalID);
                if (retval == 0)
                        goto retry;
                break;
        default:
                retval = -ENXIO;
                break;
        }
done:
        alarm(0);                       /* clear timeout */

        return (retval);
}

/*
 * Variant for acceptor role: We support any frequency, blocks, bands, and
 * allocation. Returns 0 on success, < 0 on failure.
 */
static int
avdtpSendCapabilitiesResponseSBCForACP(int fd, int trans)
{
        uint8_t data[10];

        data[0] = mediaTransport;
        data[1] = 0;
        data[2] = mediaCodec;
        data[3] = 0x6;
        data[4] = mediaTypeAudio;
        data[5] = SBC_CODEC_ID;
        data[6] =
            (1 << (3 - MODE_STEREO)) |
            (1 << (3 - MODE_JOINT)) |
            (1 << (3 - MODE_DUAL)) |
            (1 << (3 - MODE_MONO)) |
            (1 << (7 - FREQ_44_1K)) |
            (1 << (7 - FREQ_48K)) |
            (1 << (7 - FREQ_32K)) |
            (1 << (7 - FREQ_16K));
        data[7] =
            (1 << (7 - BLOCKS_4)) |
            (1 << (7 - BLOCKS_8)) |
            (1 << (7 - BLOCKS_12)) |
            (1 << (7 - BLOCKS_16)) |
            (1 << (3 - BANDS_4)) |
            (1 << (3 - BANDS_8)) | (1 << ALLOC_LOUDNESS) | (1 << ALLOC_SNR);
        data[8] = MIN_BITPOOL;
        data[9] = DEFAULT_MAXBPOOL;

        return (avdtpSendPacket(fd, AVDTP_GET_CAPABILITIES, trans,
            RESPONSEACCEPT, data, sizeof(data), NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpSendAccept(int fd, uint8_t trans, uint8_t myCommand)
{
        return (avdtpSendPacket(fd, myCommand, trans, RESPONSEACCEPT,
            NULL, 0, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpSendReject(int fd, uint8_t trans, uint8_t myCommand)
{
        uint8_t value = 0;

        return (avdtpSendPacket(fd, myCommand, trans, RESPONSEREJECT,
            &value, 1, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpSendDiscResponseAudio(int fd, uint8_t trans,
    uint8_t mySep, uint8_t is_sink)
{
        uint8_t data[2];

        data[0] = mySep << 2;
        data[1] = mediaTypeAudio << 4 | (is_sink ? (1 << 3) : 0);

        return (avdtpSendPacket(fd, AVDTP_DISCOVER, trans, RESPONSEACCEPT,
            data, 2, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpDiscoverAndConfig(struct bt_config *cfg, bool isSink)
{
        struct avdtpGetPacketInfo info;
        uint16_t offset;
        uint8_t chmode = cfg->chmode;
        uint8_t aacMode1 = cfg->aacMode1;
        uint8_t aacMode2 = cfg->aacMode2;
        int retval;

        retval = avdtpSendSyncCommand(cfg->hc, &info, AVDTP_DISCOVER, 0,
            NULL, 0, NULL, 0);
        if (retval)
                return (retval);

        retval = -EBUSY;
        for (offset = 0; offset + 2 <= info.buffer_len; offset += 2) {
                cfg->sep = info.buffer_data[offset] >> 2;
                cfg->media_Type = info.buffer_data[offset + 1] >> 4;
                cfg->chmode = chmode;
                cfg->aacMode1 = aacMode1;
                cfg->aacMode2 = aacMode2;
                if (info.buffer_data[offset] & DISCOVER_SEP_IN_USE)
                        continue;
                if (info.buffer_data[offset + 1] & DISCOVER_IS_SINK) {
                        if (!isSink)
                                continue;
                } else {
                        if (isSink)
                                continue;
                }
                /* try to configure SBC */
                retval = avdtpAutoConfig(cfg);
                if (retval == 0)
                        return (0);
        }
        return (retval);
}

/* Returns 0 on success, < 0 on failure. */
static int
avdtpGetCapabilities(int fd, uint8_t sep, struct avdtpGetPacketInfo *info)
{
        uint8_t address = (sep << 2);

        return (avdtpSendSyncCommand(fd, info,
            AVDTP_GET_CAPABILITIES, 0, &address, 1,
            NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpSetConfiguration(int fd, uint8_t sep, uint8_t * data, int datasize)
{
        struct avdtpGetPacketInfo info;
        uint8_t configAddresses[2];

        configAddresses[0] = sep << 2;
        configAddresses[1] = INTSEP << 2;

        return (avdtpSendSyncCommand(fd, &info, AVDTP_SET_CONFIGURATION, 0,
            configAddresses, 2, data, datasize));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpOpen(int fd, uint8_t sep)
{
        struct avdtpGetPacketInfo info;
        uint8_t address = sep << 2;

        return (avdtpSendSyncCommand(fd, &info, AVDTP_OPEN, 0,
            &address, 1, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpStart(int fd, uint8_t sep)
{
        struct avdtpGetPacketInfo info;
        uint8_t address = sep << 2;

        return (avdtpSendSyncCommand(fd, &info, AVDTP_START, 0,
            &address, 1, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpClose(int fd, uint8_t sep)
{
        struct avdtpGetPacketInfo info;
        uint8_t address = sep << 2;

        return (avdtpSendSyncCommand(fd, &info, AVDTP_CLOSE, 0,
            &address, 1, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpSuspend(int fd, uint8_t sep)
{
        struct avdtpGetPacketInfo info;
        uint8_t address = sep << 2;

        return (avdtpSendSyncCommand(fd, &info, AVDTP_SUSPEND, 0,
            &address, 1, NULL, 0));
}

/* Returns 0 on success, < 0 on failure. */
int
avdtpAbort(int fd, uint8_t sep)
{
        struct avdtpGetPacketInfo info;
        uint8_t address = sep << 2;

        return (avdtpSendSyncCommand(fd, &info, AVDTP_ABORT, 0,
            &address, 1, NULL, 0));
}

static int
avdtpAutoConfig(struct bt_config *cfg)
{
        struct avdtpGetPacketInfo info;
        uint8_t freqmode;
        uint8_t blk_len_sb_alloc;
        uint8_t availFreqMode = 0;
        uint8_t availConfig = 0;
        uint8_t supBitpoolMin = 0;
        uint8_t supBitpoolMax = 0;
        uint8_t aacMode1 = 0;
        uint8_t aacMode2 = 0;
#ifdef HAVE_LIBAV
        uint8_t aacBitrate3 = 0;
        uint8_t aacBitrate4 = 0;
        uint8_t aacBitrate5 = 0;
#endif
        int retval;
        int i;

        retval = avdtpGetCapabilities(cfg->hc, cfg->sep, &info);
        if (retval) {
                DPRINTF("Cannot get capabilities\n");
                return (retval);
        }
retry:
        for (i = 0; (i + 1) < info.buffer_len;) {
#if 0
                DPRINTF("0x%x 0x%x 0x%x 0x%x 0x%x 0x%x\n",
                    info.buffer_data[i + 0],
                    info.buffer_data[i + 1],
                    info.buffer_data[i + 2],
                    info.buffer_data[i + 3],
                    info.buffer_data[i + 4], info.buffer_data[i + 5]);
#endif
                if (i + 2 + info.buffer_data[i + 1] > info.buffer_len)
                        break;
                switch (info.buffer_data[i]) {
                case mediaTransport:
                        break;
                case mediaCodec:
                        if (info.buffer_data[i + 1] < 2)
                                break;
                        /* check codec */
                        switch (info.buffer_data[i + 3]) {
                        case 0:                 /* SBC */
                                if (info.buffer_data[i + 1] < 6)
                                        break;
                                availFreqMode = info.buffer_data[i + 4];
                                availConfig = info.buffer_data[i + 5];
                                supBitpoolMin = info.buffer_data[i + 6];
                                supBitpoolMax = info.buffer_data[i + 7];
                                break;
                        case 2:                 /* MPEG2/4 AAC */
                                if (info.buffer_data[i + 1] < 8)
                                        break;
                                aacMode1 = info.buffer_data[i + 5];
                                aacMode2 = info.buffer_data[i + 6];
#ifdef HAVE_LIBAV
                                aacBitrate3 = info.buffer_data[i + 7];
                                aacBitrate4 = info.buffer_data[i + 8];
                                aacBitrate5 = info.buffer_data[i + 9];
#endif
                                break;
                        default:
                                break;
                        }
                }
                /* jump to next information element */
                i += 2 + info.buffer_data[i + 1];
        }
        aacMode1 &= cfg->aacMode1;
        aacMode2 &= cfg->aacMode2;

        /* Try AAC first */
        if (aacMode1 == cfg->aacMode1 && aacMode2 == cfg->aacMode2) {
#ifdef HAVE_LIBAV
                uint8_t config[12] = { mediaTransport, 0x0, mediaCodec,
                        0x8, 0x0, 0x02, 0x80, aacMode1, aacMode2, aacBitrate3,
                        aacBitrate4, aacBitrate5
                };

                if (avdtpSetConfiguration
                    (cfg->hc, cfg->sep, config, sizeof(config)) == 0) {
                        cfg->codec = CODEC_AAC;
                        return (0);
                }
#endif
        }
        /* Try SBC second */
        if (cfg->freq == FREQ_UNDEFINED)
                goto auto_config_failed;

        freqmode = (1 << (3 - cfg->freq + 4)) | (1 << (3 - cfg->chmode));

        if ((availFreqMode & freqmode) != freqmode) {
                DPRINTF("No frequency and mode match\n");
                goto auto_config_failed;
        }
        for (i = 0; i != 4; i++) {
                blk_len_sb_alloc = (1 << (i + 4)) |
                    (1 << (1 - cfg->bands + 2)) | (1 << cfg->allocm);

                if ((availConfig & blk_len_sb_alloc) == blk_len_sb_alloc)
                        break;
        }
        if (i == 4) {
                DPRINTF("No bands available\n");
                goto auto_config_failed;
        }
        cfg->blocks = (3 - i);

        if (cfg->allocm == ALLOC_SNR)
                supBitpoolMax &= ~1;

        if (cfg->chmode == MODE_DUAL || cfg->chmode == MODE_MONO)
                supBitpoolMax /= 2;

        if (cfg->bands == BANDS_4)
                supBitpoolMax /= 2;

        if (supBitpoolMax > cfg->bitpool)
                supBitpoolMax = cfg->bitpool;
        else
                cfg->bitpool = supBitpoolMax;

        do {
                uint8_t config[10] = { mediaTransport, 0x0, mediaCodec, 0x6,
                        0x0, 0x0, freqmode, blk_len_sb_alloc, supBitpoolMin,
                        supBitpoolMax
                };

                if (avdtpSetConfiguration
                    (cfg->hc, cfg->sep, config, sizeof(config)) == 0) {
                        cfg->codec = CODEC_SBC;
                        return (0);
                }
        } while (0);

auto_config_failed:
        if (cfg->chmode == MODE_STEREO) {
                cfg->chmode = MODE_MONO;
                cfg->aacMode2 ^= 0x0C;
                goto retry;
        }
        return (-EINVAL);
}

void
avdtpACPFree(struct bt_config *cfg)
{
        if (cfg->handle.sbc_enc) {
                free(cfg->handle.sbc_enc);
                cfg->handle.sbc_enc = NULL;
        }
}

/* Returns 0 on success, < 0 on failure. */
static int
avdtpParseSBCConfig(uint8_t * data, struct bt_config *cfg)
{
        if (data[0] & (1 << (7 - FREQ_48K))) {
                cfg->freq = FREQ_48K;
        } else if (data[0] & (1 << (7 - FREQ_44_1K))) {
                cfg->freq = FREQ_44_1K;
        } else if (data[0] & (1 << (7 - FREQ_32K))) {
                cfg->freq = FREQ_32K;
        } else if (data[0] & (1 << (7 - FREQ_16K))) {
                cfg->freq = FREQ_16K;
        } else {
                return -EINVAL;
        }

        if (data[0] & (1 << (3 - MODE_STEREO))) {
                cfg->chmode = MODE_STEREO;
        } else if (data[0] & (1 << (3 - MODE_JOINT))) {
                cfg->chmode = MODE_JOINT;
        } else if (data[0] & (1 << (3 - MODE_DUAL))) {
                cfg->chmode = MODE_DUAL;
        } else if (data[0] & (1 << (3 - MODE_MONO))) {
                cfg->chmode = MODE_MONO;
        } else {
                return -EINVAL;
        }

        if (data[1] & (1 << (7 - BLOCKS_16))) {
                cfg->blocks = BLOCKS_16;
        } else if (data[1] & (1 << (7 - BLOCKS_12))) {
                cfg->blocks = BLOCKS_12;
        } else if (data[1] & (1 << (7 - BLOCKS_8))) {
                cfg->blocks = BLOCKS_8;
        } else if (data[1] & (1 << (7 - BLOCKS_4))) {
                cfg->blocks = BLOCKS_4;
        } else {
                return -EINVAL;
        }

        if (data[1] & (1 << (3 - BANDS_8))) {
                cfg->bands = BANDS_8;
        } else if (data[1] & (1 << (3 - BANDS_4))) {
                cfg->bands = BANDS_4;
        } else {
                return -EINVAL;
        }

        if (data[1] & (1 << ALLOC_LOUDNESS)) {
                cfg->allocm = ALLOC_LOUDNESS;
        } else if (data[1] & (1 << ALLOC_SNR)) {
                cfg->allocm = ALLOC_SNR;
        } else {
                return -EINVAL;
        }
        cfg->bitpool = data[3];
        return 0;
}

int
avdtpACPHandlePacket(struct bt_config *cfg)
{
        struct avdtpGetPacketInfo info;
        int retval;

        if (avdtpGetPacket(cfg->hc, &info) != COMMAND)
                return (-ENXIO);

        switch (info.signalID) {
        case AVDTP_DISCOVER:
                retval =
                    avdtpSendDiscResponseAudio(cfg->hc, info.trans, ACPSEP, 1);
                if (!retval)
                        retval = AVDTP_DISCOVER;
                break;
        case AVDTP_GET_CAPABILITIES:
                retval =
                    avdtpSendCapabilitiesResponseSBCForACP(cfg->hc, info.trans);
                if (!retval)
                        retval = AVDTP_GET_CAPABILITIES;
                break;
        case AVDTP_SET_CONFIGURATION:
                if (cfg->acceptor_state != acpInitial)
                        goto err;
                cfg->sep = info.buffer_data[1] >> 2;
                int is_configured = 0;
                for (int i = 2; (i + 1) < info.buffer_len;) {
                        if (i + 2 + info.buffer_data[i + 1] > info.buffer_len)
                                break;
                        switch (info.buffer_data[i]) {
                        case mediaTransport:
                                break;
                        case mediaCodec:
                                if (info.buffer_data[i + 1] < 2)
                                        break;
                                /* check codec */
                                switch (info.buffer_data[i + 3]) {
                                case 0:         /* SBC */
                                        if (info.buffer_data[i + 1] < 6)
                                                break;
                                        retval =
                                            avdtpParseSBCConfig(info.buffer_data + i + 4, cfg);
                                        if (retval)
                                                return retval;
                                        is_configured = 1;
                                        break;
                                case 2:         /* MPEG2/4 AAC */
                                        /* TODO: Add support */
                                default:
                                        break;
                                }
                        }
                        /* jump to next information element */
                        i += 2 + info.buffer_data[i + 1];
                }
                if (!is_configured)
                        goto err;

                retval =
                    avdtpSendAccept(cfg->hc, info.trans, AVDTP_SET_CONFIGURATION);
                if (retval)
                        return (retval);

                /* TODO: Handle other codecs */
                if (cfg->handle.sbc_enc == NULL) {
                        cfg->handle.sbc_enc = malloc(sizeof(*cfg->handle.sbc_enc));
                        if (cfg->handle.sbc_enc == NULL)
                                return (-ENOMEM);
                }
                memset(cfg->handle.sbc_enc, 0, sizeof(*cfg->handle.sbc_enc));

                retval = AVDTP_SET_CONFIGURATION;
                cfg->acceptor_state = acpConfigurationSet;
                break;
        case AVDTP_OPEN:
                if (cfg->acceptor_state != acpConfigurationSet)
                        goto err;
                retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
                if (retval)
                        return (retval);
                retval = info.signalID;
                cfg->acceptor_state = acpStreamOpened;
                break;
        case AVDTP_START:
                if (cfg->acceptor_state != acpStreamOpened &&
                    cfg->acceptor_state != acpStreamSuspended) {
                        goto err;
                }
                retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
                if (retval)
                        return retval;
                retval = info.signalID;
                cfg->acceptor_state = acpStreamStarted;
                break;
        case AVDTP_CLOSE:
                if (cfg->acceptor_state != acpStreamOpened &&
                    cfg->acceptor_state != acpStreamStarted &&
                    cfg->acceptor_state != acpStreamSuspended) {
                        goto err;
                }
                retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
                if (retval)
                        return (retval);
                retval = info.signalID;
                cfg->acceptor_state = acpStreamClosed;
                break;
        case AVDTP_SUSPEND:
                if (cfg->acceptor_state != acpStreamOpened &&
                    cfg->acceptor_state != acpStreamStarted) {
                        goto err;
                }
                retval = avdtpSendAccept(cfg->hc, info.trans, info.signalID);
                if (retval)
                        return (retval);
                retval = info.signalID;
                cfg->acceptor_state = acpStreamSuspended;
                break;
        case AVDTP_GET_CONFIGURATION:
        case AVDTP_RECONFIGURE:
        case AVDTP_ABORT:
                /* TODO: Implement this. */
        default:
err:
                avdtpSendReject(cfg->hc, info.trans, info.signalID);
                return (-ENXIO);
        }
        return (retval);
}