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