X-Git-Url: https://git.cameronkatri.com/pw-darwin.git/blobdiff_plain/2674e3fae7b77b35b625a6af27042bda8c15ee1f..283922b55988102d3f82f638919bb6d03004245d:/adduser/adduser.perl diff --git a/adduser/adduser.perl b/adduser/adduser.perl index 60e89e7..322bac6 100644 --- a/adduser/adduser.perl +++ b/adduser/adduser.perl @@ -1,6 +1,7 @@ #!/usr/bin/perl # -# (c) Copyright 1995 Wolfram Schneider. All rights reserved. +# Copyright (c) 1995-1996 Wolfram Schneider . Berlin. +# All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions @@ -10,474 +11,1319 @@ # 2. Redistributions in binary form must reproduce the above copyright # notice, this list of conditions and the following disclaimer in the # documentation and/or other materials provided with the distribution. -# 3. All advertising materials mentioning features or use of this software -# must display the following acknowledgement: -# This product includes software developed by Wolfram Schneider -# 4. The name of the author may not be used to endorse or promote products -# derived from this software without specific prior written permission # -# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR -# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES -# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. -# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, -# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT -# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF -# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# -# /usr/sbin/adduser - add new user(s) -# -# Bugs: sure (my english!) -# Email: Wolfram Schneider -# -# $Id: adduser,v 1.17 1995/01/02 00:08:43 w Exp w $ +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE +# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +# SUCH DAMAGE. # +# $FreeBSD$ + +# read variables sub variables { - $verbose = 1; - $batch = 0; # batch mode - $defaultpasswd = 0; - $dotdir = "/usr/share/skel"; - - if (1) { - $home = "/home"; - $shells = "/etc/shells"; - $passwd = "/etc/master.passwd"; + $verbose = 1; # verbose = [0-2] + $usernameregexp = "^[a-z0-9_][a-z0-9_-]*\$"; # configurable + $defaultusernameregexp = $usernameregexp; # remains constant + $defaultusepassword = "yes"; # use password authentication for new users + $defaultenableaccount = "yes"; # enable the account by default + $defaultemptypassword = "no"; # don't create an empty password + $dotdir = "/usr/share/skel"; # copy dotfiles from this dir + $dotdir_bak = $dotdir; + $send_message = "/etc/adduser.message"; # send message to new user + $send_message_bak = '/etc/adduser.message'; + $config = "/etc/adduser.conf"; # config file for adduser + $config_read = 1; # read config file + $logfile = "/var/log/adduser"; # logfile + $home = "/home"; # default HOME + $etc_shells = "/etc/shells"; + $etc_passwd = "/etc/master.passwd"; $group = "/etc/group"; - $pwd_mkdb = "pwd_mkdb -p"; - } else { - $home = "/home/w/tmp/adduser/home"; - $shells = "./shells"; - $passwd = "./master.passwd"; - $group = "./group"; - $pwd_mkdb = "pwd_mkdb -p -d ."; - } + @pwd_mkdb = qw(pwd_mkdb -p); # program for building passwd database + + # List of directories where shells located @path = ('/bin', '/usr/bin', '/usr/local/bin'); - @shellpref = ('bash', 'tcsh', 'ksh', 'csh', 'sh'); - $uid_start = 1000; # new users get this uid - $uid_end = 32000; + # common shells, first element has higher priority + @shellpref = ('csh', 'sh', 'bash', 'tcsh', 'ksh'); + + $defaultshell = 'sh'; # defaultshell if not empty + $group_uniq = 'USER'; + $defaultgroup = $group_uniq;# login groupname, $group_uniq means username + $defaultclass = ''; + + $uid_start = 1000; # new users get this uid + $uid_end = 32000; # max. uid # global variables - $username = ''; # $username{username} = uid - $uid = ''; # $uid{uid} = username - $pwgid = ''; # $pwgid{pwgid} = username; gid from passwd db - $groupname =''; # $groupname{groupname} = gid - $gid = ''; # $gid{gid} = groupname; gid form group db - $defaultshell = ''; + # passwd + $username = ''; # $username{username} = uid + $uid = ''; # $uid{uid} = username + $pwgid = ''; # $pwgid{pwgid} = username; gid from passwd db + + $password = ''; # password for new users + $usepassword = ''; # use password-based auth + $useemptypassword = ''; # use an empty password + $enableaccount = ''; # enable or disable account password at creation + + # group + $groupname =''; # $groupname{groupname} = gid + $groupmembers = ''; # $groupmembers{gid} = members of group/kommalist + $gid = ''; # $gid{gid} = groupname; gid form group db + @group_comments; # Comments in the group file + + # shell + $shell = ''; # $shell{`basename sh`} = sh + + umask 022; # don't give login group write access + + $ENV{'PATH'} = "/sbin:/bin:/usr/sbin:/usr/bin"; @passwd_backup = ''; + @group_backup = ''; + @message_buffer = ''; + @user_variable_list = ''; # user variables in /etc/adduser.conf + $do_not_delete = '## DO NOT DELETE THIS LINE!'; } -# read shell database -# See also: shells(5) +# read shell database, see also: shells(5) sub shells_read { - local($s, @dummy); - open(S, $shells) || die "$shells:$!\n"; + local($sh); + local($err) = 0; + + print "Check $etc_shells\n" if $verbose; + open(S, $etc_shells) || die "$etc_shells:$!\n"; + while() { - if (/^[ \t]*\//) { - ($s, @dummy) = split; - if (-x $s) { - $shell{&basename($s)} = $s; - } else { - warn "Shell: $s not executable!\n"; - } - } + if (/^\s*\//) { + s/^\s*//; s/\s+.*//; # chop + $sh = $_; + if (-x $sh) { + $shell{&basename($sh)} = $sh; + } else { + warn "Shell: $sh not executable!\n"; + $err++; + } + } } + + # Allow /nonexistent and /bin/date as a valid shell for system utils + push(@list, "/nonexistent"); + push(@shellpref, "no") if !grep(/^no$/, @shellpref); + $shell{"no"} = "/nonexistent"; + + push(@list, "/bin/date"); + push(@shellpref, "date") if !grep(/^date$/, @shellpref); + $shell{"date"} = "/bin/date"; + + return $err; } -# add new/local shells +# add new shells if possible sub shells_add { - local($e,$dir,@list); - foreach $e (@shellpref) { - if (!$shell{$e}) { - foreach $dir (@path) { - if (-x "$dir/$e") { - push(@list, "$dir/$e") if - &confirm_yn("Found shell: $dir/$e. Add to $shells?", "yes"); - } - } - } - } - if ($#list >= 0) { - foreach $e (@list) { - $shell{&basename($e)} = $e; - #print "$e\n"; - } - &append_file($shells, @list); + local($sh,$dir,@list); + + return 1 unless $verbose; + + foreach $sh (@shellpref) { + # all known shells + if (!$shell{$sh}) { + # shell $sh is not defined as login shell + foreach $dir (@path) { + if (-x "$dir/$sh") { + # found shell + if (&confirm_yn("Found shell: $dir/$sh. Add to $etc_shells?", "yes")) { + push(@list, "$dir/$sh"); + push(@shellpref, "$sh"); + $shell{&basename("$dir/$sh")} = "$dir/$sh"; + $changes++; + } + } + } + } } + &append_file($etc_shells, @list) if $#list >= 0; } -# choise your favourite shell -sub shells_pref { - local($e,$i,$s); +# choose your favourite shell and return the shell +sub shell_default { + local($e,$i,$new_shell); + local($sh); - $i = 0; - while($i < $#shellpref) { - last if $shell{$shellpref[$i]}; - $i++; + $sh = &shell_default_valid($defaultshell); + return $sh unless $verbose; + + $new_shell = &confirm_list("Enter your default shell:", 0, + $sh, sort(keys %shell)); + print "Your default shell is: $new_shell -> $shell{$new_shell}\n"; + $changes++ if $new_shell ne $sh; + return $new_shell; +} + +sub shell_default_valid { + local($sh) = @_; + local($s,$e); + + return $sh if $shell{$sh}; + + foreach $e (@shellpref) { + $s = $e; + last if defined($shell{$s}); } - $s = &confirm_list("Enter Your default shell:", 0, - $shellpref[$i], sort(keys %shell)); - print "Your default shell is: $s -> $shell{$s}\n" if $verbose; - $defaultshell = $s; + $s = "sh" unless $s; + warn "Shell ``$sh'' is undefined, use ``$s''\n"; + return $s; } -# return default home partition +# return default home partition (e.g. "/home") +# create base directory if nesseccary sub home_partition { - local($h); + local($home) = @_; + $home = &stripdir($home); + local($h) = $home; - $h = &confirm_list("Enter Your default HOME partition:", 1, $home, ""); - if (-e "$h") { - if (!(-d _ || -l $h)) { - warn "$h exist, but is it not a directory or symlink!\n"; - return &home_partition; - } - if (! -w _) { - warn "$h is not writable!\n"; - return &home_partition; - } - } else { - return &home_partition unless &mkdirhier($h); + return $h if !$verbose && $h eq &home_partition_valid($h); + + while(1) { + $h = &confirm_list("Enter your default HOME partition:", 1, $home, ""); + $h = &stripdir($h); + last if $h eq &home_partition_valid($h); } - - $home = $h; + + $changes++ if $h ne $home; return $h; } +sub home_partition_valid { + local($h) = @_; + + $h = &stripdir($h); + # all right (I hope) + return $h if $h =~ "^/" && -e $h && -w $h && (-d $h || -l $h); + + # Errors or todo + if ($h !~ "^/") { + warn "Please use absolute path for home: ``$h''.\a\n"; + return 0; + } + + if (-e $h) { + warn "$h exists, but is not a directory or symlink!\n" + unless -d $h || -l $h; + warn "$h is not writable!\n" + unless -w $h; + return 0; + } else { + # create home partition + return $h if &mkdir_home($h); + } + return 0; +} + # check for valid passwddb sub passwd_check { - print "Check $passwd\n" if $verbose > 0; - system("$pwd_mkdb $passwd"); - die "\nInvalid $passwd - cannot add any users!\n" if $?; + system(@pwd_mkdb, '-C', $etc_passwd); + die "\nInvalid $etc_passwd - cannot add any users!\n" if $?; } # read /etc/passwd sub passwd_read { - local($un, $pw, $ui, $gi); + local($p_username, $pw, $p_uid, $p_gid, $sh, %shlist); + + print "Check $etc_passwd\n" if $verbose; + open(P, "$etc_passwd") || die "$etc_passwd: $!\n"; - open(P, "$passwd") || die "$passwd: $!\n"; while(

) { - chop; - push(@passwd_backup, $_); - ($un, $pw, $ui, $gi) = (split(/:/, $_))[0..3]; - print "$un already exist with uid: $username{$un}!\n" - if $username{$un}; - $username{$un} = $ui; - print "User $un: uid $ui exist twice: $uid{$ui}\n" - if $uid{$ui} && $verbose; - $uid{$ui} = $un; - $pwgid{$gi} = $un; + chop; + push(@passwd_backup, $_); + # ignore comments + next if /^\s*$/; + next if /^\s*#/; + + ($p_username, $pw, $p_uid, $p_gid, $sh) = (split(/:/, $_))[0..3,9]; + + print "$p_username already exists with uid: $username{$p_username}!\n" + if $username{$p_username} && $verbose; + $username{$p_username} = $p_uid; + print "User $p_username: uid $p_uid exists twice: $uid{$p_uid}\n" + if $uid{$p_uid} && $verbose && $p_uid; # don't warn for uid 0 + print "User $p_username: illegal shell: ``$sh''\n" + if ($verbose && $sh && + !$shell{&basename($sh)} && + $p_username !~ /^(news|xten|bin|nobody|uucp)$/ && + $sh !~ /\/(pppd|sliplogin|nologin|nonexistent)$/); + $uid{$p_uid} = $p_username; + $pwgid{$p_gid} = $p_username; } close P; } # read /etc/group sub group_read { - local($gn,$pw,$gi); + local($g_groupname,$pw,$g_gid, $memb); + print "Check $group\n" if $verbose; open(G, "$group") || die "$group: $!\n"; while() { - ($gn, $pw, $gi) = (split(/:/, $_))[0..2]; - warn "Groupname exist twice: $gn:$gi -> $gn:$groupname{$gn}\n" - if $groupname{$gn}; - $groupname{$gn} = $gi; - warn "Groupid exist twice: $gn:$gi -> $gid{$gi}:$gi\n" - if $gid{$gi}; - $gid{$gi} = $gn; + chop; + push(@group_backup, $_); + # Ignore empty lines + next if /^\s*$/; + # Save comments to restore later + if (/^\s*\#/) { + push(@group_comments, $_); + next; + } + + ($g_groupname, $pw, $g_gid, $memb) = (split(/:/, $_))[0..3]; + + $groupmembers{$g_gid} = $memb; + warn "Groupname exists twice: $g_groupname:$g_gid -> $g_groupname:$groupname{$g_groupname}\n" + if $groupname{$g_groupname} && $verbose; + $groupname{$g_groupname} = $g_gid; + warn "Groupid exists twice: $g_groupname:$g_gid -> $gid{$g_gid}:$g_gid\n" + if $gid{$g_gid} && $verbose; + $gid{$g_gid} = $g_groupname; } close G; } # check gids /etc/passwd <-> /etc/group sub group_check { - local($e, $user, @list); - - foreach $e (keys %pwgid) { - if (!$gid{$e}) { - $user = $pwgid{$e}; - warn "Gid $e is defined in $passwd for user ``$user''\n"; - warn "but not in $group!\n"; - if ($groupname{$user}) { - warn < $groupname{$user}) for user ``$user'' -in $passwd & $group are wrong. -See $passwd ``$user:*:$username{$user}:$e'' -See $group ``$user:*:$groupname{$user}'' -EOF - } else { - push(@list, "$user:*:$e:$user") - if (&confirm_yn("Add group``$user'' gid $e to $group?", "y")); - } - } + local($c_gid, $c_username, @list); + + foreach $c_gid (keys %pwgid) { + if (!$gid{$c_gid}) { + $c_username = $pwgid{$c_gid}; + warn "User ``$c_username'' has gid $c_gid but a group with this " . + "gid does not exist.\n" if $verbose; + } } - &append_file($group, @list) if $#list >= 0; } -sub new_users { - local(@userlist) = @_; - local($name); - local($defaultname) = "a-z0-9"; +# +# main loop for creating new users +# - print "\nOk, let's go.\n"; - print "Don't worry about mistakes. I ask You later for " . - "correct input.\n" if $verbose; +# return username +sub new_users_name { + local($name); while(1) { - $name = &confirm_list("Enter username", 1, $defaultname, ""); - if ($name !~ /^[a-z0-9]+$/) { - warn "Wrong username. " . - "Please use only lowercase characters or digits\n"; - } elsif ($username{$name}) { - warn "Username ``$name'' already exists!\n"; - } else { - last; - } + $name = &confirm_list("Enter username", 1, $usernameregexp, ""); + last if (&new_users_name_valid($name)); + } + return $name; +} + +sub new_users_name_valid { + local($name) = @_; + + if ($name eq $usernameregexp) { # user/admin just pressed + warn "Please enter a username\a\n"; + return 0; + } elsif (length($name) > 16) { + warn "Username is longer than 16 characters.\a\n"; + return 0; + } elsif ($name =~ /[:\n]/) { + warn "Username cannot contain colon or newline characters.\a\n"; + return 0; + } elsif ($name !~ /$usernameregexp/) { + if ($usernameregexp eq $defaultusernameregexp) { + warn "Illegal username.\n" . + "Please use only lowercase Roman, decimal, underscore, " . + "or hyphen characters.\n" . + "Additionally, a username should not start with a hyphen.\a\n"; + } else { + warn "Username doesn't match the regexp /$usernameregexp/\a\n"; + } + return 0; + } elsif (defined($username{$name})) { + warn "Username ``$name'' already exists!\a\n"; return 0; } + return 1; +} + +# return full name +sub new_users_fullname { + local($name) = @_; local($fullname); - while(($fullname = &confirm_list("Enter full name", 1, "", "")) =~ /:/) { - warn "``:'' is not allowed!\n"; + + while(1) { + $fullname = &confirm_list("Enter full name", 1, "", ""); + last if $fullname eq &new_users_fullname_valid($fullname); } $fullname = $name unless $fullname; - local($sh) = &confirm_list("Enter shell", 0, $defaultshell, keys %shell); - $sh = $shell{$sh}; + return $fullname; +} + +sub new_users_fullname_valid { + local($fullname) = @_; + + return $fullname if $fullname !~ /:/; + + warn "``:'' is not allowed!\a\n"; + return 0; +} + +# return shell (full path) for user +sub new_users_shell { + local($sh); + + $sh = &confirm_list("Enter shell", 0, $defaultshell, keys %shell); + return $shell{$sh}; +} + +# return home (full path) for user +# Note that the home path defaults to $home/$name for batch +sub new_users_home { + local($name) = @_; + local($userhome); + + while(1) { + $userhome = &confirm_list("Enter home directory (full path)", 1, "$home/$name", ""); + last if $userhome =~ /^\//; + warn qq{Home directory "$userhome" is not a full path\a\n}; + } + return $userhome; +} + +# return free uid and gid +sub new_users_id { + local($name) = @_; local($u_id, $g_id) = &next_id($name); + local($u_id_tmp, $e); + + while(1) { + $u_id_tmp = &confirm_list("Uid", 1, $u_id, ""); + last if $u_id_tmp =~ /^[0-9]+$/ && $u_id_tmp <= $uid_end && + ! $uid{$u_id_tmp}; + if ($uid{$u_id_tmp}) { + warn "Uid ``$u_id_tmp'' in use!\a\n"; + $uid_start = $u_id_tmp; + ($u_id, $g_id) = &next_id($name); + next; + } else { + warn "Wrong uid.\a\n"; + } + } + # use calculated uid + # return ($u_id_tmp, $g_id) if $u_id_tmp eq $u_id; + # recalculate gid + $uid_start = $u_id_tmp; + return &next_id($name); +} + +# return login class for user +sub new_users_class { + local($def) = @_; + local($class); + + $class = &confirm_list("Enter login class:", 1, $def, ($def, "default")); + $class = "" if $class eq "default"; + return $class; +} + +# add user to group +sub add_group { + local($gid, $name) = @_; + + return 0 if + $groupmembers{$gid} =~ /^(.+,)?$name(,.+)?$/; + + $groupmembers_bak{$gid} = $groupmembers{$gid}; + $groupmembers{$gid} .= "," if $groupmembers{$gid}; + $groupmembers{$gid} .= "$name"; + + return $name; +} + + +# return login group +sub new_users_grplogin { + local($name, $defaultgroup, $new_users_ok) = @_; + local($group_login, $group); + + $group = $name; + $group = $defaultgroup if $defaultgroup ne $group_uniq; + + if ($new_users_ok) { + # clean up backup + foreach $e (keys %groupmembers_bak) { delete $groupmembers_bak{$e}; } + } else { + # restore old groupmembers, user was not accept + foreach $e (keys %groupmembers_bak) { + $groupmembers{$e} = $groupmembers_bak{$e}; + } + } + + while(1) { + $group_login = &confirm_list("Login group", 1, $group, + ($name, $group)); + last if $group_login eq $group; + last if $group_login eq $name; + last if defined $groupname{$group_login}; + if ($group_login eq $group_uniq) { + $group_login = $name; last; + } + + if (defined $gid{$group_login}) { + # convert numeric groupname (gid) to groupname + $group_login = $gid{$group_login}; + last; + } + warn "Group does not exist!\a\n"; + } + + #if (defined($groupname{$group_login})) { + # &add_group($groupname{$group_login}, $name); + #} + + return ($group_login, $group_uniq) if $group_login eq $name; + return ($group_login, $group_login); +} + +# return other groups (string) +sub new_users_groups { + local($name, $other_groups) = @_; + local($string) = + "Login group is ``$group_login''. Invite $name into other groups:"; + local($e, $flag); + local($new_groups,$groups); + + $other_groups = "no" unless $other_groups; + + while(1) { + $groups = &confirm_list($string, 1, $other_groups, + ("no", $other_groups, "guest")); + # no other groups + return "" if $groups eq "no"; + + ($flag, $new_groups) = &new_users_groups_valid($groups); + last unless $flag; + } + $new_groups =~ s/\s*$//; + return $new_groups; +} + +sub new_users_groups_valid { + local($groups) = @_; + local($e, $new_groups); + local($flag) = 0; + + foreach $e (split(/[,\s]+/, $groups)) { + # convert numbers to groupname + if ($e =~ /^[0-9]+$/ && $gid{$e}) { + $e = $gid{$e}; + } + if (defined($groupname{$e})) { + if ($e eq $group_login) { + # do not add user to a group if this group + # is also the login group. + } elsif (&add_group($groupname{$e}, $name)) { + $new_groups .= "$e "; + } else { + warn "$name is already member of group ``$e''\n"; + } + } else { + warn "Group ``$e'' does not exist\a\n"; $flag++; + } + } + return ($flag, $new_groups); +} + +# your last change +sub new_users_ok { + local ($newpasswd); + # Note that we either show "password disabled" or + # "****" .. we don't show "empty password" since + # the whole point of starring out the password in + # the first place is to stop people looking over your + # shoulder and seeing the password.. -- adrian + if ($usepassword eq "no") { + $newpasswd = "Password disabled"; + } elsif ($enableaccount eq "no") { + $newpasswd = "Password disabled"; + } else { + $newpasswd = "****"; + } + print < $crash") || die "Sorry, give up\n"; - $j = join("\n", @passwd_backup); - $j =~ s/\n//; - print R $j . "\n"; - close R; - - system("$pwd_mkdb $crash"); - die "Sorry, give up\n" if $?; - die "Successfully restore $passwd. Exit.\n"; - } - # Add new group - &append_file($group, "$name:*:$g_id:$name") - unless $groupname{$name}; - - # update passwd/group variables - push(@passwd_backup, $new_entry); - $username{$name} = $u_id; - $uid{$u_id} = $name; - $pwgid{$g_id} = $name; - $groupname{$name} = $g_id; - $gid{$g_id} = $name; - - print "Added user ``$name''\n"; - local($a) = &confirm_yn("Change password", $defaultpasswd); - if (($a && $defaultpasswd) || (!$a && !$defaultpasswd)) { - while(1) { - system("passwd $name"); - last unless $?; - last unless - &confirm_yn("Passwd $name failed. Try again?", "yes"); + + return &confirm_yn("OK?", "yes"); +} + +# make password database +sub new_users_pwdmkdb { + local($last) = shift; + local($name) = shift; + + system(@pwd_mkdb, '-u', $name, $etc_passwd); + if ($?) { + warn "$last\n"; + warn "``@pwd_mkdb'' failed\n"; + exit($? >> 8); + } +} + +# update group database +sub new_users_group_update { + local($e, @a); + + # Add *new* group + if (!defined($groupname{$group_login}) && + !defined($gid{$groupname{$group_login}})) { + push(@group_backup, "$group_login:*:$g_id:"); + $groupname{$group_login} = $g_id; + $gid{$g_id} = $group_login; + # $groupmembers{$g_id} = $group_login; + } + + if ($new_groups || defined($groupname{$group_login}) || + defined($gid{$groupname{$group_login}}) && + $gid{$groupname{$group_login}} ne "+") { + # new user is member of some groups + # new login group is already in name space + rename($group, "$group.bak"); + #warn "$group_login $groupname{$group_login} $groupmembers{$groupname{$group_login}}\n"; + + # Restore comments from the top of the group file + @a = @group_comments; + foreach $e (sort {$a <=> $b} (keys %gid)) { + push(@a, "$gid{$e}:*:$e:$groupmembers{$e}"); + } + &append_file($group, @a); + } else { + &append_file($group, "$group_login:*:$g_id:"); + } + +} + +sub new_users_passwd_update { + # update passwd/group variables + push(@passwd_backup, $new_entry); + $username{$name} = $u_id; + $uid{$u_id} = $name; + $pwgid{$g_id} = $name; +} + +# send message to new user +sub new_users_sendmessage { + return 1 if $send_message eq "no"; + + local($cc) = + &confirm_list("Send message to ``$name'' and:", + 1, "no", ("root", "second_mail_address", "no")); + local($e); + $cc = "" if $cc eq "no"; + + foreach $e (@message_buffer) { + print eval "\"$e\""; + } + print "\n"; + + local(@message_buffer_append) = (); + if (!&confirm_yn("Add anything to default message", "no")) { + print "Use ``.'' or ^D alone on a line to finish your message.\n"; + push(@message_buffer_append, "\n"); + while($read = ) { + last if $read eq "\.\n"; + push(@message_buffer_append, $read); + } + } + + &sendmessage("$name $cc", (@message_buffer, @message_buffer_append)) + if (&confirm_yn("Send message", "yes")); +} + +sub sendmessage { + local($to, @message) = @_; + local($e); + + if (!open(M, "| mail -s Welcome $to")) { + warn "Cannot send mail to: $to!\n"; + return 0; + } else { + foreach $e (@message) { + print M eval "\"$e\""; + } + close M; + } +} + + +sub new_users_password { + + local($password); + + while(1) { + system("stty -echo"); + $password = &confirm_list("Enter password", 1, "", ""); + system("stty echo"); + print "\n"; + if ($password ne "") { + system("stty -echo"); + $newpass = &confirm_list("Enter password again", 1, "", ""); + system("stty echo"); + print "\n"; + last if $password eq $newpass; + print "They didn't match, please try again\n"; + } + elsif (&confirm_yn("Use an empty password?", "yes")) { + last; + } + } + + return $password; +} + +sub new_users_use_password { + local ($p) = $defaultusepassword; + $p = &confirm_yn("Use password-based authentication", $defaultusepassword); + return "yes" if (($defaultusepassword eq "yes" && $p) || + ($defaultusepassword eq "no" && !$p)); + return "no"; # otherwise +} + +sub new_users_enable_account { + local ($p) = $defaultenableaccount; + $p = &confirm_yn("Enable account password at creation", $defaultenableaccount); + return "yes" if (($defaultenableaccount eq "yes" && $p) || + ($defaultenableaccount eq "no" && !$p)); + return "no"; # otherwise +} + +sub new_users_empty_password { + local ($p) = $defaultemptypassword; + $p = &confirm_yn("Use an empty password", $defaultemptypassword); + return "yes" if (($defaultemptypassword eq "yes" && $p) || + ($defaultemptypassword eq "no" && !$p)); + return "no"; # otherwise +} + +sub new_users { + + print "\n" if $verbose; + print "Ok, let's go.\n" . + "Don't worry about mistakes. I will give you the chance later to " . + "correct any input.\n" if $verbose; + + # name: Username + # fullname: Full name + # sh: shell + # userhome: home path for user + # u_id: user id + # g_id: group id + # class: login class + # group_login: groupname of g_id + # new_groups: some other groups + local($name, $group_login, $fullname, $sh, $u_id, $g_id, $class, $new_groups); + local($userhome); + local($groupmembers_bak, $cryptpwd); + local($new_users_ok) = 1; + + + $new_groups = "no"; + $new_groups = "no" unless $groupname{$new_groups}; + + while(1) { + $name = &new_users_name; + $fullname = &new_users_fullname($name); + $sh = &new_users_shell; + $userhome = &new_users_home($name); + ($u_id, $g_id) = &new_users_id($name); + $class = &new_users_class($defaultclass); + ($group_login, $defaultgroup) = + &new_users_grplogin($name, $defaultgroup, $new_users_ok); + # do not use uniq username and login group + $g_id = $groupname{$group_login} if (defined($groupname{$group_login})); + + + # The tricky logic: + # If $usepasswd is 0, we use a * as a password + # If $usepasswd is 1, then + # if $enableaccount is 0, we prepend * as a password + # else if $enableaccount is 1 we don't prepend anything + # if $useemptypassword is 0 we ask for a password, + # else we use a blank one + # + # The logic is tasty, I'll give you that, but its flexible and + # it'll stop people shooting themselves in the foot. + + $new_groups = &new_users_groups($name, $new_groups); + + $usepassword = &new_users_use_password; + if ($usepassword eq "no") { + # note that the assignments to enableaccount and + # useemptypassword functionally do the same as + # usepasswd == "no". Just for consistency. + $password = ""; # no password! + $enableaccount = "no"; # doesn't matter here + $useemptypassword = "yes"; # doesn't matter here + } else { + $useemptypassword = &new_users_empty_password; + if ($useemptypassword eq "no") { + $password = &new_users_password; } + $enableaccount = &new_users_enable_account; } - &home_create($name); + + if (&new_users_ok) { + $new_users_ok = 1; + + $cryptpwd = ""; + $cryptpwd = crypt($password, &salt) if $password ne ""; + + if ($usepassword eq "no") { + $cryptpwd = "*"; + } else { + # cryptpwd is valid before this if mess, so if + # blankpasswd is no we don't blank the cryptpwd + if ($useemptypassword eq "yes") { + $cryptpwd = ""; + } + if ($enableaccount eq "no") { + $cryptpwd = "*" . $cryptpwd; + } + } + # obscure perl bug + $new_entry = "$name\:" . "$cryptpwd" . + "\:$u_id\:$g_id\:$class\:0:0:$fullname:$userhome:$sh"; + &append_file($etc_passwd, "$new_entry"); + &new_users_pwdmkdb("$new_entry", $name); + &new_users_group_update; + &new_users_passwd_update; print "Added user ``$name''\n"; + &new_users_sendmessage; + &adduser_log("$name:*:$u_id:$g_id($group_login):$fullname"); + &home_create($userhome, $name, $group_login); + } else { + $new_users_ok = 0; } - if (&confirm_yn("Continue with next user?", "yes")) { - &new_users; - } else { - print "Good by.\n" if $verbose; + if (!&confirm_yn("Add another user?", "yes")) { + print "Goodbye!\n" if $verbose; + last; + } + print "\n" if !$verbose; } } -# -sub password_pref { - $defaultpasswd = !&confirm_yn("Use empty passwords", "yes"); +# ask for password usage +sub password_default { + local($p) = $defaultusepassword; + if ($verbose) { + $p = &confirm_yn("Use password-based authentication", $defaultusepassword); + $changes++ unless $p; + } + return "yes" if (($defaultusepassword eq "yes" && $p) || + ($defaultusepassword eq "no" && !$p)); + return "no"; # otherwise +} + +# ask for account enable usage +sub enable_account_default { + local ($p) = $defaultenableaccount; + if ($verbose) { + $p = &confirm_yn("Enable account password at creation", $defaultenableaccount); + $changes++ unless $p; + } + return "yes" if (($defaultenableaccount eq "yes" && $p) || + ($defaultenableaccount eq "no" && !$p)); + return "no"; # otherwise +} + +# ask for empty password +sub enable_empty_password { + local ($p) = $defaultemptypassword; + if ($verbose) { + $p = &confirm_yn("Use an empty password", $defaultemptypassword); + $changes++ unless $p; + } + return "yes" if (($defaultemptypassword eq "yes" && $p) || + ($defaultemptypassword eq "no" && !$p)); + return "no"; # otherwise } # misc sub check_root { - die "You are not root!\n" if $<; + die "You are not root!\n" if $< && !$test; } sub usage { warn < 1; + # to64 + for ($i = 0; $i < 27; $i++) { + srand(time + $rand + $$); + $rand = rand(25*29*17 + $rand); + $salt .= $itoa64[$rand & $#itoa64]; + } + warn "Salt is: $salt\n" if $verbose > 1; + + return $salt; +} + + +# print banner +sub copyright { + return; +} + +# hints +sub hints { + if ($verbose) { + print "Use option ``-silent'' if you don't want to see " . + "all warnings and questions.\n\n"; + } else { + print "Use option ``-verbose'' if you want to see more warnings and " . + "questions \nor try to repair bugs.\n\n"; + } +} + # sub parse_arguments { local(@argv) = @_; while ($_ = $argv[0], /^-/) { - shift @argv; - last if /^--$/; - if (/^--?(debug|verbose)$/) { $verbose = 1 } - elsif (/^--?(silent|guru|wizard)$/) { $verbose = 0 } - elsif (/^--?(verbose)$/) { $verbose = 1 } - elsif (/^--?(h|help|\?)$/) { &usage } - elsif (/^--?(home)$/) { $home = $argv[0]; shift @argv } - elsif (/^--?(shell)$/) { $shell = $argv[0]; shift @argv } - elsif (/^--?(dotdir)$/) { $dotdir = $argv[0]; shift @argv } - elsif (/^--?(batch)$/) { $batch = 1; } - else { &usage } + shift @argv; + last if /^--$/; + if (/^--?(v|verbose)$/) { $verbose = 1 } + elsif (/^--?(s|silent|q|quiet)$/) { $verbose = 0 } + elsif (/^--?(debug)$/) { $verbose = 2 } + elsif (/^--?(h|help|\?)$/) { &usage } + elsif (/^--?(home)$/) { $home = $argv[0]; shift @argv } + elsif (/^--?(shell)$/) { $defaultshell = $argv[0]; shift @argv } + elsif (/^--?(dotdir)$/) { $dotdir = $argv[0]; shift @argv } + elsif (/^--?(uid)$/) { $uid_start = $argv[0]; shift @argv } + elsif (/^--?(class)$/) { $defaultclass = $argv[0]; shift @argv } + elsif (/^--?(group)$/) { $defaultgroup = $argv[0]; shift @argv } + elsif (/^--?(check_only)$/) { $check_only = 1 } + elsif (/^--?(message)$/) { $send_message = $argv[0]; shift @argv; + $sendmessage = 1; } + elsif (/^--?(batch)$/) { + warn "The -batch option is not supported anymore.\n", + "Please use the pw(8) command line tool!\n"; + exit(0); + } + # see &config_read + elsif (/^--?(config_create)$/) { &create_conf; } + elsif (/^--?(noconfig)$/) { $config_read = 0; } + else { &usage } } #&usage if $#argv < 0; } sub basename { local($name) = @_; - $name =~ s|.*/||; + $name =~ s|/+$||; + $name =~ s|.*/+||; return $name; } -# -sub home_create { +sub dirname { local($name) = @_; - local(@list); - local($e,$from, $to); - - print "Create HOME directory\n"; - if(!mkdir("$home/$name", 0755)) { - warn "Cannot create HOME directory for $name: $!\n"; - return 0; - } - push(@list, "$home/$name"); - if ($dotdir) { - opendir(D, "$dotdir") || warn "$dotdir: $!\n"; - foreach $from (readdir(D)) { - if ($from !~ /^(\.|\.\.)$/) { - $to = $from; - $to =~ s/^dot\././; - $to = "$home/$name/$to"; - push(@list, $to); - &cp("$dotdir/$from", "$to", 1); - } - } - closedir D; + $name = &stripdir($name); + $name =~ s|/+[^/]+$||; + $name = "/" unless $name; # dirname of / is / + return $name; +} + +# return 1 if $file is a readable file or link +sub filetest { + local($file, $verb) = @_; + + if (-e $file) { + if (-f $file || -l $file) { + return 1 if -r _; + warn "$file unreadable\n" if $verbose; + } else { + warn "$file is not a plain file or link\n" if $verbose; + } + } + return 0; +} + +# create configuration files and exit +sub create_conf { + $create_conf = 1; + if ($send_message ne 'no') { + &message_create($send_message); + } else { + &message_create($send_message_bak); + } + &config_write(1); + exit(0); +} + +# log for new user in /var/log/adduser +sub adduser_log { + local($string) = @_; + local($e); + + return 1 if $logfile eq "no"; + + local($sec, $min, $hour, $mday, $mon, $year) = localtime; + $year += 1900; + $mon++; + + foreach $e ('sec', 'min', 'hour', 'mday', 'mon', 'year') { + # '7' -> '07' + eval "\$$e = 0 . \$$e" if (eval "\$$e" < 10); + } + + &append_file($logfile, "$year/$mon/$mday $hour:$min:$sec $string"); +} + +# create HOME directory, copy dotfiles from $dotdir to $HOME +sub home_create { + local($homedir, $name, $group) = @_; + local($rootdir); + + if (-e "$homedir") { + warn "HOME Directory ``$homedir'' already exist\a\n"; + return 0; } - #warn "Chown: $name, $name, @list\n"; - #chown in perl does not work - system("chown $name:$name @list") || warn "$!\n" && return 0; + + # if the home directory prefix doesn't exist, create it + # First, split the directory into a list; then remove the user's dir + @dir = split('/', $homedir); pop(@dir); + # Put back together & strip to get directory prefix + $rootdir = &stripdir(join('/', @dir)); + + if (!&mkdirhier("$rootdir")) { + # warn already displayed + return 0; + } + + if ($dotdir eq 'no') { + if (!mkdir("$homedir", 0755)) { + warn "$dir: $!\n"; return 0; + } + system 'chown', "$name:$group", $homedir; + return !$?; + } + + # copy files from $dotdir to $homedir + # rename 'dot.foo' files to '.foo' + print "Copy files from $dotdir to $homedir\n" if $verbose; + system('cp', '-R', $dotdir, $homedir); + system('chmod', '-R', 'u+wrX,go-w', $homedir); + system('chown', '-Rh', "$name:$group", $homedir); + + # security + opendir(D, $homedir); + foreach $file (readdir(D)) { + if ($file =~ /^dot\./ && -f "$homedir/$file") { + $file =~ s/^dot\././; + rename("$homedir/dot$file", "$homedir/$file"); + } + chmod(0600, "$homedir/$file") + if ($file =~ /^\.(rhosts|Xauthority|kermrc|netrc)$/); + chmod(0700, "$homedir/$file") + if ($file =~ /^(Mail|prv|\.(iscreen|term))$/); + } + closedir D; return 1; } # makes a directory hierarchy -sub mkdirhier { +sub mkdir_home { local($dir) = @_; + $dir = &stripdir($dir); + local($user_partition) = "/usr"; + local($dirname) = &dirname($dir); - if ($dir =~ "^/[^/]+$") { - print "Create /usr/$dir\n" if $verbose; - if (!mkdir("/usr$dir", 0755)) { - warn "/usr/$dir: $!\n"; return 0; - } - print "Create symlink: /usr$dir -> $dir\n" if $verbose; - if (!symlink("/usr$dir", $dir)) { - warn "$dir: $!\n"; return 0; - } + -e $dirname || &mkdirhier($dirname); + + if (((stat($dirname))[0]) == ((stat("/"))[0])){ + # home partition is on root partition + # create home partition on $user_partition and make + # a symlink from $dir to $user_partition/`basename $dir` + # For instance: /home -> /usr/home + + local($basename) = &basename($dir); + local($d) = "$user_partition/$basename"; + + + if (-d $d) { + warn "Oops, $d already exist\n" if $verbose; + } else { + print "Create $d\n" if $verbose; + if (!mkdir("$d", 0755)) { + warn "$d: $!\a\n"; return 0; + } + } + + unlink($dir); # symlink to nonexist file + print "Create symlink: $dir -> $d\n" if $verbose; + if (!symlink("$d", $dir)) { + warn "Symlink $d: $!\a\n"; return 0; + } } else { - local($d,$p); - foreach $d (split('/', $dir)) { - $dir = "$p/$d"; - $dir =~ s|^//|/|; - if (! -e "$dir") { - print "Create $dir\n" if $verbose; - if (!mkdir("$dir", 0755)) { - warn "$dir: $!\n"; return 0; - } - } - $p .= "/$d"; - } + print "Create $dir\n" if $verbose; + if (!mkdir("$dir", 0755)) { + warn "Directory ``$dir'': $!\a\n"; return 0; + } } return 1; } +sub mkdirhier { + local($dir) = @_; + local($d,$p); + + $dir = &stripdir($dir); + + foreach $d (split('/', $dir)) { + $dir = "$p/$d"; + $dir =~ s|^//|/|; + if (! -e "$dir") { + print "Create $dir\n" if $verbose; + if (!mkdir("$dir", 0755)) { + warn "$dir: $!\n"; return 0; + } + } + $p .= "/$d"; + } + return 1; +} + +# stript unused '/' +# F.i.: //usr///home// -> /usr/home +sub stripdir { + local($dir) = @_; + + $dir =~ s|/+|/|g; # delete double '/' + $dir =~ s|/$||; # delete '/' at end + return $dir if $dir ne ""; + return '/'; +} # Read one of the elements from @list. $confirm is default. # If !$allow accept only elements from @list. sub confirm_list { local($message, $allow, $confirm, @list) = @_; - local($read, $c); + local($read, $c, $print); + + $print = "$message" if $message; + $print .= " " unless $message =~ /\n$/ || $#list == 0; + + $print .= join($", &uniq(@list)); #" + $print .= " " unless $message =~ /\n$/ && $#list == 0; + print "$print"; + print "\n" if (length($print) + length($confirm)) > 60; + print "[$confirm]: "; - print "$message " if $message; - print "@list [$confirm]: "; chop($read = ); - $read =~ s/^[ \t]*//; - $read =~ s/[ \t\n]*$//; - return $confirm unless $read; - return $read if $allow; + $read =~ s/^\s*//; + $read =~ s/\s*$//; + return $confirm if $read eq ""; + return "$read" if $allow; foreach $c (@list) { - return $read if $c eq $read; + return $read if $c eq $read; } - warn "$read: is not allowed!\n"; + warn "$read: is not allowed!\a\n"; return &confirm_list($message, $allow, $confirm, @list); } # YES or NO question -# $confirm => 'y' or 'n'. Return true if answer 'y' (or 'n') +# return 1 if &confirm("message", "yes") and answer is yes +# or if &confirm("message", "no") an answer is no +# otherwise 0 sub confirm_yn { local($message, $confirm) = @_; - local($yes) = "^(yes|YES|y|Y)$"; - local($no) = "^(no|NO|n|N)$"; + local($yes) = '^(yes|YES|y|Y)$'; + local($no) = '^(no|NO|n|N)$'; local($read, $c); if ($confirm && ($confirm =~ "$yes" || $confirm == 1)) { - $confirm = "y"; + $confirm = "y"; } else { - $confirm = "n"; + $confirm = "n"; } print "$message (y/n) [$confirm]: "; chop($read = ); - $read =~ s/^[ \t]*//; - $read =~ s/[ \t\n]*$//; + $read =~ s/^\s*//; + $read =~ s/\s*$//; return 1 unless $read; if (($confirm eq "y" && $read =~ "$yes") || - ($confirm eq "n" && $read =~ "$no")) { - return 1; + ($confirm eq "n" && $read =~ "$no")) { + return 1; } if ($read !~ "$yes" && $read !~ "$no") { - warn "Wrong value. Enter again!\a\n"; - return &confirm_yn($message, $confirm); + warn "Wrong value. Enter again!\a\n"; + return &confirm_yn($message, $confirm); } return 0; } +# allow configuring usernameregexp +sub usernameregexp_default { + local($r) = $usernameregexp; + + while ($verbose) { + $r = &confirm_list("Usernames must match regular expression:", 1, + $r, ""); + eval "'foo' =~ /$r/"; + last unless $@; + warn "Invalid regular expression\a\n"; + } + $changes++ if $r ne $usernameregexp; + return $r; +} + # test if $dotdir exist -sub dotdir_check { - return 1 if -e $dotdir && -r _ && (-d _ || -l $dotdir); - warn "Directory: $dotdir does not exist or unreadable. " . - "Cannot copy dotfiles!\n"; - $dotdir = ''; - return 0; +# return "no" if $dotdir not exist or dotfiles should not copied +sub dotdir_default { + local($dir) = $dotdir; + + return &dotdir_default_valid($dir) unless $verbose; + while($verbose) { + $dir = &confirm_list("Copy dotfiles from:", 1, + $dir, ("no", $dotdir_bak, $dir)); + last if $dir eq &dotdir_default_valid($dir); + } + warn "Do not copy dotfiles.\n" if $verbose && $dir eq "no"; + + $changes++ if $dir ne $dotdir; + return $dir; +} + +sub dotdir_default_valid { + local($dir) = @_; + + return $dir if (-e $dir && -r _ && (-d _ || -l $dir) && $dir =~ "^/"); + return $dir if $dir eq "no"; + warn "Dotdir ``$dir'' is not a directory\a\n"; + return "no"; +} + +# ask for messages to new users +sub message_default { + local($file) = $send_message; + local(@d) = ($file, $send_message_bak, "no"); + + while($verbose) { + $file = &confirm_list("Send message from file:", 1, $file, @d); + last if $file eq "no"; + last if &filetest($file, 1); + + # maybe create message file + &message_create($file) if &confirm_yn("Create ``$file''?", "yes"); + last if &filetest($file, 0); + last if !&confirm_yn("File ``$file'' does not exist, try again?", + "yes"); + } + + if ($file eq "no" || !&filetest($file, 0)) { + warn "Do not send message\n" if $verbose; + $file = "no"; + } else { + &message_read($file); + } + + $changes++ if $file ne $send_message && $verbose; + return $file; +} + +# create message file +sub message_create { + local($file) = @_; + + rename($file, "$file.bak"); + if (!open(M, "> $file")) { + warn "Messagefile ``$file'': $!\n"; return 0; + } + print M <) { + push(@message_buffer, $_) unless /^\s*#/; + } + close R; } # write @list to $file with file-locking @@ -485,11 +1331,16 @@ sub append_file { local($file,@list) = @_; local($e); local($LOCK_EX) = 2; + local($LOCK_NB) = 4; local($LOCK_UN) = 8; open(F, ">> $file") || die "$file: $!\n"; print "Lock $file.\n" if $verbose > 1; - flock(F, $LOCK_EX); + while(!flock(F, $LOCK_EX | $LOCK_NB)) { + warn "Cannot lock file: $file\a\n"; + die "Sorry, give up\n" + unless &confirm_yn("Try again?", "yes"); + } print F join("\n", @list) . "\n"; close F; print "Unlock $file.\n" if $verbose > 1; @@ -501,76 +1352,207 @@ sub append_file { sub next_id { local($group) = @_; + $uid_start = 1000 if ($uid_start <= 0 || $uid_start >= $uid_end); # looking for next free uid while($uid{$uid_start}) { - $uid_start++; - print "$uid_start\n" if $verbose > 1; + $uid_start++; + $uid_start = 1000 if $uid_start >= $uid_end; + print "$uid_start\n" if $verbose > 1; } local($gid_start) = $uid_start; # group for user (username==groupname) already exist if ($groupname{$group}) { - $gid_start = $groupname{$group}; + $gid_start = $groupname{$group}; } # gid is in use, looking for another gid. # Note: uid an gid are not equal elsif ($gid{$uid_start}) { - while($gid{$gid_start} || $uid{$gid_start}) { - $gid_start--; - $gid_start = $uid_end if $gid_start < 100; - } + while($gid{$gid_start} || $uid{$gid_start}) { + $gid_start--; + $gid_start = $uid_end if $gid_start < 100; + } } return ($uid_start, $gid_start); } -sub cp { - local($from, $to, $tilde) = @_; +# read config file +sub config_read { + local($opt) = @_; + local($user_flag) = 0; + + # don't read config file + return 1 if $opt =~ /-(noconfig|config_create)/ || !$config_read; - if (-e "$to") { - warn "cp: ``$to'' already exist, do not overwrite\n"; return 0; - } elsif (!(-f $from || -l $from)) { - warn "$from is not a file or symlink!\n"; return 0; - } elsif (!open(F, "$from")) { - warn "$from: $!\n"; return 0; - } elsif (!open(T, "> $to")) { - warn "$to: $!\n"; return 0; + if(!open(C, "$config")) { + warn "$config: $!\n"; return 0; } - if ($tilde) { - $tilde = $to; - $tilde =~ s|.*/([^/]+/[^/]+)$|~$1|; - } else { - $tilde = $to; + while() { + # user defined variables + /^$do_not_delete/ && $user_flag++; + # found @array or $variable + if (s/^(\w+\s*=\s*\()/\@$1/ || s/^(\w+\s*=)/\$$1/) { + eval $_; + #warn "$_"; + } + # lines with '^##' are not saved + push(@user_variable_list, $_) + if $user_flag && !/^##/ && (s/^[\$\@]// || /^[#\s]/); } - print "copy $from to $tilde\n" if $verbose; - while() { - print T $_; + #warn "X @user_variable_list X\n"; + close C; +} + + +# write config file +sub config_write { + local($silent) = @_; + + # nothing to do + return 1 unless ($changes || ! -e $config || !$config_read || $silent); + + if (!$silent) { + if (-e $config) { + return 1 if &confirm_yn("\nWrite your changes to $config?", "no"); + } else { + return 1 unless + &confirm_yn("\nWrite your configuration to $config?", "yes"); + } } - close F; - close T; - return 1; + rename($config, "$config.bak"); + open(C, "> $config") || die "$config: $!\n"; + + # prepare some variables + $send_message = "no" unless $send_message; + $defaultusepassword = "no" unless $defaultusepassword; + $defaultenableaccount = "yes" unless $defaultenableaccount; + $defaultemptypassword = "no" unless $defaultemptypassword; + local($shpref) = "'" . join("', '", @shellpref) . "'"; + local($shpath) = "'" . join("', '", @path) . "'"; + local($user_var) = join('', @user_variable_list); + + print C <