Module: Rack::Utils::Multipart

Defined in:

lib/rack/utils.rb

Overview

A multipart form data parser, adapted from IOWA.

Usually, Rack::Request#POST takes care of calling this.

Defined Under Namespace

Classes: UploadedFile

Constant Summary

EOL =

"\r\n"

MULTIPART_BOUNDARY =

"AaB03x"

Class Method Summary

• .build_multipart(params, first = true) ⇒ Object
• .parse_multipart(env) ⇒ Object

Class Method Details

.build_multipart(params, first = true) ⇒ Object

# File 'lib/rack/utils.rb', line 457

def self.build_multipart(params, first = true)
  if first
    unless params.is_a?(Hash)
      raise ArgumentError, "value must be a Hash"
    end

    multipart = false
    query = lambda { |value|
      case value
      when Array
        value.each(&query)
      when Hash
        value.values.each(&query)
      when UploadedFile
        multipart = true
      end
    }
    params.values.each(&query)
    return nil unless multipart
  end

  flattened_params = Hash.new

  params.each do |key, value|
    k = first ? key.to_s : "[#{key}]"

    case value
    when Array
      value.map { |v|
        build_multipart(v, false).each { |subkey, subvalue|
          flattened_params["#{k}[]#{subkey}"] = subvalue
        }
      }
    when Hash
      build_multipart(value, false).each { |subkey, subvalue|
        flattened_params[k + subkey] = subvalue
      }
    else
      flattened_params[k] = value
    end
  end

  if first
    flattened_params.map { |name, file|
      if file.respond_to?(:original_filename)
        ::File.open(file.path, "rb") do |f|
          f.set_encoding(Encoding::BINARY) if f.respond_to?(:set_encoding)
<<-EOF
--#{MULTIPART_BOUNDARY}\r
Content-Disposition: form-data; name="#{name}"; filename="#{Utils.escape(file.original_filename)}"\r
Content-Type: #{file.content_type}\r
Content-Length: #{::File.stat(file.path).size}\r
\r
#{f.read}\r
EOF
        end
      else
<<-EOF
--#{MULTIPART_BOUNDARY}\r
Content-Disposition: form-data; name="#{name}"\r
\r
#{file}\r
EOF
      end
    }.join + "--#{MULTIPART_BOUNDARY}--\r"
  else
    flattened_params
  end
end

.parse_multipart(env) ⇒ Object

# File 'lib/rack/utils.rb', line 355

def self.parse_multipart(env)
  unless env['CONTENT_TYPE'] =~
      %r|\Amultipart/.*boundary=\"?([^\";,]+)\"?|n
    nil
  else
    boundary = "--#{$1}"

    params = {}
    buf = ""
    content_length = env['CONTENT_LENGTH'].to_i
    input = env['rack.input']
    input.rewind

    boundary_size = Utils.bytesize(boundary) + EOL.size
    bufsize = 16384

    content_length -= boundary_size

    read_buffer = ''

    status = input.read(boundary_size, read_buffer)
    raise EOFError, "bad content body"  unless status == boundary + EOL

    rx = /(?:#{EOL})?#{Regexp.quote boundary}(#{EOL}|--)/n

    loop {
      head = nil
      body = ''
      filename = content_type = name = nil

      until head && buf =~ rx
        if !head && i = buf.index(EOL+EOL)
          head = buf.slice!(0, i+2) # First \r\n
          buf.slice!(0, 2)          # Second \r\n

          filename = head[/Content-Disposition:.* filename="?([^\";]*)"?/ni, 1]
          content_type = head[/Content-Type: (.*)#{EOL}/ni, 1]
          name = head[/Content-Disposition:.*\s+name="?([^\";]*)"?/ni, 1] || head[/Content-ID:\s*([^#{EOL}]*)/ni, 1]

          if content_type || filename
            body = Tempfile.new("RackMultipart")
            body.binmode  if body.respond_to?(:binmode)
          end

          next
        end

        # Save the read body part.
        if head && (boundary_size+4 < buf.size)
          body << buf.slice!(0, buf.size - (boundary_size+4))
        end

        c = input.read(bufsize < content_length ? bufsize : content_length, read_buffer)
        raise EOFError, "bad content body"  if c.nil? || c.empty?
        buf << c
        content_length -= c.size
      end

      # Save the rest.
      if i = buf.index(rx)
        body << buf.slice!(0, i)
        buf.slice!(0, boundary_size+2)

        content_length = -1  if $1 == "--"
      end

      if filename == ""
        # filename is blank which means no file has been selected
        data = nil
      elsif filename
        body.rewind

        # Take the basename of the upload's original filename.
        # This handles the full Windows paths given by Internet Explorer
        # (and perhaps other broken user agents) without affecting
        # those which give the lone filename.
        filename =~ /^(?:.*[:\\\/])?(.*)/m
        filename = $1

        data = {:filename => filename, :type => content_type,
                :name => name, :tempfile => body, :head => head}
      elsif !filename && content_type
        body.rewind

        # Generic multipart cases, not coming from a form
        data = {:type => content_type,
                :name => name, :tempfile => body, :head => head}
      else
        data = body
      end

      Utils.normalize_params(params, name, data) unless data.nil?

      break  if buf.empty? || content_length == -1
    }

    input.rewind

    params
  end
end