ruby-net-nntp 0.2.2 → 1.0.0

data/lib/net/nntp/request.rb

@@ -0,0 +1,840 @@
+module Net
+
+  class NNTP
+  # NNTP Request base clase. Do not instantiate, use subclasses.
+  #
+  # == Class Hierarchy
+  #   
+  # * Net::NNTP::Request
+  #   * Net::NNTP::Authinfo
+  #   * Net::NNTP::Capabilities
+  #   * Net::NNTP::Date
+  #   * Net::NNTP::Group
+  #   * Net::NNTP::Hdr
+  #   * Net::NNTP::Help
+  #   * Net::NNTP::List
+  #   * Net::NNTP::Modereader
+  #   * Net::NNTP::Newgroups
+  #   * Net::NNTP::Newnews
+  #   * Net::NNTP::Over
+  #   * Net::NNTP::PostingRequest
+  #     * Net::NNTP::Post
+  #     * Net::NNTP::Ihave
+  #   * Net::NNTP::Quit
+  #   * Net::NNTP::RetrievalRequest
+  #     * Net::NNTP::Article
+  #     * Net::NNTP::Body
+  #     * Net::NNTP::Head
+  #     * Net::NNTP::Stat
+  #   * Net::NNTP::SelectionRequest
+  #     * Net::NNTP::Group
+  #     * Net::NNTP::Listgroup
+  #     * Net::NNTP::Last
+  #     * Net::NNTP::Next
+  #   * Net::NNTP::Xhdr
+  #   * Net::NNTP::Xover
+  #   * Net::NNTP::Xpat
+  class Request
+
+    def initialize(command, rest=nil)
+      @command = ("%s %s" % [command.upcase, rest]).strip
+    end
+
+    def command
+      return [@command, "\r\n"].join
+    end
+
+    def dotstuff # :nodoc:
+      # dot-stuffing. Mail SHOULD be raw
+      stuff_regex = /^\./m
+      @body.to_s.gsub(stuff_regex, "..")
+    end
+
+    def msgid_or_range(rest) # :nodoc:
+      rval = ''
+      if rest  
+        case rest
+        when String
+          rval = rest
+        when Hash
+          if rest.has_key? :msgid
+            rval = rest[:msgid].to_s
+          else
+            rval = range(rest)
+          end
+        end
+      end
+      rval
+    end
+
+    def range(rest) # :nodoc:
+      return rest unless rest
+      rval = ''
+      if rest.has_key? :start
+        rval = rest[:start].to_s << "-"
+        if rest.has_key? :end
+          rval << rest[:end].to_s
+        end
+      end
+      rval
+    end
+
+    def valid_responses
+      []
+    end
+    private :valid_responses
+
+    # Can be used to make sure that the response is valid (or a generic response) according to RFCs 3977 and 4643
+    def valid_response?(response)
+      response.generic? || valid_responses().include?(response.class)
+    end
+
+    # Returns the capability that the server should mention on a Capability Request to notify the user that the server
+    # is capable to process the request. Older and broken NNTP servers do not respond to a Capability request, thus
+    # leaving it to trial-and-error.
+    def capability
+      'mandatory'
+    end
+  end
+
+    class ParameterError < StandardError; end
+
+    # {RFC 4643}[http://tools.ietf.org/html/rfc4643]
+    #
+    # Plain text AUTHINFO Request. Set user and pass with new. 
+    #
+    # Parameter:
+    #
+    # * keyword:: either 'user' or 'pass'
+    # * data:: username if keyword is USER, password if keyword is PASS
+    #
+    # == Usage Example
+    #   
+    #   nntp = Net::NNTP.new
+    #   nntp.server = 'localhost'
+    #   nntp.connect
+    #   request = Authinfo.new('user', 'test')
+    #   response = nntp.process(request)
+    #   if PasswordRequired === response
+    #     request = Authinfo.new('pass', 'xxx')
+    #     response = nntp.process(request)
+    #     if OKResponse === response
+    #       # authenticated, go ahead
+    #     else
+    #       raise StandardError, response.message
+    #     end
+    #   end
+    #   
+    # Valid Responses: PasswordRequired, AuthenticationAccepted, AuthenticationFailed, AuthenticationOutOfSequence
+    class Authinfo < Request
+
+      # +user+ is the string used in AUTHINFO USER
+      # +pass+ is the string used in AUTHINFO PASS
+      #
+      # See: user_command, pass_command
+      def initialize(keyword, data)
+        super 'AUTHINFO', [keyword.upcase, data].join(" ")
+      end
+
+      def valid_responses
+        [PasswordRequired, AuthenticationAccepted, AuthenticationFailed, AuthenticationOutOfSequence]
+      end
+      private :valid_responses
+
+      def capability 
+        'authinfo'
+      end
+    end
+
+    # Classification of Requests expecting response codes in the 1xx range.
+    #
+    # == Subclasses:
+    # * Help
+    # * Capabilities
+    class InformationRequest < Request
+      class << self
+        private :new
+      end
+    end
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # Valid Response: HelpResponse
+    class Help < InformationRequest
+      class << self
+        public :new
+      end
+      def initialize
+        super 'HELP'
+      end
+      def valid_responses
+        [HelpResponse]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # CAPABILITIES Request. Should be used to discover the commands that the server can process. Can change if MODE or
+    # authentication changes the state of the connection. Sadly, most servers do not implement this, leaving either the
+    # option to parse the informal response to a HELP request, or use trial-and-error.
+    #
+    # == Usage Example
+    #
+    #   nntp = Net::NNTP.new
+    #   nntp.server = 'localhost'
+    #   nntp.connect
+    #   request = Capabilities.new
+    #   response = nntp.process(request)
+    #   response.capabilities['version'] # returns the version, either as number, or array of numbers, i.e. [2, 3]
+    #
+    # Valid Response: CapabilityList
+    class Capabilities < InformationRequest
+      class << self
+        public :new
+      end
+      def initialize
+        super 'CAPABILITIES'
+      end
+
+      def valid_responses
+        [CapabilityList]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # Generates a 'MODE READER' command. 
+    #
+    # Valid Responses: PostingAllowed, PostingProhibited
+    class Modereader < Request
+      def initialize()
+        super 'MODE', 'READER'
+      end
+
+      def valid_responses
+        [PostingAllowed, PostingProhibited]
+      end
+      private :valid_responses
+
+      def capability
+        'mode-reader'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # Generates a QUIT command. *Important*: after issuing QUIT to the server, the connection MUST be closed by the
+    # client after a ConnectionClosing Response has been received.
+    #
+    # == Usage Example
+    #
+    #   nntp = Net::NNTP.new
+    #   nntp.server = 'localhost'
+    #   nntp.connect
+    #   request = Quit.new
+    #   response = nntp.process(request)
+    #   if (ConnectionClosing === response)
+    #     nntp.disconnect
+    #   end
+    #
+    # Valid Response: ConnectionClosing
+    class Quit < Request
+      def initialize
+        super 'QUIT'
+      end
+      def valid_responses
+        [ConnectionClosing]
+      end
+      private :valid_responses
+    end
+
+    # Categorizes requests that manipulate the internal server state (selecting groups and/or articles)
+    #
+    # Parent: Net::NNTP::Request
+    #
+    # Subclasses:
+    #
+    # * Net::NNTP::Group
+    # * Net::NNTP::Listgroup
+    # * Net::NNTP::Last
+    # * Net::NNTP::Next
+    class SelectionRequest < Request
+      class << self
+        private :new
+      end
+
+      def capability
+        'reader'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # Request for retrieving group information. 
+    #
+    # Parent: Net::NNTP::SelectionRequest
+    #
+    # Valid Response: GroupSelected
+    class Group < SelectionRequest
+      class << self
+        public :new
+      end
+
+      #
+      # +group+ is the group name for which the information should be
+      # retrieved.
+      def initialize(groupname)
+        super 'GROUP', groupname
+      end
+
+      def valid_responses
+        [GroupSelected]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # LISTGROUP request.
+    #
+    # Parent: Net::NNTP::SelectionRequest
+    #
+    # Valid Responses: GroupSelected, GroupUnknown, NoGroupSelected
+    class Listgroup < SelectionRequest
+      class << self
+        public :new
+      end
+
+      # * +groupname+ is the group that should be selected. If a name is given, the group will be selected; on success,
+      #   the first article returned will be selected. If no name is given, the currently selected group will be used,
+      #   and no range can be specified.
+      # * +range+ a range of article numbers in the specified group, given as Hash with the keys :start and :end; if
+      #   :end is not specified, the range is seen as 'open range', thus selecting all articles beginning with the
+      #   number given as :start value to the last number available in the group.
+      #
+      # == Usage Example
+      #
+      #   # no groupname
+      #   request = Net::NNTP::Listgroup.new
+      #       # request.command => 'LISTGROUP'
+      #   # only groupname
+      #   request = Net::NNTP::Listgroup.new('alt.test')
+      #       # request.command => 'LISTGROUP alt.test'
+      #   # given only a start number
+      #   request = Net::NNTP::Listgroup.new('alt.test', :start => 1000) 
+      #       # request.command => 'LISTGROUP alt.test 1000-'
+      #
+      #   # given a range
+      #   request = Net::NNTP::Listgroup.new('alt.test', :start => 1000, :end => 5000) 
+      #       # request.command => 'LISTGROUP alt.test 1000- 5000'
+      def initialize(groupname=nil, range={})
+        param = nil
+        if groupname then
+          param = groupname
+          unless range.empty?
+            if range.has_key?(:start)
+              if range.has_key?(:end)
+                param = "#{groupname} #{range[:start]}-#{range[:end]}"
+              else
+                param = "#{groupname} #{range[:start]}-"
+              end
+            end
+          end
+        end
+        super 'LISTGROUP', param
+      end
+
+      def valid_responses
+        [GroupSelected, GroupUnknown, NoGroupSelected]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # Request to select the article preceding the selected article in the current group.
+    #
+    # Parent: Net::NNTP::SelectionRequest
+    #
+    # Valid Responses: ArticleSelected, NoGroupSelected, InvalidArticle, NoPreviousArticle
+    class Last < SelectionRequest
+      class << self
+        public :new
+      end
+
+      def initialize
+        super 'LAST'
+      end
+
+      def valid_responses
+        [ArticleSelected, NoGroupSelected, InvalidArticle, NoPreviousArticle]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # LAST request.
+    #
+    # Parent: Net::NNTP::SelectionRequest
+    #
+    # Valid Responses: ArticleSelected, NoGroupSelected, InvalidArticle, NoNextArticle
+    class Next < SelectionRequest
+      class << self
+        public :new
+      end
+
+      def initialize
+        super 'NEXT'
+      end
+
+      def valid_responses
+        [ArticleSelected, NoGroupSelected, InvalidArticle, NoNextArticle]
+      end
+      private :valid_responses
+    end
+
+    # Categorizes the requests which are used to retrieve article information.
+    #
+    # Parent: Net::Request
+    #
+    # Subclasses:
+    #
+    # * Net::NNTP::Article
+    # * Net::NNTP::Head
+    # * Net::NNTP::Body
+    # * Net::NNTP::Stat
+    class RetrievalRequest < Request
+      class << self
+        private :new
+      end
+      def initialize(keyword, param) 
+        super keyword, param
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    #  ARTICLE Request (headers and body).
+    #
+    #  Valid Responses: ArticleResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid
+    class Article < RetrievalRequest
+      class << self
+        public :new
+      end
+
+      #
+      # * +param+ is either a message-id or an article number in the selected group.
+      #
+      # == Usage Example:
+      #   request = Net::NNTP::Article.new(100)  # => request.command will be 'ARTICLE 100'
+      def initialize(param=nil)
+        super 'ARTICLE', param
+      end
+      def valid_responses
+        [ArticleResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid]
+      end
+      private :valid_responses
+
+      def capability
+        'reader'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    # 
+    # HEAD request
+    #
+    # Valid Responses: HeaderResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid
+    class Head < RetrievalRequest
+      class << self
+        public :new
+      end
+      # 
+      # * +param+ is either a message-id or an article number in the selected group.
+      #
+      # see Net::NNTP::Article.new
+      def initialize(param=nil)
+        super 'HEAD', param
+      end
+      def valid_responses
+        [HeaderResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # BODY request
+    #
+    # Valid Responses: BodyResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid
+    class Body < RetrievalRequest
+      class << self
+        public :new
+      end
+      # 
+      # * +param+ is either a message-id or an article number in the selected group.
+      #
+      # see Net::NNTP::Article.new
+      def initialize(param=nil)
+        super 'BODY', param
+      end
+      def valid_responses
+        [BodyResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid]
+      end
+      private :valid_responses
+
+      def capability
+        'reader'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # STAT request
+    #
+    # Valid Responses: ArticleSelected, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid
+    class Stat < Request
+      class << self
+        public :new
+      end
+      # 
+      # * +param+ is either a message-id or an article number in the selected group.
+      #
+      # see Net::NNTP::Article.new
+      def initialize(param=nil)
+        super 'STAT', param
+      end
+
+      def valid_responses
+        [ArticleSelected, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid]
+      end
+      private :valid_responses
+    end
+
+    # Posting Request Base class. 
+    #
+    # Do NOT instantiate, use subclasses Post or Ihave.
+    class PostingRequest < Request
+      class << self
+        private :new
+      end
+
+      def initialize(keyword, param=nil)
+        super keyword, param
+      end
+
+      # Sets the body of the posting to be transmitted.
+      #
+      # Do NOT use any dot stuffing or <CRLF>.<CRLF> sequences - dot-stuffing will happen automatically when sending. 
+      #
+      # +body+ can be a TMail::Mail object, a string or any line-based IO object supporting +readline+, where the
+      # content has to be a valid mail, able to be parsed. The *body* attribute will be set to a TMail::Mail object,
+      # ready to be sent.
+      #
+      # == Example
+      #   # ...
+      #   request = Post.new # use subclass Post
+      #   request.body =<<-EOF
+      #   Newsgroups: alt.test
+      #   From: Demo User <user@example.com>
+      #   Subject: I am a test posting
+      #
+      #   This is just a test posting
+      #   EOF
+      #   puts request.body.to_s
+      #
+      #     # => From: Demo User <user@example.com>
+      #     # => Subject: I am a test posting
+      #     # => Newsgroups: alt.test
+      #     # => 
+      #     # => This is just a test posting.
+      #
+      def body=(body)
+        if body.is_a?(TMail::Mail) 
+          @body = body
+        else
+          if body.respond_to? :readline
+            begin
+              raw = ''
+              loop do
+                line = body.readline
+                raw << line
+              end
+            rescue EOFError => e
+            end
+          else
+            raw = body
+          end
+          @body = TMail::Mail.parse(raw)
+        end
+      end
+
+      # Returns the *body* attribute; given a block, sets the body from the result of that block first.
+      def body
+        if block_given?
+          self.body = yield
+        end
+        @body
+      end
+
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # POST request.
+    #
+    # Valid Responses: ArticleReceived, PostArticle, PostingNotPermitted, PostingFailed
+    class Post < PostingRequest
+      class << self
+        public :new
+      end
+
+      # The parameter +body+ should be the body in Mail format. DO NOT use dot-stuffing or <CR-LF>.<CR-LF> delimiter! 
+      # 
+      # See PostingRequest for an example.
+      def initialize(body=nil)
+        self.body = body unless body.nil?
+        super "POST"
+      end
+
+      def valid_responses
+        [ArticleReceived, PostArticle, PostingNotPermitted, PostingFailed]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # IHAVE request.
+    #
+    # Valid Responses: TransferOK, TransferArticle, ArticleNotWanted, TransferNotPossible, TransferRejected
+    class Ihave < PostingRequest
+      class << self
+        public :new
+      end
+
+      # * +id+ is the messageid that will be presented to the server. Will be superficially formally checked
+      # * +body+ is the posting that should be subsequently posted on a good response (335). It MUST NOT
+      #   be dot-stuffed. 
+      # See also: Post, PostingRequest, TransferOK, TransferArticle, ArticleNotWanted, TransferNotPossible, TransferRejected
+      def initialize(id, body=nil) 
+        raise ParameterError,"Messageid must not be nil!" unless id 
+        raise ParameterError,"Malformed messageid" unless id.match(/<.+@.+>/)
+        self.body = body unless body.nil?
+        super "IHAVE", id
+      end
+
+      def valid_responses
+        [TransferOK, TransferArticle, ArticleNotWanted, TransferNotPossible, TransferRejected]
+      end
+      private :valid_responses
+
+      def capability
+        'ihave'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # DATE request.
+    #
+    # Valid Response: DateResponse
+    class Date < Request
+      def initialize
+        super 'DATE'
+      end
+      
+      def valid_responses
+        [DateResponse]
+      end
+      private :valid_responses
+
+      def capability
+        'reader'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # NEWGROUPS request.
+    #
+    # Valid Response: NewgroupsResponse
+    class Newgroups < Request
+      # * +date_str+ should be a string that will be parsed by DateTime.parse. Do not use system dates, rather use the
+      #   date given by a Date request or a formerly stored date from a Date request. 
+      # * +is_gmt+ denotes that the given date should be used as GMT (UTC) date (adding the string GMT to the request.) 
+      #   Use if possible.
+      def initialize(date_str, is_gmt=true)
+        super 'NEWGROUPS', DateTime.parse(date_str, true).strftime('%Y%m%d %H%M%S') << (is_gmt ? ' GMT' : '')
+      end
+      
+      def valid_responses
+        [NewgroupsResponse]
+      end
+      private :valid_responses
+
+      def capability
+        'reader'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # NEWNEWS request.
+    #
+    # Valid Response: NewnewsResponse
+    class Newnews < Request
+      #
+      # * +group+ must be an array of group wildmatches which should be checked for news since date_str.
+      # * +date_str+ should be a string that will be parsed by DateTime.parse. Do not use system dates, rather use the
+      #   date given by a Date request or a formerly stored date from a Date request. 
+      # * +is_gmt+ denotes that the given date should be used as GMT (UTC) date (adding the string GMT to the request.) 
+      #   Use if possible.
+      def initialize(groups, date_str, is_gmt=true)
+        super 'NEWNEWS', groups.join(',') << ' ' << DateTime.parse(date_str, true).strftime('%Y%m%d %H%M%S') << (is_gmt ? ' GMT' : '')
+      end
+      
+      def valid_responses
+        [NewnewsResponse]
+      end
+      private :valid_responses
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # LIST request.
+    #
+    # Valid Response: ListInformationFollows
+    class List < Request
+      attr_reader :keyword
+      # * +keyword+ must be nil or one of ACTIVE, ACTIVE.TIMES, DISTRIB.PATS, HEADERS, NEWSGROUPS or OVERVIEW.FMT. 
+      # * +rest+ can be a string or a hash with either the key :msgid or the keys :start and optionally :end to denote a
+      #   range. 
+      #
+      # == Example
+      #   request = Net::NNTP::List.new                                           # => LIST
+      #   request = Net::NNTP::List.new('ACTIVE')                                 # => LIST ACTIVE
+      #   request = Net::NNTP::List.new('ACTIVE.TIMES', 'at.*')                   # => LIST ACTIVE at.*
+      #   request = Net::NNTP::List.new('HEADERS', :msgid => '<this.is@invalid>') # => LIST HEADERS <this.is@invalid>
+      #   request = Net::NNTP::List.new('HEADERS', :start => 123, :end => 456)    # => LIST HEADERS 123-456
+      #
+      def initialize(keyword=nil, rest={}) 
+        Net::NNTP.logger.debug("Keyword: <#{keyword}>")
+        @keyword = keyword.strip.upcase if keyword
+        parameters = (@keyword ? @keyword.dup : '') 
+        parameters << ' ' << msgid_or_range(rest)
+        super 'LIST', parameters
+      end
+
+      def valid_responses
+        [ListInformationFollows]
+      end
+
+      def capability
+        'list'
+      end
+    end
+
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # OVER request.
+    #
+    # Valid Responses: OverviewInformation, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid
+    class Over < Request
+      # * +range+ can be a string or a hash with either the key :msgid or the keys :start and optionally :end to denote a
+      #   range. 
+      def initialize(range=nil)
+        super 'OVER', msgid_or_range(range)
+      end
+
+      def valid_responses
+        [OverviewInformation, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid]
+      end
+      private :valid_responses
+
+      def capability
+        'over'
+      end
+    end
+    
+    # {RFC 3977}[http://tools.ietf.org/html/rfc3977]
+    #
+    # HDR request.
+    #
+    # Valid Responses: HdrResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid
+    class Hdr < Request
+      # * +field+ is the header field that should be retrieved
+      # * +range+ can be a string or a hash with either the key :msgid or the keys :start and optionally :end to denote a
+      #   range. 
+      def initialize(field, range=nil)
+        params = field
+        params << ' ' << msgid_or_range(range) if range
+        super 'HDR', params
+      end
+
+      def valid_responses
+        [HdrResponse, NoGroupSelected, InvalidArticle, InvalidNumberOrRange, NoSuchMessageid]
+      end
+      private :valid_responses
+
+      def capability
+        'hdr'
+      end
+    end
+
+    # Extension {RFC2980}[http://tools.ietf.org/html/rfc2980]
+    #
+    # XHDR request.
+    #
+    # *Warning*:: Deprecated in {RFC 3977}[http://tools.ietf.org/html/rfc3977]. See Hdr. Still there, because a lot of
+    #             servers do run the old version.
+    #
+    # See also: HeaderResponse
+    class Xhdr < Request
+      #
+      # * +field+ is the header field that should be retrieved
+      # * +range+ can be a string or a hash with either the key :msgid or the keys :start and optionally :end to denote a
+      #   range. 
+      def initialize(field, range=nil)
+        params = field
+        params << ' ' << msgid_or_range(range) if range
+        super 'XHDR', params
+      end
+    end
+
+    # Extension {RFC2980}[http://tools.ietf.org/html/rfc2980]
+    #
+    # XOVER request.
+    #
+    # *Warning*:: Deprecated in {RFC 3977}[http://tools.ietf.org/html/rfc3977]. See Over. Still there, because a lot of
+    #             servers do run the old version.
+    #
+    # Valid Response: OverviewInformation
+    class Xover < Request
+      #
+      # * +range+ can be a string or a hash with either the key :msgid or the keys :start and optionally :end to denote a
+      #   range. 
+      def initialize(range=nil)
+        super 'XOVER', range(range)
+      end
+    end
+
+    # Extension {RFC2980}[http://tools.ietf.org/html/rfc2980]
+    #
+    # XPAT request.
+    class Xpat < Request
+      # * +field+ is the header field that should be searched
+      # * +patterns+ is a string or an array of patterns
+      # * +range+ can be a string or a hash with either the key :msgid or the keys :start and optionally :end to denote a
+      #   range. 
+      def initialize(field, patterns, range)
+        patterns = [patterns] unless patterns.is_a?(Array)
+        parameters = field << ' ' << msgid_or_range(range) << ' ' << patterns.join(' ')
+        super 'XPAT', parameters
+      end
+    end
+  end
+
+end