Basically what you do is correct. Looking at redmine docs you linked to, it seems that suffix after the dot in the url denotes type of posted data (.json for JSON, .xml for XML), which agrees with the response you get - Processing by AttachmentsController#upload as XML. I guess maybe there's a bug in docs and to post binary data you should try using http://redmine/uploads url instead of http://redmine/uploads.xml.

Btw, I highly recommend very good and very popular Requests library for http in Python. It's much better than what's in the standard lib (urllib2). It supports authentication as well but I skipped it for brevity here.

import requests
with open('./x.png', 'rb') as f:
    data = f.read()
res = requests.post(url='http://httpbin.org/post',
                    data=data,
                    headers={'Content-Type': 'application/octet-stream'})

# let's check if what we sent is what we intended to send...
import json
import base64

assert base64.b64decode(res.json()['data'][len('data:application/octet-stream;base64,'):]) == data

UPDATE

To find out why this works with Requests but not with urllib2 we have to examine the difference in what's being sent. To see this I'm sending traffic to http proxy (Fiddler) running on port 8888:

Using Requests

import requests

data = 'test data'
res = requests.post(url='http://localhost:8888',
                    data=data,
                    headers={'Content-Type': 'application/octet-stream'})

we see

POST http://localhost:8888/ HTTP/1.1
Host: localhost:8888
Content-Length: 9
Content-Type: application/octet-stream
Accept-Encoding: gzip, deflate, compress
Accept: */*
User-Agent: python-requests/1.0.4 CPython/2.7.3 Windows/Vista

test data

and using urllib2

import urllib2

data = 'test data'    
req = urllib2.Request('http://localhost:8888', data)
req.add_header('Content-Length', '%d' % len(data))
req.add_header('Content-Type', 'application/octet-stream')
res = urllib2.urlopen(req)

we get

POST http://localhost:8888/ HTTP/1.1
Accept-Encoding: identity
Content-Length: 9
Host: localhost:8888
Content-Type: application/octet-stream
Connection: close
User-Agent: Python-urllib/2.7

test data

I don't see any differences which would warrant different behavior you observe. Having said that it's not uncommon for http servers to inspect User-Agent header and vary behavior based on its value. Try to change headers sent by Requests one by one making them the same as those being sent by urllib2 and see when it stops working.

Ask yourself this question: "What is the first byte of post data that I send to the server?". Do you see that you don't know -- it's whatever your platform happens to store as the first byte of the array, which will depend on how your particular CPU stores integers.

The server has no idea how your CPU stores integers, so you are sending it information there is no possible way it could make sense out of. You have to send the server a query that consists of bytes in whatever format the server expects, not whatever server your platform likes.

Also, you tell the server that you are going to send it bufferLength bytes, but then you send it bufferLength*sizeof(int) bytes. You must be consistent. (Presumably, you aren't on a platform that uses one-byte integers.)

The option in request library to send binary data as such is encoding: null. The default value of encoding is string so contents by default get converted to utf-8.

So the correct way to send binary data in the above example would be:

const makeWitSpeechRequest = (audioBinary) => {
  request({
    url: 'https://api.wit.ai/speech?v=20160526',
    method: 'POST',
    body: audioBinary,
    encoding: null
  }, (error, response, body) => {
    if (error) {
       console.log('Error sending message: ', error)
    } else {
      console.log('Response: ', response.body)
    }
  })
}

Will simply sending base64 encoded data work?

There is no need to use base 64 encoding - this will simply increase the number of bytes you must transfer. Mobile operators normally limit mangling of responses to content types that they understand - i.e. images, stylesheets, etc.

How are the HTTP sessions handled?

HTTP sessions are normally handled either via a URL query parameter or via a cookie value. However, from what you have said it doesn't sound like sessions are necessary.

Arbitrary sockets can be kept alive for a long time, but HTTP verbs are usually short lived. Does this mean I will need to create a new connection for each packet of data?

HTTP requests can last for an arbitrarily long period of time, just as for raw TCP sockets. A GET request can last for hours if necessary. You need not create a new connection for each request — take a look at the Connection: Keep-Alive HTTP header.

Or is there a way to send server responses in chunks, over a single connection?

If you don't know the length of the response you can either omit a Content-Length header or, preferably, use the Transfer-Encoding: chunked HTTP header.

In what ways can an ISP proxy mess with the data, or the headers? For example, a proxy can sometimes keep a connection alive, even if the server closes it.

ISPs don't tend to reveal the changes they make to HTTP responses. If you are concerned about this a simple solution would be to encrypt the data and specify a Content-Encoding HTTP header. This would require you to control both the HTTP client and server.

As expected, this is the same as the non-binary request. So, with the results being the same, what exactly is the difference between is passing a binary vs a non-binary request body? Are there any benefits to using binary data? If so, what are some examples when I would want to use binary data instead?

Many questions at once, let's decipher this:

So, with the results being the same, what exactly is the difference between is passing a binary vs a non-binary request body?

This has been mentioned in the comments and also in answers. The difference is that when not using "binary data" parsing might occur changing the meaning of the data (as raw binary data) to something different, like a file to upload or character encoding of the shell (which might apply as well to binary data but then it being less unexpected).

Are there any benefits to using binary data?

Yes, it's more expressive. You more correctly say which data you want to transfer under any circumstances (still modifications of option argument based on your shell rule might still apply).

If so, what are some examples when I would want to use binary data instead?

I'm lazy to provide these, so just do two tests, one with and one without. As you're testing and from your question you're expecting both to be the same. If you encode that expectation in the same test-case, you can add a data-provider and then add regressions when you run over them. These changes will answer your question(s) over time. Point in case is here, that if you can't answer the questiuon and even after feedback from Stackoverflow and other resources, you need to ensure that your expectations are fulfilled, even if these are two at once.

These are your tests. Write them as you understand them. If in error, fix them later. This is what version control is for. If you are in error, your tests will tell you. Use tests for your own needs. That is basically it. You might need to do changes in future as you were wrong. However the tests normally reflect your state of mind at the time you write them. So in this case, your tests should have alreay specified that you don't understand the difference between those two options, so just assert that both do the same thing. Document that by writing your test (but don't skip one option while you think it's the same but you're not really sure it is), and you will write the right test. You can fix tests later if you become aware of a mistake and at that time the change should fully document what you expect should be done. Don't hide your questions, assert the answers wihtin the test instead. A test is easy to run again, so you can easily check what you expect.

Yes. HTTP/1.1 message header blocks are text, but the payload of messages can be arbitrary binary data.

You should forget about MIME, that is only needed if you are sending multiple files to the server. Your best bet is to just send these headers, then a blank line, then your data:

POST /api/users HTTP/1.1
Accept: */*
Content-Type: application/octet-stream
Content-Length: 123

On the other end, you just look at "request.body" and it should have your binary data. (Replace 123 with sizeof(buffer))