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	    $email = mailmap_email($email);
 987	    my ($name, $address) = parse_email($email);
 988
 989	    my $tmp_email = format_email($name, $address, $email_usename);
 990	    push_email_address($tmp_email, '');
 991	    add_role($tmp_email, 'in file');
 992	}
 993    }
 994
 995    foreach my $fix (@fixes) {
 996	vcs_add_commit_signers($fix, "blamed_fixes");
 997    }
 998
 999    my @to = ();
1000    if ($email || $email_list) {
1001	if ($email) {
1002	    @to = (@to, @email_to);
1003	}
1004	if ($email_list) {
1005	    @to = (@to, @list_to);
1006	}
1007    }
1008
1009    if ($interactive) {
1010	@to = interactive_get_maintainers(\@to);
1011    }
1012
1013    return @to;
1014}
1015
1016sub file_match_pattern {
1017    my ($file, $pattern) = @_;
1018    if (substr($pattern, -1) eq "/") {
1019	if ($file =~ m@^$pattern@) {
1020	    return 1;
1021	}
1022    } else {
1023	if ($file =~ m@^$pattern@) {
1024	    my $s1 = ($file =~ tr@/@@);
1025	    my $s2 = ($pattern =~ tr@/@@);
1026	    if ($s1 == $s2) {
1027		return 1;
1028	    }
1029	}
1030    }
1031    return 0;
1032}
1033
1034sub usage {
1035    print <<EOT;
1036usage: $P [options] patchfile
1037       $P [options] -f file|directory
1038version: $V
1039
1040MAINTAINER field selection options:
1041  --email => print email address(es) if any
1042    --git => include recent git \*-by: signers
1043    --git-all-signature-types => include signers regardless of signature type
1044        or use only ${signature_pattern} signers (default: $email_git_all_signature_types)
1045    --git-fallback => use git when no exact MAINTAINERS pattern (default: $email_git_fallback)
1046    --git-chief-penguins => include ${penguin_chiefs}
1047    --git-min-signatures => number of signatures required (default: $email_git_min_signatures)
1048    --git-max-maintainers => maximum maintainers to add (default: $email_git_max_maintainers)
1049    --git-min-percent => minimum percentage of commits required (default: $email_git_min_percent)
1050    --git-blame => use git blame to find modified commits for patch or file
1051    --git-blame-signatures => when used with --git-blame, also include all commit signers
1052    --git-since => git history to use (default: $email_git_since)
1053    --hg-since => hg history to use (default: $email_hg_since)
1054    --interactive => display a menu (mostly useful if used with the --git option)
1055    --m => include maintainer(s) if any
1056    --r => include reviewer(s) if any
1057    --n => include name 'Full Name <addr\@domain.tld>'
1058    --l => include list(s) if any
1059    --moderated => include moderated lists(s) if any (default: true)
1060    --s => include subscriber only list(s) if any (default: false)
1061    --remove-duplicates => minimize duplicate email names/addresses
1062    --roles => show roles (status:subsystem, git-signer, list, etc...)
1063    --rolestats => show roles and statistics (commits/total_commits, %)
1064    --file-emails => add email addresses found in -f file (default: 0 (off))
1065    --fixes => for patches, add signatures of commits with 'Fixes: <commit>' (default: 1 (on))
1066  --scm => print SCM tree(s) if any
1067  --status => print status if any
1068  --subsystem => print subsystem name if any
1069  --web => print website(s) if any
1070
1071Output type options:
1072  --separator [, ] => separator for multiple entries on 1 line
1073    using --separator also sets --nomultiline if --separator is not [, ]
1074  --multiline => print 1 entry per line
1075
1076Other options:
1077  --pattern-depth => Number of pattern directory traversals (default: 0 (all))
1078  --keywords => scan patch for keywords (default: $keywords)
1079  --sections => print all of the subsystem sections with pattern matches
1080  --letters => print all matching 'letter' types from all matching sections
1081  --mailmap => use .mailmap file (default: $email_use_mailmap)
1082  --no-tree => run without a kernel tree
1083  --self-test => show potential issues with MAINTAINERS file content
1084  --version => show version
1085  --help => show this help information
1086
1087Default options:
1088  [--email --tree --nogit --git-fallback --m --r --n --l --multiline
1089   --pattern-depth=0 --remove-duplicates --rolestats]
1090
1091Notes:
1092  Using "-f directory" may give unexpected results:
1093      Used with "--git", git signators for _all_ files in and below
1094          directory are examined as git recurses directories.
1095          Any specified X: (exclude) pattern matches are _not_ ignored.
1096      Used with "--nogit", directory is used as a pattern match,
1097          no individual file within the directory or subdirectory
1098          is matched.
1099      Used with "--git-blame", does not iterate all files in directory
1100  Using "--git-blame" is slow and may add old committers and authors
1101      that are no longer active maintainers to the output.
1102  Using "--roles" or "--rolestats" with git send-email --cc-cmd or any
1103      other automated tools that expect only ["name"] <email address>
1104      may not work because of additional output after <email address>.
1105  Using "--rolestats" and "--git-blame" shows the #/total=% commits,
1106      not the percentage of the entire file authored.  # of commits is
1107      not a good measure of amount of code authored.  1 major commit may
1108      contain a thousand lines, 5 trivial commits may modify a single line.
1109  If git is not installed, but mercurial (hg) is installed and an .hg
1110      repository exists, the following options apply to mercurial:
1111          --git,
1112          --git-min-signatures, --git-max-maintainers, --git-min-percent, and
1113          --git-blame
1114      Use --hg-since not --git-since to control date selection
1115  File ".get_maintainer.conf", if it exists in the linux kernel source root
1116      directory, can change whatever get_maintainer defaults are desired.
1117      Entries in this file can be any command line argument.
1118      This file is prepended to any additional command line arguments.
1119      Multiple lines and # comments are allowed.
1120  Most options have both positive and negative forms.
1121      The negative forms for --<foo> are --no<foo> and --no-<foo>.
1122
1123EOT
1124}
1125
1126sub top_of_kernel_tree {
1127    my ($lk_path) = @_;
1128
1129    if ($lk_path ne "" && substr($lk_path,length($lk_path)-1,1) ne "/") {
1130	$lk_path .= "/";
1131    }
1132    if (   (-f "${lk_path}COPYING")
1133	&& (-f "${lk_path}CREDITS")
1134	&& (-f "${lk_path}Kbuild")
1135	&& (-e "${lk_path}MAINTAINERS")
1136	&& (-f "${lk_path}Makefile")
1137	&& (-f "${lk_path}README")
1138	&& (-d "${lk_path}Documentation")
1139	&& (-d "${lk_path}arch")
1140	&& (-d "${lk_path}include")
1141	&& (-d "${lk_path}drivers")
1142	&& (-d "${lk_path}fs")
1143	&& (-d "${lk_path}init")
1144	&& (-d "${lk_path}ipc")
1145	&& (-d "${lk_path}kernel")
1146	&& (-d "${lk_path}lib")
1147	&& (-d "${lk_path}scripts")) {
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}