X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=Debbugs%2FMIME.pm;h=909191549ca13b380a2f815ea5da8d97c1ee5495;hb=b33403cc853dc5f8376ace6d4411a59ed9c49692;hp=1269e17b4a077ea86f148a2d546372b7f20376a6;hpb=bece9d17fd221748f93bf3a1858ae99a8d92c01c;p=debbugs.git diff --git a/Debbugs/MIME.pm b/Debbugs/MIME.pm index 1269e17..9091915 100644 --- a/Debbugs/MIME.pm +++ b/Debbugs/MIME.pm @@ -1,19 +1,62 @@ +# This module is part of debbugs, and is released +# under the terms of the GPL version 2, or any later +# version at your option. +# See the file README and COPYING for more information. +# +# [Other people have contributed to this file; their copyrights should +# go here too.] +# Copyright 2006 by Don Armstrong . + + package Debbugs::MIME; +=head1 NAME + +Debbugs::MIME -- Mime handling routines for debbugs + +=head1 SYNOPSIS + + use Debbugs::MIME qw(parse decode_rfc1522); + +=head1 DESCRIPTION + + +=head1 BUGS + +None known. + +=cut + +use warnings; use strict; use base qw(Exporter); -use vars qw($VERSION @EXPORT_OK); +use vars qw($DEBUG $VERSION @EXPORT_OK %EXPORT_TAGS @EXPORT); BEGIN { $VERSION = 1.00; + $DEBUG = 0 unless defined $DEBUG; + + @EXPORT = (); - @EXPORT_OK = qw(parse decode_rfc1522 encode_rfc1522 convert_to_utf8 create_mime_message); + %EXPORT_TAGS = (mime => [qw(parse create_mime_message getmailbody)], + rfc1522 => [qw(decode_rfc1522 encode_rfc1522)], + ); + @EXPORT_OK=(); + Exporter::export_ok_tags(keys %EXPORT_TAGS); + $EXPORT_TAGS{all} = [@EXPORT_OK]; } use File::Path; +use File::Temp qw(); use MIME::Parser; +use POSIX qw(strftime); +use List::MoreUtils qw(apply); + +# for convert_to_utf8 +use Debbugs::UTF8 qw(convert_to_utf8 encode_utf8_safely); + # for decode_rfc1522 use MIME::WordDecoder qw(); use Encode qw(decode encode encode_utf8 decode_utf8 is_utf8); @@ -21,15 +64,14 @@ use Encode qw(decode encode encode_utf8 decode_utf8 is_utf8); # for encode_rfc1522 use MIME::Words qw(); -sub getmailbody ($); -sub getmailbody ($) +sub getmailbody { my $entity = shift; my $type = $entity->effective_type; if ($type eq 'text/plain' or - ($type =~ m#text/# and $type ne 'text/html') or + ($type =~ m#text/?# and $type ne 'text/html') or $type eq 'application/pgp') { - return $entity->bodyhandle; + return $entity; } elsif ($type eq 'multipart/alternative') { # RFC 2046 says we should use the last part we recognize. for my $part (reverse $entity->parts) { @@ -47,22 +89,29 @@ sub getmailbody ($) return undef; } -sub parse ($) +sub parse { # header and decoded body respectively my (@headerlines, @bodylines); - my $parser = new MIME::Parser; - mkdir "mime.tmp.$$", 0777; - $parser->output_under("mime.tmp.$$"); + my $parser = MIME::Parser->new(); + my $tempdir = File::Temp::tempdir(); + $parser->output_under($tempdir); my $entity = eval { $parser->parse_data($_[0]) }; if ($entity and $entity->head->tags) { @headerlines = @{$entity->head->header}; chomp @headerlines; - my $entity_body = getmailbody($entity); - @bodylines = $entity_body ? $entity_body->as_lines() : (); + my $entity_body = getmailbody($entity); + my $entity_body_handle; + my $charset; + if (defined $entity_body) { + $entity_body_handle = $entity_body->bodyhandle(); + $charset = $entity_body->head()->mime_attr('content-type.charset'); + } + @bodylines = $entity_body_handle ? $entity_body_handle->as_lines() : (); + @bodylines = map {convert_to_utf8($_,$charset)} @bodylines; chomp @bodylines; } else { # Legacy pre-MIME code, kept around in case MIME::Parser fails. @@ -82,14 +131,19 @@ sub parse ($) @bodylines = @msg[$i .. $#msg]; } - rmtree "mime.tmp.$$", 0, 1; + rmtree $tempdir, 0, 1; # Remove blank lines. shift @bodylines while @bodylines and $bodylines[0] !~ /\S/; # Strip off RFC2440-style PGP clearsigning. if (@bodylines and $bodylines[0] =~ /^-----BEGIN PGP SIGNED/) { - shift @bodylines while @bodylines and length $bodylines[0]; + shift @bodylines while @bodylines and + length $bodylines[0] and + # we currently don't strip \r; handle this for the + # time being, though eventually it should be stripped + # too, I think. [See #565981] + $bodylines[0] ne "\r"; shift @bodylines while @bodylines and $bodylines[0] !~ /\S/; for my $findsig (0 .. $#bodylines) { if ($bodylines[$findsig] =~ /^-----BEGIN PGP SIGNATURE/) { @@ -105,13 +159,17 @@ sub parse ($) =head2 create_mime_message - create_mime_message([To=>'don@debian.org'],$body,[$attach1, $attach2]); + create_mime_message([To=>'don@debian.org'],$body,[$attach1, $attach2],$include_date); Creates a MIME encoded message with headers given by the first argument, and a message given by the second. Optional attachments can be specified in the third arrayref argument. +Whether to include the date in the header is the final argument; it +defaults to true, setting the Date header if one is not already +present. + Headers are passed directly to MIME::Entity::build, the message is the first attachment. @@ -123,16 +181,29 @@ MIME::Entity::attach =cut sub create_mime_message{ - my ($headers,$body,$attachments) = @_; + my ($headers,$body,$attachments,$include_date) = @_; $attachments = [] if not defined $attachments; + $include_date = 1 if not defined $include_date; die "The first argument to create_mime_message must be an arrayref" unless ref($headers) eq 'ARRAY'; die "The third argument to create_mime_message must be an arrayref" unless ref($attachments) eq 'ARRAY'; + if ($include_date) { + my %headers = apply {lc($_)} @{$headers}; + if (not exists $headers{date}) { + push @{$headers}, + ('Date', + strftime("%a, %d %b %Y %H:%M:%S +0000",gmtime) + ); + } + } + # Build the message # MIME::Entity is stupid, and doesn't rfc1522 encode its headers, so we do it for it. - my $msg = MIME::Entity->build(map{encode_rfc1522($_)} @{$headers}, - Data => $body + my $msg = MIME::Entity->build('Content-Type' => 'text/plain; charset=utf-8', + 'Encoding' => 'quoted-printable', + (map{encode_rfc1522(encode_utf8_safely($_))} @{$headers}), + Data => encode_utf8_safely($body), ); # Attach the attachments @@ -167,25 +238,6 @@ sub create_mime_message{ } -# Bug #61342 et al. - -sub convert_to_utf8 { - my ($data, $charset) = @_; - # raw data just gets returned (that's the charset WordDecorder - # uses when it doesn't know what to do) - return $data if $charset eq 'raw' or is_utf8($data,1); - my $result; - eval { - # this encode/decode madness is to make sure that the data - # really is valid utf8 and that the is_utf8 flag is off. - $result = encode("utf8",decode($charset,$data)) - }; - if ($@) { - warn "Unable to decode charset; '$charset' and '$data': $@"; - return $data; - } - return $result; -} =head2 decode_rfc1522 @@ -204,13 +256,16 @@ BEGIN { ])); } -sub decode_rfc1522 ($) -{ +sub decode_rfc1522 { my ($string) = @_; + # this is craptacular, but leading space is hacked off by unmime. + # Save it. + my $leading_space = ''; + $leading_space = $1 if $string =~ s/^(\s+)//; # unmime calls the default MIME::WordDecoder handler set up at # initialization time. - return MIME::WordDecoder::unmime($string); + return $leading_space . MIME::WordDecoder::unmime($string); } =head2 encode_rfc1522 @@ -225,13 +280,19 @@ MIME::Words::encode_mimeword on distinct words as appropriate. # We cannot use MIME::Words::encode_mimewords because that function # does not handle spaces properly at all. -sub encode_rfc1522 ($) { +sub encode_rfc1522 { my ($rawstr) = @_; + # handle being passed undef properly + return undef if not defined $rawstr; + # convert to octets if is_utf8 is set + $rawstr= encode_utf8_safely($rawstr); # We process words in reverse so we can preserve spacing between # encoded words. This regex splits on word|nonword boundaries and - # nonword|nonword boundaries. - my @words = reverse split /(?:(?<=[\s\n])|(?=[\s\n]))/m, $rawstr; + # nonword|nonword boundaries. We also consider parenthesis and " + # to be nonwords to avoid escaping them in comments in violation + # of RFC1522 + my @words = reverse split /(?:(?<=[\s\n\)\(\"])|(?=[\s\n\)\(\"]))/m, $rawstr; my $previous_word_encoded = 0; my $string = ''; @@ -253,7 +314,7 @@ sub encode_rfc1522 ($) { if (length $encoded > 75) { # Turn utf8 into the internal perl representation # so . is a character, not a byte. - my $tempstr = decode_utf8($word,Encode::FB_DEFAULT); + my $tempstr = is_utf8($word)?$word:decode_utf8($word,Encode::FB_DEFAULT); my @encoded; # Strip it into 10 character long segments, and encode # the segments