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