C-Style unsigned char parsing and manipulation Note that I'm using a C++ compiler ( hence, the cast on the calloc function calls) to do this, but the code is essentially C.

Basically, I have a typedef to an unsigned char known as viByte, which I'm using to create a string buffer to parse a file from binary (a TGA file, to be exact - but, that's irrelevant).

I'm writing basic functions for it right now; append, prepend, new, etc.

The problem is that, on the first iteration of the first loop in viByteBuf_Prepend, I get a segmentation fault. I need to know why, exactly, as this is something which could keep me up all night without some pointers (pun intended). 

I also would like to know if my algorithms are correct in terms of how the buffer is pre-pending the viByte string. For example, I have a feeling that using memset too much might be a bad idea, and whether or not my printf format for the unsigned char is correct (I have a feeling it isn't, as nothing is getting output to my console). 

Compiling on GCC, Linux.

#ifdef VI_BYTEBUF_DEBUG
void viByteBuf_TestPrepend( void )
{
    viByteBuf* buf = viByteBuf_New( 4 );

    buf-&gt;str = ( viByte* ) 0x1;

    printf(" Before viByteBuf_Prepend =&gt; %uc ", buf-&gt;str);

    viByteBuf_Prepend( buf, 3, ( viByte* ) 0x2 );

    printf(" After viByteBuf_Prepend =&gt; %uc ", buf-&gt;str);
}
#endif

viByteBuf* viByteBuf_New( unsigned int len )
{
    viByteBuf* buf = ( viByteBuf* ) calloc( sizeof( viByteBuf ), 1 );

    const int buflen = len + 1;

    buf-&gt;str = ( viByte* ) calloc( sizeof( viByte ), buflen );
    buf-&gt;len = buflen;

    buf-&gt;str[ buflen ] = '\0';

    return buf;
}

void viByteBuf_Prepend( viByteBuf* buf, unsigned int len, viByte* str )
{
    unsigned int pos, i;
    const unsigned int totallen = buf-&gt;len + len;
    viByteBuf* tmp = viByteBuf_New( totallen );
    viByte* strpos = buf-&gt;str;


    memset( tmp-&gt;str, 0, tmp-&gt;len );

    int index;

    for( i = 0; i &lt; buf-&gt;len; ++i )
    {

       index = ( buf-&gt;len - i ) - 1;

       *strpos = buf-&gt;str[ 0 ];
       ++strpos;
    }

    memset( buf-&gt;str, 0, buf-&gt;len );

    printf( "%uc\n", buf-&gt;str );

    i = totallen;

    for ( pos = 0; pos &lt; len; ++pos )
    {
        tmp-&gt;str[ pos ] = str[ pos ];
        tmp-&gt;str[ i ]   = buf-&gt;str[ i ];

        --i;
    }

    memset( buf-&gt;str, 0, buf-&gt;len );

    buf-&gt;len = tmp-&gt;len;

    memcpy( buf-&gt;str, tmp-&gt;str, tmp-&gt;len );

    viByteBuf_Free( tmp );

    //memset(  )
    //realloc( ( viByteBuf* ) buf, sizeof( viByteBuf ) * tmp-&gt;len );
}
Your problem is here:
buf-&gt;str[ buflen ] = '\0';

You allocate a buffer (str) of buflen bytes.
This means you can index it (str) from 0 -&gt; (buflen-1).
Thus the accesses above is writing one past the end of the buffer and corrupting memory.
You probably meant:
buf-&gt;str[ len ] = '\0';

Since you are using C++ compiler. You should use std::vector&lt;viByte&gt; or std::basic_string&lt;viByte&gt;.
This kind of bug is easy to introduce and unless you have good unit test hard to find. So why not use a class that already is unit test and has had 10 years of millions of people lookign at it to make sure it works correctly.
Other comments:
Broken and illegal.
    buf-&gt;str = ( viByte* ) 0x1;

Wrong. buf-&gt;str is a pointer and it was expecting a unsigned integer (they are not the same). Use %p to print a pointer value.
    printf(&quot; Before viByteBuf_Prepend =&gt; %uc &quot;, buf-&gt;str);

Broken and illegal (0x2 is not yours)
    viByteBuf_Prepend( buf, 3, ( viByte* ) 0x2 );

No check for NULL. (calloc can return NULL when it fails).
    viByteBuf* buf = ( viByteBuf* ) calloc( sizeof( viByteBuf ), 1 );

Again no check for NULL.
    buf-&gt;str = ( viByte* ) calloc( sizeof( viByte ), buflen );

Is this really what you want? Buflen includes the portion with the '\0' character. You need to be consistent and decide if len does or does not include the null.
    buf-&gt;len = buflen;

As pointed out above (write past the end of the buffer).
    buf-&gt;str[ buflen ] = '\0';

How do you handle failure?
As pointed out above calloc can fail. How do you propagate that failure to the caller.
    viByteBuf* tmp = viByteBuf_New( totallen );

Why are you nulling the whole array. You are just about to write over it.
Seems like a complete waste of time.
    memset( tmp-&gt;str, 0, tmp-&gt;len );

Looks like this loop is trying to reverse the string in place.
Which will fail as by the time you overwrite the first half the second half is a copy of the back half. Luckily it completely fails because you don't actually use the index variable.
    for( i = 0; i &lt; buf-&gt;len; ++i )
    {

       index = ( buf-&gt;len - i ) - 1;

       *strpos = buf-&gt;str[ 0 ];
       ++strpos;
    }

Now that you have failed to reverse it. You then overwrite it again with 0 (presumably to cover up the failure to reverse it).
    memset( buf-&gt;str, 0, buf-&gt;len );

Illegal parameter to printf() again.
    printf( &quot;%uc\n&quot;, buf-&gt;str );

More copying for unknow reason.
    memcpy( buf-&gt;str, tmp-&gt;str, tmp-&gt;len );

This code is so full of bugs. It has no write to work.