1#!/usr/bin/perl -w 2# (c) 2007, Joe Perches <joe@perches.com> 3# created from checkpatch.pl 4# 5# Print selected MAINTAINERS information for 6# the files modified in a patch or for a file 7# 8# usage: perl scripts/get_maintainer.pl [OPTIONS] <patch> 9# perl scripts/get_maintainer.pl [OPTIONS] -f <file> 10# 11# Licensed under the terms of the GNU GPL License version 2 12 13use strict; 14 15my $P = $0; 16my $V = '0.26'; 17 18use Getopt::Long qw(:config no_auto_abbrev); 19 20my $lk_path = "./"; 21my $email = 1; 22my $email_usename = 1; 23my $email_maintainer = 1; 24my $email_list = 1; 25my $email_subscriber_list = 0; 26my $email_git_penguin_chiefs = 0; 27my $email_git = 0; 28my $email_git_all_signature_types = 0; 29my $email_git_blame = 0; 30my $email_git_blame_signatures = 1; 31my $email_git_fallback = 1; 32my $email_git_min_signatures = 1; 33my $email_git_max_maintainers = 5; 34my $email_git_min_percent = 5; 35my $email_git_since = "1-year-ago"; 36my $email_hg_since = "-365"; 37my $interactive = 0; 38my $email_remove_duplicates = 1; 39my $email_use_mailmap = 1; 40my $output_multiline = 1; 41my $output_separator = ", "; 42my $output_roles = 0; 43my $output_rolestats = 1; 44my $scm = 0; 45my $web = 0; 46my $subsystem = 0; 47my $status = 0; 48my $keywords = 1; 49my $sections = 0; 50my $file_emails = 0; 51my $from_filename = 0; 52my $pattern_depth = 0; 53my $version = 0; 54my $help = 0; 55 56my $vcs_used = 0; 57 58my $exit = 0; 59 60my %commit_author_hash; 61my %commit_signer_hash; 62 63my @penguin_chief = (); 64push(@penguin_chief, "Linus Torvalds:torvalds\@linux-foundation.org"); 65#Andrew wants in on most everything - 2009/01/14 66#push(@penguin_chief, "Andrew Morton:akpm\@linux-foundation.org"); 67 68my @penguin_chief_names = (); 69foreach my $chief (@penguin_chief) { 70 if ($chief =~ m/^(.*):(.*)/) { 71 my $chief_name = $1; 72 my $chief_addr = $2; 73 push(@penguin_chief_names, $chief_name); 74 } 75} 76my $penguin_chiefs = "\(" . join("|", @penguin_chief_names) . "\)"; 77 78# Signature types of people who are either 79# a) responsible for the code in question, or 80# b) familiar enough with it to give relevant feedback 81my @signature_tags = (); 82push(@signature_tags, "Signed-off-by:"); 83push(@signature_tags, "Reviewed-by:"); 84push(@signature_tags, "Acked-by:"); 85 86my $signature_pattern = "\(" . join("|", @signature_tags) . "\)"; 87 88# rfc822 email address - preloaded methods go here. 89my $rfc822_lwsp = "(?:(?:\\r\\n)?[ \\t])"; 90my $rfc822_char = '[\\000-\\377]'; 91 92# VCS command support: class-like functions and strings 93 94my %VCS_cmds; 95 96my %VCS_cmds_git = ( 97 "execute_cmd" => \&git_execute_cmd, 98 "available" => '(which("git") ne "") && (-e ".git")', 99 "find_signers_cmd" => 100 "git log --no-color --follow --since=\$email_git_since " . 101 '--numstat --no-merges ' . 102 '--format="GitCommit: %H%n' . 103 'GitAuthor: %an <%ae>%n' . 104 'GitDate: %aD%n' . 105 'GitSubject: %s%n' . 106 '%b%n"' . 107 " -- \$file", 108 "find_commit_signers_cmd" => 109 "git log --no-color " . 110 '--numstat ' . 111 '--format="GitCommit: %H%n' . 112 'GitAuthor: %an <%ae>%n' . 113 'GitDate: %aD%n' . 114 'GitSubject: %s%n' . 115 '%b%n"' . 116 " -1 \$commit", 117 "find_commit_author_cmd" => 118 "git log --no-color " . 119 '--numstat ' . 120 '--format="GitCommit: %H%n' . 121 'GitAuthor: %an <%ae>%n' . 122 'GitDate: %aD%n' . 123 'GitSubject: %s%n"' . 124 " -1 \$commit", 125 "blame_range_cmd" => "git blame -l -L \$diff_start,+\$diff_length \$file", 126 "blame_file_cmd" => "git blame -l \$file", 127 "commit_pattern" => "^GitCommit: ([0-9a-f]{40,40})", 128 "blame_commit_pattern" => "^([0-9a-f]+) ", 129 "author_pattern" => "^GitAuthor: (.*)", 130 "subject_pattern" => "^GitSubject: (.*)", 131 "stat_pattern" => "^(\\d+)\\t(\\d+)\\t\$file\$", 132); 133 134my %VCS_cmds_hg = ( 135 "execute_cmd" => \&hg_execute_cmd, 136 "available" => '(which("hg") ne "") && (-d ".hg")', 137 "find_signers_cmd" => 138 "hg log --date=\$email_hg_since " . 139 "--template='HgCommit: {node}\\n" . 140 "HgAuthor: {author}\\n" . 141 "HgSubject: {desc}\\n'" . 142 " -- \$file", 143 "find_commit_signers_cmd" => 144 "hg log " . 145 "--template='HgSubject: {desc}\\n'" . 146 " -r \$commit", 147 "find_commit_author_cmd" => 148 "hg log " . 149 "--template='HgCommit: {node}\\n" . 150 "HgAuthor: {author}\\n" . 151 "HgSubject: {desc|firstline}\\n'" . 152 " -r \$commit", 153 "blame_range_cmd" => "", # not supported 154 "blame_file_cmd" => "hg blame -n \$file", 155 "commit_pattern" => "^HgCommit: ([0-9a-f]{40,40})", 156 "blame_commit_pattern" => "^([ 0-9a-f]+):", 157 "author_pattern" => "^HgAuthor: (.*)", 158 "subject_pattern" => "^HgSubject: (.*)", 159 "stat_pattern" => "^(\\d+)\t(\\d+)\t\$file\$", 160); 161 162my $conf = which_conf(".get_maintainer.conf"); 163if (-f $conf) { 164 my @conf_args; 165 open(my $conffile, '<', "$conf") 166 or warn "$P: Can't find a readable .get_maintainer.conf file $!\n"; 167 168 while (<$conffile>) { 169 my $line = $_; 170 171 $line =~ s/\s*\n?$//g; 172 $line =~ s/^\s*//g; 173 $line =~ s/\s+/ /g; 174 175 next if ($line =~ m/^\s*#/); 176 next if ($line =~ m/^\s*$/); 177 178 my @words = split(" ", $line); 179 foreach my $word (@words) { 180 last if ($word =~ m/^#/); 181 push (@conf_args, $word); 182 } 183 } 184 close($conffile); 185 unshift(@ARGV, @conf_args) if @conf_args; 186} 187 188if (!GetOptions( 189 'email!' => \$email, 190 'git!' => \$email_git, 191 'git-all-signature-types!' => \$email_git_all_signature_types, 192 'git-blame!' => \$email_git_blame, 193 'git-blame-signatures!' => \$email_git_blame_signatures, 194 'git-fallback!' => \$email_git_fallback, 195 'git-chief-penguins!' => \$email_git_penguin_chiefs, 196 'git-min-signatures=i' => \$email_git_min_signatures, 197 'git-max-maintainers=i' => \$email_git_max_maintainers, 198 'git-min-percent=i' => \$email_git_min_percent, 199 'git-since=s' => \$email_git_since, 200 'hg-since=s' => \$email_hg_since, 201 'i|interactive!' => \$interactive, 202 'remove-duplicates!' => \$email_remove_duplicates, 203 'mailmap!' => \$email_use_mailmap, 204 'm!' => \$email_maintainer, 205 'n!' => \$email_usename, 206 'l!' => \$email_list, 207 's!' => \$email_subscriber_list, 208 'multiline!' => \$output_multiline, 209 'roles!' => \$output_roles, 210 'rolestats!' => \$output_rolestats, 211 'separator=s' => \$output_separator, 212 'subsystem!' => \$subsystem, 213 'status!' => \$status, 214 'scm!' => \$scm, 215 'web!' => \$web, 216 'pattern-depth=i' => \$pattern_depth, 217 'k|keywords!' => \$keywords, 218 'sections!' => \$sections, 219 'fe|file-emails!' => \$file_emails, 220 'f|file' => \$from_filename, 221 'v|version' => \$version, 222 'h|help|usage' => \$help, 223 )) { 224 die "$P: invalid argument - use --help if necessary\n"; 225} 226 227if ($help != 0) { 228 usage(); 229 exit 0; 230} 231 232if ($version != 0) { 233 print("${P} ${V}\n"); 234 exit 0; 235} 236 237if (-t STDIN && !@ARGV) { 238 # We're talking to a terminal, but have no command line arguments. 239 die "$P: missing patchfile or -f file - use --help if necessary\n"; 240} 241 242$output_multiline = 0 if ($output_separator ne ", "); 243$output_rolestats = 1 if ($interactive); 244$output_roles = 1 if ($output_rolestats); 245 246if ($sections) { 247 $email = 0; 248 $email_list = 0; 249 $scm = 0; 250 $status = 0; 251 $subsystem = 0; 252 $web = 0; 253 $keywords = 0; 254 $interactive = 0; 255} else { 256 my $selections = $email + $scm + $status + $subsystem + $web; 257 if ($selections == 0) { 258 die "$P: Missing required option: email, scm, status, subsystem or web\n"; 259 } 260} 261 262if ($email && 263 ($email_maintainer + $email_list + $email_subscriber_list + 264 $email_git + $email_git_penguin_chiefs + $email_git_blame) == 0) { 265 die "$P: Please select at least 1 email option\n"; 266} 267 268if (!top_of_kernel_tree($lk_path)) { 269 die "$P: The current directory does not appear to be " 270 . "a linux kernel source tree.\n"; 271} 272 273## Read MAINTAINERS for type/value pairs 274 275my @typevalue = (); 276my %keyword_hash; 277 278open (my $maint, '<', "${lk_path}MAINTAINERS") 279 or die "$P: Can't open MAINTAINERS: $!\n"; 280while (<$maint>) { 281 my $line = $_; 282 283 if ($line =~ m/^(\C):\s*(.*)/) { 284 my $type = $1; 285 my $value = $2; 286 287 ##Filename pattern matching 288 if ($type eq "F" || $type eq "X") { 289 $value =~ s@\.@\\\.@g; ##Convert . to \. 290 $value =~ s/\*/\.\*/g; ##Convert * to .* 291 $value =~ s/\?/\./g; ##Convert ? to . 292 ##if pattern is a directory and it lacks a trailing slash, add one 293 if ((-d $value)) { 294 $value =~ s@([^/])$@$1/@; 295 } 296 } elsif ($type eq "K") { 297 $keyword_hash{@typevalue} = $value; 298 } 299 push(@typevalue, "$type:$value"); 300 } elsif (!/^(\s)*$/) { 301 $line =~ s/\n$//g; 302 push(@typevalue, $line); 303 } 304} 305close($maint); 306 307 308# 309# Read mail address map 310# 311 312my $mailmap; 313 314read_mailmap(); 315 316sub read_mailmap { 317 $mailmap = { 318 names => {}, 319 addresses => {} 320 }; 321 322 return if (!$email_use_mailmap || !(-f "${lk_path}.mailmap")); 323 324 open(my $mailmap_file, '<', "${lk_path}.mailmap") 325 or warn "$P: Can't open .mailmap: $!\n"; 326 327 while (<$mailmap_file>) { 328 s/#.*$//; #strip comments 329 s/^\s+|\s+$//g; #trim 330 331 next if (/^\s*$/); #skip empty lines 332 #entries have one of the following formats: 333 # name1 <mail1> 334 # <mail1> <mail2> 335 # name1 <mail1> <mail2> 336 # name1 <mail1> name2 <mail2> 337 # (see man git-shortlog) 338 339 if (/^([^<]+)<([^>]+)>$/) { 340 my $real_name = $1; 341 my $address = $2; 342 343 $real_name =~ s/\s+$//; 344 ($real_name, $address) = parse_email("$real_name <$address>"); 345 $mailmap->{names}->{$address} = $real_name; 346 347 } elsif (/^<([^>]+)>\s*<([^>]+)>$/) { 348 my $real_address = $1; 349 my $wrong_address = $2; 350 351 $mailmap->{addresses}->{$wrong_address} = $real_address; 352 353 } elsif (/^(.+)<([^>]+)>\s*<([^>]+)>$/) { 354 my $real_name = $1; 355 my $real_address = $2; 356 my $wrong_address = $3; 357 358 $real_name =~ s/\s+$//; 359 ($real_name, $real_address) = 360 parse_email("$real_name <$real_address>"); 361 $mailmap->{names}->{$wrong_address} = $real_name; 362 $mailmap->{addresses}->{$wrong_address} = $real_address; 363 364 } elsif (/^(.+)<([^>]+)>\s*(.+)\s*<([^>]+)>$/) { 365 my $real_name = $1; 366 my $real_address = $2; 367 my $wrong_name = $3; 368 my $wrong_address = $4; 369 370 $real_name =~ s/\s+$//; 371 ($real_name, $real_address) = 372 parse_email("$real_name <$real_address>"); 373 374 $wrong_name =~ s/\s+$//; 375 ($wrong_name, $wrong_address) = 376 parse_email("$wrong_name <$wrong_address>"); 377 378 my $wrong_email = format_email($wrong_name, $wrong_address, 1); 379 $mailmap->{names}->{$wrong_email} = $real_name; 380 $mailmap->{addresses}->{$wrong_email} = $real_address; 381 } 382 } 383 close($mailmap_file); 384} 385 386## use the filenames on the command line or find the filenames in the patchfiles 387 388my @files = (); 389my @range = (); 390my @keyword_tvi = (); 391my @file_emails = (); 392 393if (!@ARGV) { 394 push(@ARGV, "&STDIN"); 395} 396 397foreach my $file (@ARGV) { 398 if ($file ne "&STDIN") { 399 ##if $file is a directory and it lacks a trailing slash, add one 400 if ((-d $file)) { 401 $file =~ s@([^/])$@$1/@; 402 } elsif (!(-f $file)) { 403 die "$P: file '${file}' not found\n"; 404 } 405 } 406 if ($from_filename) { 407 push(@files, $file); 408 if ($file ne "MAINTAINERS" && -f $file && ($keywords || $file_emails)) { 409 open(my $f, '<', $file) 410 or die "$P: Can't open $file: $!\n"; 411 my $text = do { local($/) ; <$f> }; 412 close($f); 413 if ($keywords) { 414 foreach my $line (keys %keyword_hash) { 415 if ($text =~ m/$keyword_hash{$line}/x) { 416 push(@keyword_tvi, $line); 417 } 418 } 419 } 420 if ($file_emails) { 421 my @poss_addr = $text =~ m$[A-Za-zÀ-ÿ\"\' \,\.\+-]*\s*[\,]*\s*[\(\<\{]{0,1}[A-Za-z0-9_\.\+-]+\@[A-Za-z0-9\.-]+\.[A-Za-z0-9]+[\)\>\}]{0,1}$g; 422 push(@file_emails, clean_file_emails(@poss_addr)); 423 } 424 } 425 } else { 426 my $file_cnt = @files; 427 my $lastfile; 428 429 open(my $patch, "< $file") 430 or die "$P: Can't open $file: $!\n"; 431 432 # We can check arbitrary information before the patch 433 # like the commit message, mail headers, etc... 434 # This allows us to match arbitrary keywords against any part 435 # of a git format-patch generated file (subject tags, etc...) 436 437 my $patch_prefix = ""; #Parsing the intro 438 439 while (<$patch>) { 440 my $patch_line = $_; 441 if (m/^\+\+\+\s+(\S+)/ or m/^---\s+(\S+)/) { 442 my $filename = $1; 443 $filename =~ s@^[^/]*/@@; 444 $filename =~ s@\n@@; 445 $lastfile = $filename; 446 push(@files, $filename); 447 $patch_prefix = "^[+-].*"; #Now parsing the actual patch 448 } elsif (m/^\@\@ -(\d+),(\d+)/) { 449 if ($email_git_blame) { 450 push(@range, "$lastfile:$1:$2"); 451 } 452 } elsif ($keywords) { 453 foreach my $line (keys %keyword_hash) { 454 if ($patch_line =~ m/${patch_prefix}$keyword_hash{$line}/x) { 455 push(@keyword_tvi, $line); 456 } 457 } 458 } 459 } 460 close($patch); 461 462 if ($file_cnt == @files) { 463 warn "$P: file '${file}' doesn't appear to be a patch. " 464 . "Add -f to options?\n"; 465 } 466 @files = sort_and_uniq(@files); 467 } 468} 469 470@file_emails = uniq(@file_emails); 471 472my %email_hash_name; 473my %email_hash_address; 474my @email_to = (); 475my %hash_list_to; 476my @list_to = (); 477my @scm = (); 478my @web = (); 479my @subsystem = (); 480my @status = (); 481my %deduplicate_name_hash = (); 482my %deduplicate_address_hash = (); 483 484my @maintainers = get_maintainers(); 485 486if (@maintainers) { 487 @maintainers = merge_email(@maintainers); 488 output(@maintainers); 489} 490 491if ($scm) { 492 @scm = uniq(@scm); 493 output(@scm); 494} 495 496if ($status) { 497 @status = uniq(@status); 498 output(@status); 499} 500 501if ($subsystem) { 502 @subsystem = uniq(@subsystem); 503 output(@subsystem); 504} 505 506if ($web) { 507 @web = uniq(@web); 508 output(@web); 509} 510 511exit($exit); 512 513sub range_is_maintained { 514 my ($start, $end) = @_; 515 516 for (my $i = $start; $i < $end; $i++) { 517 my $line = $typevalue[$i]; 518 if ($line =~ m/^(\C):\s*(.*)/) { 519 my $type = $1; 520 my $value = $2; 521 if ($type eq 'S') { 522 if ($value =~ /(maintain|support)/i) { 523 return 1; 524 } 525 } 526 } 527 } 528 return 0; 529} 530 531sub range_has_maintainer { 532 my ($start, $end) = @_; 533 534 for (my $i = $start; $i < $end; $i++) { 535 my $line = $typevalue[$i]; 536 if ($line =~ m/^(\C):\s*(.*)/) { 537 my $type = $1; 538 my $value = $2; 539 if ($type eq 'M') { 540 return 1; 541 } 542 } 543 } 544 return 0; 545} 546 547sub get_maintainers { 548 %email_hash_name = (); 549 %email_hash_address = (); 550 %commit_author_hash = (); 551 %commit_signer_hash = (); 552 @email_to = (); 553 %hash_list_to = (); 554 @list_to = (); 555 @scm = (); 556 @web = (); 557 @subsystem = (); 558 @status = (); 559 %deduplicate_name_hash = (); 560 %deduplicate_address_hash = (); 561 if ($email_git_all_signature_types) { 562 $signature_pattern = "(.+?)[Bb][Yy]:"; 563 } else { 564 $signature_pattern = "\(" . join("|", @signature_tags) . "\)"; 565 } 566 567 # Find responsible parties 568 569 my %exact_pattern_match_hash = (); 570 571 foreach my $file (@files) { 572 573 my %hash; 574 my $tvi = find_first_section(); 575 while ($tvi < @typevalue) { 576 my $start = find_starting_index($tvi); 577 my $end = find_ending_index($tvi); 578 my $exclude = 0; 579 my $i; 580 581 #Do not match excluded file patterns 582 583 for ($i = $start; $i < $end; $i++) { 584 my $line = $typevalue[$i]; 585 if ($line =~ m/^(\C):\s*(.*)/) { 586 my $type = $1; 587 my $value = $2; 588 if ($type eq 'X') { 589 if (file_match_pattern($file, $value)) { 590 $exclude = 1; 591 last; 592 } 593 } 594 } 595 } 596 597 if (!$exclude) { 598 for ($i = $start; $i < $end; $i++) { 599 my $line = $typevalue[$i]; 600 if ($line =~ m/^(\C):\s*(.*)/) { 601 my $type = $1; 602 my $value = $2; 603 if ($type eq 'F') { 604 if (file_match_pattern($file, $value)) { 605 my $value_pd = ($value =~ tr@/@@); 606 my $file_pd = ($file =~ tr@/@@); 607 $value_pd++ if (substr($value,-1,1) ne "/"); 608 $value_pd = -1 if ($value =~ /^\.\*/); 609 if ($value_pd >= $file_pd && 610 range_is_maintained($start, $end) && 611 range_has_maintainer($start, $end)) { 612 $exact_pattern_match_hash{$file} = 1; 613 } 614 if ($pattern_depth == 0 || 615 (($file_pd - $value_pd) < $pattern_depth)) { 616 $hash{$tvi} = $value_pd; 617 } 618 } 619 } elsif ($type eq 'N') { 620 if ($file =~ m/$value/x) { 621 $hash{$tvi} = 0; 622 } 623 } 624 } 625 } 626 } 627 $tvi = $end + 1; 628 } 629 630 foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) { 631 add_categories($line); 632 if ($sections) { 633 my $i; 634 my $start = find_starting_index($line); 635 my $end = find_ending_index($line); 636 for ($i = $start; $i < $end; $i++) { 637 my $line = $typevalue[$i]; 638 if ($line =~ /^[FX]:/) { ##Restore file patterns 639 $line =~ s/([^\\])\.([^\*])/$1\?$2/g; 640 $line =~ s/([^\\])\.$/$1\?/g; ##Convert . back to ? 641 $line =~ s/\\\./\./g; ##Convert \. to . 642 $line =~ s/\.\*/\*/g; ##Convert .* to * 643 } 644 $line =~ s/^([A-Z]):/$1:\t/g; 645 print("$line\n"); 646 } 647 print("\n"); 648 } 649 } 650 } 651 652 if ($keywords) { 653 @keyword_tvi = sort_and_uniq(@keyword_tvi); 654 foreach my $line (@keyword_tvi) { 655 add_categories($line); 656 } 657 } 658 659 foreach my $email (@email_to, @list_to) { 660 $email->[0] = deduplicate_email($email->[0]); 661 } 662 663 foreach my $file (@files) { 664 if ($email && 665 ($email_git || ($email_git_fallback && 666 !$exact_pattern_match_hash{$file}))) { 667 vcs_file_signoffs($file); 668 } 669 if ($email && $email_git_blame) { 670 vcs_file_blame($file); 671 } 672 } 673 674 if ($email) { 675 foreach my $chief (@penguin_chief) { 676 if ($chief =~ m/^(.*):(.*)/) { 677 my $email_address; 678 679 $email_address = format_email($1, $2, $email_usename); 680 if ($email_git_penguin_chiefs) { 681 push(@email_to, [$email_address, 'chief penguin']); 682 } else { 683 @email_to = grep($_->[0] !~ /${email_address}/, @email_to); 684 } 685 } 686 } 687 688 foreach my $email (@file_emails) { 689 my ($name, $address) = parse_email($email); 690 691 my $tmp_email = format_email($name, $address, $email_usename); 692 push_email_address($tmp_email, ''); 693 add_role($tmp_email, 'in file'); 694 } 695 } 696 697 my @to = (); 698 if ($email || $email_list) { 699 if ($email) { 700 @to = (@to, @email_to); 701 } 702 if ($email_list) { 703 @to = (@to, @list_to); 704 } 705 } 706 707 if ($interactive) { 708 @to = interactive_get_maintainers(\@to); 709 } 710 711 return @to; 712} 713 714sub file_match_pattern { 715 my ($file, $pattern) = @_; 716 if (substr($pattern, -1) eq "/") { 717 if ($file =~ m@^$pattern@) { 718 return 1; 719 } 720 } else { 721 if ($file =~ m@^$pattern@) { 722 my $s1 = ($file =~ tr@/@@); 723 my $s2 = ($pattern =~ tr@/@@); 724 if ($s1 == $s2) { 725 return 1; 726 } 727 } 728 } 729 return 0; 730} 731 732sub usage { 733 print <<EOT; 734usage: $P [options] patchfile 735 $P [options] -f file|directory 736version: $V 737 738MAINTAINER field selection options: 739 --email => print email address(es) if any 740 --git => include recent git \*-by: signers 741 --git-all-signature-types => include signers regardless of signature type 742 or use only ${signature_pattern} signers (default: $email_git_all_signature_types) 743 --git-fallback => use git when no exact MAINTAINERS pattern (default: $email_git_fallback) 744 --git-chief-penguins => include ${penguin_chiefs} 745 --git-min-signatures => number of signatures required (default: $email_git_min_signatures) 746 --git-max-maintainers => maximum maintainers to add (default: $email_git_max_maintainers) 747 --git-min-percent => minimum percentage of commits required (default: $email_git_min_percent) 748 --git-blame => use git blame to find modified commits for patch or file 749 --git-since => git history to use (default: $email_git_since) 750 --hg-since => hg history to use (default: $email_hg_since) 751 --interactive => display a menu (mostly useful if used with the --git option) 752 --m => include maintainer(s) if any 753 --n => include name 'Full Name <addr\@domain.tld>' 754 --l => include list(s) if any 755 --s => include subscriber only list(s) if any 756 --remove-duplicates => minimize duplicate email names/addresses 757 --roles => show roles (status:subsystem, git-signer, list, etc...) 758 --rolestats => show roles and statistics (commits/total_commits, %) 759 --file-emails => add email addresses found in -f file (default: 0 (off)) 760 --scm => print SCM tree(s) if any 761 --status => print status if any 762 --subsystem => print subsystem name if any 763 --web => print website(s) if any 764 765Output type options: 766 --separator [, ] => separator for multiple entries on 1 line 767 using --separator also sets --nomultiline if --separator is not [, ] 768 --multiline => print 1 entry per line 769 770Other options: 771 --pattern-depth => Number of pattern directory traversals (default: 0 (all)) 772 --keywords => scan patch for keywords (default: $keywords) 773 --sections => print all of the subsystem sections with pattern matches 774 --mailmap => use .mailmap file (default: $email_use_mailmap) 775 --version => show version 776 --help => show this help information 777 778Default options: 779 [--email --nogit --git-fallback --m --n --l --multiline -pattern-depth=0 780 --remove-duplicates --rolestats] 781 782Notes: 783 Using "-f directory" may give unexpected results: 784 Used with "--git", git signators for _all_ files in and below 785 directory are examined as git recurses directories. 786 Any specified X: (exclude) pattern matches are _not_ ignored. 787 Used with "--nogit", directory is used as a pattern match, 788 no individual file within the directory or subdirectory 789 is matched. 790 Used with "--git-blame", does not iterate all files in directory 791 Using "--git-blame" is slow and may add old committers and authors 792 that are no longer active maintainers to the output. 793 Using "--roles" or "--rolestats" with git send-email --cc-cmd or any 794 other automated tools that expect only ["name"] <email address> 795 may not work because of additional output after <email address>. 796 Using "--rolestats" and "--git-blame" shows the #/total=% commits, 797 not the percentage of the entire file authored. # of commits is 798 not a good measure of amount of code authored. 1 major commit may 799 contain a thousand lines, 5 trivial commits may modify a single line. 800 If git is not installed, but mercurial (hg) is installed and an .hg 801 repository exists, the following options apply to mercurial: 802 --git, 803 --git-min-signatures, --git-max-maintainers, --git-min-percent, and 804 --git-blame 805 Use --hg-since not --git-since to control date selection 806 File ".get_maintainer.conf", if it exists in the linux kernel source root 807 directory, can change whatever get_maintainer defaults are desired. 808 Entries in this file can be any command line argument. 809 This file is prepended to any additional command line arguments. 810 Multiple lines and # comments are allowed. 811EOT 812} 813 814sub top_of_kernel_tree { 815 my ($lk_path) = @_; 816 817 if ($lk_path ne "" && substr($lk_path,length($lk_path)-1,1) ne "/") { 818 $lk_path .= "/"; 819 } 820 if ( (-f "${lk_path}COPYING") 821 && (-f "${lk_path}CREDITS") 822 && (-f "${lk_path}Kbuild") 823 && (-f "${lk_path}MAINTAINERS") 824 && (-f "${lk_path}Makefile") 825 && (-f "${lk_path}README") 826 && (-d "${lk_path}Documentation") 827 && (-d "${lk_path}arch") 828 && (-d "${lk_path}include") 829 && (-d "${lk_path}drivers") 830 && (-d "${lk_path}fs") 831 && (-d "${lk_path}init") 832 && (-d "${lk_path}ipc") 833 && (-d "${lk_path}kernel") 834 && (-d "${lk_path}lib") 835 && (-d "${lk_path}scripts")) { 836 return 1; 837 } 838 return 0; 839} 840 841sub parse_email { 842 my ($formatted_email) = @_; 843 844 my $name = ""; 845 my $address = ""; 846 847 if ($formatted_email =~ /^([^<]+)<(.+\@.*)>.*$/) { 848 $name = $1; 849 $address = $2; 850 } elsif ($formatted_email =~ /^\s*<(.+\@\S*)>.*$/) { 851 $address = $1; 852 } elsif ($formatted_email =~ /^(.+\@\S*).*$/) { 853 $address = $1; 854 } 855 856 $name =~ s/^\s+|\s+$//g; 857 $name =~ s/^\"|\"$//g; 858 $address =~ s/^\s+|\s+$//g; 859 860 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars 861 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes 862 $name = "\"$name\""; 863 } 864 865 return ($name, $address); 866} 867 868sub format_email { 869 my ($name, $address, $usename) = @_; 870 871 my $formatted_email; 872 873 $name =~ s/^\s+|\s+$//g; 874 $name =~ s/^\"|\"$//g; 875 $address =~ s/^\s+|\s+$//g; 876 877 if ($name =~ /[^\w \-]/i) { ##has "must quote" chars 878 $name =~ s/(?<!\\)"/\\"/g; ##escape quotes 879 $name = "\"$name\""; 880 } 881 882 if ($usename) { 883 if ("$name" eq "") { 884 $formatted_email = "$address"; 885 } else { 886 $formatted_email = "$name <$address>"; 887 } 888 } else { 889 $formatted_email = $address; 890 } 891 892 return $formatted_email; 893} 894 895sub find_first_section { 896 my $index = 0; 897 898 while ($index < @typevalue) { 899 my $tv = $typevalue[$index]; 900 if (($tv =~ m/^(\C):\s*(.*)/)) { 901 last; 902 } 903 $index++; 904 } 905 906 return $index; 907} 908 909sub find_starting_index { 910 my ($index) = @_; 911 912 while ($index > 0) { 913 my $tv = $typevalue[$index]; 914 if (!($tv =~ m/^(\C):\s*(.*)/)) { 915 last; 916 } 917 $index--; 918 } 919 920 return $index; 921} 922 923sub find_ending_index { 924 my ($index) = @_; 925 926 while ($index < @typevalue) { 927 my $tv = $typevalue[$index]; 928 if (!($tv =~ m/^(\C):\s*(.*)/)) { 929 last; 930 } 931 $index++; 932 } 933 934 return $index; 935} 936 937sub get_maintainer_role { 938 my ($index) = @_; 939 940 my $i; 941 my $start = find_starting_index($index); 942 my $end = find_ending_index($index); 943 944 my $role = "unknown"; 945 my $subsystem = $typevalue[$start]; 946 if (length($subsystem) > 20) { 947 $subsystem = substr($subsystem, 0, 17); 948 $subsystem =~ s/\s*$//; 949 $subsystem = $subsystem . "..."; 950 } 951 952 for ($i = $start + 1; $i < $end; $i++) { 953 my $tv = $typevalue[$i]; 954 if ($tv =~ m/^(\C):\s*(.*)/) { 955 my $ptype = $1; 956 my $pvalue = $2; 957 if ($ptype eq "S") { 958 $role = $pvalue; 959 } 960 } 961 } 962 963 $role = lc($role); 964 if ($role eq "supported") { 965 $role = "supporter"; 966 } elsif ($role eq "maintained") { 967 $role = "maintainer"; 968 } elsif ($role eq "odd fixes") { 969 $role = "odd fixer"; 970 } elsif ($role eq "orphan") { 971 $role = "orphan minder"; 972 } elsif ($role eq "obsolete") { 973 $role = "obsolete minder"; 974 } elsif ($role eq "buried alive in reporters") { 975 $role = "chief penguin"; 976 } 977 978 return $role . ":" . $subsystem; 979} 980 981sub get_list_role { 982 my ($index) = @_; 983 984 my $i; 985 my $start = find_starting_index($index); 986 my $end = find_ending_index($index); 987 988 my $subsystem = $typevalue[$start]; 989 if (length($subsystem) > 20) { 990 $subsystem = substr($subsystem, 0, 17); 991 $subsystem =~ s/\s*$//; 992 $subsystem = $subsystem . "..."; 993 } 994 995 if ($subsystem eq "THE REST") { 996 $subsystem = ""; 997 } 998 999 return $subsystem; 1000} 1001 1002sub add_categories { 1003 my ($index) = @_; 1004 1005 my $i; 1006 my $start = find_starting_index($index); 1007 my $end = find_ending_index($index); 1008 1009 push(@subsystem, $typevalue[$start]); 1010 1011 for ($i = $start + 1; $i < $end; $i++) { 1012 my $tv = $typevalue[$i]; 1013 if ($tv =~ m/^(\C):\s*(.*)/) { 1014 my $ptype = $1; 1015 my $pvalue = $2; 1016 if ($ptype eq "L") { 1017 my $list_address = $pvalue; 1018 my $list_additional = ""; 1019 my $list_role = get_list_role($i); 1020 1021 if ($list_role ne "") { 1022 $list_role = ":" . $list_role; 1023 } 1024 if ($list_address =~ m/([^\s]+)\s+(.*)$/) { 1025 $list_address = $1; 1026 $list_additional = $2; 1027 } 1028 if ($list_additional =~ m/subscribers-only/) { 1029 if ($email_subscriber_list) { 1030 if (!$hash_list_to{lc($list_address)}) { 1031 $hash_list_to{lc($list_address)} = 1; 1032 push(@list_to, [$list_address, 1033 "subscriber list${list_role}"]); 1034 } 1035 } 1036 } else { 1037 if ($email_list) { 1038 if (!$hash_list_to{lc($list_address)}) { 1039 $hash_list_to{lc($list_address)} = 1; 1040 if ($list_additional =~ m/moderated/) { 1041 push(@list_to, [$list_address, 1042 "moderated list${list_role}"]); 1043 } else { 1044 push(@list_to, [$list_address, 1045 "open list${list_role}"]); 1046 } 1047 } 1048 } 1049 } 1050 } elsif ($ptype eq "M") { 1051 my ($name, $address) = parse_email($pvalue); 1052 if ($name eq "") { 1053 if ($i > 0) { 1054 my $tv = $typevalue[$i - 1]; 1055 if ($tv =~ m/^(\C):\s*(.*)/) { 1056 if ($1 eq "P") { 1057 $name = $2; 1058 $pvalue = format_email($name, $address, $email_usename); 1059 } 1060 } 1061 } 1062 } 1063 if ($email_maintainer) { 1064 my $role = get_maintainer_role($i); 1065 push_email_addresses($pvalue, $role); 1066 } 1067 } elsif ($ptype eq "T") { 1068 push(@scm, $pvalue); 1069 } elsif ($ptype eq "W") { 1070 push(@web, $pvalue); 1071 } elsif ($ptype eq "S") { 1072 push(@status, $pvalue); 1073 } 1074 } 1075 } 1076} 1077 1078sub email_inuse { 1079 my ($name, $address) = @_; 1080 1081 return 1 if (($name eq "") && ($address eq "")); 1082 return 1 if (($name ne "") && exists($email_hash_name{lc($name)})); 1083 return 1 if (($address ne "") && exists($email_hash_address{lc($address)})); 1084 1085 return 0; 1086} 1087 1088sub push_email_address { 1089 my ($line, $role) = @_; 1090 1091 my ($name, $address) = parse_email($line); 1092 1093 if ($address eq "") { 1094 return 0; 1095 } 1096 1097 if (!$email_remove_duplicates) { 1098 push(@email_to, [format_email($name, $address, $email_usename), $role]); 1099 } elsif (!email_inuse($name, $address)) { 1100 push(@email_to, [format_email($name, $address, $email_usename), $role]); 1101 $email_hash_name{lc($name)}++ if ($name ne ""); 1102 $email_hash_address{lc($address)}++; 1103 } 1104 1105 return 1; 1106} 1107 1108sub push_email_addresses { 1109 my ($address, $role) = @_; 1110 1111 my @address_list = (); 1112 1113 if (rfc822_valid($address)) { 1114 push_email_address($address, $role); 1115 } elsif (@address_list = rfc822_validlist($address)) { 1116 my $array_count = shift(@address_list); 1117 while (my $entry = shift(@address_list)) { 1118 push_email_address($entry, $role); 1119 } 1120 } else { 1121 if (!push_email_address($address, $role)) { 1122 warn("Invalid MAINTAINERS address: '" . $address . "'\n"); 1123 } 1124 } 1125} 1126 1127sub add_role { 1128 my ($line, $role) = @_; 1129 1130 my ($name, $address) = parse_email($line); 1131 my $email = format_email($name, $address, $email_usename); 1132 1133 foreach my $entry (@email_to) { 1134 if ($email_remove_duplicates) { 1135 my ($entry_name, $entry_address) = parse_email($entry->[0]); 1136 if (($name eq $entry_name || $address eq $entry_address) 1137 && ($role eq "" || !($entry->[1] =~ m/$role/)) 1138 ) { 1139 if ($entry->[1] eq "") { 1140 $entry->[1] = "$role"; 1141 } else { 1142 $entry->[1] = "$entry->[1],$role"; 1143 } 1144 } 1145 } else { 1146 if ($email eq $entry->[0] 1147 && ($role eq "" || !($entry->[1] =~ m/$role/)) 1148 ) { 1149 if ($entry->[1] eq "") { 1150 $entry->[1] = "$role"; 1151 } else { 1152 $entry->[1] = "$entry->[1],$role"; 1153 } 1154 } 1155 } 1156 } 1157} 1158 1159sub which { 1160 my ($bin) = @_; 1161 1162 foreach my $path (split(/:/, $ENV{PATH})) { 1163 if (-e "$path/$bin") { 1164 return "$path/$bin"; 1165 } 1166 } 1167 1168 return ""; 1169} 1170 1171sub which_conf { 1172 my ($conf) = @_; 1173 1174 foreach my $path (split(/:/, ".:$ENV{HOME}:.scripts")) { 1175 if (-e "$path/$conf") { 1176 return "$path/$conf"; 1177 } 1178 } 1179 1180 return ""; 1181} 1182 1183sub mailmap_email { 1184 my ($line) = @_; 1185 1186 my ($name, $address) = parse_email($line); 1187 my $email = format_email($name, $address, 1); 1188 my $real_name = $name; 1189 my $real_address = $address; 1190 1191 if (exists $mailmap->{names}->{$email} || 1192 exists $mailmap->{addresses}->{$email}) { 1193 if (exists $mailmap->{names}->{$email}) { 1194 $real_name = $mailmap->{names}->{$email}; 1195 } 1196 if (exists $mailmap->{addresses}->{$email}) { 1197 $real_address = $mailmap->{addresses}->{$email}; 1198 } 1199 } else { 1200 if (exists $mailmap->{names}->{$address}) { 1201 $real_name = $mailmap->{names}->{$address}; 1202 } 1203 if (exists $mailmap->{addresses}->{$address}) { 1204 $real_address = $mailmap->{addresses}->{$address}; 1205 } 1206 } 1207 return format_email($real_name, $real_address, 1); 1208} 1209 1210sub mailmap { 1211 my (@addresses) = @_; 1212 1213 my @mapped_emails = (); 1214 foreach my $line (@addresses) { 1215 push(@mapped_emails, mailmap_email($line)); 1216 } 1217 merge_by_realname(@mapped_emails) if ($email_use_mailmap); 1218 return @mapped_emails; 1219} 1220 1221sub merge_by_realname { 1222 my %address_map; 1223 my (@emails) = @_; 1224 1225 foreach my $email (@emails) { 1226 my ($name, $address) = parse_email($email); 1227 if (exists $address_map{$name}) { 1228 $address = $address_map{$name}; 1229 $email = format_email($name, $address, 1); 1230 } else { 1231 $address_map{$name} = $address; 1232 } 1233 } 1234} 1235 1236sub git_execute_cmd { 1237 my ($cmd) = @_; 1238 my @lines = (); 1239 1240 my $output = `$cmd`; 1241 $output =~ s/^\s*//gm; 1242 @lines = split("\n", $output); 1243 1244 return @lines; 1245} 1246 1247sub hg_execute_cmd { 1248 my ($cmd) = @_; 1249 my @lines = (); 1250 1251 my $output = `$cmd`; 1252 @lines = split("\n", $output); 1253 1254 return @lines; 1255} 1256 1257sub extract_formatted_signatures { 1258 my (@signature_lines) = @_; 1259 1260 my @type = @signature_lines; 1261 1262 s/\s*(.*):.*/$1/ for (@type); 1263 1264 # cut -f2- -d":" 1265 s/\s*.*:\s*(.+)\s*/$1/ for (@signature_lines); 1266 1267## Reformat email addresses (with names) to avoid badly written signatures 1268 1269 foreach my $signer (@signature_lines) { 1270 $signer = deduplicate_email($signer); 1271 } 1272 1273 return (\@type, \@signature_lines); 1274} 1275 1276sub vcs_find_signers { 1277 my ($cmd, $file) = @_; 1278 my $commits; 1279 my @lines = (); 1280 my @signatures = (); 1281 my @authors = (); 1282 my @stats = (); 1283 1284 @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); 1285 1286 my $pattern = $VCS_cmds{"commit_pattern"}; 1287 my $author_pattern = $VCS_cmds{"author_pattern"}; 1288 my $stat_pattern = $VCS_cmds{"stat_pattern"}; 1289 1290 $stat_pattern =~ s/(\$\w+)/$1/eeg; #interpolate $stat_pattern 1291 1292 $commits = grep(/$pattern/, @lines); # of commits 1293 1294 @authors = grep(/$author_pattern/, @lines); 1295 @signatures = grep(/^[ \t]*${signature_pattern}.*\@.*$/, @lines); 1296 @stats = grep(/$stat_pattern/, @lines); 1297 1298# print("stats: <@stats>\n"); 1299 1300 return (0, \@signatures, \@authors, \@stats) if !@signatures; 1301 1302 save_commits_by_author(@lines) if ($interactive); 1303 save_commits_by_signer(@lines) if ($interactive); 1304 1305 if (!$email_git_penguin_chiefs) { 1306 @signatures = grep(!/${penguin_chiefs}/i, @signatures); 1307 } 1308 1309 my ($author_ref, $authors_ref) = extract_formatted_signatures(@authors); 1310 my ($types_ref, $signers_ref) = extract_formatted_signatures(@signatures); 1311 1312 return ($commits, $signers_ref, $authors_ref, \@stats); 1313} 1314 1315sub vcs_find_author { 1316 my ($cmd) = @_; 1317 my @lines = (); 1318 1319 @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); 1320 1321 if (!$email_git_penguin_chiefs) { 1322 @lines = grep(!/${penguin_chiefs}/i, @lines); 1323 } 1324 1325 return @lines if !@lines; 1326 1327 my @authors = (); 1328 foreach my $line (@lines) { 1329 if ($line =~ m/$VCS_cmds{"author_pattern"}/) { 1330 my $author = $1; 1331 my ($name, $address) = parse_email($author); 1332 $author = format_email($name, $address, 1); 1333 push(@authors, $author); 1334 } 1335 } 1336 1337 save_commits_by_author(@lines) if ($interactive); 1338 save_commits_by_signer(@lines) if ($interactive); 1339 1340 return @authors; 1341} 1342 1343sub vcs_save_commits { 1344 my ($cmd) = @_; 1345 my @lines = (); 1346 my @commits = (); 1347 1348 @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); 1349 1350 foreach my $line (@lines) { 1351 if ($line =~ m/$VCS_cmds{"blame_commit_pattern"}/) { 1352 push(@commits, $1); 1353 } 1354 } 1355 1356 return @commits; 1357} 1358 1359sub vcs_blame { 1360 my ($file) = @_; 1361 my $cmd; 1362 my @commits = (); 1363 1364 return @commits if (!(-f $file)); 1365 1366 if (@range && $VCS_cmds{"blame_range_cmd"} eq "") { 1367 my @all_commits = (); 1368 1369 $cmd = $VCS_cmds{"blame_file_cmd"}; 1370 $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd 1371 @all_commits = vcs_save_commits($cmd); 1372 1373 foreach my $file_range_diff (@range) { 1374 next if (!($file_range_diff =~ m/(.+):(.+):(.+)/)); 1375 my $diff_file = $1; 1376 my $diff_start = $2; 1377 my $diff_length = $3; 1378 next if ("$file" ne "$diff_file"); 1379 for (my $i = $diff_start; $i < $diff_start + $diff_length; $i++) { 1380 push(@commits, $all_commits[$i]); 1381 } 1382 } 1383 } elsif (@range) { 1384 foreach my $file_range_diff (@range) { 1385 next if (!($file_range_diff =~ m/(.+):(.+):(.+)/)); 1386 my $diff_file = $1; 1387 my $diff_start = $2; 1388 my $diff_length = $3; 1389 next if ("$file" ne "$diff_file"); 1390 $cmd = $VCS_cmds{"blame_range_cmd"}; 1391 $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd 1392 push(@commits, vcs_save_commits($cmd)); 1393 } 1394 } else { 1395 $cmd = $VCS_cmds{"blame_file_cmd"}; 1396 $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd 1397 @commits = vcs_save_commits($cmd); 1398 } 1399 1400 foreach my $commit (@commits) { 1401 $commit =~ s/^\^//g; 1402 } 1403 1404 return @commits; 1405} 1406 1407my $printed_novcs = 0; 1408sub vcs_exists { 1409 %VCS_cmds = %VCS_cmds_git; 1410 return 1 if eval $VCS_cmds{"available"}; 1411 %VCS_cmds = %VCS_cmds_hg; 1412 return 2 if eval $VCS_cmds{"available"}; 1413 %VCS_cmds = (); 1414 if (!$printed_novcs) { 1415 warn("$P: No supported VCS found. Add --nogit to options?\n"); 1416 warn("Using a git repository produces better results.\n"); 1417 warn("Try Linus Torvalds' latest git repository using:\n"); 1418 warn("git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git\n"); 1419 $printed_novcs = 1; 1420 } 1421 return 0; 1422} 1423 1424sub vcs_is_git { 1425 vcs_exists(); 1426 return $vcs_used == 1; 1427} 1428 1429sub vcs_is_hg { 1430 return $vcs_used == 2; 1431} 1432 1433sub interactive_get_maintainers { 1434 my ($list_ref) = @_; 1435 my @list = @$list_ref; 1436 1437 vcs_exists(); 1438 1439 my %selected; 1440 my %authored; 1441 my %signed; 1442 my $count = 0; 1443 my $maintained = 0; 1444 foreach my $entry (@list) { 1445 $maintained = 1 if ($entry->[1] =~ /^(maintainer|supporter)/i); 1446 $selected{$count} = 1; 1447 $authored{$count} = 0; 1448 $signed{$count} = 0; 1449 $count++; 1450 } 1451 1452 #menu loop 1453 my $done = 0; 1454 my $print_options = 0; 1455 my $redraw = 1; 1456 while (!$done) { 1457 $count = 0; 1458 if ($redraw) { 1459 printf STDERR "\n%1s %2s %-65s", 1460 "*", "#", "email/list and role:stats"; 1461 if ($email_git || 1462 ($email_git_fallback && !$maintained) || 1463 $email_git_blame) { 1464 print STDERR "auth sign"; 1465 } 1466 print STDERR "\n"; 1467 foreach my $entry (@list) { 1468 my $email = $entry->[0]; 1469 my $role = $entry->[1]; 1470 my $sel = ""; 1471 $sel = "*" if ($selected{$count}); 1472 my $commit_author = $commit_author_hash{$email}; 1473 my $commit_signer = $commit_signer_hash{$email}; 1474 my $authored = 0; 1475 my $signed = 0; 1476 $authored++ for (@{$commit_author}); 1477 $signed++ for (@{$commit_signer}); 1478 printf STDERR "%1s %2d %-65s", $sel, $count + 1, $email; 1479 printf STDERR "%4d %4d", $authored, $signed 1480 if ($authored > 0 || $signed > 0); 1481 printf STDERR "\n %s\n", $role; 1482 if ($authored{$count}) { 1483 my $commit_author = $commit_author_hash{$email}; 1484 foreach my $ref (@{$commit_author}) { 1485 print STDERR " Author: @{$ref}[1]\n"; 1486 } 1487 } 1488 if ($signed{$count}) { 1489 my $commit_signer = $commit_signer_hash{$email}; 1490 foreach my $ref (@{$commit_signer}) { 1491 print STDERR " @{$ref}[2]: @{$ref}[1]\n"; 1492 } 1493 } 1494 1495 $count++; 1496 } 1497 } 1498 my $date_ref = \$email_git_since; 1499 $date_ref = \$email_hg_since if (vcs_is_hg()); 1500 if ($print_options) { 1501 $print_options = 0; 1502 if (vcs_exists()) { 1503 print STDERR <<EOT 1504 1505Version Control options: 1506g use git history [$email_git] 1507gf use git-fallback [$email_git_fallback] 1508b use git blame [$email_git_blame] 1509bs use blame signatures [$email_git_blame_signatures] 1510c# minimum commits [$email_git_min_signatures] 1511%# min percent [$email_git_min_percent] 1512d# history to use [$$date_ref] 1513x# max maintainers [$email_git_max_maintainers] 1514t all signature types [$email_git_all_signature_types] 1515m use .mailmap [$email_use_mailmap] 1516EOT 1517 } 1518 print STDERR <<EOT 1519 1520Additional options: 15210 toggle all 1522tm toggle maintainers 1523tg toggle git entries 1524tl toggle open list entries 1525ts toggle subscriber list entries 1526f emails in file [$file_emails] 1527k keywords in file [$keywords] 1528r remove duplicates [$email_remove_duplicates] 1529p# pattern match depth [$pattern_depth] 1530EOT 1531 } 1532 print STDERR 1533"\n#(toggle), A#(author), S#(signed) *(all), ^(none), O(options), Y(approve): "; 1534 1535 my $input = <STDIN>; 1536 chomp($input); 1537 1538 $redraw = 1; 1539 my $rerun = 0; 1540 my @wish = split(/[, ]+/, $input); 1541 foreach my $nr (@wish) { 1542 $nr = lc($nr); 1543 my $sel = substr($nr, 0, 1); 1544 my $str = substr($nr, 1); 1545 my $val = 0; 1546 $val = $1 if $str =~ /^(\d+)$/; 1547 1548 if ($sel eq "y") { 1549 $interactive = 0; 1550 $done = 1; 1551 $output_rolestats = 0; 1552 $output_roles = 0; 1553 last; 1554 } elsif ($nr =~ /^\d+$/ && $nr > 0 && $nr <= $count) { 1555 $selected{$nr - 1} = !$selected{$nr - 1}; 1556 } elsif ($sel eq "*" || $sel eq '^') { 1557 my $toggle = 0; 1558 $toggle = 1 if ($sel eq '*'); 1559 for (my $i = 0; $i < $count; $i++) { 1560 $selected{$i} = $toggle; 1561 } 1562 } elsif ($sel eq "0") { 1563 for (my $i = 0; $i < $count; $i++) { 1564 $selected{$i} = !$selected{$i}; 1565 } 1566 } elsif ($sel eq "t") { 1567 if (lc($str) eq "m") { 1568 for (my $i = 0; $i < $count; $i++) { 1569 $selected{$i} = !$selected{$i} 1570 if ($list[$i]->[1] =~ /^(maintainer|supporter)/i); 1571 } 1572 } elsif (lc($str) eq "g") { 1573 for (my $i = 0; $i < $count; $i++) { 1574 $selected{$i} = !$selected{$i} 1575 if ($list[$i]->[1] =~ /^(author|commit|signer)/i); 1576 } 1577 } elsif (lc($str) eq "l") { 1578 for (my $i = 0; $i < $count; $i++) { 1579 $selected{$i} = !$selected{$i} 1580 if ($list[$i]->[1] =~ /^(open list)/i); 1581 } 1582 } elsif (lc($str) eq "s") { 1583 for (my $i = 0; $i < $count; $i++) { 1584 $selected{$i} = !$selected{$i} 1585 if ($list[$i]->[1] =~ /^(subscriber list)/i); 1586 } 1587 } 1588 } elsif ($sel eq "a") { 1589 if ($val > 0 && $val <= $count) { 1590 $authored{$val - 1} = !$authored{$val - 1}; 1591 } elsif ($str eq '*' || $str eq '^') { 1592 my $toggle = 0; 1593 $toggle = 1 if ($str eq '*'); 1594 for (my $i = 0; $i < $count; $i++) { 1595 $authored{$i} = $toggle; 1596 } 1597 } 1598 } elsif ($sel eq "s") { 1599 if ($val > 0 && $val <= $count) { 1600 $signed{$val - 1} = !$signed{$val - 1}; 1601 } elsif ($str eq '*' || $str eq '^') { 1602 my $toggle = 0; 1603 $toggle = 1 if ($str eq '*'); 1604 for (my $i = 0; $i < $count; $i++) { 1605 $signed{$i} = $toggle; 1606 } 1607 } 1608 } elsif ($sel eq "o") { 1609 $print_options = 1; 1610 $redraw = 1; 1611 } elsif ($sel eq "g") { 1612 if ($str eq "f") { 1613 bool_invert(\$email_git_fallback); 1614 } else { 1615 bool_invert(\$email_git); 1616 } 1617 $rerun = 1; 1618 } elsif ($sel eq "b") { 1619 if ($str eq "s") { 1620 bool_invert(\$email_git_blame_signatures); 1621 } else { 1622 bool_invert(\$email_git_blame); 1623 } 1624 $rerun = 1; 1625 } elsif ($sel eq "c") { 1626 if ($val > 0) { 1627 $email_git_min_signatures = $val; 1628 $rerun = 1; 1629 } 1630 } elsif ($sel eq "x") { 1631 if ($val > 0) { 1632 $email_git_max_maintainers = $val; 1633 $rerun = 1; 1634 } 1635 } elsif ($sel eq "%") { 1636 if ($str ne "" && $val >= 0) { 1637 $email_git_min_percent = $val; 1638 $rerun = 1; 1639 } 1640 } elsif ($sel eq "d") { 1641 if (vcs_is_git()) { 1642 $email_git_since = $str; 1643 } elsif (vcs_is_hg()) { 1644 $email_hg_since = $str; 1645 } 1646 $rerun = 1; 1647 } elsif ($sel eq "t") { 1648 bool_invert(\$email_git_all_signature_types); 1649 $rerun = 1; 1650 } elsif ($sel eq "f") { 1651 bool_invert(\$file_emails); 1652 $rerun = 1; 1653 } elsif ($sel eq "r") { 1654 bool_invert(\$email_remove_duplicates); 1655 $rerun = 1; 1656 } elsif ($sel eq "m") { 1657 bool_invert(\$email_use_mailmap); 1658 read_mailmap(); 1659 $rerun = 1; 1660 } elsif ($sel eq "k") { 1661 bool_invert(\$keywords); 1662 $rerun = 1; 1663 } elsif ($sel eq "p") { 1664 if ($str ne "" && $val >= 0) { 1665 $pattern_depth = $val; 1666 $rerun = 1; 1667 } 1668 } elsif ($sel eq "h" || $sel eq "?") { 1669 print STDERR <<EOT 1670 1671Interactive mode allows you to select the various maintainers, submitters, 1672commit signers and mailing lists that could be CC'd on a patch. 1673 1674Any *'d entry is selected. 1675 1676If you have git or hg installed, you can choose to summarize the commit 1677history of files in the patch. Also, each line of the current file can 1678be matched to its commit author and that commits signers with blame. 1679 1680Various knobs exist to control the length of time for active commit 1681tracking, the maximum number of commit authors and signers to add, 1682and such. 1683 1684Enter selections at the prompt until you are satisfied that the selected 1685maintainers are appropriate. You may enter multiple selections separated 1686by either commas or spaces. 1687 1688EOT 1689 } else { 1690 print STDERR "invalid option: '$nr'\n"; 1691 $redraw = 0; 1692 } 1693 } 1694 if ($rerun) { 1695 print STDERR "git-blame can be very slow, please have patience..." 1696 if ($email_git_blame); 1697 goto &get_maintainers; 1698 } 1699 } 1700 1701 #drop not selected entries 1702 $count = 0; 1703 my @new_emailto = (); 1704 foreach my $entry (@list) { 1705 if ($selected{$count}) { 1706 push(@new_emailto, $list[$count]); 1707 } 1708 $count++; 1709 } 1710 return @new_emailto; 1711} 1712 1713sub bool_invert { 1714 my ($bool_ref) = @_; 1715 1716 if ($$bool_ref) { 1717 $$bool_ref = 0; 1718 } else { 1719 $$bool_ref = 1; 1720 } 1721} 1722 1723sub deduplicate_email { 1724 my ($email) = @_; 1725 1726 my $matched = 0; 1727 my ($name, $address) = parse_email($email); 1728 $email = format_email($name, $address, 1); 1729 $email = mailmap_email($email); 1730 1731 return $email if (!$email_remove_duplicates); 1732 1733 ($name, $address) = parse_email($email); 1734 1735 if ($name ne "" && $deduplicate_name_hash{lc($name)}) { 1736 $name = $deduplicate_name_hash{lc($name)}->[0]; 1737 $address = $deduplicate_name_hash{lc($name)}->[1]; 1738 $matched = 1; 1739 } elsif ($deduplicate_address_hash{lc($address)}) { 1740 $name = $deduplicate_address_hash{lc($address)}->[0]; 1741 $address = $deduplicate_address_hash{lc($address)}->[1]; 1742 $matched = 1; 1743 } 1744 if (!$matched) { 1745 $deduplicate_name_hash{lc($name)} = [ $name, $address ]; 1746 $deduplicate_address_hash{lc($address)} = [ $name, $address ]; 1747 } 1748 $email = format_email($name, $address, 1); 1749 $email = mailmap_email($email); 1750 return $email; 1751} 1752 1753sub save_commits_by_author { 1754 my (@lines) = @_; 1755 1756 my @authors = (); 1757 my @commits = (); 1758 my @subjects = (); 1759 1760 foreach my $line (@lines) { 1761 if ($line =~ m/$VCS_cmds{"author_pattern"}/) { 1762 my $author = $1; 1763 $author = deduplicate_email($author); 1764 push(@authors, $author); 1765 } 1766 push(@commits, $1) if ($line =~ m/$VCS_cmds{"commit_pattern"}/); 1767 push(@subjects, $1) if ($line =~ m/$VCS_cmds{"subject_pattern"}/); 1768 } 1769 1770 for (my $i = 0; $i < @authors; $i++) { 1771 my $exists = 0; 1772 foreach my $ref(@{$commit_author_hash{$authors[$i]}}) { 1773 if (@{$ref}[0] eq $commits[$i] && 1774 @{$ref}[1] eq $subjects[$i]) { 1775 $exists = 1; 1776 last; 1777 } 1778 } 1779 if (!$exists) { 1780 push(@{$commit_author_hash{$authors[$i]}}, 1781 [ ($commits[$i], $subjects[$i]) ]); 1782 } 1783 } 1784} 1785 1786sub save_commits_by_signer { 1787 my (@lines) = @_; 1788 1789 my $commit = ""; 1790 my $subject = ""; 1791 1792 foreach my $line (@lines) { 1793 $commit = $1 if ($line =~ m/$VCS_cmds{"commit_pattern"}/); 1794 $subject = $1 if ($line =~ m/$VCS_cmds{"subject_pattern"}/); 1795 if ($line =~ /^[ \t]*${signature_pattern}.*\@.*$/) { 1796 my @signatures = ($line); 1797 my ($types_ref, $signers_ref) = extract_formatted_signatures(@signatures); 1798 my @types = @$types_ref; 1799 my @signers = @$signers_ref; 1800 1801 my $type = $types[0]; 1802 my $signer = $signers[0]; 1803 1804 $signer = deduplicate_email($signer); 1805 1806 my $exists = 0; 1807 foreach my $ref(@{$commit_signer_hash{$signer}}) { 1808 if (@{$ref}[0] eq $commit && 1809 @{$ref}[1] eq $subject && 1810 @{$ref}[2] eq $type) { 1811 $exists = 1; 1812 last; 1813 } 1814 } 1815 if (!$exists) { 1816 push(@{$commit_signer_hash{$signer}}, 1817 [ ($commit, $subject, $type) ]); 1818 } 1819 } 1820 } 1821} 1822 1823sub vcs_assign { 1824 my ($role, $divisor, @lines) = @_; 1825 1826 my %hash; 1827 my $count = 0; 1828 1829 return if (@lines <= 0); 1830 1831 if ($divisor <= 0) { 1832 warn("Bad divisor in " . (caller(0))[3] . ": $divisor\n"); 1833 $divisor = 1; 1834 } 1835 1836 @lines = mailmap(@lines); 1837 1838 return if (@lines <= 0); 1839 1840 @lines = sort(@lines); 1841 1842 # uniq -c 1843 $hash{$_}++ for @lines; 1844 1845 # sort -rn 1846 foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) { 1847 my $sign_offs = $hash{$line}; 1848 my $percent = $sign_offs * 100 / $divisor; 1849 1850 $percent = 100 if ($percent > 100); 1851 $count++; 1852 last if ($sign_offs < $email_git_min_signatures || 1853 $count > $email_git_max_maintainers || 1854 $percent < $email_git_min_percent); 1855 push_email_address($line, ''); 1856 if ($output_rolestats) { 1857 my $fmt_percent = sprintf("%.0f", $percent); 1858 add_role($line, "$role:$sign_offs/$divisor=$fmt_percent%"); 1859 } else { 1860 add_role($line, $role); 1861 } 1862 } 1863} 1864 1865sub vcs_file_signoffs { 1866 my ($file) = @_; 1867 1868 my $authors_ref; 1869 my $signers_ref; 1870 my $stats_ref; 1871 my @authors = (); 1872 my @signers = (); 1873 my @stats = (); 1874 my $commits; 1875 1876 $vcs_used = vcs_exists(); 1877 return if (!$vcs_used); 1878 1879 my $cmd = $VCS_cmds{"find_signers_cmd"}; 1880 $cmd =~ s/(\$\w+)/$1/eeg; # interpolate $cmd 1881 1882 ($commits, $signers_ref, $authors_ref, $stats_ref) = vcs_find_signers($cmd, $file); 1883 1884 @signers = @{$signers_ref} if defined $signers_ref; 1885 @authors = @{$authors_ref} if defined $authors_ref; 1886 @stats = @{$stats_ref} if defined $stats_ref; 1887 1888# print("commits: <$commits>\nsigners:<@signers>\nauthors: <@authors>\nstats: <@stats>\n"); 1889 1890 foreach my $signer (@signers) { 1891 $signer = deduplicate_email($signer); 1892 } 1893 1894 vcs_assign("commit_signer", $commits, @signers); 1895 vcs_assign("authored", $commits, @authors); 1896 if ($#authors == $#stats) { 1897 my $stat_pattern = $VCS_cmds{"stat_pattern"}; 1898 $stat_pattern =~ s/(\$\w+)/$1/eeg; #interpolate $stat_pattern 1899 1900 my $added = 0; 1901 my $deleted = 0; 1902 for (my $i = 0; $i <= $#stats; $i++) { 1903 if ($stats[$i] =~ /$stat_pattern/) { 1904 $added += $1; 1905 $deleted += $2; 1906 } 1907 } 1908 my @tmp_authors = uniq(@authors); 1909 foreach my $author (@tmp_authors) { 1910 $author = deduplicate_email($author); 1911 } 1912 @tmp_authors = uniq(@tmp_authors); 1913 my @list_added = (); 1914 my @list_deleted = (); 1915 foreach my $author (@tmp_authors) { 1916 my $auth_added = 0; 1917 my $auth_deleted = 0; 1918 for (my $i = 0; $i <= $#stats; $i++) { 1919 if ($author eq deduplicate_email($authors[$i]) && 1920 $stats[$i] =~ /$stat_pattern/) { 1921 $auth_added += $1; 1922 $auth_deleted += $2; 1923 } 1924 } 1925 for (my $i = 0; $i < $auth_added; $i++) { 1926 push(@list_added, $author); 1927 } 1928 for (my $i = 0; $i < $auth_deleted; $i++) { 1929 push(@list_deleted, $author); 1930 } 1931 } 1932 vcs_assign("added_lines", $added, @list_added); 1933 vcs_assign("removed_lines", $deleted, @list_deleted); 1934 } 1935} 1936 1937sub vcs_file_blame { 1938 my ($file) = @_; 1939 1940 my @signers = (); 1941 my @all_commits = (); 1942 my @commits = (); 1943 my $total_commits; 1944 my $total_lines; 1945 1946 $vcs_used = vcs_exists(); 1947 return if (!$vcs_used); 1948 1949 @all_commits = vcs_blame($file); 1950 @commits = uniq(@all_commits); 1951 $total_commits = @commits; 1952 $total_lines = @all_commits; 1953 1954 if ($email_git_blame_signatures) { 1955 if (vcs_is_hg()) { 1956 my $commit_count; 1957 my $commit_authors_ref; 1958 my $commit_signers_ref; 1959 my $stats_ref; 1960 my @commit_authors = (); 1961 my @commit_signers = (); 1962 my $commit = join(" -r ", @commits); 1963 my $cmd; 1964 1965 $cmd = $VCS_cmds{"find_commit_signers_cmd"}; 1966 $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd 1967 1968 ($commit_count, $commit_signers_ref, $commit_authors_ref, $stats_ref) = vcs_find_signers($cmd, $file); 1969 @commit_authors = @{$commit_authors_ref} if defined $commit_authors_ref; 1970 @commit_signers = @{$commit_signers_ref} if defined $commit_signers_ref; 1971 1972 push(@signers, @commit_signers); 1973 } else { 1974 foreach my $commit (@commits) { 1975 my $commit_count; 1976 my $commit_authors_ref; 1977 my $commit_signers_ref; 1978 my $stats_ref; 1979 my @commit_authors = (); 1980 my @commit_signers = (); 1981 my $cmd; 1982 1983 $cmd = $VCS_cmds{"find_commit_signers_cmd"}; 1984 $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd 1985 1986 ($commit_count, $commit_signers_ref, $commit_authors_ref, $stats_ref) = vcs_find_signers($cmd, $file); 1987 @commit_authors = @{$commit_authors_ref} if defined $commit_authors_ref; 1988 @commit_signers = @{$commit_signers_ref} if defined $commit_signers_ref; 1989 1990 push(@signers, @commit_signers); 1991 } 1992 } 1993 } 1994 1995 if ($from_filename) { 1996 if ($output_rolestats) { 1997 my @blame_signers; 1998 if (vcs_is_hg()) {{ # Double brace for last exit 1999 my $commit_count; 2000 my @commit_signers = (); 2001 @commits = uniq(@commits); 2002 @commits = sort(@commits); 2003 my $commit = join(" -r ", @commits); 2004 my $cmd; 2005 2006 $cmd = $VCS_cmds{"find_commit_author_cmd"}; 2007 $cmd =~ s/(\$\w+)/$1/eeg; #substitute variables in $cmd 2008 2009 my @lines = (); 2010 2011 @lines = &{$VCS_cmds{"execute_cmd"}}($cmd); 2012 2013 if (!$email_git_penguin_chiefs) { 2014 @lines = grep(!/${penguin_chiefs}/i, @lines); 2015 } 2016 2017 last if !@lines; 2018 2019 my @authors = (); 2020 foreach my $line (@lines) { 2021 if ($line =~ m/$VCS_cmds{"author_pattern"}/) { 2022 my $author = $1; 2023 $author = deduplicate_email($author); 2024 push(@authors, $author); 2025 } 2026 } 2027 2028 save_commits_by_author(@lines) if ($interactive); 2029 save_commits_by_signer(@lines) if ($interactive); 2030 2031 push(@signers, @authors); 2032 }} 2033 else { 2034 foreach my $commit (@commits) { 2035 my $i; 2036 my $cmd = $VCS_cmds{"find_commit_author_cmd"}; 2037 $cmd =~ s/(\$\w+)/$1/eeg; #interpolate $cmd 2038 my @author = vcs_find_author($cmd); 2039 next if !@author; 2040 2041 my $formatted_author = deduplicate_email($author[0]); 2042 2043 my $count = grep(/$commit/, @all_commits); 2044 for ($i = 0; $i < $count ; $i++) { 2045 push(@blame_signers, $formatted_author); 2046 } 2047 } 2048 } 2049 if (@blame_signers) { 2050 vcs_assign("authored lines", $total_lines, @blame_signers); 2051 } 2052 } 2053 foreach my $signer (@signers) { 2054 $signer = deduplicate_email($signer); 2055 } 2056 vcs_assign("commits", $total_commits, @signers); 2057 } else { 2058 foreach my $signer (@signers) { 2059 $signer = deduplicate_email($signer); 2060 } 2061 vcs_assign("modified commits", $total_commits, @signers); 2062 } 2063} 2064 2065sub uniq { 2066 my (@parms) = @_; 2067 2068 my %saw; 2069 @parms = grep(!$saw{$_}++, @parms); 2070 return @parms; 2071} 2072 2073sub sort_and_uniq { 2074 my (@parms) = @_; 2075 2076 my %saw; 2077 @parms = sort @parms; 2078 @parms = grep(!$saw{$_}++, @parms); 2079 return @parms; 2080} 2081 2082sub clean_file_emails { 2083 my (@file_emails) = @_; 2084 my @fmt_emails = (); 2085 2086 foreach my $email (@file_emails) { 2087 $email =~ s/[\(\<\{]{0,1}([A-Za-z0-9_\.\+-]+\@[A-Za-z0-9\.-]+)[\)\>\}]{0,1}/\<$1\>/g; 2088 my ($name, $address) = parse_email($email); 2089 if ($name eq '"[,\.]"') { 2090 $name = ""; 2091 } 2092 2093 my @nw = split(/[^A-Za-zÀ-ÿ\'\,\.\+-]/, $name); 2094 if (@nw > 2) { 2095 my $first = $nw[@nw - 3]; 2096 my $middle = $nw[@nw - 2]; 2097 my $last = $nw[@nw - 1]; 2098 2099 if (((length($first) == 1 && $first =~ m/[A-Za-z]/) || 2100 (length($first) == 2 && substr($first, -1) eq ".")) || 2101 (length($middle) == 1 || 2102 (length($middle) == 2 && substr($middle, -1) eq "."))) { 2103 $name = "$first $middle $last"; 2104 } else { 2105 $name = "$middle $last"; 2106 } 2107 } 2108 2109 if (substr($name, -1) =~ /[,\.]/) { 2110 $name = substr($name, 0, length($name) - 1); 2111 } elsif (substr($name, -2) =~ /[,\.]"/) { 2112 $name = substr($name, 0, length($name) - 2) . '"'; 2113 } 2114 2115 if (substr($name, 0, 1) =~ /[,\.]/) { 2116 $name = substr($name, 1, length($name) - 1); 2117 } elsif (substr($name, 0, 2) =~ /"[,\.]/) { 2118 $name = '"' . substr($name, 2, length($name) - 2); 2119 } 2120 2121 my $fmt_email = format_email($name, $address, $email_usename); 2122 push(@fmt_emails, $fmt_email); 2123 } 2124 return @fmt_emails; 2125} 2126 2127sub merge_email { 2128 my @lines; 2129 my %saw; 2130 2131 for (@_) { 2132 my ($address, $role) = @$_; 2133 if (!$saw{$address}) { 2134 if ($output_roles) { 2135 push(@lines, "$address ($role)"); 2136 } else { 2137 push(@lines, $address); 2138 } 2139 $saw{$address} = 1; 2140 } 2141 } 2142 2143 return @lines; 2144} 2145 2146sub output { 2147 my (@parms) = @_; 2148 2149 if ($output_multiline) { 2150 foreach my $line (@parms) { 2151 print("${line}\n"); 2152 } 2153 } else { 2154 print(join($output_separator, @parms)); 2155 print("\n"); 2156 } 2157} 2158 2159my $rfc822re; 2160 2161sub make_rfc822re { 2162# Basic lexical tokens are specials, domain_literal, quoted_string, atom, and 2163# comment. We must allow for rfc822_lwsp (or comments) after each of these. 2164# This regexp will only work on addresses which have had comments stripped 2165# and replaced with rfc822_lwsp. 2166 2167 my $specials = '()<>@,;:\\\\".\\[\\]'; 2168 my $controls = '\\000-\\037\\177'; 2169 2170 my $dtext = "[^\\[\\]\\r\\\\]"; 2171 my $domain_literal = "\\[(?:$dtext|\\\\.)*\\]$rfc822_lwsp*"; 2172 2173 my $quoted_string = "\"(?:[^\\\"\\r\\\\]|\\\\.|$rfc822_lwsp)*\"$rfc822_lwsp*"; 2174 2175# Use zero-width assertion to spot the limit of an atom. A simple 2176# $rfc822_lwsp* causes the regexp engine to hang occasionally. 2177 my $atom = "[^$specials $controls]+(?:$rfc822_lwsp+|\\Z|(?=[\\[\"$specials]))"; 2178 my $word = "(?:$atom|$quoted_string)"; 2179 my $localpart = "$word(?:\\.$rfc822_lwsp*$word)*"; 2180 2181 my $sub_domain = "(?:$atom|$domain_literal)"; 2182 my $domain = "$sub_domain(?:\\.$rfc822_lwsp*$sub_domain)*"; 2183 2184 my $addr_spec = "$localpart\@$rfc822_lwsp*$domain"; 2185 2186 my $phrase = "$word*"; 2187 my $route = "(?:\@$domain(?:,\@$rfc822_lwsp*$domain)*:$rfc822_lwsp*)"; 2188 my $route_addr = "\\<$rfc822_lwsp*$route?$addr_spec\\>$rfc822_lwsp*"; 2189 my $mailbox = "(?:$addr_spec|$phrase$route_addr)"; 2190 2191 my $group = "$phrase:$rfc822_lwsp*(?:$mailbox(?:,\\s*$mailbox)*)?;\\s*"; 2192 my $address = "(?:$mailbox|$group)"; 2193 2194 return "$rfc822_lwsp*$address"; 2195} 2196 2197sub rfc822_strip_comments { 2198 my $s = shift; 2199# Recursively remove comments, and replace with a single space. The simpler 2200# regexps in the Email Addressing FAQ are imperfect - they will miss escaped 2201# chars in atoms, for example. 2202 2203 while ($s =~ s/^((?:[^"\\]|\\.)* 2204 (?:"(?:[^"\\]|\\.)*"(?:[^"\\]|\\.)*)*) 2205 \((?:[^()\\]|\\.)*\)/$1 /osx) {} 2206 return $s; 2207} 2208 2209# valid: returns true if the parameter is an RFC822 valid address 2210# 2211sub rfc822_valid { 2212 my $s = rfc822_strip_comments(shift); 2213 2214 if (!$rfc822re) { 2215 $rfc822re = make_rfc822re(); 2216 } 2217 2218 return $s =~ m/^$rfc822re$/so && $s =~ m/^$rfc822_char*$/; 2219} 2220 2221# validlist: In scalar context, returns true if the parameter is an RFC822 2222# valid list of addresses. 2223# 2224# In list context, returns an empty list on failure (an invalid 2225# address was found); otherwise a list whose first element is the 2226# number of addresses found and whose remaining elements are the 2227# addresses. This is needed to disambiguate failure (invalid) 2228# from success with no addresses found, because an empty string is 2229# a valid list. 2230 2231sub rfc822_validlist { 2232 my $s = rfc822_strip_comments(shift); 2233 2234 if (!$rfc822re) { 2235 $rfc822re = make_rfc822re(); 2236 } 2237 # * null list items are valid according to the RFC 2238 # * the '1' business is to aid in distinguishing failure from no results 2239 2240 my @r; 2241 if ($s =~ m/^(?:$rfc822re)?(?:,(?:$rfc822re)?)*$/so && 2242 $s =~ m/^$rfc822_char*$/) { 2243 while ($s =~ m/(?:^|,$rfc822_lwsp*)($rfc822re)/gos) { 2244 push(@r, $1); 2245 } 2246 return wantarray ? (scalar(@r), @r) : 1; 2247 } 2248 return wantarray ? () : 0; 2249} 2250