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