Merge "HACK: cutils: restore record_stream temporarily"

/*

 * Copyright (C) 2006 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.

 */

/*

 * A simple utility for reading fixed records out of a stream fd

 */

#ifndef _CUTILS_RECORD_STREAM_H

#define _CUTILS_RECORD_STREAM_H

#ifdef __cplusplus

extern "C" {

#endif

typedef struct RecordStream RecordStream;

extern RecordStream *record_stream_new(int fd, size_t maxRecordLen);

extern void record_stream_free(RecordStream *p_rs);

extern int record_stream_get_next (RecordStream *p_rs, void ** p_outRecord, 

                                    size_t *p_outRecordLen);

#ifdef __cplusplus

}

#endif

#endif /*_CUTILS_RECORD_STREAM_H*/

	open_memstream.c \

	strdup16to8.c \

	strdup8to16.c \

	record_stream.c \

	process_name.c \

	threads.c \

	sched_policy.c \

/* libs/cutils/record_stream.c

**

** Copyright 2006, 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 <stdlib.h>

#include <unistd.h>

#include <assert.h>

#include <errno.h>

#include <cutils/record_stream.h>

#include <string.h>

#include <stdint.h>

#ifdef HAVE_WINSOCK

#include <winsock2.h>   /* for ntohl */

#else

#include <netinet/in.h>

#endif

#define HEADER_SIZE 4

struct RecordStream {

    int fd;

    size_t maxRecordLen;

    unsigned char *buffer;

    unsigned char *unconsumed;

    unsigned char *read_end;

    unsigned char *buffer_end;

};

extern RecordStream *record_stream_new(int fd, size_t maxRecordLen)

{

    RecordStream *ret;

    assert (maxRecordLen <= 0xffff);

    ret = (RecordStream *)calloc(1, sizeof(RecordStream));

    ret->fd = fd;

    ret->maxRecordLen = maxRecordLen;

    ret->buffer = (unsigned char *)malloc (maxRecordLen + HEADER_SIZE);

    ret->unconsumed = ret->buffer;

    ret->read_end = ret->buffer;

    ret->buffer_end = ret->buffer + maxRecordLen + HEADER_SIZE;

    return ret;

}

extern void record_stream_free(RecordStream *rs)

{

    free(rs->buffer);

    free(rs);

}

/* returns NULL; if there isn't a full record in the buffer */

static unsigned char * getEndOfRecord (unsigned char *p_begin,

                                            unsigned char *p_end)

{

    size_t len;

    unsigned char * p_ret;

    if (p_end < p_begin + HEADER_SIZE) {

        return NULL;

    }

    //First four bytes are length

    len = ntohl(*((uint32_t *)p_begin));

    p_ret = p_begin + HEADER_SIZE + len;

    if (p_end < p_ret) {

        return NULL;

    }

    return p_ret;

}

static void *getNextRecord (RecordStream *p_rs, size_t *p_outRecordLen)

{

    unsigned char *record_start, *record_end;

    record_end = getEndOfRecord (p_rs->unconsumed, p_rs->read_end);

    if (record_end != NULL) {

        /* one full line in the buffer */

        record_start = p_rs->unconsumed + HEADER_SIZE;

        p_rs->unconsumed = record_end;

        *p_outRecordLen = record_end - record_start;

        return record_start;

    }

    return NULL;

}

/**

 * Reads the next record from stream fd

 * Records are prefixed by a 16-bit big endian length value

 * Records may not be larger than maxRecordLen

 *

 * Doesn't guard against EINTR

 *

 * p_outRecord and p_outRecordLen may not be NULL

 *

 * Return 0 on success, -1 on fail

 * Returns 0 with *p_outRecord set to NULL on end of stream

 * Returns -1 / errno = EAGAIN if it needs to read again

 */

int record_stream_get_next (RecordStream *p_rs, void ** p_outRecord, 

                                    size_t *p_outRecordLen)

{

    void *ret;

    ssize_t countRead;

    /* is there one record already in the buffer? */

    ret = getNextRecord (p_rs, p_outRecordLen);

    if (ret != NULL) {

        *p_outRecord = ret;

        return 0;

    }

    // if the buffer is full and we don't have a full record

    if (p_rs->unconsumed == p_rs->buffer 

        && p_rs->read_end == p_rs->buffer_end

    ) {

        // this should never happen

        //ALOGE("max record length exceeded\n");

        assert (0);

        errno = EFBIG;

        return -1;

    }

    if (p_rs->unconsumed != p_rs->buffer) {

        // move remainder to the beginning of the buffer

        size_t toMove;

        toMove = p_rs->read_end - p_rs->unconsumed;

        if (toMove) {

            memmove(p_rs->buffer, p_rs->unconsumed, toMove);

        }

        p_rs->read_end = p_rs->buffer + toMove;

        p_rs->unconsumed = p_rs->buffer;

    }

    countRead = read (p_rs->fd, p_rs->read_end, p_rs->buffer_end - p_rs->read_end);

    if (countRead <= 0) {

        /* note: end-of-stream drops through here too */

        *p_outRecord = NULL;

        return countRead;

    }

    p_rs->read_end += countRead;

    ret = getNextRecord (p_rs, p_outRecordLen);

    if (ret == NULL) {

        /* not enough of a buffer to for a whole command */

        errno = EAGAIN;

        return -1;

    }

    *p_outRecord = ret;        

    return 0;

}