Byte Stream implementation in C

Question

This is a byte stream implementation in C. Its usage and purpose should be evident from main.

Implementation is not finished; this is just start. Comments are still welcome.

.h:

#include <stdint.h>


typedef struct
{
    uint8_t * data;
    uint32_t length;
    uint32_t offset;
} ByteStream;


int32_t BSInitWithSize(ByteStream *bs, uint32_t len);
uint32_t BSNrOfRemainingBytes(ByteStream *bs);
int32_t BSFreeUnderlyingArray(ByteStream *bs);
void BSPrintContents(ByteStream *bs);
void BSRewind(ByteStream *bs);
int32_t BSPutU8(ByteStream *bs, uint8_t v);
int32_t BSGetU8(ByteStream *bs, uint8_t *out);
int32_t BSPutU16LE(ByteStream *bs, uint16_t v);

.c:

#include "ByteStream.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

int32_t BSInitWithSize(ByteStream *bs, uint32_t len)
{
    if (NULL == bs)
        return -1;

    // Allocate data array of sufficient length
    bs->data = (uint8_t*)malloc(len); // Note: Probably should check return value here
    memset(bs->data,0,len); // set values to nil

    bs->length = len;
    bs->offset = 0;

    return 0;
}

uint32_t BSNrOfRemainingBytes(ByteStream *bs)
{
    return bs->length - bs->offset;
}

void BSRewind(ByteStream *bs)
{
    bs->offset=0;
}

int32_t BSPutU8(ByteStream *bs, uint8_t v)
{
    if(BSNrOfRemainingBytes(bs)<1)
        return -1;

    bs->data[bs->offset]=v;
    bs->offset++;

    return 0;
}

int32_t BSGetU8(ByteStream *bs, uint8_t *out)
{
    if(BSNrOfRemainingBytes(bs)<1)
        return -1;

    bs->offset++;
    *out= bs->data[bs->offset-1];

    return 0;
}

int32_t BSPutU16LE(ByteStream *bs, uint16_t v)
{
    if(BSNrOfRemainingBytes(bs)<2)
        return -1;

    // This code compiles on LE machine, so
    // copying a integer to buffer will write
    // the integer into the buffer in a little endian way
    // exactly what this method is supposed to do
    // Note: Probably this is not portable
    memcpy(&bs->data[bs->offset],&v,2);
    bs->offset+=2;

    return 0;

}

void BSPrintContents(ByteStream *bs)
{
    int i = 0;
    for(i=0; i<bs->offset; i++)
    {
        printf("%02X ",bs->data[i]);
    }
}

int32_t BSFreeUnderlyingArray(ByteStream *bs)
{
    // Free underlying data array of BS object if it is not NULL
    if(NULL != bs->data)
    {
        free(bs->data);
        bs->data=NULL; // Set to NULL
        return 0;
    }

    return -1;
}

main:

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

extern "C"
{
#include "ByteStream.h"
}

int _tmain(int argc, _TCHAR* argv[])
{
    ByteStream b;
    memset(&b,0,sizeof(b));

    // Init bs
    BSInitWithSize(&b,14);

    // Add values
    for(int i=0;i<12;i++)
    {
        if(-1 == BSPutU8(&b, (uint8_t)i))
            printf("Error putting data \n");

        printf("Remaining Free Bytes: %d\n",BSNrOfRemainingBytes(&b));
    }

    // Rewind
    printf("---\n");
    BSRewind(&b);

    // Print values
    for(int i=0;i<12;i++)
    {
        uint8_t t;

        if(-1 == BSGetU8(&b, &t))
        {
            printf("ERROR Getting value \n");
        }
        else
            printf("Value at %d is %d \n", i, t);
    }

    // Put short integer in a little endian way
    if(-1 == BSPutU16LE(&b,765))
        printf("Error putting short \n");

    BSPrintContents(&b);

    // Free underlying buffer
    BSFreeUnderlyingArray(&b);


    return 0;
}

In many cases I decided to return error code from functions, and pass return values as out parameters.

Answer 1

A few things:

• You are casting the result of your calls to malloc. That is something you shouldn't do actually.
• If possible, try not to used fixed-size integer types (uint32_t, int32_t, etc...) for they are only conditionally supported by the compiler. For example, I doubt that you need a fixed-size type for your error codes. At least, use int_least32_t instead.
• When you are not using any format string, you should consider using puts to printf (e.g. puts("---") instead of printf("---\n"). That's both shorther and safer.
• Also, you initialize i to 0 twice in BSPrintContents. That seems pretty useless.