am bbf627a6: Merge "Remove unused code."

	fuse_adb_provider.c \

	sockets.c \

	services.c \

	utils.c

LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter

LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE

/*

 * Copyright (C) 2008 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 "utils.h"

#include <stdarg.h>

#include <stdio.h>

#include <string.h>

char*

buff_addc (char*  buff, char*  buffEnd, int  c)

{

    int  avail = buffEnd - buff;

    if (avail <= 0)  /* already in overflow mode */

        return buff;

    if (avail == 1) {  /* overflowing, the last byte is reserved for zero */

        buff[0] = 0;

        return buff + 1;

    }

    buff[0] = (char) c;  /* add char and terminating zero */

    buff[1] = 0;

    return buff + 1;

}

char*

buff_adds (char*  buff, char*  buffEnd, const char*  s)

{

    int  slen = strlen(s);

    return buff_addb(buff, buffEnd, s, slen);

}

char*

buff_addb (char*  buff, char*  buffEnd, const void*  data, int  len)

{

    int  avail = (buffEnd - buff);

    if (avail <= 0 || len <= 0)  /* already overflowing */

        return buff;

    if (len > avail)

        len = avail;

    memcpy(buff, data, len);

    buff += len;

    /* ensure there is a terminating zero */

    if (buff >= buffEnd) {  /* overflow */

        buff[-1] = 0;

    } else

        buff[0] = 0;

    return buff;

}

char*

buff_add  (char*  buff, char*  buffEnd, const char*  format, ... )

{

    int      avail;

    avail = (buffEnd - buff);

    if (avail > 0) {

        va_list  args;

        int      nn;

        va_start(args, format);

        nn = vsnprintf( buff, avail, format, args);

        va_end(args);

        if (nn < 0) {

            /* some C libraries return -1 in case of overflow,

             * but they will also do that if the format spec is

             * invalid. We assume ADB is not buggy enough to

             * trigger that last case. */

            nn = avail;

        }

        else if (nn > avail) {

            nn = avail;

        }

        buff += nn;

        /* ensure that there is a terminating zero */

        if (buff >= buffEnd)

            buff[-1] = 0;

        else

            buff[0] = 0;

    }

    return buff;

}

/*

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

 */

#ifndef _ADB_UTILS_H

#define _ADB_UTILS_H

#ifdef __cplusplus

extern "C" {

#endif

/* bounded buffer functions */

/* all these functions are used to append data to a bounded buffer.

 *

 * after each operation, the buffer is guaranteed to be zero-terminated,

 * even in the case of an overflow. they all return the new buffer position

 * which allows one to use them in succession, only checking for overflows

 * at the end. For example:

 *

 *    BUFF_DECL(temp,p,end,1024);

 *    char*    p;

 *

 *    p = buff_addc(temp, end, '"');

 *    p = buff_adds(temp, end, string);

 *    p = buff_addc(temp, end, '"');

 *

 *    if (p >= end) {

 *        overflow detected. note that 'temp' is

 *        zero-terminated for safety. 

 *    }

 *    return strdup(temp);

 */

/* tries to add a character to the buffer, in case of overflow

 * this will only write a terminating zero and return buffEnd.

 */

char*   buff_addc (char*  buff, char*  buffEnd, int  c);

/* tries to add a string to the buffer */

char*   buff_adds (char*  buff, char*  buffEnd, const char*  s);

/* tries to add a bytes to the buffer. the input can contain zero bytes,

 * but a terminating zero will always be appended at the end anyway

 */

char*   buff_addb (char*  buff, char*  buffEnd, const void*  data, int  len);

/* tries to add a formatted string to a bounded buffer */

char*   buff_add  (char*  buff, char*  buffEnd, const char*  format, ... );

/* convenience macro used to define a bounded buffer, as well as

 * a 'cursor' and 'end' variables all in one go.

 *

 * note: this doesn't place an initial terminating zero in the buffer,

 * you need to use one of the buff_ functions for this. or simply

 * do _cursor[0] = 0 manually.

 */

#define  BUFF_DECL(_buff,_cursor,_end,_size)   \

    char   _buff[_size], *_cursor=_buff, *_end = _cursor + (_size)

#ifdef __cplusplus

}

#endif

#endif /* _ADB_UTILS_H */