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