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