Module: WEBrick::HTTPUtils

Defined in:
lib/webrick/httputils.rb

Defined Under Namespace

Classes: FormData

Constant Summary collapse

DefaultMimeTypes = 
{
  "ai"    => "application/postscript",
  "asc"   => "text/plain",
  "avi"   => "video/x-msvideo",
  "bin"   => "application/octet-stream",
  "bmp"   => "image/bmp",
  "class" => "application/octet-stream",
  "cer"   => "application/pkix-cert",
  "crl"   => "application/pkix-crl",
  "crt"   => "application/x-x509-ca-cert",
 #"crl"   => "application/x-pkcs7-crl",
  "css"   => "text/css",
  "dms"   => "application/octet-stream",
  "doc"   => "application/msword",
  "dvi"   => "application/x-dvi",
  "eps"   => "application/postscript",
  "etx"   => "text/x-setext",
  "exe"   => "application/octet-stream",
  "gif"   => "image/gif",
  "htm"   => "text/html",
  "html"  => "text/html",
  "jpe"   => "image/jpeg",
  "jpeg"  => "image/jpeg",
  "jpg"   => "image/jpeg",
  "lha"   => "application/octet-stream",
  "lzh"   => "application/octet-stream",
  "mov"   => "video/quicktime",
  "mpe"   => "video/mpeg",
  "mpeg"  => "video/mpeg",
  "mpg"   => "video/mpeg",
  "pbm"   => "image/x-portable-bitmap",
  "pdf"   => "application/pdf",
  "pgm"   => "image/x-portable-graymap",
  "png"   => "image/png",
  "pnm"   => "image/x-portable-anymap",
  "ppm"   => "image/x-portable-pixmap",
  "ppt"   => "application/vnd.ms-powerpoint",
  "ps"    => "application/postscript",
  "qt"    => "video/quicktime",
  "ras"   => "image/x-cmu-raster",
  "rb"    => "text/plain",
  "rd"    => "text/plain",
  "rtf"   => "application/rtf",
  "sgm"   => "text/sgml",
  "sgml"  => "text/sgml",
  "tif"   => "image/tiff",
  "tiff"  => "image/tiff",
  "txt"   => "text/plain",
  "xbm"   => "image/x-xbitmap",
  "xls"   => "application/vnd.ms-excel",
  "xml"   => "text/xml",
  "xpm"   => "image/x-xpixmap",
  "xwd"   => "image/x-xwindowdump",
  "zip"   => "application/zip",
}
UNESCAPED = 
_make_regex(control+space+delims+unwise+nonascii)
UNESCAPED_FORM = 
_make_regex(reserved+control+delims+unwise+nonascii)
NONASCII = 
_make_regex(nonascii)
ESCAPED = 
/%([0-9a-fA-F]{2})/
UNESCAPED_PCHAR = 
_make_regex!(unreserved+":@&=+$,")

Class Method Summary collapse

Class Method Details

._escape(str, regex) ⇒ Object 



360
 
# File 'lib/webrick/httputils.rb', line 360

def _escape(str, regex) str.gsub(regex){ "%%%02X" % $1[0] } end

._make_regex(str) ⇒ Object 



358
 
# File 'lib/webrick/httputils.rb', line 358

def _make_regex(str) /([#{Regexp.escape(str)}])/n end

._make_regex!(str) ⇒ Object 



359
 
# File 'lib/webrick/httputils.rb', line 359

def _make_regex!(str) /([^#{Regexp.escape(str)}])/n end

._unescape(str, regex) ⇒ Object 



361
 
# File 'lib/webrick/httputils.rb', line 361

def _unescape(str, regex) str.gsub(regex){ $1.hex.chr } end

.dequote(str) ⇒ Object 



197
198
199
200
201
 
# File 'lib/webrick/httputils.rb', line 197

def dequote(str)
  ret = (/\A"(.*)"\Z/ =~ str) ? $1 : str.dup
  ret.gsub!(/\\(.)/, "\\1")
  ret
end

.escape(str) ⇒ Object 



369
370
371
 
# File 'lib/webrick/httputils.rb', line 369

def escape(str)
  _escape(str, UNESCAPED)
end

.escape8bit(str) ⇒ Object 



395
396
397
 
# File 'lib/webrick/httputils.rb', line 395

def escape8bit(str)
  _escape(str, NONASCII)
end

.escape_form(str) ⇒ Object 



377
378
379
380
381
 
# File 'lib/webrick/httputils.rb', line 377

def escape_form(str)
  ret = _escape(str, UNESCAPED_FORM)
  ret.gsub!(/ /, "+")
  ret
end

.escape_path(str) ⇒ Object 



387
388
389
390
391
392
393
 
# File 'lib/webrick/httputils.rb', line 387

def escape_path(str)
  result = ""
  str.scan(%r{/([^/]*)}).each{|i|
    result << "/" << _escape(i[0], UNESCAPED_PCHAR)
  }
  return result
end

.load_mime_types(file) ⇒ Object

Load Apache compatible mime.types file.



101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/webrick/httputils.rb', line 101

def load_mime_types(file)
  open(file){ |io|
    hash = Hash.new
    io.each{ |line|
      next if /^#/ =~ line
      line.chomp!
      mimetype, ext0 = line.split(/\s+/, 2)
      next unless ext0   
      next if ext0.empty?
      ext0.split(/\s+/).each{ |ext| hash[ext] = mimetype }
    }
    hash
  }
end

.mime_type(filename, mime_tab) ⇒ Object 



117
118
119
120
121
 
# File 'lib/webrick/httputils.rb', line 117

def mime_type(filename, mime_tab)
  suffix1 = (/\.(\w+)$/ =~ filename && $1.downcase)
  suffix2 = (/\.(\w+)\.[\w\-]+$/ =~ filename && $1.downcase)
  mime_tab[suffix1] || mime_tab[suffix2] || "application/octet-stream"
end

.normalize_path(path) ⇒ Object 



21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/webrick/httputils.rb', line 21

def normalize_path(path)
  raise "abnormal path `#{path}'" if path[0] != ?/
  ret = path.dup

  ret.gsub!(%r{/+}o, '/')                    # //      => /
  while ret.sub!(%r{/\.(/|\Z)}o, '/'); end   # /.      => /
  begin                                      # /foo/.. => /foo
    match = ret.sub!(%r{/([^/]+)/\.\.(/|\Z)}o){
      if $1 == ".."
        raise "abnormal path `#{path}'"
      else
        "/"
      end
    }
  end while match

  raise "abnormal path `#{path}'" if %r{/\.\.(/|\Z)} =~ ret
  ret
end

.parse_form_data(io, boundary) ⇒ Object 



314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/webrick/httputils.rb', line 314

def parse_form_data(io, boundary)
  boundary_regexp = /\A--#{boundary}(--)?#{CRLF}\z/
  form_data = Hash.new
  return form_data unless io
  data = nil
  io.each{|line|
    if boundary_regexp =~ line
      if data
        data.chop!
        key = data.name
        if form_data.has_key?(key)
          form_data[key].append_data(data)
        else
          form_data[key] = data 
        end
      end
      data = FormData.new
      next
    else
      if data
        data << line
      end
    end
  }
  return form_data
end

.parse_header(raw) ⇒ Object 



126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/webrick/httputils.rb', line 126

def parse_header(raw)
  header = Hash.new([].freeze)
  field = nil
  raw.each{|line|
    case line
    when /^([A-Za-z0-9!\#$%&'*+\-.^_`|~]+):\s*(.*?)\s*\z/om
      field, value = $1, $2
      field.downcase!
      header[field] = [] unless header.has_key?(field)
      header[field] << value
    when /^\s+(.*?)\s*\z/om
      value = $1
      unless field
        raise "bad header '#{line.inspect}'."
      end
      header[field][-1] << " " << value
    else
      raise "bad header '#{line.inspect}'."
    end
  }
  header.each{|key, values|
    values.each{|value|
      value.strip!
      value.gsub!(/\s+/, " ")
    }
  }
  header
end

.parse_query(str) ⇒ Object 



293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
 
# File 'lib/webrick/httputils.rb', line 293

def parse_query(str)
  query = Hash.new
  if str
    str.split(/[&;]/).each{|x|
      next if x.empty? 
      key, val = x.split(/=/,2)
      key = unescape_form(key)
      val = unescape_form(val.to_s)
      val = FormData.new(val)
      val.name = key
      if query.has_key?(key)
        query[key].append_data(val)
        next
      end
      query[key] = val
    }
  end
  query
end

.parse_qvalues(value) ⇒ Object 



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/webrick/httputils.rb', line 177

def parse_qvalues(value)
  tmp = []
  if value
    parts = value.split(/,\s*/)
    parts.each {|part|
      if m = %r{^([^\s,]+?)(?:;\s*q=(\d+(?:\.\d+)?))?$}.match(part)
        val = m[1]
        q = (m[2] or 1).to_f
        tmp.push([val, q])
      end
    }
    tmp = tmp.sort_by{|val, q| -q}
    tmp.collect!{|val, q| val}
  end
  return tmp
end

.parse_range_header(ranges_specifier) ⇒ Object 



162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/webrick/httputils.rb', line 162

def parse_range_header(ranges_specifier)
  if /^bytes=(.*)/ =~ ranges_specifier
    byte_range_set = split_header_value($1)
    byte_range_set.collect{|range_spec|
      case range_spec
      when /^(\d+)-(\d+)/ then $1.to_i .. $2.to_i
      when /^(\d+)-/      then $1.to_i .. -1
      when /^-(\d+)/      then -($1.to_i) .. -1
      else return nil
      end
    }
  end
end

.quote(str) ⇒ Object 



204
205
206
 
# File 'lib/webrick/httputils.rb', line 204

def quote(str)
  '"' << str.gsub(/[\\\"]/o, "\\\1") << '"'
end

.split_header_value(str) ⇒ Object 



156
157
158
159
 
# File 'lib/webrick/httputils.rb', line 156

def split_header_value(str)
  str.scan(/((?:"(?:\\.|[^"])+?"|[^",]+)+)
            (?:,\s*|\Z)/xn).collect{|v| v[0] }
end

.unescape(str) ⇒ Object 



373
374
375
 
# File 'lib/webrick/httputils.rb', line 373

def unescape(str)
  _unescape(str, ESCAPED)
end

.unescape_form(str) ⇒ Object 



383
384
385
 
# File 'lib/webrick/httputils.rb', line 383

def unescape_form(str)
  _unescape(str.gsub(/\+/, " "), ESCAPED)
end