include/c/adbus-iterator.h

/* vim: ts=4 sw=4 sts=4 et
 *
 * Copyright (c) 2009 James R. McKaskill
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 * ----------------------------------------------------------------------------
 */

#ifndef ADBUS_ITERATOR_H
#define ADBUS_ITERATOR_H

#include <adbus.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <string.h>

struct adbus_Iterator
{
    const char*     data;   
    size_t          size;   
    const char*     sig;    
};

/* This alignment thing is from ORBit2
 * Align a value upward to a boundary, expressed as a number of bytes.
 * E.g. align to an 8-byte boundary with argument of 8.
 */

/*
 *   (this + boundary - 1)
 *          &
 *    ~(boundary - 1)
 */

#define ADBUS_ALIGN(PTR, BOUNDARY) \
  ((((uintptr_t) (PTR)) + (((uintptr_t) (BOUNDARY)) - 1)) & (~(((uintptr_t)(BOUNDARY))-1)))


ADBUS_INLINE int adbus_iter_align(adbus_Iterator* i, int alignment)
{
    size_t diff = (char*) ADBUS_ALIGN(i->data, alignment) - i->data;
    if (i->size < diff)
        return -1;

    i->data += diff;
    i->size -= diff;
    return 0;
}

ADBUS_INLINE int adbus_iter_alignfield(adbus_Iterator* i, char field)
{
    switch (field)
    {
        case 'y': // u8
        case 'g': // signature
        case 'v': // variant
            return 0;

        case 'n': // i16
        case 'q': // u16
            return adbus_iter_align(i,2);

        case 'b': // bool
        case 'i': // i32
        case 'u': // u32
        case 's': // string
        case 'o': // object path
        case 'a': // array
            return adbus_iter_align(i,4);

        case 'x': // i64
        case 't': // u64
        case 'd': // double
        case '(': // struct
        case '{': // dict entry
            return adbus_iter_align(i,8);

        default:
            assert(0);
            return -1;
    }
}

ADBUS_INLINE int adbusI_iter_sig(adbus_Iterator* i, char field)
{
    if (*i->sig++ != field) {
        assert(0);
        return -1;
    }
    return 0;
}

ADBUS_INLINE int adbusI_iter_get8(adbus_Iterator* i, const uint8_t** v)
{
    if (i->size < 1)
        return -1;

    if (v)
        *v = (const uint8_t*) i->data;
    i->data += 1;
    i->size -= 1;
    return 0;
}

ADBUS_INLINE int adbusI_iter_get16(adbus_Iterator* i, const uint16_t** v)
{
    if (adbus_iter_align(i, 2) || i->size < 2)
        return -1;

    if (v)
        *v = (const uint16_t*) i->data;
    i->data += 2;
    i->size -= 2;
    return 0;
}

ADBUS_INLINE int adbusI_iter_get32(adbus_Iterator* i, const uint32_t** v)
{
    if (adbus_iter_align(i, 4) || i->size < 4)
        return -1;

    if (v)
        *v = (const uint32_t*) i->data;
    i->data += 4;
    i->size -= 4;
    return 0;
}

ADBUS_INLINE int adbusI_iter_get64(adbus_Iterator* i, const uint64_t** v)
{
    if (adbus_iter_align(i, 8) || i->size < 8)
        return -1;

    if (v)
        *v = (const uint64_t*) i->data;
    i->data += 8;
    i->size -= 8;
    return 0;
}

ADBUS_INLINE int adbus_iter_bool(adbus_Iterator* i, const adbus_Bool** v)
{ return adbusI_iter_sig(i, 'b') || adbusI_iter_get32(i, (const uint32_t**) v); }

ADBUS_INLINE int adbus_iter_u8(adbus_Iterator* i, const uint8_t** v)
{ return adbusI_iter_sig(i, 'y') || adbusI_iter_get8(i, v); }

ADBUS_INLINE int adbus_iter_i16(adbus_Iterator* i, const int16_t** v)
{ return adbusI_iter_sig(i, 'n') || adbusI_iter_get16(i, (const uint16_t**) v); }

ADBUS_INLINE int adbus_iter_u16(adbus_Iterator* i, const uint16_t** v)
{ return adbusI_iter_sig(i, 'q') || adbusI_iter_get16(i, v); }

ADBUS_INLINE int adbus_iter_i32(adbus_Iterator* i, const int32_t** v)
{ return adbusI_iter_sig(i, 'i') || adbusI_iter_get32(i, (const uint32_t**) v); }

ADBUS_INLINE int adbus_iter_u32(adbus_Iterator* i, const uint32_t** v)
{ return adbusI_iter_sig(i, 'u') || adbusI_iter_get32(i, v); }

ADBUS_INLINE int adbus_iter_i64(adbus_Iterator* i, const int64_t** v)
{ return adbusI_iter_sig(i, 'x') || adbusI_iter_get64(i, (const uint64_t**) v); }

ADBUS_INLINE int adbus_iter_u64(adbus_Iterator* i, const uint64_t** v)
{ return adbusI_iter_sig(i, 't') || adbusI_iter_get64(i, v); }

ADBUS_INLINE int adbus_iter_double(adbus_Iterator* i, const double** v)
{ return adbusI_iter_sig(i, 'd') || adbusI_iter_get64(i, (const uint64_t**) v); }

ADBUS_INLINE int adbusI_iter_getstring(adbus_Iterator* i, size_t strsz, const char** pstr, size_t* pstrsz)
{
    const char* str = i->data;
    if (i->size < (size_t) (strsz + 1))
        return -1;
    if (memchr(str, '\0', strsz + 1) != str + strsz)
        return -1;
    i->data += strsz + 1;
    i->size -= strsz + 1;
    if (pstr)
        *pstr = str;
    if (pstrsz)
        *pstrsz = strsz;
    return 0;
}

ADBUS_INLINE int adbus_iter_string(adbus_Iterator* i, const char** str, size_t* strsz)
{
    const uint32_t* len;
    return adbusI_iter_sig(i, 's')
        || adbusI_iter_get32(i, &len)
        || adbusI_iter_getstring(i, *len, str, strsz);
}

ADBUS_INLINE int adbus_iter_objectpath(adbus_Iterator* i, const char** str, size_t* strsz)
{
    const uint32_t* len;
    return adbusI_iter_sig(i, 'o')
        || adbusI_iter_get32(i, &len)
        || adbusI_iter_getstring(i, *len, str, strsz);
}

ADBUS_INLINE int adbus_iter_signature(adbus_Iterator* i, const char** str, size_t* strsz)
{
    const uint8_t* len;
    return adbusI_iter_sig(i, 'g')
        || adbusI_iter_get8(i, &len)
        || adbusI_iter_getstring(i, *len, str, strsz);
}

struct adbus_IterArray
{
    const char* sig;    
    size_t sigsz;       
    const char* data;   
    size_t size;        
};

ADBUS_API const char* adbus_nextarg(const char* sig);

#define ADBUS_MAXIMUM_ARRAY_LENGTH 67108864

ADBUS_INLINE int adbus_iter_beginarray(adbus_Iterator* i, adbus_IterArray* a)
{
    const uint32_t* len;
    if (adbusI_iter_sig(i, 'a') || adbusI_iter_get32(i, &len))
        return -1;

    if (*len > ADBUS_MAXIMUM_ARRAY_LENGTH)
        return -1;

    if (adbus_iter_alignfield(i, *i->sig))
        return -1;

    const char* sigend = adbus_nextarg(i->sig);
    if (sigend == NULL)
        return -1;

    a->data  = i->data;
    a->size  = *len;
    a->sig   = i->sig;
    a->sigsz = sigend - a->sig;
    return 0;
}

ADBUS_INLINE adbus_Bool adbus_iter_inarray(adbus_Iterator* i, adbus_IterArray* a)
{
    if (i->data < a->data + a->size) {
        i->sig = a->sig;
        return 1;
    } else {
        return 0;
    }
}

ADBUS_INLINE int adbus_iter_endarray(adbus_Iterator* i, adbus_IterArray* a)
{
    i->data = a->data + a->size;
    i->sig = a->sig + a->sigsz;
    return 0;
}

ADBUS_INLINE int adbus_iter_begindictentry(adbus_Iterator* i)
{ return adbusI_iter_sig(i, '{') || adbus_iter_align(i, 8); }

ADBUS_INLINE int adbus_iter_enddictentry(adbus_Iterator* i)
{ return adbusI_iter_sig(i, '}'); }

ADBUS_INLINE int adbus_iter_beginstruct(adbus_Iterator* i)
{ return adbusI_iter_sig(i, '(') || adbus_iter_align(i, 8); }

ADBUS_INLINE int adbus_iter_endstruct(adbus_Iterator* i)
{ return adbusI_iter_sig(i, ')'); }

struct adbus_IterVariant
{
    const char* origsig;    
    const char* sig;        
    const char* data;       
    size_t size;            
};

ADBUS_INLINE int adbus_iter_beginvariant(adbus_Iterator* i, adbus_IterVariant* v)
{ 
    const char* vsig;
    const uint8_t* len;
    if (    adbusI_iter_sig(i, 'v')
        ||  adbusI_iter_get8(i, &len)
        ||  adbusI_iter_getstring(i, *len, &vsig, NULL)
        ||  adbus_iter_alignfield(i, *vsig))
    {
        return -1;
    }

    v->origsig = i->sig;
    v->data = i->data;
    v->sig = vsig;
    i->sig = vsig;
    return 0;
}

ADBUS_INLINE int adbus_iter_endvariant(adbus_Iterator* i, adbus_IterVariant* v)
{
    if (*i->sig)
        return -1;
    i->sig = v->origsig;
    v->size = i->data - v->data;
    return 0;
}


#endif /* ADBUS_ITERATOR_H */

---