Debian Codegraph @

scripts/mailbox2html

raw
1 #!/usr/bin/perl -w
2 use strict;
3
4 use Mail::Box::Manager;
5
6 my $VERSION = '2.107';
7
8 Mail::Box->VERSION($VERSION);
9
10 # file-globals.
11 my ($manager, @folderpage, @messagepage);
12
13 sub create_folder(@);
14 sub create_message(@);
15 sub clean_dir($);
16 sub default_folderpage();
17 sub default_messagepage();
18
19 =head1 NAME
20
21 mailbox2html - EXPERIMENTAL: convert mail folders into an HTML structure
22
23 =head1 SYNOPSIS
24
25 mailbox2html [-src folder] [-dest directory] [-norecurse]
26
27 =cut
28
29 sub usage($)
30 { my $rc = shift;
31
32 warn <<USAGE;
33 Usage: $0 [options]
34 options:
35 -cleanup clean the destination directory before producing
36 -dest directory output location of translated
37 -folderpage filename template for folder-pages
38 -help -? show this help
39 -index filename name of the directory-index
40 -messagepage filename template for message-pages
41 -norecurse descend into sub-folders
42 -src folder folder(-directory) to be translated into html
43 -template the page-template file
44 -verbose verbose messages
45 USAGE
46
47 exit $rc;
48 }
49
50 my %option =
51 ( cleanup => 0
52 , dest => exists $ENV{TMPDIR} ? "$ENV{TMPDIR}/mail2html"
53 : -d '/var/tmp' ? '/var/tmp/mail2html'
54 : -d '/tmp' ? '/tmp/mail2html'
55 : '.'
56 , folderpage => undef
57 , help => 0
58 , index => 'index.html'
59 , messagepage => undef
60 , recurse => 1
61 , src => exists $ENV{MAIL} ? $ENV{MAIL}
62 : exists $ENV{mail} ? $ENV{mail}
63 : exists $ENV{HOME} && -d "$ENV{HOME}/Mail" ? "$ENV{HOME}/Mail"
64 : exists $ENV{home} && -d "$ENV{home}/Mail" ? "$ENV{home}/Mail"
65 : '.'
66
67 , verbose => 0
68 );
69
70 sub get_options()
71 { use Getopt::Long;
72 GetOptions \%option
73 , 'src=s'
74 , 'dest=s'
75 , 'folderpage=s'
76 , 'index=s'
77 , 'messagepage=s'
78 , 'recurse!'
79 , 'verbose!'
80 , 'cleanup!'
81 , 'help|?!';
82 }
83
84 sub trace(@) { warn @_,"\n" if $option{verbose} }
85
86 sub clean_dir($)
87 { my $dir = shift;
88 trace "cleaning $dir.\n";
89
90 opendir DIR, $dir or return;
91 my (@files, @directories);
92
93 while(my $entry = readdir DIR)
94 { next if $entry =~ m/^\.\.?$/;
95 if(-d $entry) {push @directories, $entry}
96 else {push @files, $entry}
97 }
98
99 closedir DIR;
100
101 unlink "$dir/$_" for @files;
102 clean_dir "$dir/$_" for @directories;
103 unlink $dir;
104 }
105
106 sub create_uplinks(@)
107 { return () unless @_;
108 my @links = ('<B>'.(pop).'</B>');
109 my $href = '..';
110 while(@_)
111 { unshift @links, "<A HREF=$href>".(pop)."</A>";
112 $href .= '/..';
113 }
114 @links;
115 }
116
117 sub create_folder(@)
118 { my %args = @_;
119 my $folder = $args{folder};
120 my $name = $folder->name;
121
122 #
123 # Output location
124 #
125
126 my $dirname = "$args{dest}/$name";
127 for($dirname) # some cleanups.
128 { s!/\./!/!g;
129 s!/\=(/|$)!/!g;
130 }
131 unless(-d $dirname)
132 { trace "Create directory $dirname.";
133 mkdir $dirname, 0700
134 or die "Cannot create directory $dirname: $!\n";
135 }
136 my $filename = "$dirname/$option{index}";
137
138 #
139 # Sub-directory preparations.
140 #
141
142 my @subfolders;
143 if($option{recurse})
144 { my @subs = sort $folder->listSubFolders;
145 my $prev;
146
147 for(my $i=0; $i<@subs; $i++)
148 {
149 my @path = $args{path} ? @{$args{path}} : ();
150 my $sub = $folder->openSubFolder($subs[$i]);
151 my $sum = create_folder
152 ( folder => $sub
153 , dest => $args{dest}
154 , path => [ @path , $name]
155 , previous => ($i <= 0 ? ''
156 : "Previous:&nbsp;<A HREF=\"../$subs[$i-1]\">$subs[$i-1]</A>")
157 , next => ($i >= @subs-1 ? ''
158 : "Next:&nbsp;<A HREF=\"../$subs[$i+1]\">$subs[$i+1]</A>")
159 );
160 push @subfolders, $sum;
161 }
162 }
163
164 #
165 # Summerize data about this folder.
166 #
167
168 trace "processing folder $name";
169
170 my @uplinks = create_uplinks @{$args{path}};
171 my @messages = $folder->messages;
172
173 my %sum = # collect info for super-folder, so no place
174 ( foldername => $name # for sub-folder stuff.
175 , foldersize => 0
176 , seen_messages => 0
177 , nr_messages => scalar @messages
178 , nr_subfolders => scalar @subfolders
179 );
180
181 $sum{foldersize} += $_->{foldersize} foreach @subfolders;
182 $sum{newest} = $sum{oldest} = $messages[0]->timestamp if @messages;
183
184 foreach my $message (@messages)
185 { $sum{deleted}++ if $message->deleted;
186 $sum{seen_messages}++ if $message->label('seen');
187 $sum{foldersize} += $message->size;
188 if(my $timestamp = $message->timestamp)
189 { $sum{newest_message} = $timestamp if $timestamp > $sum{newest};
190 $sum{oldest_message} = $timestamp if $timestamp < $sum{oldest};
191 }
192
193 create_message
194 ( message => $message
195 , folder => $folder
196 , manager => $manager
197 , dirname => $dirname
198 );
199 }
200
201 $sum{new_messages} = @messages - $sum{seen_messages};
202
203 #
204 # Page output.
205 #
206
207 local *HTML;
208 open HTML, '>', $filename
209 or die "Cannot create $filename: $!\n";
210
211 my $oldout = select HTML;
212
213 use_template
214 ( template => \@folderpage
215 , folder => $folder
216 , subfolders => \@subfolders
217 , messages => \@messages
218 , manager => $manager
219 , %sum
220 );
221
222 select $oldout;
223 close HTML;
224
225 \%sum;
226 }
227
228 sub create_message(@)
229 { my %args = @_;
230 my $message = $args{message};
231
232 # f.i. usable for constructing links, because all specials are stripped.
233 my $clean_id = $message->messageID;
234 for($clean_id)
235 { s/^\s*\<(.*?)\>\s*$/$1/g;
236 tr/a-zA-Z0-9_/-/cs;
237 }
238 my $filename = "$args{dirname}/${clean_id}.html";
239 my $subject = $message->head->get('subject') || '&lt;no subject&gt;';
240 chomp $subject;
241
242 $message->label
243 ( clean_id => $clean_id
244 , filename => $filename
245 , subject => $subject
246 );
247
248 local *HTML;
249 open HTML, '>', $filename
250 or die "Cannot create $filename: $!\n";
251
252 my $oldout = select HTML;
253
254 use_template
255 ( template => \@messagepage
256 , message => $message
257 , filename => $filename
258 , folder => $args{folder}
259 , subject => $subject
260 , manager => $manager
261 , indexfile=> $option{index}
262 );
263
264 select $oldout;
265 close HTML;
266 }
267
268 sub parse_template($@)
269 { my $name = shift;
270 my (@parts, $rest);
271 while(@_)
272 { $rest .= shift;
273 while($rest =~ m/\<\#perl\b/)
274 { push @parts, $`;
275 $rest = $';
276 $rest .= shift while @_ && $rest !~ m/\#\>/;
277
278 $rest =~ m/\#\>/
279 or die "Perl part not closed in $name.\n";
280
281 (my $code, $rest) = split /\s*\#\>\s*/, $rest, 2;
282 if($code =~ s/^\s*BEGIN\s+//)
283 { WEBPAGE::run_code($code);
284 $rest = (pop @parts).$rest;
285 }
286 else
287 { push @parts, $code;
288 }
289 }
290 }
291 push @parts, $rest;
292 @parts;
293 }
294
295 sub use_template(@)
296 { my %args = @_;
297
298 foreach (keys %args)
299 { no strict 'refs';
300 ${"WEBPAGE::$_"} = $args{$_};
301 }
302
303 my $template = $args{template};
304 my $lines = @$template;
305 for(my $t=0; $t<$lines; $t++)
306 { print $template->[$t++];
307 WEBPAGE::run_code($template->[$t]) if $t<$lines;
308 }
309 }
310
311 package WEBPAGE;
312 no strict;
313 sub run_code($)
314 { eval shift;
315 die $@ if $@;
316 }
317
318 package main;
319 use strict;
320
321 #####
322 ##### MAIN
323 #####
324
325 usage 22 unless get_options;
326 usage 0 if $option{help};
327
328 # Prepare destination directory.
329
330 clean_dir $option{dest}
331 if $option{cleanup} && -d $option{dest};
332
333 unless(-d $option{dest})
334 { trace "Creating $option{dest}.";
335 mkdir $option{dest}, 0700
336 or die "Cannot create destination directory $option{dest}: $!\n";
337 }
338
339 #
340 # Get the configuration
341 #
342
343 # Parse folderpage.
344
345 if(my $foldtempl = $option{folderpage})
346 { trace "Parsing folderpage-template from $foldtempl.";
347 open TEMPLATE, $foldtempl
348 or die "Cannot read $foldtempl: $!\n";
349
350 @folderpage = parse_template 'folderpage', <TEMPLATE>;
351 close TEMPLATE;
352 }
353 else
354 { trace "Taking default folderpage template.";
355 @folderpage = parse_template 'default folderpage', default_folderpage;
356 }
357
358 # Parse messagepage.
359
360 if(my $msgtempl = $option{messagepage})
361 { trace "Parsing messagepage-template from $msgtempl.";
362 open TEMPLATE, $msgtempl
363 or die "Cannot read $msgtempl: $!\n";
364
365 @messagepage = parse_template 'messagepage', <TEMPLATE>;
366 close TEMPLATE;
367 }
368 else
369 { trace "Taking default messagepage template.";
370 @messagepage = parse_template 'default messagepage', default_messagepage;
371 }
372
373 #
374 # Start handling the folder
375 #
376
377 trace "Start folder manager.";
378 $manager = Mail::Box::Manager->new;
379
380 trace "Opening folder `$option{src}'.";
381 my $folder = $manager->open
382 ( folderdir => $option{src}
383 , folder => '=' # open folderdir
384 , extract => 'ALWAYS' # need all messages anyway.
385 );
386
387 die "Cannot open folder `$option{src}'.\n"
388 unless $folder;
389
390 trace "Folder-type is ",ref $folder, ".";
391
392 create_folder
393 ( dest => $option{dest}
394 , folder => $folder
395 );
396
397 #-------------------------------------------
398
399 sub default_folderpage()
400 { <<'DEFAULT_FOLDERPAGE';
401 <#perl BEGIN
402
403 use File::Basename;
404
405 sub nicemessage($)
406 { my $msg = shift;
407 '<A HREF="'.(basename $msg->label('filename')).'">'
408 . $msg->label('subject') . '</A>';
409 }
410
411 sub polish($)
412 { my @lines = split /\n/, shift;
413 foreach (@lines)
414 { if( my ($layout,$rest) = m/^(.*?)(\<.*)$/ )
415 { $layout =~ s/ /&nbsp;/g;
416 $_ = "<TT>$layout</TT>$rest";
417 }
418 s/$/<BR>\n/;
419 }
420 @lines;
421 }
422 #>
423
424 <HTML>
425 <HEAD><TITLE><#perl print $foldername#></TITLE></HEAD>
426 <BODY BGCOLOR=#FFFFFF TEXT=#000000>
427 See the templates as included in the Mail::Box-package for nicer output
428 and more detailed examples.
429 <#perl
430 print "SUB: $nr_subfolders ".@$subfolders."\n";
431 print "NR=$nr_subfolders, NR=".@$subfolders."\n";
432 if($nr_subfolders)
433 { print "<H4>$nr_subfolders subfolders:</H4>\n";
434 foreach (@$subfolders)
435 { my $subname = basename $_->{foldername};
436 print "<A HREF=\"$subname/$indexfile\">$subname</A> "
437 , "($_->{nr_messages} messages)<BR>\n";
438 }
439 }
440
441 if($nr_messages)
442 { print "\n<H4>$nr_messages messages:</H4>\n";
443 print polish($_->threadToString(\&nicemessage))
444 foreach $manager->threads(folder => $folder)->sortedAll;
445 }
446
447 #>
448 </BODY></HTML>
449 DEFAULT_FOLDERPAGE
450 }
451
452 sub default_messagepage()
453 { <<'DEFAULT_MESSAGEPAGE';
454
455 <HTML><HEAD><TITLE><#perl print $subject#></TITLE></HEAD>
456
457 <BODY BGCOLOR=#FFFFFF TEXT=#000000>
458 <PRE>
459 <#perl if($message) {$message->print(select)} else {print '<undef>'} #>
460 </PRE>
461 </BODY></HTML>
462 DEFAULT_MESSAGEPAGE
463 }
464
465 #-------------------------------------------
466
467 __END__
468
469 =head1 DESCRIPTION
470
471 Convert various kinds of mail folders to HTML, permitting them to be
472 read by a web browser.
473
474 Options:
475
476 =over 4
477
478 =item -cleanup =E<gt> BOOLEAN
479
480 (or C<-cleanup> or C<-nocleanup>) removes the directory before generating
481 the data.
482
483 =item -dest =E<gt> DIRECTORY
484
485 The output directory. When this option is not specified, the program will
486 try to create a sub-directory named C<mail2html> in the directory pointed
487 to by the environment variable TMPDIR or tmpdir, otherwise the output will
488 be in C</var/tmp> or C</tmp>.
489
490 =item -folderpage =E<gt> FILENAME
491
492 # DWC Hm... 2nd sentence doesn't make sense
493 The template which is used to create folder pages. See the examples with
494 the distribution of this code for examples.
495
496 =item -help =E<gt> BOOLEAN
497
498 (or C<-help> or C<-?>) Print a brief help
499
500 =item -index =E<gt> FILENAME
501
502 The filename which the web server loads when the user specifies only the
503 name of the directory in a URL. This option is set to C<index.html> by
504 default.
505
506 =item -messagepage =E<gt> FILENAME
507
508 # DWC Hm... 2nd sentence doesn't make sense
509 The template which is used to create one page per message.
510 See the examples with the distribution of this code for examples.
511
512 =item -recurse =E<gt> BOOLEAN
513
514 (or C<-recurse> or <-norecurse>) Recurse through subfolders. By default,
515 recursive production is enabled.
516
517 =item -src =E<gt> FILE | DIRECTORY
518
519 Start with the folder(-directory) which can be found at the specified
520 location. The type of folder is auto-detected. By default, the contents
521 of the directory specified by the C<MAIL> or C<mail> environment variable
522 are used. If these variables are not defined, C<HOME> and C<home> are
523 checked for a sub-directory named C<Mail>. If these are unsuccessful as
524 well, the current directory is used.
525
526 =item -verbose =E<gt> BOOLEAN
527
528 (or C<-verbose> or C<-noverbose>) Be verbose about the progress of the
529 program. This is especially useful for debugging purposes.
530
531 =back
532
533 =head1 AUTHOR
534
535 Mark Overmeer (F<[email protected]>).
536 All rights reserved. This program is free software; you can redistribute
537 it and/or modify it under the same terms as Perl itself.
538
539 =head1 VERSION
540
541 This code is beta, version 2.107
542
543 =cut
544
545 1;