sync-accounts/sync-accounts

   1 #!/usr/bin/perl
   2 # This is part of sync-accounts, a tool for synchronising UN*X password data.
   3 #
   4 # sync-accounts is
   5 #  Copyright 1999-2000,2002 Ian Jackson <ian@davenant.greenend.org.uk>
   6 #  Copyright 2000-2001 nCipher Corporation Ltd
   7 #
   8 #  sync-accounts is free software; you can redistribute it and/or
   9 #  modify it under the terms of the GNU General Public License as
  10 #  published by the Free Software Foundation; either version 2, or (at
  11 #  your option) any later version.
  12 #
  13 #  sync-accounts is distributed in the hope that it will be useful,
  14 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 #  General Public License for more details.
  17 #
  18 #  You should already have a copy of the GNU General Public License.
  19 #  If not, write to the Free Software Foundation, Inc., 59 Temple
  20 #  Place - Suite 330, Boston, MA 02111-1307, USA.
  21 #
  22 # $Id: sync-accounts,v 1.22 2002-07-14 22:21:29 ianmdlvl Exp $
  23
  24 use POSIX;
  25
  26 $configfile= '/etc/sync-accounts';
  27 $def_createuser= 'sync-accounts-createuser';
  28 $ch_homebase= '/home';
  29 $ch_defaultshell= '/bin/sh';
  30 $defaultgid= -1; # -1 => usergroups; -2 => nousergroups
  31 @groupglobs= [ '.*', 0 ];
  32 regroupglobs();
  33
  34 $file{'passwd','std'}= 'passwd';
  35 $file{'shadow','std'}= 'shadow';
  36 $file{'group','std'}= 'group';
  37
  38 $file{'passwd','bsd'}= 'master.passwd';
  39 $file{'shadow','bsd'}= 'shadow-non-existent';
  40 $file{'group','bsd'}= 'group';
  41
  42 @fields_pw_std= qw(USER PW UID GID COMMENT HOME SHELL);
  43 @fields_pw_bsd= qw(USER PW UID GID CLASS CHANGE EXPIRE COMMENT HOME SHELL);
  44 fields_fmt('PW','std');
  45 fields('GR',qw(GROUP PW GID USERS));
  46 fields('SP',qw(USER PW DAYSCHGD DAYSFIX DAYSEXP DAYSWARN DAYSEXPDIS DAYSDISD RESERVED));
  47 # The name field had better always be field 0 !
  48
  49 END {
  50     foreach $x (@unlocks) {
  51         ($fn, $style, $arg) = @$x;
  52         &{ "unlock_$style" } ( $fn,$arg );
  53     }
  54 }
  55
  56 sub fields {
  57     my ($pfx,@l) = @_;
  58     my ($i, $v, $vn);
  59     foreach $v (@l) { $vn= "${pfx}_$v"; $$vn = $i++; }
  60     $vn= "${pfx}_fields"; $$vn= $i;
  61 }
  62
  63 sub fields_fmt ($$) {
  64     my ($pfx,$fmt) = @_;
  65     my ($vn);
  66     $vn= "fields_pw_$fmt";
  67     die "unknown format $fmt\n" unless defined @$vn;
  68     fields($pfx,@$vn);
  69     $vn= "${pfx}_format";
  70     $$vn= $fmt;
  71 }
  72
  73 sub newentry {
  74     my ($pfx,$name,@field_val_list) = @_;
  75     my (@rv, $vn, $fn, $v, $i);
  76     @rv= ();
  77     $vn= "${pfx}_fields";
  78     for ($i=0; $i<$$vn; $i++) { $rv[$i]= ''; }
  79     die "@field_val_list ?" if @field_val_list % 2;
  80     $rv[0] = $name;
  81     while (@field_val_list) {
  82         ($fn,$v,@field_val_list) = @field_val_list;
  83         $vn= "${pfx}_$fn";
  84 #print STDERR ">$fn|$v|$vn|$$vn<\n";
  85         $rv[$$vn]= $v;
  86     }
  87     return @rv;
  88 }
  89
  90 $|=1;
  91 $cdays= int(time/86400);
  92
  93 @envs_createuser= qw(USER UID GID COMMENT HOME SHELL);
  94
  95 if (@ARGV == 1 && length $ENV{'SYNC_ACCOUNTS_RUNVIA_INFO'}) {
  96     @na= map {
  97         s/\%([0-9a-f][0-9a-f])/ pack("C", hex $1) /ge;
  98         $_;
  99     } split(/\:/, $ENV{'SYNC_ACCOUNTS_RUNVIA_INFO'});
 100     delete $ENV{'SYNC_ACCOUNTS_RUNVIA_INFO'};
 101     $ta= shift @na;
 102     $ENV{"SYNC_ACCOUNTS_RUNVIA_LOCKEDGOT_$ta"} = $ARGV[0];
 103     @ARGV= @na;
 104 }
 105
 106 @orgargv= @ARGV;
 107
 108 while ($ARGV[0] =~ m/^-/) {
 109     $_= shift @ARGV;
 110     last if m/^--$/;
 111     if (m/^-C/) {
 112         $configfile= $';
 113     } elsif (m/^-n$/) {
 114         $no_act= 1;
 115         $display= 0;
 116     } elsif (m/^-q$/) {
 117         $no_act= 1;
 118         $display= 1;
 119     } else {
 120         die "unknown option $_\n";
 121     }
 122 }
 123
 124 die "hosts must not be specified with -q\n" if @ARGV && $display;
 125
 126 for $h (@ARGV) { $wanthost{$h}= 1; }
 127
 128 open CF,"< $configfile" or die "$configfile: $!";
 129
 130 sub fetchfile (\%$) {
 131     my ($ary_ref,$get_str) = @_;
 132
 133     undef %$ary_ref;
 134     open G,"$get_str" or die "$get_str: $!";
 135     while (<G>) {
 136         chomp;
 137         m/^([^:]+)\:/ or die "$ch_name: $get_str:$.: $_ ?\n";
 138         $ary_ref->{$1}= [ split(/\:/,$_,-1) ];
 139     }
 140     close G; $? and die "$ch_name: $get_str: exit code $?\n";
 141 }
 142
 143 sub lockstyle_ ($$) {
 144     my ($fn,$lock) = @_;
 145
 146     die "$configfile:$.: locking mechanism for $fn not".
 147         " defined (use lockpasswd/lockgroup)\n";
 148 }
 149
 150 sub abslock (@) {
 151     my ($fn,$lock) = @_;
 152
 153     $fn= "/etc/$fn";
 154     $lock= "$fn$lock" unless $lock =~ m,^/,;
 155     return ($fn,$lock);
 156 }
 157
 158 sub lock_none ($$) { return (abslock(@_))[0]; }
 159 sub unlock_none ($$) { }
 160
 161 sub lock_link ($$) {
 162     my ($fn,$lock) = abslock(@_);
 163     link $fn,$lock or die "cannot lock $fn by creating $lock: $!\n";
 164     return $fn;
 165 }
 166 sub unlock_link ($$) {
 167     my ($fn,$lock) = abslock(@_);
 168     unlink $lock or warn "unable to unlock by removing $lock: $!\n";
 169 }
 170
 171 sub lock_runvia ($$) {
 172     my ($fn,$lock) = @_;
 173     my ($evn);
 174     $evn= "SYNC_ACCOUNTS_RUNVIA_LOCKEDGOT_$fn";
 175     return $ENV{$evn} if exists $ENV{$evn};
 176
 177     @na= map {
 178         s/\W/ sprintf("%%%02x", unpack("C", $&)) /ge;
 179         $_;
 180     } ($fn,@orgargv);
 181     $ENV{'SYNC_ACCOUNTS_RUNVIA_INFO'}= join(":", @na);
 182     $ENV{'EDITOR'}= $0;
 183     delete $ENV{'VISUAL'};
 184     exec $lock; die "cannot lock $fn by executing $lock: $!\n";
 185 }
 186 sub unlock_runvia ($$) { }
 187
 188 sub fetchownfile (\@$$$$) {
 189     my ($ary_ref,$fn_str,$nfields,$style,$lock_arg) = @_;
 190     my ($fn_use, $record, $fn_emsg);
 191     $fn_emsg= $fn_str;
 192     if (!$no_act) {
 193         $fn_use= &{ "lock_$style" } ($fn_str, $lock_arg);
 194         push @unlocks, [ $fn_str, $style, $lock_arg ];
 195         $savebackto{$fn_str}= $fn_use;
 196     } else {
 197         $fn_use= $fn_emsg= "/etc/".$file{$fn_str,$PW_format};
 198     }
 199     open O,"$fn_use" or die "$fn_use ($fn_str): $!";
 200     while (<O>) {
 201         chomp;
 202         if (m/^\#/ || !m/\S/) {
 203             $record= $_;
 204         } else {
 205             $record= [ split(/\:/,$_,-1) ];
 206             die "$fn_emsg:$.:wrong number of fields:\`$_'\n"
 207                 unless @$record == $nfields;
 208         }
 209         push @$ary_ref, $record;
 210     }
 211     close O or die "$fn_use ($fn_str): $!";
 212 }
 213
 214 sub diag ($) {
 215     print "$diagstr: $_[0]\n" or die $!;
 216 }
 217
 218 sub regroupglobs () {
 219     $nogroups= (@groupglobs == 1 &&
 220                 $groupglobs[0]->[0] eq '.*' &&
 221                 !$groupglobs[0]->[1]);
 222     $ggfunc= "sub wantsyncgroup {\n  \$_= \$_[0];\n  return\n";
 223     for $g (@groupglobs) { $ggfunc.= "    m/^$g->[0]\$/ ? $g->[1] :\n"; }
 224     $ggfunc.= "    die;\n};\n1;\n";
 225 #print STDERR "$ggfunc\n";
 226     eval $ggfunc or die "$ggfunc // $@";
 227 }
 228
 229 sub fetchown () {
 230     if (!$own_fetchedpasswd) {
 231 #print STDERR ">$PW_fields<\n";
 232         fetchownfile(@ownpasswd,'passwd',
 233                      $PW_fields, $ch_lockstyle_passwd, $ch_lock_passwd);
 234         $shadowfile= $file{'shadow',$PW_format};
 235         if (stat("/etc/$shadowfile")) {
 236             $own_haveshadow= 1;
 237             $own_fetchedshadow= 1;
 238             fetchownfile(@ownshadow,'shadow',$SP_fields,'none','');
 239         } elsif ($! == &ENOENT) {
 240             $own_haveshadow= 0;
 241         } else {
 242             die "unable to check for /etc/$shadowfile: $!\n";
 243         }
 244         $own_fetchedpasswd= 1;
 245     }
 246     if (!$own_fetchedgroup) {
 247         fetchownfile(@owngroup,'group',$GR_fields,
 248                      $ch_lockstyle_group, $ch_lock_group);
 249         $own_fetchedgroup= 1;
 250     }
 251 #print STDERR "fetchown() -> $#ownpasswd $#owngroup\n";
 252 }
 253
 254 sub checkuid ($$) {
 255     my ($useuid,$foruser) = @_;
 256     for $e (@ownpasswd) {
 257         next unless ref $e;
 258         if ($e->[$PW_USER] ne $foruser && $e->[$PW_UID] == $useuid) {
 259             diag("uid clash with $e->[$PW_USER] (uid $e->[$PW_UID])");
 260             return 0;
 261         }
 262     }
 263     return 1;
 264 }
 265
 266 sub copyfield ($$$$) {
 267     my ($file,$entry,$field,$value) = @_;
 268     eval "\$ary_ref= \\\@own$file; 1;" or die $@;
 269 #print STDERR "copyfield($file,$entry,$field,$value)\n";
 270     for $e (@$ary_ref) {
 271 #print STDERR "copyfield($file,$entry,$field,$value) $e->[0] $e->[field] ".join(':',@$e)."\n";
 272         next unless $e->[0] eq $entry;
 273         next if $e->[$field] eq $value;
 274         $e->[$field]= $value;
 275         eval "\$modified$file= 1; 1;" or die $@;
 276     }
 277 }
 278
 279 sub fetchpasswd () {
 280     return if $ch_fetchedpasswd;
 281     die "$configfile:$.: getpasswd not specified for host $ch_name\n"
 282         unless length $ch_getpasswd;
 283     undef %remshadow;
 284     fetchfile(%rempasswd,"$ch_getpasswd |");
 285     if (length $ch_getshadow) {
 286         fetchfile(%remshadow,"$ch_getshadow |");
 287         for $k (keys %rempasswd) {
 288             $rempasswd{$k}->[$REM_PW]= 'xx' unless length $rempasswd{$k}->[$REM_PW];
 289         }
 290         for $k (keys %remshadow) {
 291             next unless exists $rempasswd{$k};
 292             $rempasswd{$k}->[$REM_PW]= $remshadow{$k}->[$SP_PW];
 293         }
 294     }
 295     $ch_fetchedpasswd= 1;
 296 }
 297
 298 sub fetchgroup () {
 299     return if $ch_fetchedgroup;
 300     die "$configfile:$.: getgroup not specified for host $ch_name\n"
 301         unless length $ch_getgroup;
 302     fetchfile(%remgroup,"$ch_getgroup |");
 303     $ch_fetchedgroup= 1;
 304 }
 305
 306 sub syncusergroup ($$) {
 307     my ($lu,$luid) = @_;
 308
 309     return 1 if $defaultgid != -1;
 310 #print STDERR "syncusergroup($lu,$luid)\n";
 311     $ugfound=0;
 312
 313     for $e (@owngroup) {
 314         next unless ref $e;
 315         $samename= $e->[$GR_GROUP] eq $lu;
 316         $sameid= $e->[$GR_GID] eq $luid;
 317         next unless $samename || $sameid;
 318         if (!$samename || !$sameid) {
 319             diag("local group $e->[$GR_GROUP] ($e->[$GR_GID]) mismatch vs.".
 320                  " local user $lu ($luid)");
 321             return 0;
 322         }
 323         if ($ugfound) {
 324             diag("per-user group $lu ($luid) duplicated");
 325             return 0;
 326         }
 327         $ugfound=1;
 328     }
 329
 330     return 1 if $ugfound;
 331
 332     if (!length $opt_createuser) {
 333         diag("account creation not enabled, not creating per-user group");
 334         return 0;
 335     }
 336     push @owngroup, [ newentry('GR', $lu,
 337                                'PW', 'x',
 338                                'GID', $luid) ];
 339     $modifiedgroup= 1;
 340     return 1;
 341 }
 342
 343 sub hosthead ($) {
 344     my ($th) = @_;
 345     return if $hostheaddone eq $th;
 346     print "\n\n" or die $! if length $hostheaddone;
 347     print "==== $th ====\n" or die $!;
 348     $hostheaddone= $th;
 349 }
 350
 351 sub syncuser ($$) {
 352     my ($lu,$ru) = @_;
 353     my ($vn);
 354
 355 #print STDERR "syncuser($lu,$ru)\n";
 356     return if $doneuser{$lu}++;
 357     next unless $ch_doinghost;
 358     return if !length $ru;
 359
 360     fetchown();
 361
 362     if ($display) {
 363         for $e (@ownpasswd) {
 364             next unless ref $e && $e->[$PW_USER] eq $lu;
 365             hosthead("from $ch_name");
 366             print ($lu eq $ru ? " $lu" : " $lu($ru)") or die $!;
 367             print "<DUPLICATE>" if $displaydone{$lu}++;
 368         }
 369         return;
 370     }
 371
 372     $diagstr= "user $lu from $ch_name!$ru";
 373
 374 #print STDERR "syncuser($lu,$ru) doing\n";
 375     fetchpasswd();
 376
 377     if (!$rempasswd{$ru}) { diag("no remote entry"); return; }
 378     if (length $ch_getshadow && exists $remshadow{$ru} &&
 379         length $remshadow{$ru}->[$SP_DAYSDISD]) {
 380         diag("remote account disabled in shadow");
 381         return;
 382     }
 383
 384     if (!grep(ref $_ && $_->[$PW_USER] eq $lu, @ownpasswd)) {
 385         if (!length $opt_createuser) { diag("account creation not enabled"); return; }
 386         if ($no_act) { diag("-n specified; not creating account"); return; }
 387
 388         if ($opt_sameuid) {
 389             $useuid= $rempasswd{$ru}->[$REM_UID];
 390             $usegid= $rempasswd{$ru}->[$REM_GID];
 391         } else {
 392             die "nousergroups specified, cannot create users\n" if $defaultgid==-2;
 393             length $ch_uidmin or die "no uidmin specified, cannot create users\n";
 394             length $ch_uidmax or die "no uidmax specified, cannot create users\n";
 395             $ch_uidmin<$ch_uidmax or die "uidmin>=uidmax, cannot create users\n";
 396
 397             $useuid= $ch_uidmin;
 398             for $e ($defaultgid==-1 ? (@ownpasswd, @owngroup) : (@ownpasswd)) {
 399                 next unless ref $e;
 400                 $tuid= $e->[$PW_UID]; next if $tuid<$useuid || $tuid>$ch_uidmax;
 401                 if ($tuid==$ch_uidmax) {
 402                     diag("uid (or gid?) $ch_uidmax used, cannot create users");
 403                     return;
 404                 }
 405                 $useuid= $tuid+1;
 406             }
 407             $usegid= $defaultgid==-1 ? $useuid : $defaultgid;
 408         }
 409
 410         @newpwent= newentry('PW', $lu,
 411                             'PW', 'x',
 412                             'UID', $useuid,
 413                             'GID', $usegid,
 414                             'COMMENT', $rempasswd{$ru}->[$REM_COMMENT],
 415                             'HOME', "$ch_homebase/$lu",
 416                             'SHELL', $ch_defaultshell);
 417
 418         defined($c= open CU,"-|") or die $!;
 419         if (!$c) {
 420             @unlocks= ();
 421             defined($c2= open STDIN,"-|") or die $!;
 422             if (!$c2) {
 423                 print STDOUT join(':',@newpwent),"\n" or die $!;
 424                 exit 0;
 425             }
 426             for ($i=0; $i<@envs_createuser; $i++) {
 427                 $vn= "PW_$envs_createuser[$i]";
 428 #print STDERR ">$i|$vn|$$vn|$newpwent[$$vn]<\n";
 429                 $ENV{"SYNCUSER_CREATE_$envs_createuser[$i]"}= $newpwent[$$vn];
 430             }
 431             exec $opt_createuser; die "$configfile:$.: ($lu): $opt_createuser: $!\n";
 432         }
 433         $newpwent= <CU>;
 434         close CU; $? and die "$configfile:$.: ($lu): $opt_createuser: code $?\n";
 435         chomp $newpwent;
 436         if (length $newpwent) {
 437             if ($newpwent !~ m/\:/) { diag("creation script demurred"); return; }
 438             @newpwent= split(/\:/,$newpwent,-1);
 439         }
 440         die "$opt_createuser: bad result: \`".join(':',@newpwent)."\'\n"
 441             if @newpwent != $PW_fields or $newpwent[$PW_USER] ne $lu;
 442         checkuid($newpwent[$PW_UID],$lu) or return;
 443         if ($own_haveshadow) {
 444             push @ownshadow, [ newentry('SP', $lu,
 445                                         'PW', 'x',
 446                                         'DAYSCHGD', $cdays,
 447                                         'DAYSFIX', 0,
 448                                         'DAYSEXP', 99999,
 449                                         'DAYSEXPDIS', 7) ];
 450             $modifiedshadow= 1;
 451         }
 452         syncusergroup($lu,$newpwent[$PW_UID]) or return;
 453         push @ownpasswd,[ @newpwent ];
 454         $modifiedpasswd= 1;
 455     }
 456
 457     for $e (@ownpasswd) {
 458         next unless ref $e && $e->[$PW_USER] eq $lu;
 459         syncusergroup($lu,$e->[$PW_UID]) or return;
 460     }
 461
 462     $ruid= $rempasswd{$ru}->[$REM_UID];
 463     $rgid= $rempasswd{$ru}->[$REM_GID];
 464     if ($opt_sameuid && checkuid($ruid,$lu)) {
 465         for $e (@ownpasswd) {
 466             next unless ref $e && $e->[$PW_USER] eq $lu;
 467             $luid= $e->[$PW_UID]; $lgid= $e->[$PW_GID];
 468             die "$diagstr: local uid $luid, remote uid $ruid\n" if $luid ne $ruid;
 469             die "$diagstr: local gid $lgid, remote gid $rgid\n" if $lgid ne $rgid;
 470         }
 471     }
 472
 473 #print STDERR "syncuser($lu,$ru) exists $own_haveshadow\n";
 474     if ($own_haveshadow && grep(ref $_ && $_->[$PW_USER] eq $lu, @ownshadow)) {
 475 #print STDERR "syncuser($lu,$ru) shadow $rempasswd{$ru}->[$REM_PW]\n";
 476         copyfield('shadow',$lu,$SP_PW, $rempasswd{$ru}->[$REM_PW]);
 477     } else {
 478 #print STDERR "syncuser($lu,$ru) passwd $rempasswd{$ru}->[$REM_PW]\n";
 479         copyfield('passwd',$lu,$PW_PW, $rempasswd{$ru}->[$REM_PW]);
 480     }
 481     copyfield('passwd',$lu,$PW_COMMENT, $rempasswd{$ru}->[$REM_COMMENT]);
 482
 483     $newsh= $rempasswd{$ru}->[$REM_SHELL];
 484     $oksh= $checkedshell{$newsh};
 485     if (!length $oksh) { $checkedshell{$newsh}= $oksh= (-x $newsh) ? 1 : 0; }
 486     copyfield('passwd',$lu,$PW_SHELL, $newsh) if $oksh;
 487
 488     if (!$nogroups) {
 489         for $e (@owngroup) {
 490             next unless ref $e;
 491             $tgroup= $e->[$GR_GROUP];
 492 #print STDERR "syncuser($lu,$ru) group $tgroup\n";
 493             next unless &wantsyncgroup($tgroup);
 494 #print STDERR "syncuser($lu,$ru) group $tgroup yes\n";
 495             fetchgroup();
 496             if (!exists $remgroup{$tgroup}) {
 497                 diag("group $tgroup: not on remote host");
 498                 next;
 499             }
 500             $inremote= grep($_ eq $ru, split(/\,/,$remgroup{$tgroup}->[$GR_USERS]));
 501             $cusers= $e->[$GR_USERS]; $inlocal= grep($_ eq $lu, split(/\,/,$cusers));
 502             if ($inremote && !$inlocal) {
 503                 $cusers.= ',' if length $cusers;
 504                 $cusers.= $lu;
 505             } elsif ($inlocal && !$inremote) {
 506                 $cusers= join(',', grep($_ ne $lu, split(/\,/, $cusers)));
 507             } else {
 508                 next;
 509             }
 510             $e->[$GR_USERS]= $cusers;
 511             $modifiedgroup= 1;
 512         }
 513     }
 514 }
 515
 516 sub banner () {
 517     return if $bannerdone;
 518     print "\n" or die $!; system 'date'; $? and die $?;
 519     $bannerdone= 1;
 520 }
 521
 522 sub finish () {
 523     my ($record);
 524
 525     for $h (keys %wanthost) {
 526         die "host $h not in config file\n" if $wanthost{$h};
 527     }
 528
 529     if ($display) {
 530 #print STDERR "\n\nfinish display=$display pw=$pw\n\n";
 531         for $e (@ownpasswd) {
 532             next unless ref $e;
 533             $tu= $e->[$PW_USER];
 534             $tuid= $e->[$PW_UID];
 535             next if $displaydone{$tu};
 536             $tpw= $e->[$PW_PW];
 537 #print STDERR ">$tu|$tpw<\n";
 538             for $e2 (@ownshadow) {
 539                 next unless ref $e2 && $e2->[$SP_USER] eq $tu;
 540                 $tpw= $e2->[$SP_PW]; last;
 541             }
 542             $tpw= length($tpw)>=13 ? 1 : length($tpw) ? -1 : 0;
 543             $head= ($tpw == 1 ? "unsynched" :
 544                     $tpw == 0 ? "unsynched, passwordless" :
 545                     "unsynched, no-logins").
 546                     ($tuid < 100 ? " system account" : " normal user");
 547             $unsynch_type{$head} .= " $e->[$PW_USER]";
 548         }
 549         foreach $head (sort keys %unsynch_type) {
 550             hosthead($head);
 551             print $unsynch_type{$head} or die $!;
 552         }
 553         print "\n\n" or die $!;
 554         exit 0;
 555     }
 556
 557     umask 077;
 558     for $file (qw(passwd shadow group)) {
 559         $realfile= $file{$file,$PW_format};
 560         eval "\$modified= \$modified$file; \$data_ref= \\\@own$file;".
 561             " \$fetched= \$own_fetched$file; 1;" or die $@;
 562         next if !$modified;
 563         die $file unless $fetched;
 564         banner();
 565         if ($no_act) {
 566             $newfileinst= "/etc/$realfile";
 567             $newfile= "$realfile.new";
 568         } else {
 569             $newfileinst= $savebackto{$file};
 570             $newfile= "$newfileinst.new";
 571         }
 572         open NF,"> $newfile" or die "$newfile: $!";
 573         for $e (@$data_ref) {
 574             $record= ref $e ? join(':',@$e) : $e;
 575             print NF $record,"\n" or die $!;
 576         }
 577         close NF or die $!;
 578         system 'diff','-U0','--label',$realfile,$newfileinst,
 579                             '--label',"$realfile.new",$newfile;
 580         $?==256 or die $?;
 581         if (!$no_act) {
 582             (@stats= stat $newfileinst) or die "$file: $!";
 583             chown $stats[4],$stats[5], $newfile or die $!;
 584             chmod $stats[2] & 07777, $newfile or die $!;
 585             rename $newfile, $newfileinst or die $!;
 586         }
 587     }
 588     exit 0;
 589 }
 590
 591 while (<CF>) {
 592     chomp;
 593     s/^\s*//; s/\s*$//;
 594     next if m/^\#/ || !m/\S/;
 595     finish() if m/^end$/;
 596     if (m/^host\s+(\S+)$/) {
 597         $ch_name= $1;
 598         $ch_getpasswd= $ch_getgroup= $ch_getshadow= '';
 599         $ch_fetchedpasswd= $ch_fetchedgroup;
 600         if (!@ARGV) {
 601             $ch_doinghost= 1;
 602         } elsif (exists $wanthost{$ch_name}) {
 603             $wanthost{$ch_name}= 0;
 604             $ch_doinghost= 1;
 605         } else {
 606             $ch_doinghost= 0;
 607         }
 608         fields_fmt('REM','std');
 609     } elsif (m/^(getpasswd|getshadow|getgroup)\s+(.*\S)$/) {
 610         eval "\$ch_$1= \$2; 1;" or die $@;
 611     } elsif (m/^(local|remote)format\s+(\w+)$/) {
 612         fields_fmt($1 eq 'local' ? 'PW' :
 613                    $1 eq 'remote' ? 'REM' : die,
 614                    $2);
 615     } elsif (m/^lock(passwd|group)\s+(runvia|link)\s+(\S+)$/) {
 616         eval "\$ch_lock_$1= \$3; \$ch_lockstyle_$1= \$2; 1;" or die $@;
 617     } elsif (m/^lock(passwd|group)\s+(none)$/) {
 618         eval "\$ch_lockstyle_$1= \$2; 1;" or die $@;
 619     } elsif (m,^(homebase|defaultshell)\s+(/\S+)$,) {
 620         eval "\$ch_$1= \$2; 1;" or die $@;
 621     } elsif (m/^(uidmin|uidmax)\s+(\d+)$/ && $2>0) {
 622         eval "\$ch_$1= \$2; 1;" or die $@;
 623     } elsif (m/^createuser$/) {
 624         $opt_createuser= $def_createuser;
 625     } elsif (m/^nocreateuser$/) {
 626         $opt_createuser= '';
 627     } elsif (m/^createuser\s+(\S+)$/) {
 628         $opt_createuser= $1;
 629     } elsif (m/^logfile\s+(.*\S)$/) {
 630         if (!$no_act) {
 631             open STDOUT,">> $1" or die "$1: $!"; $|=1;
 632             $!=0; system 'date'; $? and die "date: $! $?\n";
 633         } elsif (!$display) {
 634             print "would log to $1\n" or die $!;
 635         }
 636     } elsif (m/^(no|)(sameuid)$/) {
 637         eval "\$opt_$2= ".($1 eq 'no' ? 0 : 1)."; 1;" or die $@;
 638     } elsif (m/^usergroups$/) {
 639         $defaultgid= -1;
 640     } elsif (m/^nousergroups$/) {
 641         $defaultgid= -2;
 642     } elsif (m/^defaultgid\s+(\d+)$/) {
 643         $defaultgid= $1;
 644     } elsif (m/^(no|)group\s+([-+.0-9a-zA-Z*?]+)$/) {
 645         $yes= $1 eq 'no' ? 0 : 1;
 646         $_= $2;
 647         @groupglobs=() if $_ eq '*';
 648         s/[-+._]/\\$1/g;
 649         s/\*/\.\*/g;
 650         s/\?/\./g;
 651         unshift @groupglobs, [ $_, $yes ];
 652         regroupglobs();
 653     } elsif (m/^user\s+(\S+)$/) {
 654         syncuser($1,$1);
 655     } elsif (m/^user\s+(\S+)\s+remote\=(\S+)$/) {
 656         syncuser($1,$2);
 657     } elsif (m/^nouser\s+(\S+)$/) {
 658         syncuser($1,'');
 659     } elsif (m/^users\s+(\d+)\-(\d+)$/) {
 660         $tmin= $1; $tmax= $2; $except= $3;
 661         fetchpasswd();
 662         for $k (keys %rempasswd) {
 663             $tuid= $rempasswd{$k}->[2];
 664             next if $tuid<$1 or $tuid>$2;
 665             syncuser($k,$k);
 666         }
 667     } elsif (m/^addhere$/) {
 668     } else {
 669         die "$configfile:$.: unknown directive\n";
 670     }
 671 }
 672
 673 die "$configfile:$.: missing \`end', or read error\n";