mail 2.5.5 → 2.6.0

data/lib/mail/parsers/content_location_parser.rb

@@ -0,0 +1,35 @@
+module Mail::Parsers
+  class ContentLocationParser
+    def parse(s)
+      content_location = ContentLocationStruct.new(nil)
+      if s.blank?
+        return content_location
+      end
+
+      actions, error = Ragel.parse(:content_location, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentLocationElement, s, error)
+      end
+
+      qstr_s = token_string_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then content_location.location = s[qstr_s..(p-1)]
+
+        # Token String
+        when :token_string_s then token_string_s = p
+        when :token_string_e
+          content_location.location = s[token_string_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentLocationElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      content_location
+    end
+  end
+end

data/lib/mail/parsers/content_transfer_encoding_parser.rb

@@ -0,0 +1,33 @@
+module Mail::Parsers
+  class ContentTransferEncodingParser
+
+    def parse(s)
+      content_transfer_encoding = ContentTransferEncodingStruct.new("")
+      if s.blank?
+        return content_transfer_encoding
+      end
+
+      actions, error = Ragel.parse(:content_transfer_encoding, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentTransferEncodingElement, s, error)
+      end
+
+      encoding_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Encoding
+        when :encoding_s then encoding_s = p
+        when :encoding_e
+          content_transfer_encoding.encoding = s[encoding_s..(p-1)].downcase
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentTransferEncodingElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      content_transfer_encoding
+    end
+  end
+end

data/lib/mail/parsers/content_type_parser.rb

@@ -0,0 +1,64 @@
+module Mail::Parsers
+  class ContentTypeParser
+    include Mail::Utilities
+
+    def parse(s)
+      actions, error = Ragel.parse(:content_type, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::ContentTypeElement, s, error)
+      end
+
+      content_type = ContentTypeStruct.new(nil,nil,[])
+
+      content_type.parameters = []
+
+      main_type_s = sub_type_s = param_attr_s = param_attr = nil
+      qstr_s = qstr = param_val_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Main Type
+        when :main_type_s then main_type_s = p
+        when :main_type_e then
+          content_type.main_type = s[main_type_s..(p-1)].downcase
+
+        # Sub Type
+        when :sub_type_s then sub_type_s = p
+        when :sub_type_e
+          content_type.sub_type = s[sub_type_s..(p-1)].downcase
+
+        # Parameter Attribute
+        when :param_attr_s then param_attr_s = p
+        when :param_attr_e then param_attr = s[param_attr_s..(p-1)]
+
+        # Quoted String.
+        when :qstr_s then qstr_s = p
+        when :qstr_e then qstr = s[qstr_s..(p-1)]
+
+        # Parameter Value
+        when :param_val_s then param_val_s = p
+        when :param_val_e
+          if param_attr.nil?
+            raise Mail::Field::ParseError.new(Mail::ContentTypeElement, s, "no attribute for value")
+          end
+
+          # Use quoted s value if one exists, otherwise use parameter value
+          if qstr
+            value = qstr
+          else
+            value = s[param_val_s..(p-1)]
+          end
+
+          content_type.parameters <<  { param_attr => value }
+          param_attr = nil
+          qstr = nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::ContentTypeElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      content_type
+    end
+  end
+end

data/lib/mail/parsers/date_time_parser.rb

@@ -0,0 +1,36 @@
+module Mail::Parsers
+  class DateTimeParser
+    include Mail::Utilities
+
+    def parse(s)
+      date_time = DateTimeStruct.new([])
+
+      actions, error = Ragel.parse(:date_time, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::DateTimeElement, s, error)
+      end
+
+      date_s = time_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Date
+        when :date_s then date_s = p
+        when :date_e
+          date_time.date_string = s[date_s..(p-1)]
+
+        # Time
+        when :time_s then time_s = p
+        when :time_e
+          date_time.time_string = s[time_s..(p-1)]
+
+        else
+          raise Mail::Field::ParseError.new(Mail::DateTimeElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      date_time
+    end
+  end
+end

data/lib/mail/parsers/envelope_from_parser.rb

@@ -0,0 +1,45 @@
+module Mail::Parsers
+  class EnvelopeFromParser
+    def parse(s)
+      envelope_from = EnvelopeFromStruct.new
+      if s.blank?
+        return envelope_from
+      end
+
+      actions, error = Ragel.parse(:envelope_from, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::EnvelopeFromElement, s, error)
+      end
+
+      address_s = ctime_date_s = nil
+      envelope_from = EnvelopeFromStruct.new
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Address
+        when :address_s then address_s = p
+        when :address_e
+          envelope_from.address = s[address_s..(p-1)].rstrip
+
+        # ctime_date
+        when :ctime_date_s then ctime_date_s = p
+        when :ctime_date_e
+          envelope_from.ctime_date = s[ctime_date_s..(p-1)]
+
+        # ignored actions
+        when :angle_addr_s, :comment_e, :comment_s,
+             :domain_e, :domain_s, :local_dot_atom_e,
+             :local_dot_atom_pre_comment_e,
+             :local_dot_atom_pre_comment_s,
+             :local_dot_atom_s, :qstr_e, :qstr_s
+          nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::EnvelopeFromElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      envelope_from
+    end
+  end
+end

data/lib/mail/parsers/message_ids_parser.rb

@@ -0,0 +1,39 @@
+module Mail::Parsers
+  class MessageIdsParser
+    def parse(s)
+      if s.blank?
+        return MessageIdsStruct.new
+      end
+
+      message_ids = MessageIdsStruct.new([])
+
+      actions, error = Ragel.parse(:message_ids, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::MessageIdsElement, s, error)
+      end
+
+      msg_id_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Message Ids
+        when :msg_id_s then msg_id_s = p
+        when :msg_id_e
+          message_ids.message_ids << s[msg_id_s..(p-1)].rstrip
+
+        when :domain_e, :domain_s, :local_dot_atom_e,
+          :local_dot_atom_pre_comment_e,
+          :local_dot_atom_pre_comment_s,
+          :local_dot_atom_s
+
+          # ignored actions
+
+        else
+          raise Mail::Field::ParseError.new(Mail::MessageIdsElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      message_ids
+    end
+  end
+end

data/lib/mail/parsers/mime_version_parser.rb

@@ -0,0 +1,41 @@
+module Mail::Parsers
+  class MimeVersionParser
+    include Mail::Utilities
+
+    def parse(s)
+      if s.blank?
+        return MimeVersionStruct.new("", nil)
+      end
+
+      mime_version = MimeVersionStruct.new
+
+      actions, error = Ragel.parse(:mime_version, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::MimeVersionElement, s, error)
+      end
+
+      major_digits_s = minor_digits_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Major Digits
+        when :major_digits_s then major_digits_s = p
+        when :major_digits_e
+          mime_version.major = s[major_digits_s..(p-1)]
+
+        # Minor Digits
+        when :minor_digits_s then minor_digits_s = p
+        when :minor_digits_e
+          mime_version.minor = s[minor_digits_s..(p-1)]
+
+        when :comment_e, :comment_s then nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::MimeVersionElement, s, "Failed to process unknown action: #{action}")
+        end
+      end
+      mime_version
+    end
+  end
+end

data/lib/mail/parsers/phrase_lists_parser.rb

@@ -0,0 +1,33 @@
+module Mail::Parsers
+  class PhraseListsParser
+
+    def parse(s)
+      actions, error = Ragel.parse(:phrase_lists, s)
+      if error
+        raise Mail::Field::ParseError.new(Mail::PhraseList, s, error)
+      end
+
+      phrase_lists = PhraseListsStruct.new([])
+
+      phrase_s = nil
+      actions.each_slice(2) do |action_id, p|
+        action = Mail::Parsers::Ragel::ACTIONS[action_id]
+        case action
+
+        # Phrase
+        when :phrase_s then phrase_s = p
+        when :phrase_e
+          phrase_lists.phrases << s[phrase_s..(p-1)] if phrase_s
+          phrase_s = nil
+
+        when :comment_e, :comment_s, :qstr_s, :qstr_e then nil
+
+        else
+          raise Mail::Field::ParseError.new(Mail::PhraseList, s, "Failed to process unknown action: #{action}")
+        end
+      end
+
+      phrase_lists
+    end
+  end
+end

data/lib/mail/parsers/ragel.rb

@@ -0,0 +1,17 @@
+module Mail
+  module Parsers
+    module Ragel
+      require 'mail/parsers/ragel/parser_info'
+      require "mail/parsers/ragel/ruby"
+
+      def self.parse(machine, string)
+        @machine_module ||= Ruby
+        @machine_module.parse(machine, string)
+      end
+
+      def self.machine_module=(m)
+        @machine_module = m
+      end
+    end
+  end
+end

data/lib/mail/parsers/ragel/common.rl

@@ -0,0 +1,184 @@
+%%{
+
+  machine common;
+
+  action comment_begin { fcall comment_tail; }
+  action comment_exit { fret; }
+
+  # RFC5322: address_lists, date_time, message_ids, phrase_lists, received
+
+  obs_NO_WS_CTL = 0x01..0x08 | 0x0b | 0x0c | 0x0e..0x1f | 0x7f;
+  LF = "\n";
+  CR = "\r";
+  CRLF = "\r\n";
+  WSP = 0x09 | 0x20;
+  obs_ctext = obs_NO_WS_CTL;
+  VCHAR = 0x21..0x7e;
+  obs_qp = "\\" (0x00 | obs_NO_WS_CTL | LF | CR);
+  obs_FWS = (CRLF? WSP)+;
+  ctext = 0x21..0x27 | 0x2a..0x5b | 0x5d..0x7e | obs_ctext;
+  quoted_pair = ("\\" (VCHAR | WSP)) | obs_qp;
+  FWS = (WSP* CRLF WSP+) | (CRLF WSP+) | obs_FWS;
+  ALPHA = [a-zA-Z];
+  DIGIT = [0-9];
+  DQUOTE = '"';
+  obs_qtext = obs_NO_WS_CTL;
+  atext = ALPHA | DIGIT | "!" | "#" | "$" | "%" | "&" |
+          "'" | "*" | "+" | "-" | "/" | "=" | "?" | "^" |
+          "_" | "`" | "{" | "|" | "}" | "~";
+  qtext = 0x21 | 0x23..0x5b | 0x5d..0x7e | obs_qtext;
+  obs_dtext = obs_NO_WS_CTL | quoted_pair;
+  qcontent = qtext | quoted_pair;
+
+  # Handle recursive comments
+  ccontent = ctext | quoted_pair | "(" @comment_begin;
+  comment_tail := ((FWS? ccontent)* >comment_s) FWS? ")" @comment_exit;
+  comment = "(" @comment_begin %comment_e;
+  CFWS = ((FWS? comment)+ FWS?) | FWS;
+
+  quoted_string = CFWS?
+                  (DQUOTE
+                    (((FWS? qcontent)* FWS?) >qstr_s %qstr_e)
+                  DQUOTE)
+                  CFWS?;
+
+  atom = CFWS? atext+ CFWS?;
+  word = atom | quoted_string;
+
+  # phrase_lists
+  obs_phrase = (word | "." | "@")+;
+  phrase = (obs_phrase | word+) >phrase_s %phrase_e;
+  phrase_lists = phrase ("," FWS* phrase)*;
+
+  # address_lists
+
+  # local_part:
+  domain_text = (DQUOTE (FWS? qcontent)+ FWS? DQUOTE) | atext+;
+  local_dot_atom_text = ("."* domain_text "."*)+;
+  local_dot_atom = CFWS?
+                   (local_dot_atom_text >local_dot_atom_s %local_dot_atom_pre_comment_e)
+                   CFWS?;
+  obs_local_part = word ("." word)*;
+  local_part = (local_dot_atom >local_dot_atom_s %local_dot_atom_e |
+                (quoted_string %local_quoted_string_e) |
+                obs_local_part);
+
+  # Treetop parser behavior was to ignore addresses missing '@' inside of angle
+  # brackets. This construction preserves that behavior.
+  local_part_no_capture = (local_dot_atom | quoted_string | obs_local_part);
+
+  # domain:
+  dot_atom_text = "."* domain_text ("."* domain_text)*;
+  dtext = 0x21..0x5a | 0x5e..0x7e | obs_dtext;
+  dot_atom = CFWS? dot_atom_text (CFWS? >(comment_after_address,1));
+  domain_literal = CFWS? "[" (FWS? dtext)* FWS? "]" CFWS?;
+  obs_domain = atom ("." atom)*;
+  domain = (dot_atom | domain_literal | obs_domain) >domain_s %domain_e;
+
+  # addr_spec:
+
+  # The %(end_addr,N) priority resolves uncertainty when whitespace
+  # after an addr_spec could cause it to be interpreted as a
+  # display name: "bar@example.com ,..."
+
+  addr_spec_in_angle_brackets =
+    (local_part "@" domain) %(end_addr,1) |
+    local_part_no_capture   %(end_addr,0);
+
+  addr_spec_no_angle_brackets =
+    (local_part "@" domain) %(end_addr,1) |
+    local_part              %(end_addr,0);
+
+  # angle_addr:
+  obs_domain_list = (CFWS | ",")* "@" domain ("," CFWS? ("@" domain)?)*;
+  obs_route = (obs_domain_list ":") >obs_domain_list_s %obs_domain_list_e;
+  obs_angle_addr = CFWS? "<" obs_route? addr_spec_in_angle_brackets ">" CFWS?;
+
+  angle_addr = CFWS? ("<" >angle_addr_s) addr_spec_in_angle_brackets ">" CFWS? |
+                obs_angle_addr;
+
+  # Address
+  display_name = phrase;
+  name_addr = display_name? %(end_addr,2) angle_addr;
+  mailbox = (name_addr | addr_spec_no_angle_brackets) >address_s %address_e;
+  obs_mbox_list = (CFWS? ",")* mailbox ("," (mailbox | CFWS)?)*;
+  mailbox_list = (mailbox (("," | ";") mailbox)*) | obs_mbox_list;
+  obs_group_list = (CFWS? ",")+ CFWS?;
+  group_list = mailbox_list | CFWS | obs_group_list;
+  group = (display_name >group_name_s %group_name_e) ":"
+            (group_list?) ";" CFWS?;
+  address = group | mailbox;
+  #obs_addr_list = (CFWS? ",")* address ("," (address | CFWS)?)*;
+  address_lists = address? %(comment_after_address,0)
+                  (FWS* ("," | ";") FWS* address?)*;
+
+  # message_ids
+  obs_id_left = local_part;
+  id_left = dot_atom_text | obs_id_left;
+  # id_right modifications to support multiple '@' in msg_id.
+  msg_id_atext = ALPHA | DIGIT | "!" | "#" | "$" | "%" | "&" | "'" | "*" |
+                 "+" | "-" | "/" | "=" | "?" | "^" | "_" | "`" | "{" | "|" |
+                 "}" | "~" | "@";
+  msg_id_dot_atom_text = (msg_id_atext+ "."?)+;
+  obs_id_right = domain;
+  no_fold_literal = "[" (dtext)* "]";
+  id_right = msg_id_dot_atom_text | no_fold_literal | obs_id_right;
+  msg_id = (CFWS)?
+           (("<" id_left "@" id_right ">") >msg_id_s %msg_id_e)
+           (CFWS)?;
+  message_ids = msg_id (CFWS? msg_id)*;
+
+  include date_time "date_time.rl";
+  date_time = (day_of_week ",")?
+              (date >date_s %date_e) <: (time >time_s %time_e) CFWS?;
+
+  # Added CFWS? to increase robustness
+  # (qmail likes to include a comment style string...?)
+  received_token = word | angle_addr | addr_spec_no_angle_brackets | domain;
+  received = ((CFWS? received_token*) >received_tokens_s %received_tokens_e)
+              ";" date_time;
+
+  # RFC2045: mime_version, content_type, content_transfer_encoding
+  mime_version = CFWS?
+            (DIGIT+ >major_digits_s %major_digits_e)
+            comment? "." comment?
+            (DIGIT+ >minor_digits_s %minor_digits_e)
+            CFWS?;
+
+  token = 0x21..0x27 | 0x2a..0x2b | 0x2c..0x2e |
+          0x30..0x39 | 0x41..0x5a | 0x5e..0x7e;
+  value = (quoted_string | (token -- '"' | 0x3d)+) >param_val_s %param_val_e;
+  attribute = (token+) >param_attr_s %param_attr_e;
+  parameter = CFWS? attribute "=" value CFWS?;
+
+  ietf_token = token+;
+  custom_x_token = 'x'i "-" token+;
+  extension_token = ietf_token | custom_x_token;
+  discrete_type = 'text'i | 'image'i | 'audio'i | 'video'i |
+                  'application'i | extension_token;
+  composite_type = 'message'i | 'multipart'i | extension_token;
+  iana_token = token+;
+  main_type = (discrete_type | composite_type) >main_type_s %main_type_e;
+  sub_type = (extension_token | iana_token) >sub_type_s %sub_type_e;
+  content_type = main_type "/" sub_type (((CFWS? ";"+) | CFWS) parameter CFWS?)*;
+
+  encoding = ('7bits' | '8bits' | '7bit' | '8bit' | 'binary' |
+              'quoted-printable' | 'base64' | ietf_token |
+              custom_x_token) >encoding_s %encoding_e;
+  content_transfer_encoding = CFWS? encoding CFWS? ";"? CFWS?;
+
+  # RFC2183: content_disposition
+  # TODO: recognize filename, size, creation date, etc.
+  disposition_type = 'inline'i | 'attachment'i | extension_token | '';
+  content_disposition = (disposition_type >disp_type_s %disp_type_e)
+                        (CFWS? ";" parameter CFWS?)*;
+
+  # Envelope From
+  ctime_date = day_name " "+ month " "+ day " " time_of_day " " year;
+  envelope_from = (addr_spec_no_angle_brackets) >address_s %address_e " "
+                  (ctime_date >ctime_date_s %ctime_date_e);
+
+  # content_location
+  location = quoted_string | ((token | 0x3d)+ >token_string_s %token_string_e);
+  content_location = CFWS? location CFWS?;
+}%%