use warnings;

use strict;

my $P = $0;

my $V = '0.26';

use Getopt::Long qw(:config no_auto_abbrev);

use Cwd;

use File::Find;

use File::Spec::Functions;

my $cur_path = fastgetcwd() . '/';

my $lk_path = "./";

my $email = 1;

my $email_usename = 1;

my $email_maintainer = 1;

my $email_reviewer = 1;

my $email_fixes = 1;

my $email_list = 1;

my $email_moderated_list = 1;

my $email_subscriber_list = 0;

my $email_git_penguin_chiefs = 0;

my $email_git = 0;

my $email_git_all_signature_types = 0;

my $email_git_blame = 0;

my $email_git_blame_signatures = 1;

my $email_git_fallback = 1;

my $email_git_min_signatures = 1;

my $email_git_max_maintainers = 5;

my $email_git_min_percent = 5;

my $email_git_since = "1-year-ago";

my $email_hg_since = "-365";

my $interactive = 0;

my $email_remove_duplicates = 1;

my $email_use_mailmap = 1;

my $output_multiline = 1;

my $output_separator = ", ";

my $output_roles = 0;

my $output_rolestats = 1;

my $output_section_maxlen = 50;

my $scm = 0;

my $tree = 1;

my $web = 0;

my $subsystem = 0;

my $status = 0;

my $letters = "";

my $keywords = 1;

my $sections = 0;

my $email_file_emails = 0;

my $from_filename = 0;

my $pattern_depth = 0;

my $self_test = undef;

my $version = 0;

my $help = 0;

my $find_maintainer_files = 0;

my $maintainer_path;

my $vcs_used = 0;

my $exit = 0;

my @files = ();

my @fixes = (); # If a patch description includes Fixes: lines

my @range = ();

my @keyword_tvi = ();

my @file_emails = ();

my %commit_author_hash;

my %commit_signer_hash;

my @penguin_chief = ();

push(@penguin_chief, "Linus Torvalds:torvalds\@linux-foundation.org");

my @penguin_chief_names = ();

foreach my $chief (@penguin_chief) {

if ($chief =~ m/^(.*):(.*)/) {

my $chief_name = $1;

my $chief_addr = $2;

push(@penguin_chief_names, $chief_name);

}

}

my $penguin_chiefs = "\(" . join("|", @penguin_chief_names) . "\)";

my @signature_tags = ();

push(@signature_tags, "Signed-off-by:");

push(@signature_tags, "Reviewed-by:");

push(@signature_tags, "Acked-by:");

my $signature_pattern = "\(" . join("|", @signature_tags) . "\)";

my $rfc822_lwsp = "(?:(?:\\r\\n)?[ \\t])";

my $rfc822_char = '[\\000-\\377]';

my %VCS_cmds;

my %VCS_cmds_git = (

"execute_cmd" => \&git_execute_cmd,

"available" => '(which("git") ne "") && (-e ".git")',

"find_signers_cmd" =>

"git log --no-color --follow --since=\$email_git_since " .

'--numstat --no-merges ' .

'--format="GitCommit: %H%n' .

'GitAuthor: %an <%ae>%n' .

'GitDate: %aD%n' .

'GitSubject: %s%n' .

'%b%n"' .

" -- \$file",

"find_commit_signers_cmd" =>

"git log --no-color " .

'--numstat ' .

'--format="GitCommit: %H%n' .

'GitAuthor: %an <%ae>%n' .

'GitDate: %aD%n' .

'GitSubject: %s%n' .

'%b%n"' .

" -1 \$commit",

"find_commit_author_cmd" =>

"git log --no-color " .

'--numstat ' .

'--format="GitCommit: %H%n' .

'GitAuthor: %an <%ae>%n' .

'GitDate: %aD%n' .

'GitSubject: %s%n"' .

" -1 \$commit",

"blame_range_cmd" => "git blame -l -L \$diff_start,+\$diff_length \$file",

"blame_file_cmd" => "git blame -l \$file",

"commit_pattern" => "^GitCommit: ([0-9a-f]{40,40})",

"blame_commit_pattern" => "^([0-9a-f]+) ",

"author_pattern" => "^GitAuthor: (.*)",

"subject_pattern" => "^GitSubject: (.*)",

"stat_pattern" => "^(\\d+)\\t(\\d+)\\t\$file\$",

"file_exists_cmd" => "git ls-files \$file",

"list_files_cmd" => "git ls-files \$file",

);

my %VCS_cmds_hg = (

"execute_cmd" => \&hg_execute_cmd,

"available" => '(which("hg") ne "") && (-d ".hg")',

"find_signers_cmd" =>

"hg log --date=\$email_hg_since " .

"--template='HgCommit: {node}\\n" .

"HgAuthor: {author}\\n" .

"HgSubject: {desc}\\n'" .

" -- \$file",

"find_commit_signers_cmd" =>

"hg log " .

"--template='HgSubject: {desc}\\n'" .

" -r \$commit",

"find_commit_author_cmd" =>

"hg log " .

"--template='HgCommit: {node}\\n" .

"HgAuthor: {author}\\n" .

"HgSubject: {desc|firstline}\\n'" .

" -r \$commit",

"blame_range_cmd" => "", # not supported

"blame_file_cmd" => "hg blame -n \$file",

"commit_pattern" => "^HgCommit: ([0-9a-f]{40,40})",

"blame_commit_pattern" => "^([ 0-9a-f]+):",

"author_pattern" => "^HgAuthor: (.*)",

"subject_pattern" => "^HgSubject: (.*)",

"stat_pattern" => "^(\\d+)\t(\\d+)\t\$file\$",

"file_exists_cmd" => "hg files \$file",

"list_files_cmd" => "hg manifest -R \$file",

);

my $conf = which_conf(".get_maintainer.conf");

if (-f $conf) {

my @conf_args;

open(my $conffile, '<', "$conf")

or warn "$P: Can't find a readable .get_maintainer.conf file $!\n";

while (<$conffile>) {

my $line = $_;

$line =~ s/\s*\n?$//g;

$line =~ s/^\s*//g;

$line =~ s/\s+/ /g;

next if ($line =~ m/^\s*#/);

next if ($line =~ m/^\s*$/);

my @words = split(" ", $line);

foreach my $word (@words) {

last if ($word =~ m/^#/);

push (@conf_args, $word);

}

}

close($conffile);

unshift(@ARGV, @conf_args) if @conf_args;

}

my @ignore_emails = ();

my $ignore_file = which_conf(".get_maintainer.ignore");

if (-f $ignore_file) {

open(my $ignore, '<', "$ignore_file")

or warn "$P: Can't find a readable .get_maintainer.ignore file $!\n";

while (<$ignore>) {

my $line = $_;

$line =~ s/\s*\n?$//;

$line =~ s/^\s*//;

$line =~ s/\s+$//;

$line =~ s/#.*$//;

next if ($line =~ m/^\s*$/);

if (rfc822_valid($line)) {

push(@ignore_emails, $line);

}

}

close($ignore);

}

if ($#ARGV > 0) {

foreach (@ARGV) {

if ($_ =~ /^-{1,2}self-test(?:=|$)/) {

die "$P: using --self-test does not allow any other option or argument\n";

}

}

}

if (!GetOptions(

'email!' => \$email,

'git!' => \$email_git,

'git-all-signature-types!' => \$email_git_all_signature_types,

'git-blame!' => \$email_git_blame,

'git-blame-signatures!' => \$email_git_blame_signatures,

'git-fallback!' => \$email_git_fallback,

'git-chief-penguins!' => \$email_git_penguin_chiefs,

'git-min-signatures=i' => \$email_git_min_signatures,

'git-max-maintainers=i' => \$email_git_max_maintainers,

'git-min-percent=i' => \$email_git_min_percent,

'git-since=s' => \$email_git_since,

'hg-since=s' => \$email_hg_since,

'i|interactive!' => \$interactive,

'remove-duplicates!' => \$email_remove_duplicates,

'mailmap!' => \$email_use_mailmap,

'm!' => \$email_maintainer,

'r!' => \$email_reviewer,

'n!' => \$email_usename,

'l!' => \$email_list,

'fixes!' => \$email_fixes,

'moderated!' => \$email_moderated_list,

's!' => \$email_subscriber_list,

'multiline!' => \$output_multiline,

'roles!' => \$output_roles,

'rolestats!' => \$output_rolestats,

'separator=s' => \$output_separator,

'subsystem!' => \$subsystem,

'status!' => \$status,

'scm!' => \$scm,

'tree!' => \$tree,

'web!' => \$web,

'letters=s' => \$letters,

'pattern-depth=i' => \$pattern_depth,

'k|keywords!' => \$keywords,

'sections!' => \$sections,

'fe|file-emails!' => \$email_file_emails,

'f|file' => \$from_filename,

'find-maintainer-files' => \$find_maintainer_files,

'mpath|maintainer-path=s' => \$maintainer_path,

'self-test:s' => \$self_test,

'v|version' => \$version,

'h|help|usage' => \$help,

)) {

die "$P: invalid argument - use --help if necessary\n";

}

if ($help != 0) {

usage();

exit 0;

}

if ($version != 0) {

print("${P} ${V}\n");

exit 0;

}

if (defined $self_test) {

read_all_maintainer_files();

self_test();

exit 0;

}

if (-t STDIN && !@ARGV) {

# We're talking to a terminal, but have no command line arguments.

die "$P: missing patchfile or -f file - use --help if necessary\n";

}

$output_multiline = 0 if ($output_separator ne ", ");

$output_rolestats = 1 if ($interactive);

$output_roles = 1 if ($output_rolestats);

if ($sections || $letters ne "") {

$sections = 1;

$email = 0;

$email_list = 0;

$scm = 0;

$status = 0;

$subsystem = 0;

$web = 0;

$keywords = 0;

$interactive = 0;

} else {

my $selections = $email + $scm + $status + $subsystem + $web;

if ($selections == 0) {

die "$P: Missing required option: email, scm, status, subsystem or web\n";

}

}

if ($email &&

($email_maintainer + $email_reviewer +

$email_list + $email_subscriber_list +

$email_git + $email_git_penguin_chiefs + $email_git_blame) == 0) {

die "$P: Please select at least 1 email option\n";

}

if ($tree && !top_of_kernel_tree($lk_path)) {

die "$P: The current directory does not appear to be "

. "a linux kernel source tree.\n";

}

my @typevalue = ();

my %keyword_hash;

my @mfiles = ();

my @self_test_info = ();

sub read_maintainer_file {

my ($file) = @_;

open (my $maint, '<', "$file")

or die "$P: Can't open MAINTAINERS file '$file': $!\n";

my $i = 1;

while (<$maint>) {

my $line = $_;

chomp $line;

if ($line =~ m/^([A-Z]):\s*(.*)/) {

my $type = $1;

my $value = $2;

##Filename pattern matching

if ($type eq "F" || $type eq "X") {

$value =~ s@\.@\\\.@g; ##Convert . to \.

$value =~ s/\*/\.\*/g; ##Convert * to .*

$value =~ s/\?/\./g; ##Convert ? to .

##if pattern is a directory and it lacks a trailing slash, add one

if ((-d $value)) {

$value =~ s@([^/])$@$1/@;

}

} elsif ($type eq "K") {

$keyword_hash{@typevalue} = $value;

}

push(@typevalue, "$type:$value");

} elsif (!(/^\s*$/ || /^\s*\#/)) {

push(@typevalue, $line);

}

if (defined $self_test) {

push(@self_test_info, {file=>$file, linenr=>$i, line=>$line});

}

$i++;

}

close($maint);

}

sub find_is_maintainer_file {

my ($file) = $_;

return if ($file !~ m@/MAINTAINERS$@);

$file = $File::Find::name;

return if (! -f $file);

push(@mfiles, $file);

}

sub find_ignore_git {

return grep { $_ !~ /^\.git$/; } @_;

}

read_all_maintainer_files();

sub read_all_maintainer_files {

my $path = "${lk_path}MAINTAINERS";

if (defined $maintainer_path) {

$path = $maintainer_path;

# Perl Cookbook tilde expansion if necessary

$path =~ s@^~([^/]*)@ $1 ? (getpwnam($1))[7] : ( $ENV{HOME} || $ENV{LOGDIR} || (getpwuid($<))[7])@ex;

}

if (-d $path) {

$path .= '/' if ($path !~ m@/$@);

if ($find_maintainer_files) {

find( { wanted => \&find_is_maintainer_file,

preprocess => \&find_ignore_git,

no_chdir => 1,

}, "$path");

} else {

opendir(DIR, "$path") or die $!;

my @files = readdir(DIR);

closedir(DIR);

foreach my $file (@files) {

push(@mfiles, "$path$file") if ($file !~ /^\./);

}

}

} elsif (-f "$path") {

push(@mfiles, "$path");

} else {

die "$P: MAINTAINER file not found '$path'\n";

}

die "$P: No MAINTAINER files found in '$path'\n" if (scalar(@mfiles) == 0);

foreach my $file (@mfiles) {

read_maintainer_file("$file");

}

}

sub maintainers_in_file {

my ($file) = @_;

return if ($file =~ m@\bMAINTAINERS$@);

if (-f $file && ($email_file_emails || $file =~ /\.yaml$/)) {

open(my $f, '<', $file)

or die "$P: Can't open $file: $!\n";

my $text = do { local($/) ; <$f> };

close($f);

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;

push(@file_emails, clean_file_emails(@poss_addr));

}

}

my $mailmap;

read_mailmap();

sub read_mailmap {

$mailmap = {

names => {},

addresses => {}

};

return if (!$email_use_mailmap || !(-f "${lk_path}.mailmap"));

open(my $mailmap_file, '<', "${lk_path}.mailmap")

or warn "$P: Can't open .mailmap: $!\n";

while (<$mailmap_file>) {

s/#.*$//; #strip comments

s/^\s+|\s+$//g; #trim

next if (/^\s*$/); #skip empty lines

#entries have one of the following formats:

# name1 <mail1>

# <mail1> <mail2>

# name1 <mail1> <mail2>

# name1 <mail1> name2 <mail2>

# (see man git-shortlog)

if (/^([^<]+)<([^>]+)>$/) {

my $real_name = $1;

my $address = $2;

$real_name =~ s/\s+$//;

($real_name, $address) = parse_email("$real_name <$address>");

$mailmap->{names}->{$address} = $real_name;

} elsif (/^<([^>]+)>\s*<([^>]+)>$/) {

my $real_address = $1;

my $wrong_address = $2;

$mailmap->{addresses}->{$wrong_address} = $real_address;

} elsif (/^(.+)<([^>]+)>\s*<([^>]+)>$/) {

my $real_name = $1;

my $real_address = $2;

my $wrong_address = $3;

$real_name =~ s/\s+$//;

($real_name, $real_address) =

parse_email("$real_name <$real_address>");

$mailmap->{names}->{$wrong_address} = $real_name;

$mailmap->{addresses}->{$wrong_address} = $real_address;

} elsif (/^(.+)<([^>]+)>\s*(.+)\s*<([^>]+)>$/) {

my $real_name = $1;

my $real_address = $2;

my $wrong_name = $3;

my $wrong_address = $4;

$real_name =~ s/\s+$//;

($real_name, $real_address) =

parse_email("$real_name <$real_address>");

$wrong_name =~ s/\s+$//;

($wrong_name, $wrong_address) =

parse_email("$wrong_name <$wrong_address>");

my $wrong_email = format_email($wrong_name, $wrong_address, 1);

$mailmap->{names}->{$wrong_email} = $real_name;

$mailmap->{addresses}->{$wrong_email} = $real_address;

}

}

close($mailmap_file);

}

if (!@ARGV) {

push(@ARGV, "&STDIN");

}

foreach my $file (@ARGV) {

if ($file ne "&STDIN") {

$file = canonpath($file);

##if $file is a directory and it lacks a trailing slash, add one

if ((-d $file)) {

$file =~ s@([^/])$@$1/@;

} elsif (!(-f $file)) {

die "$P: file '${file}' not found\n";

}

}

if ($from_filename && (vcs_exists() && !vcs_file_exists($file))) {

warn "$P: file '$file' not found in version control $!\n";

}

if ($from_filename || ($file ne "&STDIN" && vcs_file_exists($file))) {

$file =~ s/^\Q${cur_path}\E//; #strip any absolute path

$file =~ s/^\Q${lk_path}\E//; #or the path to the lk tree

push(@files, $file);

if ($file ne "MAINTAINERS" && -f $file && $keywords) {

open(my $f, '<', $file)

or die "$P: Can't open $file: $!\n";

my $text = do { local($/) ; <$f> };

close($f);

if ($keywords) {

foreach my $line (keys %keyword_hash) {

if ($text =~ m/$keyword_hash{$line}/x) {

push(@keyword_tvi, $line);

}

}

}

}

} else {

my $file_cnt = @files;

my $lastfile;

open(my $patch, "< $file")

or die "$P: Can't open $file: $!\n";

# We can check arbitrary information before the patch

# like the commit message, mail headers, etc...

# This allows us to match arbitrary keywords against any part

# of a git format-patch generated file (subject tags, etc...)

my $patch_prefix = ""; #Parsing the intro

while (<$patch>) {

my $patch_line = $_;

if (m/^ mode change [0-7]+ => [0-7]+ (\S+)\s*$/) {

my $filename = $1;

push(@files, $filename);

} elsif (m/^rename (?:from|to) (\S+)\s*$/) {

my $filename = $1;

push(@files, $filename);

} elsif (m/^diff --git a\/(\S+) b\/(\S+)\s*$/) {

my $filename1 = $1;

my $filename2 = $2;

push(@files, $filename1);

push(@files, $filename2);

} elsif (m/^Fixes:\s+([0-9a-fA-F]{6,40})/) {

push(@fixes, $1) if ($email_fixes);

} elsif (m/^\+\+\+\s+(\S+)/ or m/^---\s+(\S+)/) {

my $filename = $1;

$filename =~ s@^[^/]*/@@;

$filename =~ s@\n@@;

$lastfile = $filename;

push(@files, $filename);

$patch_prefix = "^[+-].*"; #Now parsing the actual patch

} elsif (m/^\@\@ -(\d+),(\d+)/) {

if ($email_git_blame) {

push(@range, "$lastfile:$1:$2");

}

} elsif ($keywords) {

foreach my $line (keys %keyword_hash) {

if ($patch_line =~ m/${patch_prefix}$keyword_hash{$line}/x) {

push(@keyword_tvi, $line);

}

}

}

}

close($patch);

if ($file_cnt == @files) {

warn "$P: file '${file}' doesn't appear to be a patch. "

. "Add -f to options?\n";

}

@files = sort_and_uniq(@files);

}

}

@file_emails = uniq(@file_emails);

@fixes = uniq(@fixes);

my %email_hash_name;

my %email_hash_address;

my @email_to = ();

my %hash_list_to;

my @list_to = ();

my @scm = ();

my @web = ();

my @subsystem = ();

my @status = ();

my %deduplicate_name_hash = ();

my %deduplicate_address_hash = ();

my @maintainers = get_maintainers();

if (@maintainers) {

@maintainers = merge_email(@maintainers);

output(@maintainers);

}

if ($scm) {

@scm = uniq(@scm);

output(@scm);

}

if ($status) {

@status = uniq(@status);

output(@status);

}

if ($subsystem) {

@subsystem = uniq(@subsystem);

output(@subsystem);

}

if ($web) {

@web = uniq(@web);

output(@web);

}

exit($exit);

sub self_test {

my @lsfiles = ();

my @good_links = ();

my @bad_links = ();

my @section_headers = ();

my $index = 0;

@lsfiles = vcs_list_files($lk_path);

for my $x (@self_test_info) {

$index++;

## Section header duplication and missing section content

if (($self_test eq "" || $self_test =~ /\bsections\b/) &&

$x->{line} =~ /^\S[^:]/ &&

defined $self_test_info[$index] &&

$self_test_info[$index]->{line} =~ /^([A-Z]):\s*\S/) {

my $has_S = 0;

my $has_F = 0;

my $has_ML = 0;

my $status = "";

if (grep(m@^\Q$x->{line}\E@, @section_headers)) {

print("$x->{file}:$x->{linenr}: warning: duplicate section header\t$x->{line}\n");

} else {

push(@section_headers, $x->{line});

}

my $nextline = $index;

while (defined $self_test_info[$nextline] &&

$self_test_info[$nextline]->{line} =~ /^([A-Z]):\s*(\S.*)/) {

my $type = $1;

my $value = $2;

if ($type eq "S") {

$has_S = 1;

$status = $value;

} elsif ($type eq "F" || $type eq "N") {

$has_F = 1;

} elsif ($type eq "M" || $type eq "R" || $type eq "L") {

$has_ML = 1;

}

$nextline++;

}

if (!$has_ML && $status !~ /orphan|obsolete/i) {

print("$x->{file}:$x->{linenr}: warning: section without email address\t$x->{line}\n");

}

if (!$has_S) {

print("$x->{file}:$x->{linenr}: warning: section without status \t$x->{line}\n");

}

if (!$has_F) {

print("$x->{file}:$x->{linenr}: warning: section without file pattern\t$x->{line}\n");

}

}

next if ($x->{line} !~ /^([A-Z]):\s*(.*)/);

my $type = $1;

my $value = $2;

## Filename pattern matching

if (($type eq "F" || $type eq "X") &&

($self_test eq "" || $self_test =~ /\bpatterns\b/)) {

$value =~ s@\.@\\\.@g; ##Convert . to \.

$value =~ s/\*/\.\*/g; ##Convert * to .*

$value =~ s/\?/\./g; ##Convert ? to .

##if pattern is a directory and it lacks a trailing slash, add one

if ((-d $value)) {

$value =~ s@([^/])$@$1/@;

}

if (!grep(m@^$value@, @lsfiles)) {

print("$x->{file}:$x->{linenr}: warning: no file matches\t$x->{line}\n");

}

## Link reachability

} elsif (($type eq "W" || $type eq "Q" || $type eq "B") &&

$value =~ /^https?:/ &&

($self_test eq "" || $self_test =~ /\blinks\b/)) {

next if (grep(m@^\Q$value\E$@, @good_links));

my $isbad = 0;

if (grep(m@^\Q$value\E$@, @bad_links)) {

$isbad = 1;

} else {

my $output = `wget --spider -q --no-check-certificate --timeout 10 --tries 1 $value`;

if ($? == 0) {

push(@good_links, $value);

} else {

push(@bad_links, $value);

$isbad = 1;

}

}

if ($isbad) {

print("$x->{file}:$x->{linenr}: warning: possible bad link\t$x->{line}\n");

}

## SCM reachability

} elsif ($type eq "T" &&

($self_test eq "" || $self_test =~ /\bscm\b/)) {

next if (grep(m@^\Q$value\E$@, @good_links));

my $isbad = 0;

if (grep(m@^\Q$value\E$@, @bad_links)) {

$isbad = 1;

} elsif ($value !~ /^(?:git|quilt|hg)\s+\S/) {

print("$x->{file}:$x->{linenr}: warning: malformed entry\t$x->{line}\n");

} elsif ($value =~ /^git\s+(\S+)(\s+([^\(]+\S+))?/) {

my $url = $1;

my $branch = "";

$branch = $3 if $3;

my $output = `git ls-remote --exit-code -h "$url" $branch > /dev/null 2>&1`;

if ($? == 0) {

push(@good_links, $value);

} else {

push(@bad_links, $value);

$isbad = 1;

}

} elsif ($value =~ /^(?:quilt|hg)\s+(https?:\S+)/) {

my $url = $1;

my $output = `wget --spider -q --no-check-certificate --timeout 10 --tries 1 $url`;

if ($? == 0) {

push(@good_links, $value);

} else {

push(@bad_links, $value);

$isbad = 1;

}

}

if ($isbad) {

print("$x->{file}:$x->{linenr}: warning: possible bad link\t$x->{line}\n");

}

}

}

}

sub ignore_email_address {

my ($address) = @_;

foreach my $ignore (@ignore_emails) {

return 1 if ($ignore eq $address);

}

return 0;

}

sub range_is_maintained {

my ($start, $end) = @_;

for (my $i = $start; $i < $end; $i++) {

my $line = $typevalue[$i];

if ($line =~ m/^([A-Z]):\s*(.*)/) {

my $type = $1;

my $value = $2;

if ($type eq 'S') {

if ($value =~ /(maintain|support)/i) {

return 1;

}

}

}

}

return 0;

}

sub range_has_maintainer {

my ($start, $end) = @_;

for (my $i = $start; $i < $end; $i++) {

my $line = $typevalue[$i];

if ($line =~ m/^([A-Z]):\s*(.*)/) {

my $type = $1;

my $value = $2;

if ($type eq 'M') {

return 1;

}

}

}

return 0;

}

sub get_maintainers {

%email_hash_name = ();

%email_hash_address = ();

%commit_author_hash = ();

%commit_signer_hash = ();

@email_to = ();

%hash_list_to = ();

@list_to = ();

@scm = ();

@web = ();

@subsystem = ();

@status = ();

%deduplicate_name_hash = ();

%deduplicate_address_hash = ();

if ($email_git_all_signature_types) {

$signature_pattern = "(.+?)[Bb][Yy]:";

} else {

$signature_pattern = "\(" . join("|", @signature_tags) . "\)";

}

# Find responsible parties

my %exact_pattern_match_hash = ();

foreach my $file (@files) {

my %hash;

my $tvi = find_first_section();

while ($tvi < @typevalue) {

my $start = find_starting_index($tvi);

my $end = find_ending_index($tvi);

my $exclude = 0;

my $i;

#Do not match excluded file patterns

for ($i = $start; $i < $end; $i++) {

my $line = $typevalue[$i];

if ($line =~ m/^([A-Z]):\s*(.*)/) {

my $type = $1;

my $value = $2;

if ($type eq 'X') {

if (file_match_pattern($file, $value)) {

$exclude = 1;

last;

}

}

}

}

if (!$exclude) {

for ($i = $start; $i < $end; $i++) {

my $line = $typevalue[$i];

if ($line =~ m/^([A-Z]):\s*(.*)/) {

my $type = $1;

my $value = $2;

if ($type eq 'F') {

if (file_match_pattern($file, $value)) {

my $value_pd = ($value =~ tr@/@@);

my $file_pd = ($file =~ tr@/@@);

$value_pd++ if (substr($value,-1,1) ne "/");

$value_pd = -1 if ($value =~ /^\.\*/);

if ($value_pd >= $file_pd &&

range_is_maintained($start, $end) &&

range_has_maintainer($start, $end)) {

$exact_pattern_match_hash{$file} = 1;

}

if ($pattern_depth == 0 ||

(($file_pd - $value_pd) < $pattern_depth)) {

$hash{$tvi} = $value_pd;

}

}

} elsif ($type eq 'N') {

if ($file =~ m/$value/x) {

$hash{$tvi} = 0;

}

}

}

}

}

$tvi = $end + 1;

}

foreach my $line (sort {$hash{$b} <=> $hash{$a}} keys %hash) {

add_categories($line);

if ($sections) {

my $i;

my $start = find_starting_index($line);

my $end = find_ending_index($line);

for ($i = $start; $i < $end; $i++) {

my $line = $typevalue[$i];

if ($line =~ /^[FX]:/) { ##Restore file patterns

$line =~ s/([^\\])\.([^\*])/$1\?$2/g;

$line =~ s/([^\\])\.$/$1\?/g; ##Convert . back to ?

$line =~ s/\\\./\./g; ##Convert \. to .

$line =~ s/\.\*/\*/g; ##Convert .* to *

}

my $count = $line =~ s/^([A-Z]):/$1:\t/g;

if ($letters eq "" || (!$count || $letters =~ /$1/i)) {

print("$line\n");

}

}

print("\n");

}

}

maintainers_in_file($file);

}

if ($keywords) {

@keyword_tvi = sort_and_uniq(@keyword_tvi);

foreach my $line (@keyword_tvi) {

add_categories($line);

}

}

foreach my $email (@email_to, @list_to) {

$email->[0] = deduplicate_email($email->[0]);

}

foreach my $file (@files) {

if ($email &&

($email_git ||

($email_git_fallback &&

$file !~ /MAINTAINERS$/ &&

!$exact_pattern_match_hash{$file}))) {

vcs_file_signoffs($file);

}

if ($email && $email_git_blame) {

vcs_file_blame($file);

}

}

if ($email) {

foreach my $chief (@penguin_chief) {

if ($chief =~ m/^(.*):(.*)/) {

my $email_address;

$email_address = format_email($1, $2, $email_usename);

if ($email_git_penguin_chiefs) {

push(@email_to, [$email_address, 'chief penguin']);

} else {

@email_to = grep($_->[0] !~ /${email_address}/, @email_to);

}

}

}

foreach my $email (@file_emails) {

my ($name, $address) = parse_email($email);

my $tmp_email = format_email($name, $address, $email_usename);

push_email_address($tmp_email, '');

add_role($tmp_email, 'in file');

}

}

foreach my $fix (@fixes) {

vcs_add_commit_signers($fix, "blamed_fixes");

}

my @to = ();

if ($email || $email_list) {

if ($email) {