/* Copyright (C) 2015 Open Information Security Foundation

 *

 * You can copy, redistribute or modify this Program under the terms of

 * the GNU General Public License version 2 as published by the Free

 * Software Foundation.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * version 2 along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA.

 */

/**

 * \file

 *

 * \author Jason Ish <jason.ish@oisf.net>

 *

 * This file contains the DNP3 object decoders.

 */

#include "suricata-common.h"

#include "app-layer-dnp3.h"

#include "app-layer-dnp3-objects.h"

void DNP3FreeObjectPoint(int group, int variation, void *point);

#if 0

static void DNP3HexDump(uint8_t *data, int len)

{

    for (int i = 0; i < len; i++) {

        printf("%02x ", data[i]);

    }

}

#endif

/**

 * \brief Allocate a list for DNP3 points.

 */

DNP3PointList *DNP3PointListAlloc(void)

{

    DNP3PointList *items = SCCalloc(1, sizeof(*items));

    if (unlikely(items == NULL)) {

        return NULL;

    }

    TAILQ_INIT(items);

    return items;

}

/**

 * \brief Free a DNP3PointList.

 */

void DNP3FreeObjectPointList(int group, int variation, DNP3PointList *list)

{

    DNP3Point *point;

    while ((point = TAILQ_FIRST(list)) != NULL) {

        TAILQ_REMOVE(list, point, next);

        if (point->data != NULL) {

            DNP3FreeObjectPoint(group, variation, point->data);

        }

        SCFree(point);

    }

    SCFree(list);

}

/**

 * \brief Read an uint8_t from a buffer.

 *

 * Reads a uint8_t from a buffer advancing the pointer and

 * decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadUint8(const uint8_t **buf, uint32_t *len, uint8_t *out)

{

    if (*len < (int)sizeof(*out)) {

        return 0;

    }

    *out = *(uint8_t *)(*buf);

    *buf += sizeof(*out);

    *len -= sizeof(*out);

    return 1;

}

/**

 * \brief Read an uint16_t from a buffer.

 *

 * Reads an uint16_t from a buffer advancing the pointer and

 * decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadUint16(const uint8_t **buf, uint32_t *len, uint16_t *out)

{

    if (*len < (int)sizeof(*out)) {

        return 0;

    }

    *out = DNP3_SWAP16(*(uint16_t *)(*buf));

    *buf += sizeof(*out);

    *len -= sizeof(*out);

    return 1;

}

/**

 * \brief Read an unsigned 24 bit integer from a buffer.

 *

 * Reads an an unsigned 24 bit integer from a buffer advancing the

 * pointer and decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadUint24(const uint8_t **buf, uint32_t *len, uint32_t *out)

{

    if (*len < (int)(sizeof(uint8_t) * 3)) {

        return 0;

    }

#if __BYTE_ORDER__ == __BIG_ENDIAN

    *out = ((uint32_t)(*buf)[0] << 16) | ((uint32_t)(*buf)[1] << 8) |

           (uint32_t)(*buf)[2];

#elif __BYTE_ORDER == __LITTLE_ENDIAN

    *out = ((uint64_t)(*buf)[0]) | ((uint64_t)(*buf)[1] << 8) |

           ((uint64_t)(*buf)[2] << 16);

#endif

    *buf += 3;

    *len -= 3;

    return 1;

}

/**

 * \brief Read an uint32_t from a buffer.

 *

 * Reads an uint32_t from a buffer advancing the pointer and

 * decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadUint32(const uint8_t **buf, uint32_t *len, uint32_t *out)

{

    if (*len < (int)sizeof(*out)) {

        return 0;

    }

    *out = DNP3_SWAP32(*(uint32_t *)(*buf));

    *buf += sizeof(*out);

    *len -= sizeof(*out);

    return 1;

}

/**

 * \brief Read an unsigned 48 bit integer from a buffer.

 *

 * Reads an an unsigned 48 bit integer from a buffer advancing the

 * pointer and decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadUint48(const uint8_t **buf, uint32_t *len, uint64_t *out)

{

    if (*len < (int)(sizeof(uint8_t) * 6)) {

        return 0;

    }

#if __BYTE_ORDER__ == __BIG_ENDIAN

    *out = ((uint64_t)(*buf)[0] << 40) | ((uint64_t)(*buf)[1] << 32) |

           ((uint64_t)(*buf)[2] << 24) | ((uint64_t)(*buf)[3] << 16) |

           ((uint64_t)(*buf)[4] << 8) | (uint64_t)(*buf)[5];

#elif __BYTE_ORDER == __LITTLE_ENDIAN

    *out = ((uint64_t)(*buf)[0]) | ((uint64_t)(*buf)[1] << 8) |

           ((uint64_t)(*buf)[2] << 16) | ((uint64_t)(*buf)[3] << 24) |

           ((uint64_t)(*buf)[4] << 32) | ((uint64_t)(*buf)[5] << 40);

#endif

    *buf += 6;

    *len -= 6;

    return 1;

}

/**

 * \brief Read a 32 bit float from a buffer.

 *

 * Reads an 32 bit float from a buffer advancing the pointer and

 * decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadFloat32(const uint8_t **buf, uint32_t *len, float *out)

{

    if (*len < 4) {

        return 0;

    }

#if __BYTE_ORDER == __LITTLE_ENDIAN

    *((uint8_t *)out + 0) = (*buf)[0];

    *((uint8_t *)out + 1) = (*buf)[1];

    *((uint8_t *)out + 2) = (*buf)[2];

    *((uint8_t *)out + 3) = (*buf)[3];

#else

    *((uint8_t *)out + 3) = (*buf)[0];

    *((uint8_t *)out + 2) = (*buf)[1];

    *((uint8_t *)out + 1) = (*buf)[2];

    *((uint8_t *)out + 0) = (*buf)[3];

#endif

    *len -= 4;

    *buf += 4;

    return 1;

}

/**

 * \brief Read a 64 bit float from a buffer.

 *

 * Reads an 64 bit float from a buffer advancing the pointer and

 * decrementing the length.

 *

 * \param buf A pointer to the buffer to read from.

 * \param len A pointer to the buffer length.

 * \param out A pointer to where the value will be stored.

 *

 * \retval Returns 1 if there was enough space in the buffer to read from,

 *    otherwise 0 is returned.

 */

static int DNP3ReadFloat64(const uint8_t **buf, uint32_t *len, double *out)

{

    if (*len < 8) {

        return 0;

    }

#if __BYTE_ORDER == __LITTLE_ENDIAN

    *((uint8_t *)out + 0) = (*buf)[0];

    *((uint8_t *)out + 1) = (*buf)[1];

    *((uint8_t *)out + 2) = (*buf)[2];

    *((uint8_t *)out + 3) = (*buf)[3];

    *((uint8_t *)out + 4) = (*buf)[4];

    *((uint8_t *)out + 5) = (*buf)[5];

    *((uint8_t *)out + 6) = (*buf)[6];

    *((uint8_t *)out + 7) = (*buf)[7];

#else

    *((uint8_t *)out + 7) = (*buf)[0];

    *((uint8_t *)out + 6) = (*buf)[1];

    *((uint8_t *)out + 5) = (*buf)[2];

    *((uint8_t *)out + 4) = (*buf)[3];

    *((uint8_t *)out + 3) = (*buf)[4];

    *((uint8_t *)out + 2) = (*buf)[5];

    *((uint8_t *)out + 1) = (*buf)[6];

    *((uint8_t *)out + 0) = (*buf)[7];

#endif

    *len -= 8;

    *buf += 8;

    return 1;

}

/**

 * \brief Get the prefix value and advance the buffer.

 */

static int DNP3ReadPrefix(

    const uint8_t **buf, uint32_t *len, uint8_t prefix_code, uint32_t *out)

{

    uint8_t prefix_len = 0;

    switch (prefix_code) {

        case 0x01:

        case 0x04:

            prefix_len = 1;

            break;

        case 0x02:

        case 0x05:

            prefix_len = 2;

            break;

        case 0x03:

        case 0x06:

            prefix_len = 4;

        default:

            break;

    }

    if (*len < (uint32_t)prefix_len) {

        return 0;

    }

    switch (prefix_len) {

        case sizeof(uint32_t):

            if (!DNP3ReadUint32(buf, len, out)) {

                return 0;

            }

            break;

        case sizeof(uint16_t): {

            /* Temp value for strict-aliasing. */

            uint16_t val = 0;

            if (!DNP3ReadUint16(buf, len, &val)) {

                return 0;

            }

            *out = val;

            break;

        }

        case sizeof(uint8_t): {

            /* Temp value for strict-aliasing. */

            uint8_t val = 0;

            if (!DNP3ReadUint8(buf, len, &val)) {

                return 0;

            }

            *out = val;

            break;

        }

        default:

            *out = 0;

            break;

    }

    return 1;

}

/**

 * \brief Add an object to a DNP3PointList.

 *

 * \retval 1 if successful, 0 on failure.

 */

static int DNP3AddPoint(DNP3PointList *list, void *object, uint32_t point_index,

    uint8_t prefix_code, uint32_t prefix)

{

    DNP3Point *point = SCCalloc(1, sizeof(*point));

    if (unlikely(point == NULL)) {

        return 0;

    }

    TAILQ_INSERT_TAIL(list, point, next);

    point->data = object;

    point->prefix = prefix;

    point->index = point_index;

    switch (prefix_code) {

        case 0x00:

            break;

        case 0x01:

        case 0x02:

        case 0x03:

            point->index = prefix;

            break;

        case 0x04:

        case 0x05:

        case 0x06:

            point->size = prefix;

            break;

        default:

            break;

    }

    return 1;

}

/* START GENERATED CODE */

/* Code generated by:

 *     ./scripts/dnp3-gen/dnp3-gen.py

 */

static int DNP3DecodeObjectG1V1(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG1V1 *object = NULL;

    uint32_t bytes = (count / 8) + 1;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

        goto error;

    }

    for (uint32_t i = 0; i < bytes; i++) {

        uint8_t octet;

        if (!DNP3ReadUint8(buf, len, &octet)) {

            goto error;

        }

        for (int j = 0; j < 8 && count; j = j + 1) {

            object = SCCalloc(1, sizeof(*object));

            if (unlikely(object == NULL)) {

                goto error;

            }

            object->state = (octet >> j) & 0x1;

            if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

                goto error;

            }

            object = NULL;

            count--;

            point_index++;

        }

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG1V2(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG1V2 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->reserved = (octet >> 6) & 0x1;

            object->state = (octet >> 7) & 0x1;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG2V1(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG2V1 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        if (!DNP3ReadUint8(buf, len, &object->state)) {

            goto error;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG2V2(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG2V2 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->reserved = (octet >> 6) & 0x1;

            object->state = (octet >> 7) & 0x1;

        }

        if (!DNP3ReadUint48(buf, len, &object->timestamp)) {

            goto error;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG2V3(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG2V3 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->reserved = (octet >> 6) & 0x1;

            object->state = (octet >> 7) & 0x1;

        }

        if (!DNP3ReadUint16(buf, len, &object->timestamp)) {

            goto error;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG3V1(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG3V1 *object = NULL;

    uint32_t bytes = (count / 8) + 1;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

        goto error;

    }

    for (uint32_t i = 0; i < bytes; i++) {

        uint8_t octet;

        if (!DNP3ReadUint8(buf, len, &octet)) {

            goto error;

        }

        for (int j = 0; j < 8 && count; j = j + 2) {

            object = SCCalloc(1, sizeof(*object));

            if (unlikely(object == NULL)) {

                goto error;

            }

            object->state = (octet >> j) & 0x3;

            if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

                goto error;

            }

            object = NULL;

            count--;

            point_index++;

        }

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG3V2(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG3V2 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->state = (octet >> 6) & 0x3;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG4V1(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG4V1 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->state = (octet >> 6) & 0x3;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG4V2(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG4V2 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->state = (octet >> 6) & 0x3;

        }

        if (!DNP3ReadUint48(buf, len, &object->timestamp)) {

            goto error;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG4V3(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG4V3 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->chatter_filter = (octet >> 5) & 0x1;

            object->state = (octet >> 6) & 0x3;

        }

        if (!DNP3ReadUint16(buf, len, &object->relative_time_ms)) {

            goto error;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG10V1(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG10V1 *object = NULL;

    uint32_t bytes = (count / 8) + 1;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

        goto error;

    }

    for (uint32_t i = 0; i < bytes; i++) {

        uint8_t octet;

        if (!DNP3ReadUint8(buf, len, &octet)) {

            goto error;

        }

        for (int j = 0; j < 8 && count; j = j + 1) {

            object = SCCalloc(1, sizeof(*object));

            if (unlikely(object == NULL)) {

                goto error;

            }

            object->state = (octet >> j) & 0x1;

            if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

                goto error;

            }

            object = NULL;

            count--;

            point_index++;

        }

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG10V2(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG10V2 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {

        goto error;

    }

    while (count--) {

        object = SCCalloc(1, sizeof(*object));

        if (unlikely(object == NULL)) {

            goto error;

        }

        if (!DNP3ReadPrefix(buf, len, prefix_code, &prefix)) {

            goto error;

        }

        {

            uint8_t octet;

            if (!DNP3ReadUint8(buf, len, &octet)) {

                goto error;

            }

            object->online = (octet >> 0) & 0x1;

            object->restart = (octet >> 1) & 0x1;

            object->comm_lost = (octet >> 2) & 0x1;

            object->remote_forced = (octet >> 3) & 0x1;

            object->local_forced = (octet >> 4) & 0x1;

            object->reserved0 = (octet >> 5) & 0x1;

            object->reserved1 = (octet >> 6) & 0x1;

            object->state = (octet >> 7) & 0x1;

        }

        if (!DNP3AddPoint(points, object, point_index, prefix_code, prefix)) {

            goto error;

        }

        object = NULL;

        point_index++;

    }

    return 1;

error:

    if (object != NULL) {

        SCFree(object);

    }

    return 0;

}

static int DNP3DecodeObjectG11V1(const uint8_t **buf, uint32_t *len,

    uint8_t prefix_code, uint32_t start, uint32_t count,

    DNP3PointList *points)

{

    DNP3ObjectG11V1 *object = NULL;

    uint32_t prefix = 0;

    uint32_t point_index = start;

    if (*len < count/8) {