Contents of /trunk/adduser

#!/usr/bin/perl

# adduser: a utility to add users to the system
# addgroup: a utility to add groups to the system
my $version = "VERSION";

# Copyright (C) 1997, 1998, 1999 Guy Maor <maor@debian.org>
# Copyright (C) 1995 Ted Hajek <tedhajek@boombox.micro.umn.edu>
#                     Ian A. Murdock <imurdock@gnu.ai.mit.edu>
# Bugfixes and other improvements Roland Bauerschmidt <rb@debian.org>
# General scheme of the program adapted by the original debian 'adduser'
#  program by Ian A. Murdock <imurdock@gnu.ai.mit.edu>.
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
#
####################
# See the usage subroutine for explanation about how the program can be called
####################

use warnings;
use strict;
use Debian::AdduserCommon;
use Getopt::Long;

BEGIN {
    eval 'use Locale::gettext';
    if ($@) {
        *gettext = sub { shift };
        *textdomain = sub { "" };
        *LC_MESSAGES = sub { 5 };
    }
    eval {
        require POSIX;
        import POSIX qw(setlocale);
    };
    if ($@) {
        *setlocale = sub { return 1 };
    }
    eval {
        require I18N::Langinfo;
        import I18N::Langinfo qw(langinfo YESEXPR);
    };
    if ($@) {
        *langinfo = sub { "^[yY]" };
        *YESEXPR = sub { 1 };
    }
}

setlocale(LC_MESSAGES, "");
textdomain("adduser");
my $yesexpr = langinfo(YESEXPR());

my %config;                     # configuration hash

my @defaults = ("/etc/adduser.conf");
my $nogroup_id = getgrnam("nogroup") || 65534;
$0 =~ s+.*/++; 

our $verbose = 1;               # should we be verbose?
my $allow_badname = 0;          # should we allow bad names?
my $ask_passwd = 1;             # ask for a passwd? 
my $disabled_login = 0;         # leave the new account disabled?

our $configfile = undef;
our $found_group_opt = undef;
our $found_sys_opt = undef;
our $ingroup_name = undef;
our $new_firstuid = undef;
our $new_gecos = undef;
our $new_gid = undef;
our $new_lastuid = undef;
our $new_uid = undef;
our $no_create_home = undef;
our $special_home = undef;
our $special_shell = undef;
our $add_extra_groups = 0;

# Global variables we need later
my $existing_user = undef;
my $existing_group = undef;
my $new_name = undef;
my $make_group_also = 0;
my $home_dir = undef;
my $undohome = undef;
my $undouser = undef;
my $undogroup = undef;
my $shell = undef;
my $first_uid = undef;
my $last_uid = undef;
my $dir_mode = undef;
my $perm = undef;

our @names;

# Parse options, sanity checks
unless ( GetOptions ("quiet" => sub { $verbose = 0 },
            "force-badname" => \$allow_badname,
            "help|h" => sub { &usage(); exit 0 },
            "version" => sub { &version(); exit 0 },
            "system" => \$found_sys_opt,
            "group" => \$found_group_opt,
            "ingroup=s" => \$ingroup_name,
            "home=s" => \$special_home,
            "gecos=s" => \$new_gecos,
            "shell=s" => \$special_shell,
            "disabled-password" => sub { $ask_passwd = 0 },
            "disabled-login" => sub { $disabled_login = 1; $ask_passwd = 0 },
            "uid=i" => \$new_uid,
            "firstuid=i" => \$new_firstuid,
            "lastuid=i" => \$new_lastuid,
            "gid=i" => \$new_gid,
            "conf=s" => \$configfile,
            "no-create-home" => \$no_create_home,
            "add_extra_groups" => \$add_extra_groups,
            "debug" => sub { $verbose = 2 } ) ) {
    &usage;
    exit 1;
}

# everyone can issue "--help" and "--version", but only root can go on
dief (gtx("Only root may add a user or group to the system.\n")) if ($> != 0);

if( defined($configfile) ) { @defaults = ($configfile); }

# detect the right mode
my $action = $0 eq "addgroup" ? "addgroup" : "adduser";
if (defined($found_sys_opt)) {
  $action = "addsysuser" if ($action eq "adduser");
  $action = "addsysgroup" if ($action eq "addgroup");
}


############################
# checks related to @names #
############################


while (defined(my $arg = shift(@ARGV))) {
  push (@names, $arg);
}

if ( (! defined $names[0]) || length($names[0]) == 0 || @names > 2) {
    dief (gtx("Only one or two names allowed.\n"));
}
            

if (@names == 2) {      # must be addusertogroup
    dief (gtx("Specify only one name in this mode.\n"))
        if ($action eq "addsysuser" || $found_group_opt);
    $action = "addusertogroup";
    $existing_user = shift (@names);
    $existing_group = shift (@names);
}
else {
    $new_name = shift (@names);
}

###################################
# check for consistent parameters #
###################################

if ($action ne "addgroup" &&
    defined($found_group_opt) +defined($ingroup_name) +defined($new_gid) > 1 ) {
    dief (gtx("The --group, --ingroup, and --gid options are mutually exclusive.\n"));
}


if ((defined($special_home)) && ($special_home !~ m+^/+ )) {
  dief (gtx("The home dir must be an absolute path.\n"));
}
           
if (defined($special_home) && $verbose) {
    print gtx("Warning: The home dir you specified already exists.\n")
      if (!defined($no_create_home) && -d $special_home);
    print gtx("Warning: The home dir you specified does not exist.\n")
      if (defined($no_create_home) && ! -d $special_home);
}


if ($found_group_opt) {
    if ($action eq "addsysuser") {
        $make_group_also = 1;
    }
    elsif ($found_sys_opt) {
        $action = "addsysgroup";
    }
    else {
        $action = "addgroup";
    }
}


$ENV{"VERBOSE"} = $verbose;
$ENV{"DEBUG"}   = $verbose;


# preseed configuration data and then read the config file
preseed_config(\@defaults,\%config);

&checkname($new_name) if defined $new_name;
$SIG{'INT'} = $SIG{'QUIT'} = $SIG{'HUP'} = 'handler';

#####
# OK, we've processed the arguments.  $action equals one of the following,
# and the appropriate variables have been set:
#
# $action = "adduser"
#    $new_name                - the name of the new user.
#    $ingroup_name | $new_gid - the group to add the user to
#    $special_home, $new_uid, $new_gecos - optional overrides
# $action = "addgroup"
#    $new_name                - the name of the new group
#    $new_gid                 - optional override
# $action = "addsysgroup"
#    $new_name                - the name of the new group
#    $new_gid                 - optional override
# $action = "addsysuser"
#    $new_name                - the name of the new user
#    $make_group_also | $ingroup_name | $new_gid | 0  - which group
#    $special_home, $new_uid, $new_gecos - optional overrides
# $action = "addusertogroup"
#    $existing_user           - the user to be added
#    $existing_group          - the group to add her to
#####


#################
## addsysgroup ##
#################
if ($action eq "addsysgroup") {
    # Check if requested group already exists and we can exit safely
    if (existing_group_ok($new_name, $new_gid) == 1) {
        printf (gtx("The group `%s' already exists as a system group. Exiting...\n"), $new_name) if $verbose;
        exit 0;
    }
    if (existing_group_ok($new_name, $new_gid) == 2) {
        printf (gtx("The group `%s' already exists, but has a different gid, aborting...\n"), $new_name) if $verbose;
        exit 1;
    }

    dief (gtx("The group `%s' already exists and is not a system group.\n"),$new_name)
        if (defined getgrnam($new_name));
    dief (gtx("The GID `%s' is already in use.\n"),$new_gid)
        if (defined($new_gid) && defined(getgrgid($new_gid)));
    if (!defined($new_gid)) {
        $new_gid = &first_avail_gid($config{"first_system_gid"},
                                   $config{"last_system_gid"});

        if ($new_gid == -1) {
            print STDERR "$0: ";
            printf STDERR gtx("No GID is available in the range %d-%d (FIRST_SYS_GID - LAST_SYS_GID).\n"),$config{"first_system_gid"},$config{"last_system_gid"};
            dief (gtx("The group `%s' was not created.\n"),$new_name);
        }
    }

    printf (gtx("Adding group `%s' (%s)...\n"),$new_name,$new_gid) if $verbose;
    &invalidate_nscd("group");
    &systemcall('/usr/sbin/groupadd', '-g', $new_gid, $new_name);
    &invalidate_nscd("group");
    print (gtx("Done.\n")) if $verbose;
    exit 0;
}


##############
## addgroup ##
##############
if ($action eq "addgroup") {
    dief (gtx("The group `%s' already exists.\n"),$new_name)
        if (defined getgrnam($new_name));
    dief (gtx("The GID `%s' is already in use.\n"),$new_gid)
        if (defined($new_gid) && defined(getgrgid($new_gid)));
    if (!defined($new_gid)) {
        $new_gid = &first_avail_gid($config{"first_gid"},
                                   $config{"last_gid"});

        if ($new_gid == -1) {
            print STDERR "$0: ";
            printf STDERR gtx("No GID is available in the range %d-%d (FIRST_GID - LAST_GID).\n"),$config{"first_gid"},$config{"last_gid"};
            dief (gtx("The group `%s' was not created.\n"),$new_name);
        }
    }

    printf (gtx("Adding group `%s' (%s)...\n"),$new_name,$new_gid) if $verbose;
    &invalidate_nscd("group");
    &systemcall('/usr/sbin/groupadd', '-g', $new_gid, $new_name);
    &invalidate_nscd("group");
    print (gtx("Done.\n")) if $verbose;
    exit 0;
}


####################
## addusertogroup ##
####################
if ($action eq "addusertogroup") {
    dief (gtx("The user `%s' does not exist.\n"),$existing_user)
        if (!defined getpwnam($existing_user));
    dief (gtx("The group `%s' does not exist.\n"),$existing_group)
        if (!defined getgrnam($existing_group));
    if (&user_is_member($existing_user, $existing_group)) {
        printf gtx("The user `%s' is already a member of `%s'.\n"),
                $existing_user,$existing_group if $verbose;
        exit 0;                 # not really an error
    }

    printf gtx("Adding user `%s' to group `%s'...\n"),$existing_user,$existing_group
        if $verbose;
    &invalidate_nscd();
    # FIXME - the next line has a race condition.
    #&systemcall('usermod', '-G',
                #join(",", get_users_groups($existing_user), $existing_group), 
                #$existing_user);
    &systemcall('/usr/bin/gpasswd', '-M',
                join(',', get_group_members($existing_group), $existing_user),
                $existing_group);
    #&systemcall('gpasswd', '-a',$existing_user,$existing_group);
    &invalidate_nscd();
    print (gtx("Done.\n")) if $verbose;
    exit 0;
}


################
## addsysuser ##
################
if ($action eq "addsysuser") {
    if (existing_user_ok($new_name, $new_uid) == 1) {
        printf (gtx("The user `%s' already exists as a system user. Exiting...\n"), $new_name) if $verbose;
        exit 0;
    }
    if (existing_user_ok($new_name, $new_uid) == 2) {
        printf (gtx("The user `%s' already exists with a different uid. Aborting\n"), $new_name) if $verbose;
        exit 1;
    }

    if (!$ingroup_name && !defined($new_gid) && !$make_group_also) {
      $new_gid = $nogroup_id;
    }
    check_user_group(1);

    if (!defined($new_uid) && $make_group_also) {
        $new_uid = &first_avail_uid($config{"first_system_uid"},
                                   $config{"last_system_uid"});
        if ($new_uid == -1) {
            print STDERR "$0: ";
            printf STDERR gtx("No UID/GID pair is available in the range %d-%d (FIRST_SYS_UID - LAST_SYS_UID).\n"),$config{"first_system_uid"},$config{"last_system_uid"};
            dief (gtx("The user `%s' was not created.\n"),$new_name);
        }
        $new_gid = &first_avail_gid($config{"first_system_gid"},
                                    $config{"last_system_gid"});
        $ingroup_name = $new_name;
    }
    elsif (!defined($new_uid) && !$make_group_also) {
        $new_uid = &first_avail_uid($config{"first_system_uid"},
                                   $config{"last_system_uid"});
        if ($new_uid == -1) {
            print STDERR "$0: ";
            printf STDERR gtx("No UID is available in the range %d-%d (FIRST_SYS_UID - LAST_SYS_UID).\n"),$config{"first_system_uid"},$config{"last_system_uid"};
            dief (gtx("The user `%s' was not created.\n"),$new_name);
        }
        if (defined($new_gid)) { $ingroup_name = getgrgid($new_gid); }
        elsif ($ingroup_name) { $new_gid = getgrnam($ingroup_name); }
        else { dief (gtx("Internal error")); }
    }
    else {
        if (defined($new_gid)) { $ingroup_name = getgrgid($new_gid); }
        elsif ($ingroup_name) { $new_gid = getgrnam($ingroup_name); }
        elsif ($make_group_also){ $new_gid=$new_uid; $ingroup_name=$new_name; }
        else { dief (gtx("Internal error")); }
    }
    printf (gtx("Adding system user `%s' with uid %s...\n"),$new_name,$new_uid) if $verbose;

    &invalidate_nscd();
    # if we reach this point, and the group does already exist, we can use it.
    if ($make_group_also && !getgrnam($new_name)) {
        printf (gtx("Adding new group `%s' (%s).\n"),$new_name,$new_gid) if $verbose;
        $undogroup = $new_name;
        &systemcall('/usr/sbin/groupadd', '-g', $new_gid, $new_name);
        &invalidate_nscd("group");
    }

    printf gtx("Adding new user `%s' (%s) with group `%s'.\n"),$new_name,$new_uid,$ingroup_name
        if $verbose;
    $home_dir = $special_home || &homedir($new_name, $ingroup_name);
        $shell = $special_shell || '/bin/false';
    $undouser = $new_name;
    &systemcall('/usr/sbin/useradd', '-d', $home_dir, '-g', $ingroup_name, '-s',
                $shell, '-u', $new_uid, $new_name);
    print "/usr/bin/chage -M 99999 $new_name\n" if ($verbose > 1);
    # do _not_ use systemcall() here, since systemcall() dies on
    # non-zero exit code and we need to do special handling here!
    if (system('/usr/bin/chage', '-M', '99999', $new_name)) {
        if( ($?>>8) ne 15 ) {
            &cleanup("$0: `/usr/bin/chage -M 99999 $new_name' returned error code " . ($?>>8) . ".  Aborting.\n")
              if ($?>>8);
            &cleanup("$0: `/usr/bin/chage -M 99999 $new_name' exited from signal " . ($?&255) . ".  Aborting.\n");
        } else {
            print (gtx("chage failed with return code 15, shadow not enabled, password aging cannot be set. Continuing.\n"));
        }
    }
    &invalidate_nscd();

    if(defined($new_gecos)) {
        &ch_gecos($new_gecos);
    }

    create_homedir (0);

    exit 0;
}


#############
## adduser ##
#############
if ($action eq "adduser") {
    if (!$ingroup_name && !defined($new_gid)) {
        if ($config{"usergroups"} =~  /yes/i) { $make_group_also = 1; }
        else { $new_gid = $config{"users_gid"}; }
    }
    check_user_group(0);
    $first_uid = $new_firstuid || $config{"first_uid"};
    $last_uid = $new_lastuid || $config{"last_uid"};
    printf (gtx("Adding user `%s'...\n"),$new_name) if $verbose;

    if (!defined($new_uid) && $make_group_also) {
        $new_uid = &first_avail_uid($first_uid,
                                   $last_uid);
                                
        if ($new_uid == -1) {
            print STDERR "$0: ";
            printf STDERR gtx("No UID/GID pair is available in the range %d-%d (FIRST_UID - LAST_UID).\n"),$first_uid,$last_uid;
            dief (gtx("The user `%s' was not created.\n"),$new_name);
        }
        $new_gid = &first_avail_gid($config{"first_gid"}, 
                                    $config{"last_gid"});
        $ingroup_name = $new_name;
    }
    elsif (!defined($new_uid) && !$make_group_also) {
        $new_uid = &first_avail_uid($first_uid,
                                   $last_uid);
        if ($new_uid == -1) {
            print STDERR "$0: ";
            printf STDERR gtx("No UID is available in the range %d-%d (FIRST_UID - LAST_UID).\n"),$config{"first_uid"},$config{"last_uid"};
            dief (gtx("The user `%s' was not created.\n"),$new_name);
        }
        if (defined($new_gid)) { $ingroup_name = getgrgid($new_gid); }
        elsif ($ingroup_name) { $new_gid = getgrnam($ingroup_name); }
        else { dief (gtx("Internal error")); }
    }
    else {
        if (defined($new_gid)) { $ingroup_name = getgrgid($new_gid); }
        elsif ($ingroup_name) { $new_gid = getgrnam($ingroup_name); }
        elsif ($make_group_also){ $new_gid=$new_uid; $ingroup_name=$new_name; }
        else { dien (gtx("Internal error")); }
    }

    &invalidate_nscd();
    if ($make_group_also) {
        printf (gtx("Adding new group `%s' (%s).\n"),$new_name,$new_gid) if $verbose;
        $undogroup = $new_name;
        &systemcall('/usr/sbin/groupadd', '-g', $new_gid, $new_name);
        &invalidate_nscd();
    }

    printf gtx("Adding new user `%s' (%s) with group `%s'.\n"),$new_name,$new_uid,$ingroup_name
        if $verbose;
    $home_dir = $special_home || &homedir($new_name, $ingroup_name);
        $shell = $special_shell || $config{"dshell"};
    $undouser = $new_name;
    &systemcall('/usr/sbin/useradd', '-d', $home_dir, '-g', $ingroup_name, '-s',
                $shell, '-u', $new_uid, $new_name);
    &invalidate_nscd();

    create_homedir (1); # copy skeleton data

    # useradd without -p has left the account disabled (password string is '!')
    if ($ask_passwd) {
        for (;;) {
          &systemcall('/usr/bin/passwd', $new_name);
          my $ok = $? & 128;
          if ($ok != 0) {
            my $noexpr = langinfo(NOEXPR());
            my $answer;
            # hm, error, should we break now?
            print (gtx("Permission denied\n")) if ($ok == 1);
            print (gtx("invalid combination of options\n")) if ($ok == 2);
            print (gtx("unexpected failure, nothing done\n")) if ($ok == 3);
            print (gtx("unexpected failure, passwd file missing\n")) if ($ok == 3);
            print (gtx("passwd file busy, try again\n")) if ($ok == 4);
            print (gtx("invalid argument to option\n")) if ($ok == 5);
            
            # Translators: [y/N] has to be replaced by values defined in your
            # locale.  You can see by running "locale noexpr" which regular
            # expression will be checked to find positive answer.
            print (gtx("Try again(Y/n)?"));
            chop ($answer=<STDIN>);
            last if ($answer =~ m/$noexpr/o);
          }
          else {
            last; ## passwd ok
          }
        }
    } else {
        if(!$disabled_login) {
            &systemcall('/usr/sbin/usermod', '-p', '*', $new_name);
        }
    }

    if (defined($new_gecos)) {
        &ch_gecos($new_gecos);
    }
    else {
        my $yesexpr = langinfo(YESEXPR());
        for (;;) {
            &systemcall('/usr/bin/chfn', $new_name);
            # Translators: [y/N] has to be replaced by values defined in your
            # locale.  You can see by running "locale yesexpr" which regular
            # expression will be checked to find positive answer.
            print (gtx("Is the information correct? [y/N] "));
            chop (my $answer=<STDIN>);
            last if ($answer =~ m/$yesexpr/o);
        }
    }

    if ( ( $add_extra_groups || $config{"add_extra_groups"} ) && defined($config{"extra_groups"}) ) {
        printf (gtx("Adding new user `%s' to extra groups\n"), $new_name);
        foreach my $newgrp ( split ' ', $config{"extra_groups"} ) {
            if (!defined getgrnam($newgrp)) {
                warnf (gtx("The group `%s' does not exist.\n"),$newgrp);
                next;
            }
            if (&user_is_member($new_name, $newgrp)) {
                printf gtx("The user `%s' is already a member of `%s'.\n"),
                        $new_name,$newgrp if $verbose;
                next;

            }

            printf gtx("Adding user `%s' to group `%s'...\n"),$new_name,$newgrp
                if $verbose;
            &invalidate_nscd();
            &systemcall('/usr/bin/gpasswd', '-M',
                        join(',', get_group_members($newgrp), $new_name),
                        $newgrp);
            &invalidate_nscd();
        }
    }


    if ($config{"quotauser"}) {
        printf (gtx("Setting quota from `%s'.\n"),$config{quotauser});
        &systemcall('/usr/sbin/edquota', '-p', $config{quotauser}, $new_name);
    }

    &systemcall('/usr/local/sbin/adduser.local', $new_name, $new_uid,
                $new_gid, $home_dir) if (-x "/usr/local/sbin/adduser.local");
    
    exit 0;
}

#
# we never go here
#


# calculate home directory
sub homedir {
    my $dir = $config{"dhome"};
    $dir .= '/' . $_[1] if ($config{"grouphomes"} =~ /yes/i);
    $dir .= '/' . substr($_[0],0,1) if ($config{"letterhomes"} =~ /yes/i);
    $dir .= '/' . $_[0];
    return $dir;
}


# create_homedir -- create the homedirectory
# parameter 1: $copy_skeleton: 
#       if 0  -> don't copy the skeleton data
#       if 1  -> copy the files in /etc/skel to the newly created home directory
sub create_homedir {
  my ($copy_skeleton) = @_;

  if ($no_create_home) {
      printf gtx("Not creating home directory `%s'.\n"), $home_dir if $verbose;
  }
  elsif (-e $home_dir) {
      printf gtx("The home directory `%s' already exists.  Not copying from `%s'\n"),
      $home_dir,$config{skel} if $verbose && !$no_create_home;
      my @homedir_stat = stat($home_dir);
      my $home_uid = $homedir_stat[4];
      my $home_gid = $homedir_stat[5];
      if (($home_uid != $new_uid) || ($home_gid != $new_gid)) {
          warnf gtx("Warning: that home directory does not belong to the user you are currently creating\n");
      }
      undef @homedir_stat; undef $home_uid; undef $home_gid;
  }
  else {
      printf gtx("Creating home directory `%s'.\n"),$home_dir if $verbose;
      $undohome = $home_dir;
      &mktree($home_dir) || &cleanup("Couldn't create $home_dir: $!.\n");
      chown($new_uid, $new_gid, $home_dir)
          || &cleanup("chown $new_uid:$new_gid $home_dir: $!\n");
      $dir_mode = get_dir_mode($make_group_also);
      chmod ($dir_mode, $home_dir) ||
          &cleanup("chmod $dir_mode $home_dir: $!\n");

      if ($config{"skel"} && $copy_skeleton) {
          printf gtx("Copying files from `%s'\n"),$config{skel} if $verbose;
          open(FIND, "cd $config{skel}; find .  -print |")
              || &cleanup("fork for find: $!\n");
          while (<FIND>) {
              chop;
              next if ($_ eq ".");
              next if ($_ =~ qr/$config{skel_ignore_regex}/ );
              &copy_to_dir($config{"skel"}, $_, $home_dir, $new_uid,
                            $new_gid, ($config{"setgid_home"} =~ /yes/i));
          }
      }
  }
}

# create a directory and all parent directories
# we don't care about the rights and so on
sub mktree {
    my($tree) = @_;
    my($done, @path);
    my $default_dir_mode = 0755;

    $tree =~ s:^/*(.*)/*$:$1:; # chop off leading & trailing slashes
    @path = split(/\//, $tree);

    $done = "";
    while (@path) {
        $done .= '/' . shift(@path);
        -d $done || mkdir($done, $default_dir_mode) || return 0;
    }
    return 1;
}

# returns 0 if the the user doesn't exist or
# returns 1 if the user already exists with the specified uid (or $new_uid wasn't specified)
# returns 2 if the user already exists, but $new_uid doesn't matches its uid
sub existing_user_ok {
    my($new_name,$new_uid) = @_;
    my ($dummy1,$dummy2,$uid);
    if (($dummy1,$dummy2,$uid) = getpwnam($new_name)) {
        if( defined($new_uid) && $uid == $new_uid ) {
            return 1;
        }
        if (! defined($new_uid)) { 
                return 1;
        }
        if( $uid >= $config{"first_system_uid"} &&
            $uid <= $config{"last_system_uid" } ) {
                return 2;
        }
    } else {
        return 0;
    }
}

# returns 0 if the group doesn't exist or
# returns 1 if the group already exists with the specified gid (or $new_gid wasn't specified)
# returns 2 if the group already exists, but $new_gid doesn't match its gid 
sub existing_group_ok {
    my($new_name,$new_gid) = @_;
    my ($dummy1,$dummy2,$gid);
    if (($dummy1,$dummy2,$gid) = getgrnam($new_name)) {
        if( defined($new_gid) && $gid == $new_gid ) {
            return 1;
        }
        if (! defined($new_gid)) {
                return 1;
        }
        if( $gid >= $config{"first_system_gid"} &&
            $gid <= $config{"last_system_gid" } ) {
                return 2;
        }
    } else {
        return 0;
    }
}

sub check_user_group {
    my ($system) = @_;
    if( !$system || !existing_user_ok($new_name, $new_uid) ) {
        if( defined getpwnam($new_name) ) {
            if( $system ) {
                dief (gtx("The user `%s' already exists, and is not a system user.\n"),$new_name);
            } else {
                dief (gtx("The user `%s' already exists.\n"),$new_name);
            }
        }
        dief (gtx("The UID %s is already in use.\n"),$new_uid)
          if (defined($new_uid) && getpwuid($new_uid));
    }
    if ($make_group_also) {
        if( !$system || !existing_group_ok($new_name, $new_uid) ) {
            dief (gtx("The group `%s' already exists.\n"),$new_name)
              if (defined getgrnam($new_name));
            dief (gtx("The GID %s is already in use.\n"),$new_uid)
              if (defined($new_uid) && defined(getgrgid($new_uid)));
        }
    }
    else {
        dief (gtx("The group `%s' does not exist.\n"),$ingroup_name)
            if ($ingroup_name && !defined(getgrnam($ingroup_name)));
        dief (gtx("The GID %s does not exist.\n"),$new_gid)
            if (defined($new_gid) && !defined(getgrgid($new_gid)));
    }
}


# copy files, directories, symlinks    
sub copy_to_dir {
    my($fromdir, $file, $todir, $newu, $newg, $sgiddir) = @_;

    if (-l "$fromdir/$file") {
        my $target=readlink("$fromdir/$file") or &cleanup("readlink: $!\n");
        my $curgid="$)";
        my $curuid="$>";
        my $error="";
        $)="$newg";
        $>="$newu";
        symlink("$target", "$todir/$file") or $error="$!";
        $>="$curuid";
        $)="$curgid";
        if( "$error" ne "" ) {
            &cleanup("symlink: $!\n");
        }
        return;
    }
    elsif (-f "$fromdir/$file") {
        open (FILE, "$fromdir/$file") || &cleanup("open $fromdir/$file: $!");
        open (NEWFILE, ">$todir/$file") || &cleanup("open >$todir/$file: $!");

        (print NEWFILE <FILE>) || &cleanup("print $todir/$file: $!");
        close FILE;
        close(NEWFILE)  || &cleanup("close $todir/$file ");

    }
    elsif (-d "$fromdir/$file") {
        mkdir("$todir/$file", 700) || &cleanup("mkdir: $!");
    }
    else {
        &cleanup("Can't deal with $fromdir/$file.  "
                 ."Not a dir, file, or symlink.\n");
    }
    
    chown($newu, $newg, "$todir/$file")
        || &cleanup("chown $newu:$newg $todir/$file: $!\n");
    $perm = (stat("$fromdir/$file"))[2] & 07777;
    $perm |= 02000 if (-d "$fromdir/$file" && ($perm & 010) && $sgiddir);
    chmod($perm, "$todir/$file") || &cleanup("chmod $todir/$file: $!\n");
}
       

# check if the given name matches some sanity checks
sub checkname {
    my ($name) = @_;
    if ($name !~ /^[_.A-Za-z0-9][-_.A-Za-z0-9]*\$?$/) {
        print STDERR
("$0: " . gtx("To avoid problems, the username should consist of
letters, digits, underscores, periods and dashes, and not start with a
dash (as defined by IEEE Std 1003.1-2001). For compatibility with Samba
machine accounts \$ is also supported at the end of the username\n"));
        exit 1;
    }
    if ($name !~ qr/$config{"name_regex"}/) {
      if ($allow_badname) {
        print (gtx("Allowing use of questionable username.\n")) if ($verbose);
      }
      else {
        print STDERR
("$0: " . gtx("Please enter a username matching the regular expression configured
via the name_regex configuration variable.  Use the `--force-badname'
option to relax this check or reconfigure name_regex.\n"));
        exit 1;
      }
    }
}

# return the first available uid in given range
# return -1 if no free uid is available
sub first_avail_uid {
    my ($min, $max) = @_;
    printf (gtx("Selecting uid from range %s to %s.\n"),$min,$max) if ($verbose > 1);

    my $t = $min;
    while ($t <= $max) {
       return $t if (!defined(getpwuid($t)));
       $t++;
    }
    return -1; # nothing available
}

# return the first available gid in given range
# return -1 if no free gid is available
sub first_avail_gid {
    my ($min, $max) = @_;
    printf (gtx("Selecting gid from range %s to %s.\n"),$min,$max) if ($verbose > 1);

    my $t = $min;
    while ($t <= $max) {
       return $t if (!defined(getgrgid($t)));
       $t++;
    }
    return -1; # nothing available
}

sub ch_gecos {
    my $gecos = shift;
    if($gecos =~ /,/)
      {
          my($gecos_name,$gecos_room,$gecos_work,$gecos_home,$gecos_other)
            = split(/,/,$gecos);

          &systemcall('/usr/bin/chfn', '-f', $gecos_name, '-r', $gecos_room, $new_name);
          &systemcall('/usr/bin/chfn','-w',$gecos_work,$new_name)
            if(defined($gecos_work));
          &systemcall('/usr/bin/chfn','-h',$gecos_home,$new_name)
            if(defined($gecos_home));
          &systemcall('/usr/bin/chfn','-o',$gecos_other,$new_name)
            if(defined($gecos_other));
      }
    else
      {
          &systemcall('/usr/bin/chfn', '-f', $gecos, $new_name);
      }
}

# user is member of group?
sub user_is_member {
    my($user, $group) = @_;
    for (split(/ /, (getgrnam($group))[3])) {
        return 1 if ($user eq $_);
    }
    return 0;
}


sub cleanup {
    my ($msg) = @_;
    printf (gtx("Stopped: %s\n"),$msg);
    if ($undohome) {
        printf (gtx("Removing directory `%s'\n"),$undohome);
        &systemcall('rm', '-rf', $undohome);
    }
    if ($undouser) {
        printf (gtx("Removing user `%s'.\n"),$undouser);
        &systemcall('userdel', $undouser);
    }
    if ($undogroup) {
        printf (gtx("Removing group `%s'.\n"),$undogroup);
        &systemcall('groupdel', $undogroup);
    }
    # do we need to invalidate the nscd cache here, too?
    exit 1;
}

sub handler {
    my($sig) = @_;
    &cleanup("Caught a SIG$sig.\n");
}
    

sub version {
    print "$0: add a user or group to the system.  Version VERSION
Copyright (C) 1997, 1998, 1999 Guy Maor <maor\@debian.org>
Copyright (C) 1995 Ian Murdock <imurdock\@gnu.ai.mit.edu>,
                   Ted Hajek <tedhajek\@boombox.micro.umn.edu>, 
    
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or (at
your option) any later version.

This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License, /usr/share/common-licenses/GPL, for more details.
";
}

sub usage {
    printf gtx(
"adduser [--home DIR] [--shell SHELL] [--no-create-home] [--uid ID]
[--firstuid ID] [--lastuid ID] [--gecos GECOS] [--ingroup GROUP | --gid ID]
[--disabled-password] [--disabled-login] user
   Add a normal user

adduser --system [--home DIR] [--shell SHELL] [--no-create-home] [--uid ID]
[--gecos GECOS] [--group | --ingroup GROUP | --gid ID] [--disabled-password]
[--disabled-login] user
   Add a system user

adduser --group [--gid ID] group
addgroup [--gid ID] group
   Add a user group

addgroup --system [--gid ID] group
   Add a system group

adduser user group
   Add an existing user to an existing group

Other options are [--quiet] [--force-badname] [--help] [--version] [--conf
FILE].
");
}

sub get_dir_mode
  {
      my $setgid = shift;
      # no longer make home directories setgid per default (closes: #64806)
      $setgid = 0 unless $config{"setgid_home"} =~  /yes/i;

      my $dir_mode = $config{"dir_mode"};
      if(!defined($dir_mode) || ! ($dir_mode =~ /[0-7]{3}/ ||
                                   $dir_mode =~ /[0-7]{4}/))
        {
            $dir_mode = $setgid ? 2755 : 0755;
        }
      else
        {
            $dir_mode = $config{"dir_mode"};
            if($setgid && (length($dir_mode) == 3 || $dir_mode =~ /^[0-1|4-5][0-7]{3}$/))
              {
                  $dir_mode += 2000;
              }
        }
      return oct($dir_mode);
  }

# Local Variables:
# mode:cperl
# cperl-indent-level:4
# End:

