docs: def get_post_file(self, hdr, f_in, clen, post, files):
          """Reads from a multipart/form-data."""
          lens = {
              'clen': clen,
              'push': [],
          }
          prefix = "boundary="
          if not hdr.startswith(prefix):
              return None
          boundary = hdr[len(prefix):].strip().encode('utf8')
          if not boundary:
              return None
          boundary = b'--' + boundary
          raw_boundary = b'\r\n' + boundary
          end_boundary = boundary + b'--'
  
          def push_back(line):
              ln = BytesIO()
              ln.write(line)
              ln.flush()
              ln.seek(0)
              lens['clen'] += len(line)
              lens['push'].append(ln)
  
          def read_line():
              line = b''
              while not line.endswith(b'\n') and lens['push']:
                  br = lens['push'].pop()
                  line += br.readline()
                  tmp = br.read(1)
                  if tmp != b'':
                      br.seek(br.tell() - 1)
                      lens['push'].append(br)
              if not line.endswith(b'\n'):
                  line += f_in.readline(lens['clen'])
              lens['clen'] -= len(line)
              if line == b'' or lens['clen'] < 0:
                  raise ValueError("Unexpected EOF")
              return line.strip()
  
          def read(length):
              res = b''
              while len(res) < length and lens['push']:
                  br = lens['push'].pop()
                  res += br.read(length - len(res))
                  tmp = br.read(1)
                  if tmp != b'':
                      br.seek(br.tell() - 1)
                      lens['push'].append(br)
              if len(res) < length:
                  res += f_in.read(length - len(res))
              lens['clen'] -= len(res)
              if res == b'' or lens['clen'] < 0:
                  raise ValueError("Unexpected EOF")
              return res
  
          def parse_file():
              f = BytesIO()
              buff_size = 10 * 1024
  
              def write_buff(buff):
                  if f.tell() + len(buff) > self.server.max_file_size:
                      raise PreventDefaultResponse(
                          413, "Uploaded file is too large! {0} > {1}".format(
                              f.tell() + len(buff), self.server.max_file_size))
                  f.write(buff)
                  f.flush()
  
              buff = b""
              while True:
                  buff += read(min(lens['clen'], buff_size))
                  bix = buff.find(raw_boundary)
                  if bix >= 0:
                      write_buff(buff[:bix])
                      push_back(buff[bix + len(raw_boundary) - len(boundary):])
                      break
                  out_split = max(len(buff) - len(raw_boundary), 0)
                  if out_split > 0:
                      write_buff(buff[:out_split])
                      buff = buff[out_split:]
              f.seek(0)
              return f
  
          def parse_field():
              return parse_file().read().decode('utf8')
  
          while True:
              line = read_line()
              if line == end_boundary:
                  if lens['clen'] > 0:
                      raise ValueError(
                          "Expected EOF got: {0}".format(
                              repr(f_in.read(lens['clen']))))
                  return
              if line != boundary:
                  raise ValueError(
                      "Expected boundary got: {0}".format(repr(line)))
              headers = {}
              while True:
                  line = read_line()
                  if not line:
                      break
                  key, value = line.split(b':', 1)
                  headers[key.lower()] = value.strip()
              name = None
              if b'content-disposition' in headers:
                  cdis = headers[b'content-disposition']
                  if not cdis.startswith(b'form-data'):
                      raise ValueError(
                          "Unknown content-disposition: {0}".format(repr(cdis)))
                  name_field = b'name="'
                  ix = cdis.find(name_field)
                  if ix >= 0:
                      name = cdis[ix + len(name_field):]
                      name = name[:name.index(b'"')].decode('utf8')
              ctype = None
              if b'content-type' in headers:
                  ctype = headers[b'content-type']
              # b'application/octet-stream': # we treat all files the same
              if ctype is not None:
                  files[name] = parse_file()
              else:
                  post[name] = parse_field()