headius-mongrel 1.1.6.1

data/lib/mongrel/header_out.rb

@@ -0,0 +1,28 @@
+module Mongrel
+  # This class implements a simple way of constructing the HTTP headers dynamically
+  # via a Hash syntax.  Think of it as a write-only Hash.  Refer to HttpResponse for
+  # information on how this is used.
+  #
+  # One consequence of this write-only nature is that you can write multiple headers
+  # by just doing them twice (which is sometimes needed in HTTP), but that the normal
+  # semantics for Hash (where doing an insert replaces) is not there.
+  class HeaderOut
+    attr_reader :out
+    attr_accessor :allowed_duplicates
+
+    def initialize(out)
+      @sent = {}
+      @allowed_duplicates = {"Set-Cookie" => true, "Set-Cookie2" => true,
+        "Warning" => true, "WWW-Authenticate" => true}
+      @out = out
+    end
+
+    # Simply writes "#{key}: #{value}" to an output buffer.
+    def[]=(key,value)
+      if not @sent.has_key?(key) or @allowed_duplicates.has_key?(key)
+        @sent[key] = true
+        @out.write(Const::HEADER_FORMAT % [key, value])
+      end
+    end
+  end
+end

data/lib/mongrel/http_request.rb

@@ -0,0 +1,155 @@
+
+module Mongrel
+  #
+  # When a handler is found for a registered URI then this class is constructed
+  # and passed to your HttpHandler::process method.  You should assume that 
+  # *one* handler processes all requests.  Included in the HttpRequest is a
+  # HttpRequest.params Hash that matches common CGI params, and a HttpRequest.body
+  # which is a string containing the request body (raw for now).
+  #
+  # The HttpRequest.initialize method will convert any request that is larger than
+  # Const::MAX_BODY into a Tempfile and use that as the body.  Otherwise it uses 
+  # a StringIO object.  To be safe, you should assume it works like a file.
+  #
+  # The HttpHandler.request_notify system is implemented by having HttpRequest call
+  # HttpHandler.request_begins, HttpHandler.request_progress, HttpHandler.process during
+  # the IO processing.  This adds a small amount of overhead but lets you implement
+  # finer controlled handlers and filters.
+  #
+  class HttpRequest
+    attr_reader :body, :params
+
+    # You don't really call this.  It's made for you.
+    # Main thing it does is hook up the params, and store any remaining
+    # body data into the HttpRequest.body attribute.
+    def initialize(params, socket, dispatchers)
+      @params = params
+      @socket = socket
+      @dispatchers = dispatchers
+      content_length = @params[Const::CONTENT_LENGTH].to_i
+      remain = content_length - @params.http_body.length
+      
+      # tell all dispatchers the request has begun
+      @dispatchers.each do |dispatcher|
+        dispatcher.request_begins(@params) 
+      end unless @dispatchers.nil? || @dispatchers.empty?
+
+      # Some clients (like FF1.0) report 0 for body and then send a body.  This will probably truncate them but at least the request goes through usually.
+      if remain <= 0
+        # we've got everything, pack it up
+        @body = StringIO.new
+        @body.write @params.http_body
+        update_request_progress(0, content_length)
+      elsif remain > 0
+        # must read more data to complete body
+        if remain > Const::MAX_BODY
+          # huge body, put it in a tempfile
+          @body = Tempfile.new(Const::MONGREL_TMP_BASE)
+          @body.binmode
+        else
+          # small body, just use that
+          @body = StringIO.new 
+        end
+
+        @body.write @params.http_body
+        read_body(remain, content_length)
+      end
+
+      @body.rewind if @body
+    end
+
+    # updates all dispatchers about our progress
+    def update_request_progress(clen, total)
+      return if @dispatchers.nil? || @dispatchers.empty?
+      @dispatchers.each do |dispatcher|
+        dispatcher.request_progress(@params, clen, total) 
+      end 
+    end
+    private :update_request_progress
+
+    # Does the heavy lifting of properly reading the larger body requests in 
+    # small chunks.  It expects @body to be an IO object, @socket to be valid,
+    # and will set @body = nil if the request fails.  It also expects any initial
+    # part of the body that has been read to be in the @body already.
+    def read_body(remain, total)
+      begin
+        # write the odd sized chunk first
+        @params.http_body = read_socket(remain % Const::CHUNK_SIZE)
+
+        remain -= @body.write(@params.http_body)
+
+        update_request_progress(remain, total)
+
+        # then stream out nothing but perfectly sized chunks
+        until remain <= 0 or @socket.closed?
+          # ASSUME: we are writing to a disk and these writes always write the requested amount
+          @params.http_body = read_socket(Const::CHUNK_SIZE)
+          remain -= @body.write(@params.http_body)
+
+          update_request_progress(remain, total)
+        end
+      rescue Object => e
+        STDERR.puts "#{Time.now}: Error reading HTTP body: #{e.inspect}"
+        STDERR.puts e.backtrace.join("\n")
+        # any errors means we should delete the file, including if the file is dumped
+        @socket.close rescue nil
+        @body.delete if @body.class == Tempfile
+        @body = nil # signals that there was a problem
+      end
+    end
+ 
+    def read_socket(len)
+      if !@socket.closed?
+        data = @socket.read(len)
+        if !data
+          raise "Socket read return nil"
+        elsif data.length != len
+          raise "Socket read returned insufficient data: #{data.length}"
+        else
+          data
+        end
+      else
+        raise "Socket already closed when reading."
+      end
+    end
+
+    # Performs URI escaping so that you can construct proper
+    # query strings faster.  Use this rather than the cgi.rb
+    # version since it's faster.  (Stolen from Camping).
+    def self.escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2'*$1.size).join('%').upcase
+      }.tr(' ', '+') 
+    end
+
+
+    # Unescapes a URI escaped string. (Stolen from Camping).
+    def self.unescape(s)
+      s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+        [$1.delete('%')].pack('H*')
+      } 
+    end
+
+    # Parses a query string by breaking it up at the '&' 
+    # and ';' characters.  You can also use this to parse
+    # cookies by changing the characters used in the second
+    # parameter (which defaults to '&;'.
+    def self.query_parse(qs, d = '&;')
+      params = {}
+      (qs||'').split(/[#{d}] */n).inject(params) { |h,p|
+        k, v=unescape(p).split('=',2)
+        if cur = params[k]
+          if cur.class == Array
+            params[k] << v
+          else
+            params[k] = [cur, v]
+          end
+        else
+          params[k] = v
+        end
+      }
+
+      return params
+    end
+  end
+end

data/lib/mongrel/http_response.rb

@@ -0,0 +1,163 @@
+module Mongrel
+  # Writes and controls your response to the client using the HTTP/1.1 specification.
+  # You use it by simply doing:
+  #
+  #  response.start(200) do |head,out|
+  #    head['Content-Type'] = 'text/plain'
+  #    out.write("hello\n")
+  #  end
+  #
+  # The parameter to start is the response code--which Mongrel will translate for you
+  # based on HTTP_STATUS_CODES.  The head parameter is how you write custom headers.
+  # The out parameter is where you write your body.  The default status code for 
+  # HttpResponse.start is 200 so the above example is redundant.
+  # 
+  # As you can see, it's just like using a Hash and as you do this it writes the proper
+  # header to the output on the fly.  You can even intermix specifying headers and 
+  # writing content.  The HttpResponse class with write the things in the proper order
+  # once the HttpResponse.block is ended.
+  #
+  # You may also work the HttpResponse object directly using the various attributes available
+  # for the raw socket, body, header, and status codes.  If you do this you're on your own.
+  # A design decision was made to force the client to not pipeline requests.  HTTP/1.1 
+  # pipelining really kills the performance due to how it has to be handled and how 
+  # unclear the standard is.  To fix this the HttpResponse gives a "Connection: close"
+  # header which forces the client to close right away.  The bonus for this is that it
+  # gives a pretty nice speed boost to most clients since they can close their connection
+  # immediately.
+  #
+  # One additional caveat is that you don't have to specify the Content-length header
+  # as the HttpResponse will write this for you based on the out length.
+  class HttpResponse
+    attr_reader :socket
+    attr_reader :body
+    attr_writer :body
+    attr_reader :header
+    attr_reader :status
+    attr_writer :status
+    attr_reader :body_sent
+    attr_reader :header_sent
+    attr_reader :status_sent
+
+    def initialize(socket)
+      @socket = socket
+      @body = StringIO.new
+      @status = 404
+      @reason = nil
+      @header = HeaderOut.new(StringIO.new)
+      @header[Const::DATE] = Time.now.httpdate
+      @body_sent = false
+      @header_sent = false
+      @status_sent = false
+    end
+
+    # Receives a block passing it the header and body for you to work with.
+    # When the block is finished it writes everything you've done to 
+    # the socket in the proper order.  This lets you intermix header and
+    # body content as needed.  Handlers are able to modify pretty much
+    # any part of the request in the chain, and can stop further processing
+    # by simple passing "finalize=true" to the start method.  By default
+    # all handlers run and then mongrel finalizes the request when they're
+    # all done.
+    def start(status=200, finalize=false, reason=nil)
+      @status = status.to_i
+      @reason = reason
+      yield @header, @body
+      finished if finalize
+    end
+
+    # Primarily used in exception handling to reset the response output in order to write
+    # an alternative response.  It will abort with an exception if you have already
+    # sent the header or the body.  This is pretty catastrophic actually.
+    def reset
+      if @body_sent
+        raise "You have already sent the request body."
+      elsif @header_sent
+        raise "You have already sent the request headers."
+      else
+        @header.out.truncate(0)
+        @body.close
+        @body = StringIO.new
+      end
+    end
+
+    def send_status(content_length=@body.length)
+      if not @status_sent
+        @header['Content-Length'] = content_length if content_length and @status != 304
+        write(Const::STATUS_FORMAT % [@status, @reason || HTTP_STATUS_CODES[@status]])
+        @status_sent = true
+      end
+    end
+
+    def send_header
+      if not @header_sent
+        @header.out.rewind
+        write(@header.out.read + Const::LINE_END)
+        @header_sent = true
+      end
+    end
+
+    def send_body
+      if not @body_sent
+        @body.rewind
+        write(@body.read)
+        @body_sent = true
+      end
+    end 
+
+    # Appends the contents of +path+ to the response stream.  The file is opened for binary
+    # reading and written in chunks to the socket.
+    #
+    # Sendfile API support has been removed in 0.3.13.4 due to stability problems.
+    def send_file(path, small_file = false)
+      if small_file
+        File.open(path, "rb") {|f| @socket << f.read }
+      else
+        File.open(path, "rb") do |f|
+          while chunk = f.read(Const::CHUNK_SIZE) and chunk.length > 0
+            begin
+              write(chunk)
+            rescue Object => exc
+              break
+            end
+          end
+        end
+      end
+      @body_sent = true
+    end
+
+    def socket_error(details)
+      # ignore these since it means the client closed off early
+      @socket.close rescue nil
+      done = true
+      raise details
+    end
+
+    def write(data)
+      @socket.write(data)
+    rescue => details
+      socket_error(details)
+    end
+
+    # This takes whatever has been done to header and body and then writes it in the
+    # proper format to make an HTTP/1.1 response.
+    def finished
+      send_status
+      send_header
+      send_body
+    end
+
+    # Used during error conditions to mark the response as "done" so there isn't any more processing
+    # sent to the client.
+    def done=(val)
+      @status_sent = true
+      @header_sent = true
+      @body_sent = true
+    end
+
+    def done
+      (@status_sent and @header_sent and @body_sent)
+    end
+
+  end
+end

data/lib/mongrel/init.rb

@@ -0,0 +1,10 @@
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+require 'mongrel/gems'
+Mongrel::Gems.require 'gem_plugin'
+
+# File is just a stub that makes sure the mongrel_plugins gem is loaded and ready

data/lib/mongrel/mime_types.yml

@@ -0,0 +1,616 @@
+---
+.a: application/octet-stream
+.abc: text/vnd.abc
+.acgi: text/html
+.afl: video/animaflex
+.ai: application/postscript
+.aif: audio/aiff
+.aifc: audio/aiff
+.aiff: audio/aiff
+.aip: text/x-audiosoft-intra
+.ani: application/x-navi-animation
+.aps: application/mime
+.arc: application/octet-stream
+.arj: application/octet-stream
+.art: image/x-jg
+.asf: video/x-ms-asf
+.asm: text/x-asm
+.asp: text/asp
+.asr: video/x-ms-asf
+.asx: video/x-ms-asf
+.atom: application/atom+xml
+.au: audio/basic
+.au: audio/x-au
+.avi: video/avi
+.avs: video/avs-video
+.axs: application/olescript
+.bas: text/plain
+.bcpio: application/x-bcpio
+.bin: application/octet-stream
+.bm: image/bmp
+.bmp: image/bmp
+.boo: application/book
+.book: application/book
+.boz: application/x-bzip2
+.bsh: application/x-bsh
+.bz2: application/x-bzip2
+.bz: application/x-bzip
+.c: text/plain
+.cat: application/octet-stream
+.cc: text/plain
+.ccad: application/clariscad
+.cco: application/x-cocoa
+.cdf: application/cdf
+.cer: application/x-x509-ca-cert
+.cha: application/x-chat
+.chat: application/x-chat
+.class: application/java
+.class: application/octet-stream
+.clp: application/x-msclip
+.cmx: image/x-cmx
+.cod: image/cis-cod
+.com: application/octet-stream
+.com: text/plain
+.conf: text/plain
+.cpio: application/x-cpio
+.cpp: text/x-c
+.cpt: application/x-cpt
+.crd: application/x-mscardfile
+.crl: application/pkcs-crl
+.crl: application/pkix-crl
+.crt: application/x-x509-ca-cert
+.csh: application/x-csh
+.csh: text/x-script.csh
+.css: text/css
+.cxx: text/plain
+.dcr: application/x-director
+.deb: application/octet-stream
+.deepv: application/x-deepv
+.def: text/plain
+.der: application/x-x509-ca-cert
+.dhh: application/david-heinemeier-hansson
+.dif: video/x-dv
+.dir: application/x-director
+.dl: video/dl
+.dll: application/octet-stream
+.dmg: application/octet-stream
+.dms: application/octet-stream
+.doc: application/msword
+.dp: application/commonground
+.drw: application/drafting
+.dump: application/octet-stream
+.dv: video/x-dv
+.dvi: application/x-dvi
+.dwg: application/acad
+.dwg: image/x-dwg
+.dxf: application/dxf
+.dxf: image/x-dwg
+.dxr: application/x-director
+.ear: application/java-archive
+.el: text/x-script.elisp
+.elc: application/x-bytecode.elisp (compiled elisp)
+.elc: application/x-elc
+.env: application/x-envoy
+.eot: application/octet-stream
+.eps: application/postscript
+.es: application/x-esrehber
+.etx: text/x-setext
+.evy: application/envoy
+.evy: application/x-envoy
+.exe: application/octet-stream
+.f77: text/x-fortran
+.f90: text/plain
+.f90: text/x-fortran
+.f: text/x-fortran
+.fdf: application/vnd.fdf
+.fif: application/fractals
+.fif: image/fif
+.fli: video/fli
+.fli: video/x-fli
+.flo: image/florian
+.flr: x-world/x-vrml
+.flv: video/x-flv
+.flx: text/vnd.fmi.flexstor
+.fmf: video/x-atomic3d-feature
+.for: text/plain
+.for: text/x-fortran
+.fpx: image/vnd.fpx
+.fpx: image/vnd.net-fpx
+.frl: application/freeloader
+.funk: audio/make
+.g3: image/g3fax
+.g: text/plain
+.gif: image/gif
+.gl: video/gl
+.gl: video/x-gl
+.gsd: audio/x-gsm
+.gsm: audio/x-gsm
+.gsp: application/x-gsp
+.gss: application/x-gss
+.gtar: application/x-gtar
+.gz: application/x-compressed
+.gzip: application/x-gzip
+.h: text/plain
+.hdf: application/x-hdf
+.help: application/x-helpfile
+.hgl: application/vnd.hp-hpgl
+.hh: text/plain
+.hlb: text/x-script
+.hlp: application/hlp
+.hpg: application/vnd.hp-hpgl
+.hpgl: application/vnd.hp-hpgl
+.hqx: application/binhex
+.hta: application/hta
+.htc: text/x-component
+.htm: text/html
+.html: text/html
+.htmls: text/html
+.htt: text/webviewhtml
+.htx: text/html
+.ico: image/x-icon
+.idc: text/plain
+.ief: image/ief
+.iefs: image/ief
+.iges: application/iges
+.igs: application/iges
+.iii: application/x-iphone
+.ima: application/x-ima
+.imap: application/x-httpd-imap
+.img: application/octet-stream
+.inf: application/inf
+.ins: application/x-internet-signup
+.ins: application/x-internett-signup
+.ip: application/x-ip2
+.iso: application/octet-stream
+.isp: application/x-internet-signup
+.isu: video/x-isvideo
+.it: audio/it
+.iv: application/x-inventor
+.ivr: i-world/i-vrml
+.ivy: application/x-livescreen
+.jam: audio/x-jam
+.jar: application/java-archive
+.jardiff: application/x-java-archive-diff
+.jav: text/plain
+.jav: text/x-java-source
+.java: text/plain
+.java: text/x-java-source
+.jcm: application/x-java-commerce
+.jfif-tbnl: image/jpeg
+.jfif: image/jpeg
+.jfif: image/pipeg
+.jfif: image/pjpeg
+.jng: image/x-jng
+.jnlp: application/x-java-jnlp-file
+.jpe: image/jpeg
+.jpeg: image/jpeg
+.jpg: image/jpeg
+.jps: image/x-jps
+.js: application/x-javascript
+.js: text/javascript
+.jut: image/jutvision
+.kar: audio/midi
+.kar: music/x-karaoke
+.ksh: application/x-ksh
+.ksh: text/x-script.ksh
+.la: audio/nspaudio
+.la: audio/x-nspaudio
+.lam: audio/x-liveaudio
+.latex: application/x-latex
+.lha: application/lha
+.lha: application/octet-stream
+.lha: application/x-lha
+.lhx: application/octet-stream
+.list: text/plain
+.lma: audio/nspaudio
+.lma: audio/x-nspaudio
+.log: text/plain
+.lsf: video/x-la-asf
+.lsp: application/x-lisp
+.lsp: text/x-script.lisp
+.lst: text/plain
+.lsx: text/x-la-asf
+.lsx: video/x-la-asf
+.ltx: application/x-latex
+.lzh: application/octet-stream
+.lzh: application/x-lzh
+.lzx: application/lzx
+.lzx: application/octet-stream
+.lzx: application/x-lzx
+.m13: application/x-msmediaview
+.m14: application/x-msmediaview
+.m1v: video/mpeg
+.m2a: audio/mpeg
+.m2v: video/mpeg
+.m3u: audio/x-mpegurl
+.m: text/x-m
+.man: application/x-troff-man
+.map: application/x-navimap
+.mar: text/plain
+.mbd: application/mbedlet
+.mc: application/x-magic-cap-package-1.0
+.mcd: application/mcad
+.mcd: application/x-mathcad
+.mcf: image/vasa
+.mcf: text/mcf
+.mcp: application/netmc
+.mdb: application/x-msaccess
+.me: application/x-troff-me
+.mht: message/rfc822
+.mhtml: message/rfc822
+.mid: audio/mid
+.mid: audio/midi
+.mid: audio/x-mid
+.mid: audio/x-midi
+.midi: audio/midi
+.midi: audio/x-mid
+.midi: audio/x-midi
+.mif: application/x-frame
+.mif: application/x-mif
+.mime: message/rfc822
+.mime: www/mime
+.mjf: audio/x-vnd.audioexplosion.mjuicemediafile
+.mjpg: video/x-motion-jpeg
+.mm: application/base64
+.mm: application/x-meme
+.mme: application/base64
+.mml: text/mathml
+.mng: video/x-mng
+.mod: audio/mod
+.moov: video/quicktime
+.mov: video/quicktime
+.movie: video/x-sgi-movie
+.mp2: audio/mpeg
+.mp3: audio/mpeg
+.mpa: audio/mpeg
+.mpc: application/x-project
+.mpe: video/mpeg
+.mpeg: video/mpeg
+.mpg: video/mpeg
+.mpga: audio/mpeg
+.mpp: application/vnd.ms-project
+.mpt: application/x-project
+.mpv2: video/mpeg
+.mpv: application/x-project
+.mpx: application/x-project
+.mrc: application/marc
+.ms: application/x-troff-ms
+.msi: application/octet-stream
+.msm: application/octet-stream
+.msp: application/octet-stream
+.mv: video/x-sgi-movie
+.mvb: application/x-msmediaview
+.my: audio/make
+.mzz: application/x-vnd.audioexplosion.mzz
+.nap: image/naplps
+.naplps: image/naplps
+.nc: application/x-netcdf
+.ncm: application/vnd.nokia.configuration-message
+.nif: image/x-niff
+.niff: image/x-niff
+.nix: application/x-mix-transfer
+.nsc: application/x-conference
+.nvd: application/x-navidoc
+.nws: message/rfc822
+.o: application/octet-stream
+.oda: application/oda
+.omc: application/x-omc
+.omcd: application/x-omcdatamaker
+.omcr: application/x-omcregerator
+.p10: application/pkcs10
+.p10: application/x-pkcs10
+.p12: application/pkcs-12
+.p12: application/x-pkcs12
+.p7a: application/x-pkcs7-signature
+.p7b: application/x-pkcs7-certificates
+.p7c: application/pkcs7-mime
+.p7c: application/x-pkcs7-mime
+.p7m: application/pkcs7-mime
+.p7m: application/x-pkcs7-mime
+.p7r: application/x-pkcs7-certreqresp
+.p7s: application/pkcs7-signature
+.p7s: application/x-pkcs7-signature
+.p: text/x-pascal
+.part: application/pro_eng
+.pas: text/pascal
+.pbm: image/x-portable-bitmap
+.pcl: application/vnd.hp-pcl
+.pcl: application/x-pcl
+.pct: image/x-pict
+.pcx: image/x-pcx
+.pdb: application/x-pilot
+.pdf: application/pdf
+.pem: application/x-x509-ca-cert
+.pfunk: audio/make
+.pfunk: audio/make.my.funk
+.pfx: application/x-pkcs12
+.pgm: image/x-portable-graymap
+.pgm: image/x-portable-greymap
+.pic: image/pict
+.pict: image/pict
+.pkg: application/x-newton-compatible-pkg
+.pko: application/vnd.ms-pki.pko
+.pko: application/ynd.ms-pkipko
+.pl: application/x-perl
+.pl: text/plain
+.pl: text/x-script.perl
+.plx: application/x-pixclscript
+.pm4: application/x-pagemaker
+.pm5: application/x-pagemaker
+.pm: application/x-perl
+.pm: image/x-xpixmap
+.pm: text/x-script.perl-module
+.pma: application/x-perfmon
+.pmc: application/x-perfmon
+.pml: application/x-perfmon
+.pmr: application/x-perfmon
+.pmw: application/x-perfmon
+.png: image/png
+.pnm: application/x-portable-anymap
+.pnm: image/x-portable-anymap
+.pot,: application/vnd.ms-powerpoint
+.pot: application/mspowerpoint
+.pot: application/vnd.ms-powerpoint
+.pov: model/x-pov
+.ppa: application/vnd.ms-powerpoint
+.ppm: image/x-portable-pixmap
+.pps: application/mspowerpoint
+.ppt: application/mspowerpoint
+.ppz: application/mspowerpoint
+.prc: application/x-pilot
+.pre: application/x-freelance
+.prf: application/pics-rules
+.prt: application/pro_eng
+.ps: application/postscript
+.psd: application/octet-stream
+.pub: application/x-mspublisher
+.pvu: paleovu/x-pv
+.pwz: application/vnd.ms-powerpoint
+.py: text/x-script.phyton
+.pyc: applicaiton/x-bytecode.python
+.qcp: audio/vnd.qcelp
+.qd3: x-world/x-3dmf
+.qd3d: x-world/x-3dmf
+.qif: image/x-quicktime
+.qt: video/quicktime
+.qtc: video/x-qtc
+.qti: image/x-quicktime
+.qtif: image/x-quicktime
+.ra: audio/x-pn-realaudio
+.ra: audio/x-pn-realaudio-plugin
+.ra: audio/x-realaudio
+.ram: audio/x-pn-realaudio
+.rar: application/x-rar-compressed
+.ras: application/x-cmu-raster
+.ras: image/cmu-raster
+.ras: image/x-cmu-raster
+.rast: image/cmu-raster
+.rexx: text/x-script.rexx
+.rf: image/vnd.rn-realflash
+.rgb: image/x-rgb
+.rm: application/vnd.rn-realmedia
+.rm: audio/x-pn-realaudio
+.rmi: audio/mid
+.rmm: audio/x-pn-realaudio
+.rmp: audio/x-pn-realaudio
+.rmp: audio/x-pn-realaudio-plugin
+.rng: application/ringing-tones
+.rng: application/vnd.nokia.ringing-tone
+.rnx: application/vnd.rn-realplayer
+.roff: application/x-troff
+.rp: image/vnd.rn-realpix
+.rpm: application/x-redhat-package-manager
+.rpm: audio/x-pn-realaudio-plugin
+.rss: text/xml
+.rt: text/richtext
+.rt: text/vnd.rn-realtext
+.rtf: application/rtf
+.rtf: application/x-rtf
+.rtf: text/richtext
+.rtx: application/rtf
+.rtx: text/richtext
+.run: application/x-makeself
+.rv: video/vnd.rn-realvideo
+.s3m: audio/s3m
+.s: text/x-asm
+.saveme: application/octet-stream
+.sbk: application/x-tbook
+.scd: application/x-msschedule
+.scm: application/x-lotusscreencam
+.scm: text/x-script.guile
+.scm: text/x-script.scheme
+.scm: video/x-scm
+.sct: text/scriptlet
+.sdml: text/plain
+.sdp: application/sdp
+.sdp: application/x-sdp
+.sdr: application/sounder
+.sea: application/sea
+.sea: application/x-sea
+.set: application/set
+.setpay: application/set-payment-initiation
+.setreg: application/set-registration-initiation
+.sgm: text/sgml
+.sgm: text/x-sgml
+.sgml: text/sgml
+.sgml: text/x-sgml
+.sh: application/x-bsh
+.sh: application/x-sh
+.sh: application/x-shar
+.sh: text/x-script.sh
+.shar: application/x-bsh
+.shar: application/x-shar
+.shtml: text/html
+.shtml: text/x-server-parsed-html
+.sid: audio/x-psid
+.sit: application/x-sit
+.sit: application/x-stuffit
+.skd: application/x-koan
+.skm: application/x-koan
+.skp: application/x-koan
+.skt: application/x-koan
+.sl: application/x-seelogo
+.smi: application/smil
+.smil: application/smil
+.snd: audio/basic
+.snd: audio/x-adpcm
+.sol: application/solids
+.spc: application/x-pkcs7-certificates
+.spc: text/x-speech
+.spl: application/futuresplash
+.spr: application/x-sprite
+.sprite: application/x-sprite
+.src: application/x-wais-source
+.ssi: text/x-server-parsed-html
+.ssm: application/streamingmedia
+.sst: application/vnd.ms-pki.certstore
+.sst: application/vnd.ms-pkicertstore
+.step: application/step
+.stl: application/sla
+.stl: application/vnd.ms-pki.stl
+.stl: application/vnd.ms-pkistl
+.stl: application/x-navistyle
+.stm: text/html
+.stp: application/step
+.sv4cpio: application/x-sv4cpio
+.sv4crc: application/x-sv4crc
+.svf: image/vnd.dwg
+.svf: image/x-dwg
+.svg: image/svg+xml
+.svr: application/x-world
+.svr: x-world/x-svr
+.swf: application/x-shockwave-flash
+.t: application/x-troff
+.talk: text/x-speech
+.tar: application/x-tar
+.tbk: application/toolbook
+.tbk: application/x-tbook
+.tcl: application/x-tcl
+.tcl: text/x-script.tcl
+.tcsh: text/x-script.tcsh
+.tex: application/x-tex
+.texi: application/x-texinfo
+.texinfo: application/x-texinfo
+.text: application/plain
+.text: text/plain
+.tgz: application/gnutar
+.tgz: application/x-compressed
+.tif: image/tiff
+.tiff: image/tiff
+.tk: application/x-tcl
+.tr: application/x-troff
+.trm: application/x-msterminal
+.tsi: audio/tsp-audio
+.tsp: application/dsptype
+.tsp: audio/tsplayer
+.tsv: text/tab-separated-values
+.turbot: image/florian
+.txt: text/plain
+.uil: text/x-uil
+.uls: text/iuls
+.uni: text/uri-list
+.unis: text/uri-list
+.unv: application/i-deas
+.uri: text/uri-list
+.uris: text/uri-list
+.ustar: application/x-ustar
+.ustar: multipart/x-ustar
+.uu: application/octet-stream
+.uu: text/x-uuencode
+.uue: text/x-uuencode
+.vcd: application/x-cdlink
+.vcf: text/x-vcard
+.vcs: text/x-vcalendar
+.vda: application/vda
+.vdo: video/vdo
+.vew: application/groupwise
+.viv: video/vivo
+.viv: video/vnd.vivo
+.vivo: video/vivo
+.vivo: video/vnd.vivo
+.vmd: application/vocaltec-media-desc
+.vmf: application/vocaltec-media-file
+.voc: audio/voc
+.voc: audio/x-voc
+.vos: video/vosaic
+.vox: audio/voxware
+.vqe: audio/x-twinvq-plugin
+.vqf: audio/x-twinvq
+.vql: audio/x-twinvq-plugin
+.vrml: application/x-vrml
+.vrml: model/vrml
+.vrml: x-world/x-vrml
+.vrt: x-world/x-vrt
+.vsd: application/x-visio
+.vst: application/x-visio
+.vsw: application/x-visio
+.w60: application/wordperfect6.0
+.w61: application/wordperfect6.1
+.w6w: application/msword
+.war: application/java-archive
+.wav: audio/wav
+.wav: audio/x-wav
+.wb1: application/x-qpro
+.wbmp: image/vnd.wap.wbmp
+.wbmp: image/vnd.wap.wbmp
+.wcm: application/vnd.ms-works
+.wdb: application/vnd.ms-works
+.web: application/vnd.xara
+.wiz: application/msword
+.wk1: application/x-123
+.wks: application/vnd.ms-works
+.wmf: application/x-msmetafile
+.wmf: windows/metafile
+.wml: text/vnd.wap.wml
+.wmlc: application/vnd.wap.wmlc
+.wmls: text/vnd.wap.wmlscript
+.wmlsc: application/vnd.wap.wmlscriptc
+.wmv: video/x-ms-wmv
+.word: application/msword
+.wp5: application/wordperfect
+.wp6: application/wordperfect
+.wp: application/wordperfect
+.wpd: application/wordperfect
+.wps: application/vnd.ms-works
+.wq1: application/x-lotus
+.wri: application/mswrite
+.wrl: application/x-world
+.wsc: text/scriplet
+.wsrc: application/x-wais-source
+.wtk: application/x-wintalk
+.x-png: image/png
+.xaf: x-world/x-vrml
+.xbm: image/xbm
+.xdr: video/x-amt-demorun
+.xgz: xgl/drawing
+.xhtml: application/xhtml+xml
+.xif: image/vnd.xiff
+.xl: application/excel
+.xla: application/excel
+.xlb: application/excel
+.xlc: application/excel
+.xld: application/excel
+.xlk: application/excel
+.xll: application/excel
+.xlm: application/excel
+.xls: application/excel
+.xlt: application/excel
+.xlv: application/excel
+.xlw: application/excel
+.xm: audio/xm
+.xml: text/xml
+.xmz: xgl/movie
+.xof: x-world/x-vrml
+.xpi: application/x-xpinstall
+.xpix: application/x-vnd.ls-xpix
+.xpm: image/x-xpixmap
+.xpm: image/xpm
+.xsl: application/xslt+xml
+.xsr: video/x-amt-showrun
+.xwd: image/x-xwd
+.xwd: image/x-xwindowdump
+.xyz: chemical/x-pdb
+.z: application/x-compressed
+.zip: application/zip
+.zoo: application/octet-stream
+.zsh: text/x-script.zsh