Debbugs/MIME.pm

   1 package Debbugs::MIME;
   2
   3 use strict;
   4
   5 use base qw(Exporter);
   6 use vars qw($VERSION @EXPORT_OK);
   7
   8 BEGIN {
   9     $VERSION = 1.00;
  10
  11     @EXPORT_OK = qw(parse decode_rfc1522 encode_rfc1522 convert_to_utf8 create_mime_message);
  12 }
  13
  14 use File::Path;
  15 use MIME::Parser;
  16
  17 # for decode_rfc1522
  18 use MIME::WordDecoder qw();
  19 use Encode qw(decode encode encode_utf8 decode_utf8 is_utf8);
  20
  21 # for encode_rfc1522
  22 use MIME::Words qw();
  23
  24 sub getmailbody ($);
  25 sub getmailbody ($)
  26 {
  27     my $entity = shift;
  28     my $type = $entity->effective_type;
  29     if ($type eq 'text/plain' or
  30             ($type =~ m#text/# and $type ne 'text/html') or
  31             $type eq 'application/pgp') {
  32         return $entity->bodyhandle;
  33     } elsif ($type eq 'multipart/alternative') {
  34         # RFC 2046 says we should use the last part we recognize.
  35         for my $part (reverse $entity->parts) {
  36             my $ret = getmailbody($part);
  37             return $ret if $ret;
  38         }
  39     } else {
  40         # For other multipart types, we just pretend they're
  41         # multipart/mixed and run through in order.
  42         for my $part ($entity->parts) {
  43             my $ret = getmailbody($part);
  44             return $ret if $ret;
  45         }
  46     }
  47     return undef;
  48 }
  49
  50 sub parse ($)
  51 {
  52     # header and decoded body respectively
  53     my (@headerlines, @bodylines);
  54
  55     my $parser = new MIME::Parser;
  56     mkdir "mime.tmp.$$", 0777;
  57     $parser->output_under("mime.tmp.$$");
  58     my $entity = eval { $parser->parse_data($_[0]) };
  59
  60     if ($entity and $entity->head->tags) {
  61         @headerlines = @{$entity->head->header};
  62         chomp @headerlines;
  63
  64         my $entity_body = getmailbody($entity);
  65         @bodylines = $entity_body ? $entity_body->as_lines() : ();
  66         chomp @bodylines;
  67     } else {
  68         # Legacy pre-MIME code, kept around in case MIME::Parser fails.
  69         my @msg = split /\n/, $_[0];
  70         my $i;
  71
  72         for ($i = 0; $i <= $#msg; ++$i) {
  73             $_ = $msg[$i];
  74             last unless length;
  75             while ($msg[$i + 1] =~ /^\s/) {
  76                 ++$i;
  77                 $_ .= "\n" . $msg[$i];
  78             }
  79             push @headerlines, $_;
  80         }
  81
  82         @bodylines = @msg[$i .. $#msg];
  83     }
  84
  85     rmtree "mime.tmp.$$", 0, 1;
  86
  87     # Remove blank lines.
  88     shift @bodylines while @bodylines and $bodylines[0] !~ /\S/;
  89
  90     # Strip off RFC2440-style PGP clearsigning.
  91     if (@bodylines and $bodylines[0] =~ /^-----BEGIN PGP SIGNED/) {
  92         shift @bodylines while @bodylines and length $bodylines[0];
  93         shift @bodylines while @bodylines and $bodylines[0] !~ /\S/;
  94         for my $findsig (0 .. $#bodylines) {
  95             if ($bodylines[$findsig] =~ /^-----BEGIN PGP SIGNATURE/) {
  96                 $#bodylines = $findsig - 1;
  97                 last;
  98             }
  99         }
 100         map { s/^- // } @bodylines;
 101     }
 102
 103     return { header => [@headerlines], body => [@bodylines]};
 104 }
 105
 106 =head2 create_mime_message
 107
 108      create_mime_message([To=>'don@debian.org'],$body,[$attach1, $attach2]);
 109
 110 Creates a MIME encoded message with headers given by the first
 111 argument, and a message given by the second.
 112
 113 Optional attachments can be specified in the third arrayref argument.
 114
 115 Headers are passed directly to MIME::Entity::build, the message is the
 116 first attachment.
 117
 118 Each of the elements of the attachment arrayref is attached as an
 119 rfc822 message if it is a scalar or an arrayref; otherwise if it is a
 120 hashref, the contents are passed as an argument to
 121 MIME::Entity::attach
 122
 123 =cut
 124
 125 sub create_mime_message{
 126      my ($headers,$body,$attachments) = @_;
 127      $attachments = [] if not defined $attachments;
 128
 129      die "The first argument to create_mime_message must be an arrayref" unless ref($headers) eq 'ARRAY';
 130      die "The third argument to create_mime_message must be an arrayref" unless ref($attachments) eq 'ARRAY';
 131
 132      # Build the message
 133      # MIME::Entity is stupid, and doesn't rfc1522 encode its headers, so we do it for it.
 134      my $msg = MIME::Entity->build('Content-Type' => 'text/plain; charset=utf-8',
 135                                    'Encoding'     => 'quoted-printable',
 136                                    (map{encode_rfc1522($_)} @{$headers}),
 137                                    Data    => $body
 138                                   );
 139
 140      # Attach the attachments
 141      for my $attachment (@{$attachments}) {
 142           if (ref($attachment) eq 'HASH') {
 143                $msg->attach(%{$attachment});
 144           }
 145           else {
 146                # This is *craptacular*, but because various MTAs
 147                # (sendmail and exim4, at least) appear to eat From
 148                # lines in message/rfc822 attachments, we need eat
 149                # the entire From line ourselves so the MTA doesn't
 150                # leave \n detrius around.
 151                if (ref($attachment) eq 'ARRAY' and $attachment->[1] =~ /^From /) {
 152                     # make a copy so that we don't screw up anything
 153                     # that is expecting this arrayref to stay constant
 154                     $attachment = [@{$attachment}];
 155                     # remove the from line
 156                     splice @$attachment, 1, 1;
 157                }
 158                elsif (not ref($attachment)) {
 159                     # It's a scalar; remove the from line
 160                     $attachment =~ s/^(Received:[^\n]+\n)(From [^\n]+\n)/$1/s;
 161                }
 162                $msg->attach(Type => 'message/rfc822',
 163                             Data => $attachment,
 164                             Encoding => '7bit',
 165                            );
 166           }
 167      }
 168      return $msg->as_string;
 169 }
 170
 171
 172 # Bug #61342 et al.
 173
 174 sub convert_to_utf8 {
 175      my ($data, $charset) = @_;
 176      # raw data just gets returned (that's the charset WordDecorder
 177      # uses when it doesn't know what to do)
 178      return $data if $charset eq 'raw' or is_utf8($data,1);
 179      my $result;
 180      eval {
 181           # this encode/decode madness is to make sure that the data
 182           # really is valid utf8 and that the is_utf8 flag is off.
 183           $result = encode("utf8",decode($charset,$data))
 184      };
 185      if ($@) {
 186           warn "Unable to decode charset; '$charset' and '$data': $@";
 187           return $data;
 188      }
 189      return $result;
 190 }
 191
 192
 193 =head2 decode_rfc1522
 194
 195     decode_rfc1522('=?iso-8859-1?Q?D=F6n_Armstr=F3ng?= <don@donarmstrong.com>')
 196
 197 Turn RFC-1522 names into the UTF-8 equivalent.
 198
 199 =cut
 200
 201 BEGIN {
 202     # Set up the default RFC1522 decoder, which turns all charsets that
 203     # are supported into the appropriate UTF-8 charset.
 204     MIME::WordDecoder->default(new MIME::WordDecoder(
 205         ['*' => \&convert_to_utf8,
 206         ]));
 207 }
 208
 209 sub decode_rfc1522 ($)
 210 {
 211     my ($string) = @_;
 212
 213     # this is craptacular, but leading space is hacked off by unmime.
 214     # Save it.
 215     my $leading_space = '';
 216     $leading_space = $1 if $string =~ s/^(\s+)//;
 217     # unmime calls the default MIME::WordDecoder handler set up at
 218     # initialization time.
 219     return $leading_space . MIME::WordDecoder::unmime($string);
 220 }
 221
 222 =head2 encode_rfc1522
 223
 224      encode_rfc1522('Dön Armströng <don@donarmstrong.com>')
 225
 226 Encodes headers according to the RFC1522 standard by calling
 227 MIME::Words::encode_mimeword on distinct words as appropriate.
 228
 229 =cut
 230
 231 # We cannot use MIME::Words::encode_mimewords because that function
 232 # does not handle spaces properly at all.
 233
 234 sub encode_rfc1522 ($) {
 235      my ($rawstr) = @_;
 236
 237      # We process words in reverse so we can preserve spacing between
 238      # encoded words. This regex splits on word|nonword boundaries and
 239      # nonword|nonword boundaries.
 240      my @words = reverse split /(?:(?<=[\s\n])|(?=[\s\n]))/m, $rawstr;
 241
 242      my $previous_word_encoded = 0;
 243      my $string = '';
 244      for my $word (@words) {
 245           if ($word !~ m#[\x00-\x1F\x7F-\xFF]#o and $word ne ' ') {
 246                $string = $word.$string;
 247                $previous_word_encoded=0;
 248           }
 249           elsif ($word =~ /^[\s\n]$/) {
 250                $string = $word.$string;
 251                $previous_word_encoded = 0 if $word eq "\n";
 252           }
 253           else {
 254                my $encoded = MIME::Words::encode_mimeword($word, 'q', 'UTF-8');
 255                # RFC 1522 mandates that segments be at most 76 characters
 256                # long. If that's the case, we split the word up into 10
 257                # character pieces and encode it. We must use the Encode
 258                # magic here to avoid breaking on bit boundaries here.
 259                if (length $encoded > 75) {
 260                     # Turn utf8 into the internal perl representation
 261                     # so . is a character, not a byte.
 262                     my $tempstr = decode_utf8($word,Encode::FB_DEFAULT);
 263                     my @encoded;
 264                     # Strip it into 10 character long segments, and encode
 265                     # the segments
 266                     # XXX It's possible that these segments are > 76 characters
 267                     while ($tempstr =~ s/(.{1,10})$//) {
 268                          # turn the character back into the utf8 representation.
 269                          my $tempword = encode_utf8($1);
 270                          # It may actually be better to eventually use
 271                          # the base64 encoding here, but I'm not sure
 272                          # if that's as widely supported as quoted
 273                          # printable.
 274                          unshift @encoded, MIME::Words::encode_mimeword($tempword,'q','UTF-8');
 275                     }
 276                     $encoded = join(" ",@encoded);
 277                     # If the previous word was encoded, we must
 278                     # include a trailing _ that gets encoded as a
 279                     # space.
 280                     $encoded =~ s/\?\=$/_\?\=/ if $previous_word_encoded;
 281                     $string = $encoded.$string;
 282                }
 283                else {
 284                     # If the previous word was encoded, we must
 285                     # include a trailing _ that gets encoded as a
 286                     # space.
 287                     $encoded =~ s/\?\=$/_\?\=/ if $previous_word_encoded;
 288                     $string = $encoded.$string;
 289                }
 290                $previous_word_encoded = 1;
 291           }
 292      }
 293      return $string;
 294 }
 295
 296 1;