emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rewrite/shrink by tito.

Browse Source
This commit is contained in:
Rob Landley
2006-04-04 19:19:53 +00:00
parent ab8736064b
commit 9a2dd51237
2 changed files with 95 additions and 252 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
loginutils/addgroup.c
View File

@ -5,48 +5,20 @@
* Copyright (C) 1999 by Lineo, inc. and John Beppu * Copyright (C) 1999 by Lineo, inc. and John Beppu
* Copyright (C) 1999,2000,2001 by John Beppu <beppu@codepoet.org> * Copyright (C) 1999,2000,2001 by John Beppu <beppu@codepoet.org>
* *
* This program is free software; you can redistribute it and/or modify * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
* 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
* *
*/ */
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h> #include <string.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
#include "busybox.h" #include "busybox.h"
#include "pwd_.h"
#include "grp_.h"
/* structs __________________________ */
/* data _____________________________ */
/* defaults : should this be in an external file? */
static const char default_passwd[] = "x";
/* make sure gr_name isn't taken, make sure gid is kosher /* make sure gr_name isn't taken, make sure gid is kosher
* return 1 on failure */ * return 1 on failure */
static int group_study(const char *filename, struct group *g) static int group_study(struct group *g)
{ {
FILE *etc_group; FILE *etc_group;
gid_t desired; gid_t desired;
@ -54,16 +26,16 @@ static int group_study(const char *filename, struct group *g)
struct group *grp; struct group *grp;
const int max = 65000; const int max = 65000;
etc_group = bb_xfopen(filename, "r"); etc_group = bb_xfopen(bb_path_group_file, "r");
/* make sure gr_name isn't taken, make sure gid is kosher */ /* make sure gr_name isn't taken, make sure gid is kosher */
desired = g->gr_gid; desired = g->gr_gid;
while ((grp = fgetgrent(etc_group))) { while ((grp = fgetgrent(etc_group))) {
if ((strcmp(grp->gr_name, g->gr_name)) == 0) { if ((strcmp(grp->gr_name, g->gr_name)) == 0) {
bb_error_msg_and_die("%s: group already in use\n", g->gr_name); bb_error_msg_and_die("%s: group already in use", g->gr_name);
} }
if ((desired) && grp->gr_gid == desired) { if ((desired) && grp->gr_gid == desired) {
bb_error_msg_and_die("%d: gid has already been allocated\n", bb_error_msg_and_die("%d: gid already in use",
desired); desired);
} }
if ((grp->gr_gid > g->gr_gid) && (grp->gr_gid < max)) { if ((grp->gr_gid > g->gr_gid) && (grp->gr_gid < max)) {
@ -83,56 +55,33 @@ static int group_study(const char *filename, struct group *g)
} }
/* append a new user to the passwd file */ /* append a new user to the passwd file */
static int addgroup(const char *filename, char *group, gid_t gid, const char *user) static int addgroup(char *group, gid_t gid, const char *user)
{ {
FILE *etc_group; FILE *file;
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
FILE *etc_gshadow;
#endif
struct group gr; struct group gr;
/* group:passwd:gid:userlist */
static const char entryfmt[] = "%s:%s:%d:%s\n";
/* make sure gid and group haven't already been allocated */ /* make sure gid and group haven't already been allocated */
gr.gr_gid = gid; gr.gr_gid = gid;
gr.gr_name = group; gr.gr_name = group;
if (group_study(filename, &gr)) if (group_study(&gr))
return 1; return 1;
/* add entry to group */ /* add entry to group */
etc_group = bb_xfopen(filename, "a"); file = bb_xfopen(bb_path_group_file, "a");
/* group:passwd:gid:userlist */
fprintf(file, "%s:%s:%d:%s\n", group, "x", gr.gr_gid, user);
fclose(file);
fprintf(etc_group, entryfmt, group, default_passwd, gr.gr_gid, user); #if ENABLE_FEATURE_SHADOWPASSWDS
fclose(etc_group); file = bb_xfopen(bb_path_gshadow_file, "a");
fprintf(file, "%s:!::\n", group);
fclose(file);
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* add entry to gshadow if necessary */
if (access(bb_path_gshadow_file, F_OK|W_OK) == 0) {
etc_gshadow = bb_xfopen(bb_path_gshadow_file, "a");
fprintf(etc_gshadow, "%s:!::\n", group);
fclose(etc_gshadow);
}
#endif #endif
/* return 1; */ /* return 1; */
return 0; return 0;
} }
#ifndef CONFIG_ADDUSER
static inline void if_i_am_not_root(void)
{
if (geteuid()) {
bb_error_msg_and_die( "Only root may add a user or group to the system.");
}
}
#else
extern void if_i_am_not_root(void);
#endif
/* /*
* addgroup will take a login_name as its first parameter. * addgroup will take a login_name as its first parameter.
* *
@ -143,29 +92,22 @@ extern void if_i_am_not_root(void);
int addgroup_main(int argc, char **argv) int addgroup_main(int argc, char **argv)
{ {
char *group; char *group;
char *user;
gid_t gid = 0; gid_t gid = 0;
/* check for min, max and missing args and exit on error */
bb_opt_complementally = "-1:?2:?";
/* get remaining args */ if (bb_getopt_ulflags(argc, argv, "g:", &group)) {
if(bb_getopt_ulflags(argc, argv, "g:", &group)) {
gid = bb_xgetlarg(group, 10, 0, LONG_MAX); gid = bb_xgetlarg(group, 10, 0, LONG_MAX);
} }
/* move past the commandline options */
argv += optind;
if (optind < argc) { /* need to be root */
group = argv[optind]; if(geteuid()) {
optind++; bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
} else {
bb_show_usage();
} }
if (optind < argc) {
user = argv[optind];
} else {
user = "";
}
if_i_am_not_root();
/* werk */ /* werk */
return addgroup(bb_path_group_file, group, gid, user); return addgroup(argv[0], gid, (argv[1]) ? argv[1] : "");
} }

235
loginutils/adduser.c
View File

@ -8,44 +8,20 @@
* Licensed under the GPL v2 or later, see the file LICENSE in this tarball. * Licensed under the GPL v2 or later, see the file LICENSE in this tarball.
*/ */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <getopt.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <getopt.h>
#include <sys/stat.h>
#include "busybox.h" #include "busybox.h"
#define DONT_SET_PASS (1 << 4)
#define DONT_MAKE_HOME (1 << 6)
/* structs __________________________ */
typedef struct {
uid_t u;
gid_t g;
} Id;
/* data _____________________________ */
/* defaults : should this be in an external file? */
static const char default_passwd[] = "x";
static const char default_gecos[] = "Linux User,,,";
static const char default_home_prefix[] = "/home";
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* shadow in use? */
static int shadow_enabled = 0;
#endif
/* remix */ /* remix */
/* EDR recoded such that the uid may be passed in *p */ /* EDR recoded such that the uid may be passed in *p */
static int passwd_study(const char *filename, struct passwd *p) static int passwd_study(const char *filename, struct passwd *p)
@ -56,9 +32,7 @@ static int passwd_study(const char *filename, struct passwd *p)
const int min = 500; const int min = 500;
const int max = 65000; const int max = 65000;
passwd = bb_wfopen(filename, "r"); passwd = bb_xfopen(filename, "r");
if (!passwd)
return 4;
/* EDR if uid is out of bounds, set to min */ /* EDR if uid is out of bounds, set to min */
if ((p->pw_uid > max) || (p->pw_uid < min)) if ((p->pw_uid > max) || (p->pw_uid < min))
@ -100,11 +74,11 @@ static int passwd_study(const char *filename, struct passwd *p)
return 0; return 0;
} }
static void addgroup_wrapper(const char *login, gid_t gid) static void addgroup_wrapper(struct passwd *p)
{ {
char *cmd; char *cmd;
cmd = bb_xasprintf("addgroup -g %d \"%s\"", gid, login); cmd = bb_xasprintf("addgroup -g %d \"%s\"", p->pw_gid, p->pw_name);
system(cmd); system(cmd);
free(cmd); free(cmd);
} }
@ -119,92 +93,63 @@ static void passwd_wrapper(const char *login)
} }
/* putpwent(3) remix */ /* putpwent(3) remix */
static int adduser(const char *filename, struct passwd *p, int makehome, int setpass) static int adduser(struct passwd *p, unsigned long flags)
{ {
FILE *passwd; FILE *file;
int r;
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
FILE *shadow;
struct spwd *sp;
#endif
int new_group = 1;
/* if using a pre-existing group, don't create one */
if (p->pw_gid != 0)
new_group = 0;
/* make sure everything is kosher and setup uid && gid */ /* make sure everything is kosher and setup uid && gid */
passwd = bb_wfopen(filename, "a"); file = bb_xfopen(bb_path_passwd_file, "a");
if (passwd == NULL) { fseek(file, 0, SEEK_END);
return 1;
}
fseek(passwd, 0, SEEK_END);
/* if (passwd_study(filename, p) == 0) { */ switch (passwd_study(bb_path_passwd_file, p)) {
r = passwd_study(filename, p); case 1:
if (r) { bb_error_msg_and_die("%s: login already in use", p->pw_name);
if (r == 1) case 2:
bb_error_msg("%s: login already in use", p->pw_name); bb_error_msg_and_die("illegal uid or no uids left");
else if (r == 2) case 3:
bb_error_msg("illegal uid or no uids left"); bb_error_msg_and_die("%s: group name already in use", p->pw_name);
else if (r == 3) }
bb_error_msg("group name %s already in use", p->pw_name);
else
bb_error_msg("generic error.");
return 1;
}
/* add to passwd */ /* add to passwd */
if (putpwent(p, passwd) == -1) { if (putpwent(p, file) == -1) {
return 1; bb_perror_nomsg_and_die();
} }
fclose(passwd); fclose(file);
#ifdef CONFIG_FEATURE_SHADOWPASSWDS #if ENABLE_FEATURE_SHADOWPASSWDS
/* add to shadow if necessary */ /* add to shadow if necessary */
if (shadow_enabled) { file = bb_xfopen(bb_path_shadow_file, "a");
shadow = bb_wfopen(bb_path_shadow_file, "a"); fseek(file, 0, SEEK_END);
if (shadow == NULL) { fprintf(file, "%s:!:%ld:%d:%d:%d:::\n",
return 1; p->pw_name, /* username */
} time(NULL) / 86400, /* sp->sp_lstchg */
fseek(shadow, 0, SEEK_END); 0, /* sp->sp_min */
sp = pwd_to_spwd(p); 99999, /* sp->sp_max */
sp->sp_max = 99999; /* debianish */ 7); /* sp->sp_warn */
sp->sp_warn = 7; fclose(file);
fprintf(shadow, "%s:!:%ld:%ld:%ld:%ld:::\n",
sp->sp_namp, sp->sp_lstchg, sp->sp_min, sp->sp_max,
sp->sp_warn);
fclose(shadow);
}
#endif #endif
if (new_group) { /* add to group */
/* add to group */ /* addgroup should be responsible for dealing w/ gshadow */
/* addgroup should be responsible for dealing w/ gshadow */ /* if using a pre-existing group, don't create one */
addgroup_wrapper(p->pw_name, p->pw_gid); if (p->pw_gid == 0) {
addgroup_wrapper(p);
} }
/* Clear the umask for this process so it doesn't /* Clear the umask for this process so it doesn't
* * screw up the permissions on the mkdir and chown. */ * * screw up the permissions on the mkdir and chown. */
umask(0); umask(0);
if (!(flags & DONT_MAKE_HOME)) {
if (makehome) { /* Set the owner and group so it is owned by the new user,
/* mkdir */ then fix up the permissions to 2755. Can't do it before
if (mkdir(p->pw_dir, 0755)) { since chown will clear the setgid bit */
bb_perror_msg("%s", p->pw_dir); if (mkdir(p->pw_dir, 0755)
} || chown(p->pw_dir, p->pw_uid, p->pw_gid)
/* Set the owner and group so it is owned by the new user. */ || chmod(p->pw_dir, 02755)) {
if (chown(p->pw_dir, p->pw_uid, p->pw_gid)) { bb_perror_msg("%s", p->pw_dir);
bb_perror_msg("%s", p->pw_dir); }
}
/* Now fix up the permissions to 2755. Can't do it before now
* since chown will clear the setgid bit */
if (chmod(p->pw_dir, 02755)) {
bb_perror_msg("%s", p->pw_dir);
}
} }
if (setpass) { if (!(flags & DONT_SET_PASS)) {
/* interactively set passwd */ /* interactively set passwd */
passwd_wrapper(p->pw_name); passwd_wrapper(p->pw_name);
} }
@ -212,22 +157,6 @@ static int adduser(const char *filename, struct passwd *p, int makehome, int set
return 0; return 0;
} }
/* return current uid (root is always uid == 0, right?) */
#ifndef CONFIG_ADDGROUP
static inline void if_i_am_not_root(void)
#else
void if_i_am_not_root(void)
#endif
{
if (geteuid()) {
bb_error_msg_and_die( "Only root may add a user or group to the system.");
}
}
#define SETPASS (1 << 4)
#define MAKEHOME (1 << 6)
/* /*
* adduser will take a login_name as its first parameter. * adduser will take a login_name as its first parameter.
* *
@ -240,62 +169,34 @@ void if_i_am_not_root(void)
int adduser_main(int argc, char **argv) int adduser_main(int argc, char **argv)
{ {
struct passwd pw; struct passwd pw;
const char *login;
const char *gecos = default_gecos;
const char *home = NULL;
const char *shell = DEFAULT_SHELL;
const char *usegroup = NULL; const char *usegroup = NULL;
int flags; unsigned long flags;
int setpass = 1;
int makehome = 1;
/* init */ pw.pw_gecos = "Linux User,,,";
if (argc < 2) { pw.pw_shell = (char *)DEFAULT_SHELL;
bb_show_usage(); pw.pw_dir = NULL;
}
/* get args */
flags = bb_getopt_ulflags(argc, argv, "h:g:s:G:DSH", &home, &gecos, &shell, &usegroup);
if (flags & SETPASS) { /* check for min, max and missing args and exit on error */
setpass = 0; bb_opt_complementally = "-1:?1:?";
} flags = bb_getopt_ulflags(argc, argv, "h:g:s:G:DSH", &pw.pw_dir, &pw.pw_gecos, &pw.pw_shell, &usegroup);
if (flags & MAKEHOME) {
makehome = 0;
}
/* got root? */ /* got root? */
if_i_am_not_root(); if(geteuid()) {
bb_error_msg_and_die(bb_msg_perm_denied_are_you_root);
/* get login */ }
if (optind >= argc) {
bb_error_msg_and_die( "no user specified");
}
login = argv[optind];
/* create string for $HOME if not specified already */ /* create string for $HOME if not specified already */
if (!home) { if (!pw.pw_dir) {
home = concat_path_file(default_home_prefix, login); snprintf(bb_common_bufsiz1, BUFSIZ, "/home/%s", argv[optind]);
pw.pw_dir = &bb_common_bufsiz1[0];
} }
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* is /etc/shadow in use? */
shadow_enabled = (0 == access(bb_path_shadow_file, F_OK));
#endif
/* create a passwd struct */ /* create a passwd struct */
pw.pw_name = (char *)login; pw.pw_name = argv[optind];
pw.pw_passwd = (char *)default_passwd; pw.pw_passwd = "x";
pw.pw_uid = 0; pw.pw_uid = 0;
pw.pw_gid = 0; pw.pw_gid = (usegroup) ? bb_xgetgrnam(usegroup) : 0; /* exits on failure */
pw.pw_gecos = (char *)gecos;
pw.pw_dir = (char *)home;
pw.pw_shell = (char *)shell;
if (usegroup) {
/* Add user to a group that already exists */
pw.pw_gid = bb_xgetgrnam(usegroup);
/* exits on error */
}
/* grand finale */ /* grand finale */
return adduser(bb_path_passwd_file, &pw, makehome, setpass); return adduser(&pw, flags);
} }