lib/PublicInbox/Config.pm

   1 # Copyright (C) 2014-2018 all contributors <meta@public-inbox.org>
   2 # License: AGPL-3.0+ <https://www.gnu.org/licenses/agpl-3.0.txt>
   3 #
   4 # Used throughout the project for reading configuration
   5 #
   6 # Note: I hate camelCase; but git-config(1) uses it, but it's better
   7 # than alllowercasewithoutunderscores, so use lc('configKey') where
   8 # applicable for readability
   9
  10 package PublicInbox::Config;
  11 use strict;
  12 use warnings;
  13 require PublicInbox::Inbox;
  14 use PublicInbox::Spawn qw(popen_rd);
  15
  16 sub _array ($) { ref($_[0]) eq 'ARRAY' ? $_[0] : [ $_[0] ] }
  17
  18 # returns key-value pairs of config directives in a hash
  19 # if keys may be multi-value, the value is an array ref containing all values
  20 sub new {
  21         my ($class, $file) = @_;
  22         $file = default_file() unless defined($file);
  23         $file = ref $file ? $file : git_config_dump($file);
  24         my $self = bless $file, $class;
  25
  26         # caches
  27         $self->{-by_addr} ||= {};
  28         $self->{-by_name} ||= {};
  29         $self->{-by_newsgroup} ||= {};
  30         $self->{-no_obfuscate} ||= {};
  31         $self->{-limiters} ||= {};
  32         $self->{-code_repos} ||= {}; # nick => PublicInbox::Git object
  33         $self->{-cgitrc_unparsed} = $self->{'publicinbox.cgitrc'};
  34
  35         if (my $no = delete $self->{'publicinbox.noobfuscate'}) {
  36                 $no = _array($no);
  37                 my @domains;
  38                 foreach my $n (@$no) {
  39                         my @n = split(/\s+/, $n);
  40                         foreach (@n) {
  41                                 if (/\S+@\S+/) { # full address
  42                                         $self->{-no_obfuscate}->{lc $_} = 1;
  43                                 } else {
  44                                         # allow "example.com" or "@example.com"
  45                                         s/\A@//;
  46                                         push @domains, quotemeta($_);
  47                                 }
  48                         }
  49                 }
  50                 my $nod = join('|', @domains);
  51                 $self->{-no_obfuscate_re} = qr/(?:$nod)\z/i;
  52         }
  53         if (my $css = delete $self->{'publicinbox.css'}) {
  54                 $self->{css} = _array($css);
  55         }
  56
  57         $self;
  58 }
  59
  60 sub lookup {
  61         my ($self, $recipient) = @_;
  62         my $addr = lc($recipient);
  63         my $ibx = $self->{-by_addr}->{$addr};
  64         return $ibx if $ibx;
  65
  66         my $pfx;
  67
  68         foreach my $k (keys %$self) {
  69                 $k =~ m!\A(publicinbox\.[^/]+)\.address\z! or next;
  70                 my $v = $self->{$k};
  71                 if (ref($v) eq "ARRAY") {
  72                         foreach my $alias (@$v) {
  73                                 (lc($alias) eq $addr) or next;
  74                                 $pfx = $1;
  75                                 last;
  76                         }
  77                 } else {
  78                         (lc($v) eq $addr) or next;
  79                         $pfx = $1;
  80                         last;
  81                 }
  82         }
  83         defined $pfx or return;
  84         _fill($self, $pfx);
  85 }
  86
  87 sub lookup_name ($$) {
  88         my ($self, $name) = @_;
  89         $self->{-by_name}->{$name} || _fill($self, "publicinbox.$name");
  90 }
  91
  92 sub each_inbox {
  93         my ($self, $cb) = @_;
  94         if (my $section_order = $self->{-section_order}) {
  95                 foreach my $section (@$section_order) {
  96                         next if $section !~ m!\Apublicinbox\.([^/]+)\z!;
  97                         $self->{"publicinbox.$1.mainrepo"} or next;
  98                         my $ibx = lookup_name($self, $1) or next;
  99                         $cb->($ibx);
 100                 }
 101         } else {
 102                 my %seen;
 103                 foreach my $k (keys %$self) {
 104                         $k =~ m!\Apublicinbox\.([^/]+)\.mainrepo\z! or next;
 105                         next if $seen{$1};
 106                         $seen{$1} = 1;
 107                         my $ibx = lookup_name($self, $1) or next;
 108                         $cb->($ibx);
 109                 }
 110         }
 111 }
 112
 113 sub lookup_newsgroup {
 114         my ($self, $ng) = @_;
 115         $ng = lc($ng);
 116         my $rv = $self->{-by_newsgroup}->{$ng};
 117         return $rv if $rv;
 118
 119         foreach my $k (keys %$self) {
 120                 $k =~ m!\A(publicinbox\.[^/]+)\.newsgroup\z! or next;
 121                 my $v = $self->{$k};
 122                 my $pfx = $1;
 123                 if ($v eq $ng) {
 124                         $rv = _fill($self, $pfx);
 125                         return $rv;
 126                 }
 127         }
 128         undef;
 129 }
 130
 131 sub limiter {
 132         my ($self, $name) = @_;
 133         $self->{-limiters}->{$name} ||= do {
 134                 require PublicInbox::Qspawn;
 135                 my $max = $self->{"publicinboxlimiter.$name.max"} || 1;
 136                 my $limiter = PublicInbox::Qspawn::Limiter->new($max);
 137                 $limiter->setup_rlimit($name, $self);
 138                 $limiter;
 139         };
 140 }
 141
 142 sub config_dir { $ENV{PI_DIR} || "$ENV{HOME}/.public-inbox" }
 143
 144 sub default_file {
 145         my $f = $ENV{PI_CONFIG};
 146         return $f if defined $f;
 147         config_dir() . '/config';
 148 }
 149
 150 sub git_config_dump {
 151         my ($file) = @_;
 152         my (%section_seen, @section_order);
 153         return {} unless -e $file;
 154         my @cmd = (qw/git config/, "--file=$file", '-l');
 155         my $cmd = join(' ', @cmd);
 156         my $fh = popen_rd(\@cmd) or die "popen_rd failed for $file: $!\n";
 157         my %rv;
 158         local $/ = "\n";
 159         while (defined(my $line = <$fh>)) {
 160                 chomp $line;
 161                 my ($k, $v) = split(/=/, $line, 2);
 162
 163                 my ($section) = ($k =~ /\A(\S+)\.[^\.]+\z/);
 164                 unless (defined $section_seen{$section}) {
 165                         $section_seen{$section} = 1;
 166                         push @section_order, $section;
 167                 }
 168
 169                 my $cur = $rv{$k};
 170                 if (defined $cur) {
 171                         if (ref($cur) eq "ARRAY") {
 172                                 push @$cur, $v;
 173                         } else {
 174                                 $rv{$k} = [ $cur, $v ];
 175                         }
 176                 } else {
 177                         $rv{$k} = $v;
 178                 }
 179         }
 180         close $fh or die "failed to close ($cmd) pipe: $?";
 181         $rv{-section_order} = \@section_order;
 182
 183         \%rv;
 184 }
 185
 186 sub valid_inbox_name ($) {
 187         my ($name) = @_;
 188
 189         # Similar rules found in git.git/remote.c::valid_remote_nick
 190         # and git.git/refs.c::check_refname_component
 191         # We don't reject /\.lock\z/, however, since we don't lock refs
 192         if ($name eq '' || $name =~ /\@\{/ ||
 193             $name =~ /\.\./ || $name =~ m![/:\?\[\]\^~\s\f[:cntrl:]\*]! ||
 194             $name =~ /\A\./ || $name =~ /\.\z/) {
 195                 return 0;
 196         }
 197
 198         # Note: we allow URL-unfriendly characters; users may configure
 199         # non-HTTP-accessible inboxes
 200         1;
 201 }
 202
 203 # XXX needs testing for cgit compatibility
 204 # cf. cgit/scan-tree.c::add_repo
 205 sub cgit_repo_merge ($$$) {
 206         my ($self, $base, $repo) = @_;
 207         my $path = $repo->{dir};
 208         if (defined(my $se = $self->{-cgit_strict_export})) {
 209                 return unless -e "$path/$se";
 210         }
 211         return if -e "$path/noweb";
 212         # $repo = { url => 'foo.git', dir => '/path/to/foo.git' }
 213         my $rel = $repo->{url};
 214         unless (defined $rel) {
 215                 my $off = index($path, $base, 0);
 216                 if ($off != 0) {
 217                         $rel = $path;
 218                 } else {
 219                         $rel = substr($path, length($base) + 1);
 220                 }
 221
 222                 $rel =~ s!/\.git\z!! or
 223                         $rel =~ s!/+\z!!;
 224
 225                 $self->{-cgit_remove_suffix} and
 226                         $rel =~ s!/?\.git\z!!;
 227         }
 228         $self->{"coderepo.$rel.dir"} ||= $path;
 229         $self->{"coderepo.$rel.cgiturl"} ||= $rel;
 230 }
 231
 232 sub is_git_dir ($) {
 233         my ($git_dir) = @_;
 234         -d "$git_dir/objects" && -f "$git_dir/HEAD";
 235 }
 236
 237 # XXX needs testing for cgit compatibility
 238 sub scan_path_coderepo {
 239         my ($self, $base, $path) = @_;
 240         opendir(my $dh, $path) or do {
 241                 warn "error opening directory: $path\n";
 242                 return
 243         };
 244         my $git_dir = $path;
 245         if (is_git_dir($git_dir) || is_git_dir($git_dir .= '/.git')) {
 246                 my $repo = { dir => $git_dir };
 247                 cgit_repo_merge($self, $base, $repo);
 248                 return;
 249         }
 250         while (defined(my $dn = readdir $dh)) {
 251                 next if $dn eq '.' || $dn eq '..';
 252                 if (index($dn, '.') == 0 && !$self->{-cgit_scan_hidden_path}) {
 253                         next;
 254                 }
 255                 my $dir = "$path/$dn";
 256                 scan_path_coderepo($self, $base, $dir) if -d $dir;
 257         }
 258 }
 259
 260 sub scan_tree_coderepo ($$) {
 261         my ($self, $path) = @_;
 262         scan_path_coderepo($self, $path, $path);
 263 }
 264
 265 sub scan_projects_coderepo ($$$) {
 266         my ($self, $list, $path) = @_;
 267         open my $fh, '<', $list or do {
 268                 warn "failed to open cgit projectlist=$list: $!\n";
 269                 return;
 270         };
 271         foreach (<$fh>) {
 272                 chomp;
 273                 scan_path_coderepo($self, $path, "$path/$_");
 274         }
 275 }
 276
 277 sub parse_cgitrc {
 278         my ($self, $cgitrc, $nesting) = @_;
 279         if ($nesting == 0) {
 280                 # defaults:
 281                 my %s = map { $_ => 1 } qw(/cgit.css /cgit.png
 282                                                 /favicon.ico /robots.txt);
 283                 $self->{-cgit_static} = \%s;
 284         }
 285
 286         # same limit as cgit/configfile.c::parse_configfile
 287         return if $nesting > 8;
 288
 289         open my $fh, '<', $cgitrc or do {
 290                 warn "failed to open cgitrc=$cgitrc: $!\n";
 291                 return;
 292         };
 293
 294         # FIXME: this doesn't support macro expansion via $VARS, yet
 295         my $repo;
 296         foreach (<$fh>) {
 297                 chomp;
 298                 if (m!\Arepo\.url=(.+?)/*\z!) {
 299                         my $nick = $1;
 300                         cgit_repo_merge($self, $repo->{dir}, $repo) if $repo;
 301                         $repo = { url => $nick };
 302                 } elsif (m!\Arepo\.path=(.+)\z!) {
 303                         if (defined $repo) {
 304                                 $repo->{dir} = $1;
 305                         } else {
 306                                 warn "$_ without repo.url\n";
 307                         }
 308                 } elsif (m!\Ainclude=(.+)\z!) {
 309                         parse_cgitrc($self, $1, $nesting + 1);
 310                 } elsif (m!\A(scan-hidden-path|remove-suffix)=(\d+)\z!) {
 311                         my ($k, $v) = ($1, $2);
 312                         $k =~ tr/-/_/;
 313                         $self->{"-cgit_$k"} = $v;
 314                 } elsif (m!\A(project-list|strict-export)=(.+)\z!) {
 315                         my ($k, $v) = ($1, $2);
 316                         $k =~ tr/-/_/;
 317                         $self->{"-cgit_$k"} = $v;
 318                 } elsif (m!\Ascan-path=(.+)\z!) {
 319                         if (defined(my $list = $self->{-cgit_project_list})) {
 320                                 scan_projects_coderepo($self, $list, $1);
 321                         } else {
 322                                 scan_tree_coderepo($self, $1);
 323                         }
 324                 } elsif (m!\A(?:css|favicon|logo|repo\.logo)=(/.+)\z!) {
 325                         # absolute paths for static files via PublicInbox::Cgit
 326                         $self->{-cgit_static}->{$1} = 1;
 327                 }
 328         }
 329         cgit_repo_merge($self, $repo->{dir}, $repo) if $repo;
 330 }
 331
 332 # parse a code repo
 333 # Only git is supported at the moment, but SVN and Hg are possibilities
 334 sub _fill_code_repo {
 335         my ($self, $nick) = @_;
 336         my $pfx = "coderepo.$nick";
 337
 338         # TODO: support gitweb and other repository viewers?
 339         if (defined(my $cgitrc = delete $self->{-cgitrc_unparsed})) {
 340                 parse_cgitrc($self, $cgitrc, 0);
 341         }
 342         my $dir = $self->{"$pfx.dir"}; # aka "GIT_DIR"
 343         unless (defined $dir) {
 344                 warn "$pfx.dir unset\n";
 345                 return;
 346         }
 347
 348         my $git = PublicInbox::Git->new($dir);
 349         foreach my $t (qw(blob commit tree tag)) {
 350                 $git->{$t.'_url_format'} =
 351                                 _array($self->{lc("$pfx.${t}UrlFormat")});
 352         }
 353
 354         if (my $cgits = $self->{lc("$pfx.cgitUrl")}) {
 355                 $git->{cgit_url} = $cgits = _array($cgits);
 356
 357                 # cgit supports "/blob/?id=%s", but it's only a plain-text
 358                 # display and requires an unabbreviated id=
 359                 foreach my $t (qw(blob commit tag)) {
 360                         $git->{$t.'_url_format'} ||= map {
 361                                 "$_/$t/?id=%s"
 362                         } @$cgits;
 363                 }
 364         }
 365
 366         $git;
 367 }
 368
 369 sub _fill {
 370         my ($self, $pfx) = @_;
 371         my $rv = {};
 372
 373         foreach my $k (qw(mainrepo filter url newsgroup
 374                         infourl watch watchheader httpbackendmax
 375                         replyto feedmax nntpserver indexlevel)) {
 376                 my $v = $self->{"$pfx.$k"};
 377                 $rv->{$k} = $v if defined $v;
 378         }
 379         foreach my $k (qw(obfuscate)) {
 380                 my $v = $self->{"$pfx.$k"};
 381                 defined $v or next;
 382                 if ($v =~ /\A(?:false|no|off|0)\z/) {
 383                         $rv->{$k} = 0;
 384                 } elsif ($v =~ /\A(?:true|yes|on|1)\z/) {
 385                         $rv->{$k} = 1;
 386                 } else {
 387                         warn "Ignoring $pfx.$k=$v in config, not boolean\n";
 388                 }
 389         }
 390         # TODO: more arrays, we should support multi-value for
 391         # more things to encourage decentralization
 392         foreach my $k (qw(address altid nntpmirror coderepo)) {
 393                 if (defined(my $v = $self->{"$pfx.$k"})) {
 394                         $rv->{$k} = _array($v);
 395                 }
 396         }
 397
 398         return unless $rv->{mainrepo};
 399         my $name = $pfx;
 400         $name =~ s/\Apublicinbox\.//;
 401
 402         if (!valid_inbox_name($name)) {
 403                 warn "invalid inbox name: '$name'\n";
 404                 return;
 405         }
 406
 407         $rv->{name} = $name;
 408         $rv->{-pi_config} = $self;
 409         $rv = PublicInbox::Inbox->new($rv);
 410         foreach (@{$rv->{address}}) {
 411                 my $lc_addr = lc($_);
 412                 $self->{-by_addr}->{$lc_addr} = $rv;
 413                 $self->{-no_obfuscate}->{$lc_addr} = 1;
 414         }
 415         if (my $ng = $rv->{newsgroup}) {
 416                 $self->{-by_newsgroup}->{$ng} = $rv;
 417         }
 418         $self->{-by_name}->{$name} = $rv;
 419         if ($rv->{obfuscate}) {
 420                 $rv->{-no_obfuscate} = $self->{-no_obfuscate};
 421                 $rv->{-no_obfuscate_re} = $self->{-no_obfuscate_re};
 422                 each_inbox($self, sub {}); # noop to populate -no_obfuscate
 423         }
 424
 425         if (my $ibx_code_repos = $rv->{coderepo}) {
 426                 my $code_repos = $self->{-code_repos};
 427                 my $repo_objs = $rv->{-repo_objs} = [];
 428                 foreach my $nick (@$ibx_code_repos) {
 429                         my @parts = split(m!/!, $nick);
 430                         my $valid = 0;
 431                         $valid += valid_inbox_name($_) foreach (@parts);
 432                         $valid == scalar(@parts) or next;
 433
 434                         my $repo = $code_repos->{$nick} ||=
 435                                                 _fill_code_repo($self, $nick);
 436                         push @$repo_objs, $repo if $repo;
 437                 }
 438         }
 439
 440         $rv
 441 }
 442
 443 1;