"OverflowError: signed integer is greater than maximum" when streaming download

I was trying to download a 3GB using requests, to avoid having it all in memory i wanted to stream it and save the chunks to a file manually.

Unfortunately I got the following exception
```
---------------------------------------------------------------------------
OverflowError                             Traceback (most recent call last)
<ipython-input-7-bc1ab118995a> in <module>
----> 1 next(it)

/opt/venvs/venv2/lib/python3.8/site-packages/requests/models.py in generate()
    756             if hasattr(self.raw, 'stream'):
    757                 try:
--> 758                     for chunk in self.raw.stream(chunk_size, decode_content=True):
    759                         yield chunk
    760                 except ProtocolError as e:

/opt/venvs/venv2/lib/python3.8/site-packages/urllib3/response.py in stream(self, amt, decode_content)
    574         else:
    575             while not is_fp_closed(self._fp):
--> 576                 data = self.read(amt=amt, decode_content=decode_content)
    577 
    578                 if data:

/opt/venvs/venv2/lib/python3.8/site-packages/urllib3/response.py in read(self, amt, decode_content, cache_content)
    513             if amt is None:
    514                 # cStringIO doesn't like amt=None
--> 515                 data = self._fp.read() if not fp_closed else b""
    516                 flush_decoder = True
    517             else:

/usr/lib/python3.8/http/client.py in read(self, amt)
    469             else:
    470                 try:
--> 471                     s = self._safe_read(self.length)
    472                 except IncompleteRead:
    473                     self._close_conn()

/usr/lib/python3.8/http/client.py in _safe_read(self, amt)
    610         IncompleteRead exception can be used to detect the problem.
    611         """
--> 612         data = self.fp.read(amt)
    613         if len(data) < amt:
    614             raise IncompleteRead(data, amt-len(data))

/usr/lib/python3.8/socket.py in readinto(self, b)
    667         while True:
    668             try:
--> 669                 return self._sock.recv_into(b)
    670             except timeout:
    671                 self._timeout_occurred = True

/usr/lib/python3.8/ssl.py in recv_into(self, buffer, nbytes, flags)
   1239                   "non-zero flags not allowed in calls to recv_into() on %s" %
   1240                   self.__class__)
-> 1241             return self.read(nbytes, buffer)
   1242         else:
   1243             return super().recv_into(buffer, nbytes, flags)

/usr/lib/python3.8/ssl.py in read(self, len, buffer)
   1097         try:
   1098             if buffer is not None:
-> 1099                 return self._sslobj.read(len, buffer)
   1100             else:
   1101                 return self._sslobj.read(len)

OverflowError: signed integer is greater than maximum
```

My guess is that it has to do with 'Content-Length': '3221020463' being larger than 2**31\
combined with a file served over https, and using streaming and a `chunk_size = None`

## Reproduction Steps

```python
import requests
url = "https://dailymed-data.nlm.nih.gov/public-release-files/dm_spl_release_human_rx_part1.zip"
r = requests.get(url, stream=True)
it = r.iter_content(chunk_size=None)
next(it)
```

## System Information

    $ python -m requests.help

```json
{
  "chardet": {
    "version": null
  },
  "charset_normalizer": {
    "version": "2.0.7"
  },
  "cryptography": {
    "version": ""
  },
  "idna": {
    "version": "3.3"
  },
  "implementation": {
    "name": "CPython",
    "version": "3.8.5"
  },
  "platform": {
    "release": "5.4.0-48-generic",
    "system": "Linux"
  },
  "pyOpenSSL": {
    "openssl_version": "",
    "version": null
  },
  "requests": {
    "version": "2.26.0"
  },
  "system_ssl": {
    "version": "1010106f"
  },
  "urllib3": {
    "version": "1.26.7"
  },
  "using_charset_normalizer": true,
  "using_pyopenssl": false
}
```



This seems like a bug, Requests and urllib3 should only ask for a maximum number of bytes that OpenSSL is capable of handling at once. Perhaps we need a cap on the resolved `chunk_size` to be `max(sys.maxsize, content_length)`?

Yeah, this one kind of surprises me, I'd expect OpenSSL to be buffering input here. I think your solution makes sense @sethmlarson, but where do you think it should live? Requests is just passing `None` which has `read()` return as many bytes as possible. We'd need to start "chunking" the chunk inside `urllib3/response.py` to actually be safe in these situations. Otherwise, we'll be implementing the fix at both layers.

@nateprewitt Yeah this should be fixed in urllib3, not Requests. Wish we could transfer issues to repositories in different organizations! I'll open a new issue and point to this one.

Created: https://github.com/urllib3/urllib3/issues/2513

Thanks @sethmlarson! I'll resolve this in favor of the urllib3 tracking ticket.