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