Using zlib deflateBound() dynamically - dynamic-memory-allocation

Question

I have been looking at how to use deflateBound() dynamically and have not found exactly what I am looking for.
I looked at the manual for zlip, examples included in library and found these here:
Compression Libraries for ARM Cortex M3/4
Determine compressed/uncompressed buffer size for Z-lib in C
zlib, deflate: How much memory to allocate?
What I am missing is how to allocate after calling deflateBound().
E.g. this looks like it will cause problems
z_stream defstream;
uint8_t *outBuf=NULL;
uint32_t outLen=0;
defstream.zalloc = Z_NULL;
defstream.zfree = Z_NULL;
defstream.opaque = Z_NULL;
defstream.avail_in = (uInt)inLen;
defstream.next_in = (Bytef *)inBuf:
defstream.avail_out = (uInt)0;
defstream.next_out = (Bytef *)outBuf;
deflateInit(&defstream, Z_DEFAULT_COMPRESSION);
uint32_t estimateLen = deflateBound(&defstream, inLen);
outBuf = malloc(estimateLen);
defstream.avail_out = (uInt)estimateLen;
deflate(&defstream, Z_FINISH);
deflateEnd(&defstream);
I see realloc being mentioned, does this mean starting with an initial (probably too small) buffer is recommended?
z_stream defstream;
uint8_t *outBuf=NULL;
uint32_t outLen=100;
outBuf = malloc(outLen);
defstream.zalloc = Z_NULL;
defstream.zfree = Z_NULL;
defstream.opaque = Z_NULL;
defstream.avail_in = (uInt)inLen;
defstream.next_in = (Bytef *)inBuf:
defstream.avail_out = (uInt)outLen;
defstream.next_out = (Bytef *)outBuf;
deflateInit(&defstream, Z_DEFAULT_COMPRESSION);
uint32_t estimateLen = deflateBound(&defstream, inLen);
outBuf = realloc(outBufestimateLen);
defstream.avail_out = (uInt)estimateLen;
deflate(&defstream, Z_FINISH);
deflateEnd(&defstream);
Being an embedded system, I am trying to keep things simple.
Update 02/08/2019
the following code works (note Mark's fix):
static uint8_t *compressBuffer(char *inBuf, uint32_t *outLen)
{
uint32_t inLen = strlen(inBuf)+1; // +1 so the null terminator will get encoded
uint8_t *outBuf = NULL;
int result;
uint32_t tmpLen=0;
// initialize zlib
z_stream defstream;
defstream.zalloc = Z_NULL;
defstream.zfree = Z_NULL;
defstream.opaque = Z_NULL;
defstream.avail_in = inLen;
defstream.next_in = (Bytef *)inBuf;
defstream.avail_out = 0;
defstream.next_out = (Bytef *)outBuf;
if ((result = deflateInit(&defstream, Z_DEFAULT_COMPRESSION)) == Z_OK)
{
// calculate actual output length and update structure
uint32_t estimateLen = deflateBound(&defstream, inLen);
outBuf = malloc(estimateLen+10);
if (outBuf != NULL)
{
// update zlib configuration
defstream.avail_out = (uInt)estimateLen;
defstream.next_out = (Bytef *)outBuf;
// do the compression
deflate(&defstream, Z_FINISH);
tmpLen = (uint8_t*)defstream.next_out - outBuf;
}
}
// do the followimg regardless of outcome to leave in a good place
deflateEnd(&defstream);
// return whatever we have
*outLen = tmpLen;
return outBuf;
}

Answer 1

In both examples you are not setting next_out after the deflateBound(). You need defstream.next_out = (Bytef *)outBuf; after the malloc().
You do not need to do a realloc().