size_t written_size =
        CFWriteStreamWrite(cf_write_stream_, slice.begin(), slice.size());

    total_written_size += written_size;

#include <CoreFoundation/CoreFoundation.h>
#include <iostream>

void uploadFileToHTTP(const char *hostname, int port, const char *filePath) {
    CFStringRef hostString = CFStringCreateWithCString(kCFAllocatorDefault, hostname, kCFStringEncodingUTF8);
    CFReadStreamRef readStream = NULL;
    CFWriteStreamRef writeStream = NULL;
    CFStreamCreatePairWithSocketToHost(kCFAllocatorDefault, hostString, port, &readStream, &writeStream);

    if (writeStream) {
        if (CFWriteStreamOpen(writeStream)) {
            FILE *file = fopen(filePath, "rb");
            if (file) {
                fseek(file, 0, SEEK_END);
                long fileSize = ftell(file);
                fseek(file, 0, SEEK_SET);

                char headers[1024];
                snprintf(headers, sizeof(headers),
                         "POST /upload HTTP/1.1\r\n"
                         "Host: %s\r\n"
                         "Content-Type: application/octet-stream\r\n"
                         "Content-Length: %ld\r\n"
                         "Connection: close\r\n\r\n",
                         hostname, fileSize);

                CFIndex numBytesWritten = CFWriteStreamWrite(writeStream, (const UInt8 *)headers, strlen(headers));

                if (numBytesWritten < 0) {
                    // handle failure...
                    fclose(file);
                    CFWriteStreamClose(writeStream);
                    CFRelease(writeStream);
                    return;
                }

                const size_t bufferSize = 1024;
                UInt8 buffer[bufferSize];
                size_t bytesRead = 0;
                size_t chunks_nr = fileSize / bufferSize;
                int iter = 0;

                while ((bytesRead = fread(buffer, 1, bufferSize, file)) > 0) {
                    if (iter == chunks_nr - 1) {
                        //we simulate a 0-sized buffer write
                        std::cout << "writing 0-length buffer to WriteStream. chunk: "<< iter << std::endl;
                        numBytesWritten = CFWriteStreamWrite(writeStream, buffer, 0);
                        assert(numBytesWritten == 0);
                    }

                    // this call fails right after writing a 0-length buffer
                    numBytesWritten = CFWriteStreamWrite(writeStream, buffer, bytesRead);
                    if (numBytesWritten < 0) {
                        std::cout << "failed to write to WriteStream at chunk " << iter << " out of " << chunks_nr << std::endl;
                        break;
                    }

                    iter++;
                }

                fclose(file);
            } else {
                std::cout << "Failed to open file." << std::endl;
            }

            CFWriteStreamClose(writeStream);
        } else {
            std::cout << "Failed to open write stream." << std::endl;
        }

        CFRelease(writeStream);
    } else {
        std::cout << "Failed to create write stream." << std::endl;
    }

    if (hostString) CFRelease(hostString);
}

int main(int argc, char *argv[]) {
    if (argc != 4) {
        std::cout << "Usage: " << argv[0] << "<Hostname> <Port> <File Path> " << std::endl;
        return 1;
    }

    const char *hostname = argv[1];
    int port = atoi(argv[2]);
    const char *filePath = argv[3];
    uploadFileToHTTP(hostname, port, filePath);
    return 0;
}