Potentially broken deflate/zlib code

// ==========================================
// My deflate code is:
// ==========================================
int ret;
z_stream strm = {};

// 22 byte input: 34 byte output expected.
//
// -MAX_WBITS = 24 byte output
// MAX_WBITS = 30 byte output
// MAX_WBITS + 16 = 42 byte output

ret = deflateInit(&strm, 9); // 9 is maximum compression level
if (ret)
{
    std::stringstream error;
    error << "Error " << ret << " occurred with initiating compression.";
    return CreateError(error.str().c_str());
}

unsigned char * output_buffer = (unsigned char *)malloc(SendMsgSize + 256);
if (!output_buffer)
{
    deflateEnd(&strm);
    std::stringstream error;
    error << "Error with compressing send binary, could not allocate enough memory. Desired " << SendMsgSize + 256 << " bytes.";
    return CreateError(error.str().c_str());
}

strm.next_in = (unsigned char *)SendMsg;
strm.avail_in = SendMsgSize;

// Allocate memory for compression
strm.avail_out = _msize(output_buffer);
strm.next_out = output_buffer;

ret = deflate(&strm, Z_FINISH);
if (ret != Z_STREAM_END)
{
    std::stringstream error;
    error << "Error with compressing send binary, deflate() returned " << ret << ". Zlib error: " << (strm.msg ? strm.msg : "");
    free(output_buffer);
    deflateEnd(&strm);
    return CreateError(error.str().c_str());
}

deflateEnd(&strm);

void * output_bufferResize = realloc(output_buffer, strm.total_out);
if (!output_bufferResize)
{
    free(output_buffer); // realloc will not free on error
    CreateError("Error with compressing send binary, reallocating memory to remove excess space after compression failed.");
    return;
}
free(SendMsg);

SendMsg = (char *)output_bufferResize;
SendMsgSize = strm.total_out;


// ==========================================
// When inflating back, I use:
// ==========================================
z_stream strm = { };
int ret = inflateInit(&strm);
if (ret)
{
    std::stringstream error;
    error << "Error " << ret << " occurred with initiating decompression.";
    return CreateError(error.str().c_str());
}

unsigned char * output_buffer = NULL, *output_buffer_pointer = NULL;
strm.next_in = (unsigned char *)receivedMsg.content.data();
strm.avail_in = receivedMsg.content.size();
// run inflate() on input until output buffer not full, finish
// compression if all of source has been read in
do {
    // Expand memory for decompression
    output_buffer_pointer = (unsigned char *)realloc(output_buffer, (output_buffer ? _msize(output_buffer) : 0) + 1024);
    if (!output_buffer_pointer)
    {
        std::stringstream error;
        error << "Error with decompression, could not allocate enough memory. Desired "
            << (output_buffer ? _msize(output_buffer) : 0) + 1024 << " bytes.";
        free(output_buffer);

        inflateEnd(&strm);
        return CreateError(error.str().c_str());
    }

    output_buffer = output_buffer_pointer;
    output_buffer_pointer += _msize(output_buffer) - 1024;
    strm.avail_out = 1024;
    strm.next_out = output_buffer_pointer;
    ret = inflate(&strm, Z_FINISH);
    if (ret < Z_OK)
    {
        std::stringstream error;
        error << "Error with decompression, inflate() returned error " << ret
            << ". Zlib error: " << (strm.msg ? strm.msg : "");
        free(output_buffer);
        inflateEnd(&strm);
        return CreateError(error.str().c_str());
    }

} while (strm.avail_in != 0);

if (ret < 0)
{
    std::stringstream error;
    error << "Error with decompression: " << ret << ". Zlib error: " << (strm.msg ? strm.msg : "");
    inflateEnd(&strm);
    return CreateError(error.str().c_str());
}
inflateEnd(&strm);

// Update data with new message content
receivedMsg.content.assign((char *)output_buffer, _msize(output_buffer));