+2008-08-06 Nicolas François <nicolas.francois@centraliens.net>
+
+ * lib/groupio.c, lib/groupio.h, lib/pwio.c, lib/pwio.h,
+ lib/sgroupio.c, lib/sgroupio.h, lib/shadowio.c, lib/shadowio.h:
+ Added *_dbname() functions to retrieve the name of the databases.
+ * lib/groupio.c, lib/groupio.h, lib/pwio.c, lib/pwio.h,
+ lib/sgroupio.c, lib/sgroupio.h, lib/shadowio.c, lib/shadowio.h:
+ *_name() functions renamed *setname().
+ * src/grpck.c, src/pwck.c: Likewise.
+ * lib/groupio.h, lib/pwio.h, lib/sgroupio.h, lib/shadowio.h: Added
+ the name of the arguments to the prototypes.
+ * src/chage, src/chfn.c, src/chgpasswd.c, src/chpasswd.c,
+ src/chsh.c, src/gpasswd.c, src/groupadd.c, src/groupdel.c,
+ src/groupmod.c, src/grpck.c, src/grpconv.c, src/grpunconv.c,
+ src/newusers.c, src/passwd.c, src/pwck.c, src/pwconv.c,
+ src/pwunconv.c, src/useradd.c, src/userdel.c, src/usermod.c:
+ Harmonize the erro & syslog messages in case of failure of the
+ *_lock(), *_open(), *_close(), *_unlock(), *_remove() functions.
+ * src/chgpasswd.c, src/chpasswd.c, src/usermod.c: Avoid
+ capitalized messages.
+ * src/chpasswd.c, src/useradd.c, src/usermod.c: Harmonize messages
+ in case of inexistent entries.
+ * src/usermod.c: Harmonize messages in case of already existing
+ entries.
+ * src/newusers.c, src/useradd.c: Simplify PAM error handling.
+ * src/useradd.c: Report failures to unlock files (stderr, syslog,
+ and audit). But do not fail (continue).
+ * src/useradd.c (open_files): Do not report to syslog & audit
+ failures to lock or open the databases. This might be harmless,
+ and the logs were not already informed that a change was
+ requested.
+ * src/usermod.c: It's not the account which is unlocked, but its
+ password.
+
2008-08-02 Nicolas François <nicolas.francois@centraliens.net>
* src/groupadd.c: Harmonize error & syslog messages.
false /* readonly */
};
-int gr_name (const char *filename)
+int gr_setdbname (const char *filename)
{
return commonio_setname (&group_db, filename);
}
+const char *gr_dbname (void)
+{
+ return group_db.filename;
+}
+
int gr_lock (void)
{
return commonio_lock (&group_db);
#include <grp.h>
extern int gr_close (void);
-extern const struct group *gr_locate (const char *);
+extern const struct group *gr_locate (const char *name);
extern const struct group *gr_locate_gid (gid_t gid);
extern int gr_lock (void);
-extern int gr_name (const char *);
+extern int gr_setdbname (const char *filename);
+extern const char *gr_dbname (void);
extern const struct group *gr_next (void);
-extern int gr_open (int);
-extern int gr_remove (const char *);
+extern int gr_open (int mode);
+extern int gr_remove (const char *name);
extern int gr_rewind (void);
extern int gr_unlock (void);
-extern int gr_update (const struct group *);
+extern int gr_update (const struct group *gr);
extern int gr_sort (void);
#endif
false /* readonly */
};
-int pw_name (const char *filename)
+int pw_setdbname (const char *filename)
{
return commonio_setname (&passwd_db, filename);
}
+const char *pw_dbname (void)
+{
+ return passwd_db.filename;
+}
+
int pw_lock (void)
{
return commonio_lock (&passwd_db);
#include <pwd.h>
extern int pw_close (void);
-extern const struct passwd *pw_locate (const char *);
+extern const struct passwd *pw_locate (const char *name);
extern const struct passwd *pw_locate_uid (uid_t uid);
extern int pw_lock (void);
-extern int pw_name (const char *);
+extern int pw_setdbname (const char *filename);
+extern const char *pw_dbname (void);
extern const struct passwd *pw_next (void);
-extern int pw_open (int);
-extern int pw_remove (const char *);
+extern int pw_open (int mode);
+extern int pw_remove (const char *name);
extern int pw_rewind (void);
extern int pw_unlock (void);
-extern int pw_update (const struct passwd *);
+extern int pw_update (const struct passwd *pw);
extern int pw_sort (void);
#endif
false /* readonly */
};
-int sgr_name (const char *filename)
+int sgr_setdbname (const char *filename)
{
return commonio_setname (&gshadow_db, filename);
}
+const char *sgr_dbname (void)
+{
+ return gshadow_db.filename;
+}
+
bool sgr_file_present (void)
{
return commonio_present (&gshadow_db);
extern int sgr_close (void);
extern bool sgr_file_present (void);
-extern const struct sgrp *sgr_locate (const char *);
+extern const struct sgrp *sgr_locate (const char *name);
extern int sgr_lock (void);
-extern int sgr_name (const char *);
+extern int sgr_setdbname (const char *filename);
+extern const char *sgr_dbname (void);
extern const struct sgrp *sgr_next (void);
-extern int sgr_open (int);
-extern int sgr_remove (const char *);
+extern int sgr_open (int mode);
+extern int sgr_remove (const char *name);
extern int sgr_rewind (void);
extern int sgr_unlock (void);
-extern int sgr_update (const struct sgrp *);
+extern int sgr_update (const struct sgrp *sg);
extern int sgr_sort (void);
#endif
false /* readonly */
};
-int spw_name (const char *filename)
+int spw_setdbname (const char *filename)
{
return commonio_setname (&shadow_db, filename);
}
+const char *spw_dbname (void)
+{
+ return shadow_db.filename;
+}
+
bool spw_file_present (void)
{
return commonio_present (&shadow_db);
extern int spw_close (void);
extern bool spw_file_present (void);
-extern const struct spwd *spw_locate (const char *);
+extern const struct spwd *spw_locate (const char *name);
extern int spw_lock (void);
-extern int spw_name (const char *);
+extern int spw_setdbname (const char *filename);
+extern const char *spw_dbname (void);
extern const struct spwd *spw_next (void);
-extern int spw_open (int);
-extern int spw_remove (const char *);
+extern int spw_open (int mode);
+extern int spw_remove (const char *name);
extern int spw_rewind (void);
extern int spw_unlock (void);
-extern int spw_update (const struct spwd *);
+extern int spw_update (const struct spwd *sp);
extern int spw_sort (void);
#endif
*/
if (!readonly && (pw_lock () == 0)) {
fprintf (stderr,
- _("%s: can't lock password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed locking %s", PASSWD_FILE));
+ _("%s: cannot lock %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot lock %s", pw_dbname ()));
fail_exit (E_NOPERM);
}
if (!readonly) {
pw_locked = true;
}
if (pw_open (readonly ? O_RDONLY: O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed opening %s", PASSWD_FILE));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot open %s", pw_dbname ()));
fail_exit (E_NOPERM);
}
*/
if (!readonly && (spw_lock () == 0)) {
fprintf (stderr,
- _("%s: can't lock shadow password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed locking %s", SHADOW_FILE));
+ _("%s: cannot lock %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot lock %s", spw_dbname ()));
fail_exit (E_NOPERM);
}
if (!readonly) {
}
if (spw_open (readonly ? O_RDONLY: O_RDWR) == 0) {
fprintf (stderr,
- _("%s: can't open shadow password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed opening %s", SHADOW_FILE));
+ _("%s: cannot open %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot open %s", spw_dbname ()));
fail_exit (E_NOPERM);
}
}
*/
if (spw_close () == 0) {
fprintf (stderr,
- _("%s: can't rewrite shadow password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed rewriting %s", SHADOW_FILE));
+ _("%s: failure while writing changes to %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_ERR, "failure while writing changes to %s", spw_dbname ()));
fail_exit (E_NOPERM);
}
* will be re-written.
*/
if (pw_close () == 0) {
- fprintf (stderr, _("%s: can't rewrite password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed rewriting %s", PASSWD_FILE));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "failure while writing changes to %s", pw_dbname ()));
fail_exit (E_NOPERM);
}
spw_unlock ();
pwent.pw_passwd = SHADOW_PASSWD_STRING; /* XXX warning: const */
if (pw_update (&pwent) == 0) {
fprintf (stderr,
- _("%s: can't update password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed updating %s", PASSWD_FILE));
+ _("%s: cannot update %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot update %s", pw_dbname ()));
fail_exit (E_NOPERM);
}
} else {
if (spw_update (&spwent) == 0) {
fprintf (stderr,
- _("%s: can't update shadow password file\n"), Prog);
- SYSLOG ((LOG_ERR, "failed updating %s", SHADOW_FILE));
+ _("%s: cannot update %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot update %s", spw_dbname ()));
fail_exit (E_NOPERM);
}
pw = pw_locate (argv[optind]);
if (NULL == pw) {
- fprintf (stderr, _("%s: unknown user %s\n"), Prog,
- argv[optind]);
+ fprintf (stderr, _("%s: user '%s' does not exist in %s\n"),
+ Prog, argv[optind], pw_dbname ());
closelog ();
exit (E_NOPERM);
}
* password file. Get a lock on the file and open it.
*/
if (pw_lock () == 0) {
- fputs (_("Cannot lock the password file; try again later.\n"),
- stderr);
- SYSLOG ((LOG_WARN, "can't lock /etc/passwd"));
+ fprintf (stderr,
+ _("%s: cannot lock %s; try again later.\n"),
+ Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", pw_dbname ()));
closelog ();
exit (E_NOPERM);
}
if (pw_open (O_RDWR) == 0) {
- fputs (_("Cannot open the password file.\n"), stderr);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, pw_dbname ());
pw_unlock ();
- SYSLOG ((LOG_ERR, "can't open /etc/passwd"));
+ SYSLOG ((LOG_ERR, "cannot open %s", pw_dbname ()));
closelog ();
exit (E_NOPERM);
}
if (NULL == pw) {
pw_unlock ();
fprintf (stderr,
- _("%s: %s not found in /etc/passwd\n"), Prog, user);
+ _("%s: user '%s' does not exist in %s\n"),
+ Prog, user, pw_dbname ());
exit (E_NOPERM);
}
* Changes have all been made, so commit them and unlock the file.
*/
if (pw_close () == 0) {
- fputs (_("Cannot commit password file changes.\n"), stderr);
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
pw_unlock ();
- SYSLOG ((LOG_ERR, "can't rewrite /etc/passwd"));
+ SYSLOG ((LOG_ERR, "failure while writing changes to %s", pw_dbname ()));
closelog ();
exit (E_NOPERM);
}
if (pw_unlock () == 0) {
- fputs (_("Cannot unlock the password file.\n"), stderr);
- SYSLOG ((LOG_ERR, "can't unlock /etc/passwd"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "failed to unlock %s", pw_dbname ()));
closelog ();
exit (E_NOPERM);
}
user = argv[optind];
pw = xgetpwnam (user);
if (NULL == pw) {
- fprintf (stderr, _("%s: unknown user %s\n"), Prog,
+ fprintf (stderr, _("%s: user '%s' does not exist\n"), Prog,
user);
exit (E_NOPERM);
}
pw = get_my_pwent ();
if (NULL == pw) {
fprintf (stderr,
- _
- ("%s: Cannot determine your user name.\n"),
+ _("%s: Cannot determine your user name.\n"),
Prog);
exit (E_NOPERM);
}
{
if (sflg && !cflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-s", "-c");
usage ();
}
* bring all of the entries into memory where they may be updated.
*/
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, gr_dbname ());
exit (1);
}
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, gr_dbname ());
gr_unlock ();
exit (1);
}
/* Do the same for the shadowed database, if it exist */
if (is_shadow_grp) {
if (sgr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock gshadow file\n"),
- Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"),
+ Prog, sgr_dbname ());
gr_unlock ();
exit (1);
}
if (sgr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open shadow file\n"),
- Prog);
+ fprintf (stderr, _("%s: cannot open %s\n"),
+ Prog, sgr_dbname ());
gr_unlock ();
sgr_unlock ();
exit (1);
if (is_shadow_grp) {
if (sgr_close () == 0) {
fprintf (stderr,
- _("%s: error updating gshadow file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"),
+ Prog, sgr_dbname ());
gr_unlock ();
exit (1);
}
#endif
if (gr_close () == 0) {
- fprintf (stderr, _("%s: error updating group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, gr_dbname ());
exit (1);
}
gr_unlock ();
gr = gr_locate (name);
if (NULL == gr) {
fprintf (stderr,
- _("%s: line %d: unknown group %s\n"), Prog,
+ _("%s: line %d: group '%s' does not exist\n"), Prog,
line, name);
errors++;
continue;
{
if (sflg && !cflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-s", "-c");
usage ();
}
* will bring all of the entries into memory where they may be updated.
*/
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, pw_dbname ());
exit (1);
}
if (pw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, pw_dbname ());
pw_unlock ();
exit (1);
}
/* Do the same for the shadowed database, if it exist */
if (is_shadow_pwd) {
if (spw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock shadow file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"),
+ Prog, spw_dbname ());
pw_unlock ();
exit (1);
}
if (spw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open shadow file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"),
+ Prog, spw_dbname ());
pw_unlock ();
spw_unlock ();
exit (1);
if (is_shadow_pwd) {
if (spw_close () == 0) {
fprintf (stderr,
- _("%s: error updating shadow file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"),
+ Prog, spw_dbname ());
pw_unlock ();
exit (1);
}
}
if (pw_close () == 0) {
- fprintf (stderr, _("%s: error updating password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, pw_dbname ());
exit (1);
}
pw_unlock ();
pw = pw_locate (name);
if (NULL == pw) {
fprintf (stderr,
- _("%s: line %d: unknown user %s\n"), Prog,
+ _("%s: line %d: user '%s' does not exist\n"), Prog,
line, name);
errors++;
continue;
if (0 == ok) {
fprintf (stderr,
- _
- ("%s: line %d: cannot update password entry\n"),
+ _("%s: line %d: cannot update password entry\n"),
Prog, line);
errors++;
continue;
* the password file. Get a lock on the file and open it.
*/
if (pw_lock () == 0) {
- SYSLOG ((LOG_WARN, "can't lock /etc/passwd"));
+ SYSLOG ((LOG_WARN, "cannot lock %s", pw_dbname ()));
closelog ();
- fputs (_("Cannot lock the password file; try again later.\n"),
- stderr);
+ fprintf (stderr, _("%s: cannot lock %s; try again later.\n"),
+ Prog, pw_dbname ());
exit (1);
}
if (pw_open (O_RDWR) == 0) {
- SYSLOG ((LOG_ERR, "can't open /etc/passwd"));
+ SYSLOG ((LOG_ERR, "cannot open %s", pw_dbname ()));
closelog ();
- fputs (_("Cannot open the password file.\n"), stderr);
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, pw_dbname ());
pw_unlock ();
exit (1);
}
if (NULL == pw) {
pw_unlock ();
fprintf (stderr,
- _("%s: %s not found in /etc/passwd\n"), Prog, user);
+ _("%s: user '%s' does not exist in %s\n"),
+ Prog, user, pw_dbname ());
exit (1);
}
* Changes have all been made, so commit them and unlock the file.
*/
if (pw_close () == 0) {
- SYSLOG ((LOG_ERR, "can't rewrite /etc/passwd"));
+ SYSLOG ((LOG_ERR, "failure while writing changes to %s", pw_dbname ()));
closelog ();
- fputs (_("Cannot commit password file changes.\n"), stderr);
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
pw_unlock ();
exit (1);
}
if (pw_unlock () == 0) {
- SYSLOG ((LOG_ERR, "can't unlock /etc/passwd"));
+ SYSLOG ((LOG_ERR, "failed to unlock %s", pw_dbname ()));
closelog ();
- fputs (_("Cannot unlock the password file.\n"), stderr);
+ fprintf (stderr,
+ _("%s: failed to unlock %s\n"), Prog, pw_dbname ());
exit (1);
}
}
pw = xgetpwnam (user);
if (NULL == pw) {
fprintf (stderr,
- _("%s: unknown user %s\n"), Prog, user);
+ _("%s: user '%s' does not exist\n"), Prog, user);
exit (1);
}
} else {
{
if (group_locked) {
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
#ifdef SHADOWGRP
if (gshadow_locked) {
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
static void open_files (void)
{
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: cannot lock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the group file"));
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking /etc/group",
if (is_shadowgrp) {
if (sgr_lock () == 0) {
fprintf (stderr,
- _("%s: cannot lock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the shadow group file"));
+ _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking /etc/gshadow",
}
#endif
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the group file"));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening /etc/group",
}
#ifdef SHADOWGRP
if (is_shadowgrp && (sgr_open (O_RDWR) == 0)) {
- fprintf (stderr, _("%s: cannot open the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the shadow group file"));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening /etc/gshadow",
static void close_files (void)
{
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the group file"));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"rewriting /etc/group",
#ifdef SHADOWGRP
if (is_shadowgrp) {
if (sgr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the shadow group file"));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"rewriting /etc/gshadow",
fail_exit (1);
}
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
}
#endif
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
#endif
{
if (gr_update (gr) == 0) {
- fprintf (stderr, _("%s: cannot update the entry of '%s' in the group file\n"), Prog, gr->gr_name);
- SYSLOG ((LOG_WARN, "cannot update the entry of '%s' in the group file", gr->gr_name));
+ fprintf (stderr,
+ _("%s: cannot update entry '%s' in %s\n"),
+ Prog, gr->gr_name, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot update entry '%s' in %s", gr->gr_name, gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"updating /etc/group",
}
#ifdef SHADOWGRP
if (is_shadowgrp && (sgr_update (sg) == 0)) {
- fprintf (stderr, _("%s: cannot update the entry of '%s' in the shadow group file\n"), Prog, sg->sg_name);
- SYSLOG ((LOG_WARN, "cannot update the entry of '%s' in the shadow group file", sg->sg_name));
+ fprintf (stderr, _("%s: cannot update entry '%s' in %s\n"), Prog, sg->sg_name, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot update entry '%s' in %s", sg->sg_name, sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"updating /etc/gshadow",
struct sgrp const*tmpsg = NULL;
if (gr_open (O_RDONLY) == 0) {
- fprintf (stderr, _("%s: cannot open the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the group file"));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening /etc/group",
tmpgr = gr_locate (group);
if (NULL == tmpgr) {
- fprintf (stderr, _("%s: group '%s' does not exist in the group file\n"), Prog, group);
+ fprintf (stderr, _("%s: group '%s' does not exist in %s\n"), Prog, group, gr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"group lookup",
gr->gr_mem = dup_list (tmpgr->gr_mem);
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the group file"));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"closing /etc/group",
if (is_shadowgrp) {
if (sgr_open (O_RDONLY) == 0) {
fprintf (stderr,
- _("%s: cannot open the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the shadow group file"));
+ _("%s: cannot open %s\n"), Prog, sgr_dbmane ());
+ SYSLOG ((LOG_WARN, "cannot open %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening /etc/gshadow",
}
if (sgr_close () == 0) {
fprintf (stderr,
- _("%s: cannot rewrite the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the shadow group file"));
+ _("%s: failure while writing changes to %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"closing /etc/gshadow",
* Write out the new group file entry.
*/
if (gr_update (&grp) == 0) {
- fprintf (stderr, _("%s: error adding new entry '%s' in the group file\n"), Prog, grp.gr_name);
- SYSLOG ((LOG_WARN, "error adding new entry '%s' in the group file", grp.gr_name));
+ fprintf (stderr, _("%s: error adding new entry '%s' in %s\n"), Prog, grp.gr_name, gr_dbname ());
+ SYSLOG ((LOG_WARN, "error adding new entry '%s' in %s", grp.gr_name, gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
* Write out the new shadow group entries as well.
*/
if (is_shadow_grp && (sgr_update (&sgrp) == 0)) {
- fprintf (stderr, _("%s: error adding new entry '%s' in the shadow group file\n"), Prog, sgrp.sg_name);
- SYSLOG ((LOG_WARN, "error adding new entry '%s' in the shadow group file", sgrp.sg_name));
+ fprintf (stderr, _("%s: error adding new entry '%s' in %s\n"), Prog, sgrp.sg_name, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "error adding new entry '%s' in %s", sgrp.sg_name, sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
#endif /* SHADOWGRP */
static void close_files (void)
{
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the group file"));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
if (is_shadow_grp) {
if (sgr_close () == 0) {
fprintf (stderr,
- _("%s: cannot rewrite the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the shadow group file"));
+ _("%s: failure while writing changes to %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
static void open_files (void)
{
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: cannot lock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the group file"));
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking group file",
}
group_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the group file"));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening group file",
if (is_shadow_grp) {
if (sgr_lock () == 0) {
fprintf (stderr,
- _("%s: cannot lock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the shadow group file"));
+ _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking gshadow file",
gshadow_locked = true;
if (sgr_open (O_RDWR) == 0) {
fprintf (stderr,
- _("%s: cannot open the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the shadow group file"));
+ _("%s: cannot open %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening gshadow file",
{
if (group_locked) {
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
#ifdef SHADOWGRP
if (gshadow_locked) {
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
cp = strchr (optarg, '=');
if (NULL == cp) {
fprintf (stderr,
- _
- ("%s: -K requires KEY=VALUE\n"),
+ _("%s: -K requires KEY=VALUE\n"),
Prog);
exit (E_BAD_ARG);
}
/* Turn off -g, we can use any GID */
gflg = false;
} else {
- fprintf (stderr, _("%s: GID '%u' already exists\n"),
- Prog, (unsigned int) group_id);
+ fprintf (stderr, _("%s: GID '%lu' already exists\n"),
+ Prog, (unsigned long int) group_id);
fail_exit (E_GID_IN_USE);
}
}
{
if (group_locked) {
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
#ifdef SHADOWGRP
if (gshadow_locked) {
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
static void grp_update (void)
{
if (gr_remove (group_name) == 0) {
- fprintf (stderr, _("%s: cannot remove group '%s' from the group database\n"), Prog, group_name);
+ fprintf (stderr,
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, group_name, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp && (sgr_locate (group_name) != NULL)) {
if (sgr_remove (group_name) == 0) {
fprintf (stderr,
- _("%s: cannot remove group '%s' from the shadow group database\n"),
- Prog, group_name);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, group_name, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
}
SYSLOG ((LOG_INFO, "remove group '%s'\n", group_name));
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the group file"));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
if (is_shadow_grp) {
if (sgr_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the shadow group file"));
+ _("%s: failure while writing changes to %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
static void open_files (void)
{
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: cannot lock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the group file"));
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s",gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
group_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the group file"));
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp) {
if (sgr_lock () == 0)) {
fprintf (stderr,
- _("%s: cannot lock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the shadow group file"));
+ _("%s: cannot lock %s\n"),
+ Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
gshadow_locked = true;
if (sgr_open (O_RDWR) == 0)) {
fprintf (stderr,
- _("%s: cannot open the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the shadow group file"));
+ _("%s: cannot open %s\n"),
+ Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
}
{
if (group_locked) {
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
#ifdef SHADOWGRP
if (gshadow_locked) {
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
#endif /* SHADOWGRP */
if (passwd_locked) {
if (pw_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the passwd file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the passwd file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", pw_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking passwd file",
ogrp = gr_locate (group_name);
if (!ogrp) {
fprintf (stderr,
- _("%s: group '%s' does not exist in the group file\n"),
- Prog, group_name);
+ _("%s: group '%s' does not exist in %s\n"),
+ Prog, group_name, gr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"modifying group",
* Write out the new group file entry.
*/
if (gr_update (&grp) == 0) {
- fprintf (stderr, _("%s: cannot add entry '%s' to the group database\n"), Prog, grp.gr_name);
+ fprintf (stderr,
+ _("%s: cannot add entry '%s' to %s\n"),
+ Prog, grp.gr_name, gr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"adding group",
fail_exit (E_GRP_UPDATE);
}
if (nflg && (gr_remove (group_name) == 0)) {
- fprintf (stderr, _("%s: cannot remove the entry of '%s' from the group database\n"), Prog, grp.gr_name);
+ fprintf (stderr,
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, grp.gr_name, gr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"deleting group",
* "out" if there wasn't. Can't just return because there might be
* some syslogging to do.
*/
- if (NULL == osgrp)
+ if (NULL == osgrp) {
goto out;
+ }
/*
* Write out the new shadow group entries as well.
*/
if (is_shadow_grp && (sgr_update (&sgrp) == 0)) {
- fprintf (stderr, _("%s: cannot add entry '%s' to the shadow group database\n"), Prog, sgrp.sg_name);
+ fprintf (stderr, _("%s: cannot add entry '%s' to %s\n"), Prog, sgrp.sg_name, sgr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"adding group",
fail_exit (E_GRP_UPDATE);
}
if (is_shadow_grp && nflg && (sgr_remove (group_name) == 0)) {
- fprintf (stderr, _("%s: cannot remove the entry of '%s' from the shadow group database\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, sgr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"deleting group",
static void close_files (void)
{
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the group file"));
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"rewrite group file",
fail_exit (E_GRP_UPDATE);
}
if (gr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking group file",
if (is_shadow_grp) {
if (sgr_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the shadow group file"));
+ _("%s: failure while writing changes to %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"rewrite gshadow file",
fail_exit (E_GRP_UPDATE);
}
if (sgr_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the shadow group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the shadow group file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking gshadow file",
if (gflg) {
if (pw_close () == 0) {
fprintf (stderr,
- _("%s: cannot rewrite the passwd file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot rewrite the passwd file"));
+ _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", pw_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"rewrite passwd file",
fail_exit (E_GRP_UPDATE);
}
if (pw_unlock () == 0) {
- fprintf (stderr, _("%s: cannot unlock the passwd file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot unlock the passwd file"));
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", pw_dbname ()));
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"unlocking passwd file",
static void open_files (void)
{
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: cannot lock the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot lock the group file"));
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
group_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open the group file\n"), Prog);
- SYSLOG ((LOG_WARN, "cannot open the group file"));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp) {
if (sgr_lock () == 0) {
fprintf (stderr,
- _("%s: cannot lock the shadow group file\n"),
- Prog);
- SYSLOG ((LOG_WARN, "cannot lock the shadow group file"));
+ _("%s: cannot lock %s\n"),
+ Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
gshadow_locked = true;
if (sgr_open (O_RDWR) == 0) {
fprintf (stderr,
- _("%s: cannot open the shadow group file\n"),
- Prog);
- SYSLOG ((LOG_WARN, "cannot open the shadow group file"));
+ _("%s: cannot open %s\n"),
+ Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
}
if (gflg) {
if (pw_lock () == 0) {
fprintf (stderr,
- _("%s: cannot lock the passwd file\n"),
- Prog);
- SYSLOG ((LOG_WARN, "cannot lock the passwd file"));
+ _("%s: cannot lock %s\n"),
+ Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", pw_dbname ()));
fail_exit (E_GRP_UPDATE);
}
passwd_locked = true;
if (pw_open (O_RDWR) == 0) {
fprintf (stderr,
- _("%s: cannot open the passwd file\n"),
- Prog);
- SYSLOG ((LOG_WARN, "cannot open the passwd file"));
+ _("%s: cannot open %s\n"),
+ Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "cannot open %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
}
lpwd = pw_locate (pwd->pw_name);
if (NULL == lpwd) {
fprintf (stderr,
- _("%s: cannot change the primary group of user '%s' from %lu to %lu, since it is not in the passwd file.\n"),
+ _("%s: cannot change the primary group of user '%s' from %lu to %lu, since it is not in %s.\n"),
Prog, pwd->pw_name,
(unsigned long) ogid,
- (unsigned long) ngid);
+ (unsigned long) ngid,
+ pw_dbname ());
fail_exit (E_GRP_UPDATE);
} else {
npwd = *lpwd;
*/
if (optind != argc) {
grp_file = argv[optind];
- gr_name (grp_file);
+ gr_setdbname (grp_file);
use_system_grp_file = false;
}
#ifdef SHADOWGRP
if ((optind + 2) == argc) {
sgr_file = argv[optind + 1];
- sgr_name (sgr_file);
+ sgr_setdbname (sgr_file);
is_shadow = true;
use_system_sgr_file = false;
} else if (optind == argc) {
*/
if (!read_only) {
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: cannot lock file %s\n"),
+ fprintf (stderr, _("%s: cannot lock %s\n"),
Prog, grp_file);
if (use_system_grp_file) {
SYSLOG ((LOG_WARN, "cannot lock %s", grp_file));
}
#ifdef SHADOWGRP
if (is_shadow && (sgr_lock () == 0)) {
- fprintf (stderr, _("%s: cannot lock file %s\n"),
+ fprintf (stderr, _("%s: cannot lock %s\n"),
Prog, sgr_file);
if (use_system_sgr_file) {
SYSLOG ((LOG_WARN, "cannot lock %s", sgr_file));
* O_RDWR otherwise.
*/
if (gr_open (read_only ? O_RDONLY : O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open file %s\n"), Prog,
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog,
grp_file);
if (use_system_grp_file) {
SYSLOG ((LOG_WARN, "cannot open %s", grp_file));
}
#ifdef SHADOWGRP
if (is_shadow && (sgr_open (read_only ? O_RDONLY : O_RDWR) == 0)) {
- fprintf (stderr, _("%s: cannot open file %s\n"), Prog,
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog,
sgr_file);
if (use_system_sgr_file) {
SYSLOG ((LOG_WARN, "cannot open %s", sgr_file));
*/
if (changed) {
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot update file %s\n"),
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"),
Prog, grp_file);
exit (E_CANT_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow && (sgr_close () == 0)) {
- fprintf (stderr, _("%s: cannot update file %s\n"),
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"),
Prog, sgr_file);
exit (E_CANT_UPDATE);
}
(void) textdomain (PACKAGE);
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, gr_dbname ());
fail_exit (5);
}
group_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
fail_exit (1);
}
if (sgr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock shadow group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
fail_exit (5);
}
gshadow_locked = true;
if (sgr_open (O_CREAT | O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open shadow group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, sgr_dbname ());
fail_exit (1);
}
* This shouldn't happen (the entry exists) but...
*/
fprintf (stderr,
- _("%s: can't remove shadow group %s\n"),
- Prog, sg->sg_name);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, sg->sg_name, sgr_dbname ());
fail_exit (3);
}
}
}
if (sgr_close () == 0) {
- fprintf (stderr, _("%s: can't update shadow group file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, sgr_dbname ());
fail_exit (3);
}
if (gr_close () == 0) {
- fprintf (stderr, _("%s: can't update group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, gr_dbname ());
fail_exit (3);
}
sgr_unlock ();
* Copyright (c) 1996 , Michael Meskes
* Copyright (c) 1996 - 2000, Marek Michałkiewicz
* Copyright (c) 2002 - 2006, Tomasz Kłoczko
+ * Copyright (c) 2008 , Nicolas François
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
}
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, gr_dbname ());
fail_exit (5);
}
group_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, gr_dbname ());
fail_exit (1);
}
if (sgr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock shadow group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
fail_exit (5);
}
gshadow_locked = true;
if (sgr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open shadow group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, sgr_dbname ());
fail_exit (1);
}
}
if (sgr_close () == 0) {
- fprintf (stderr, _("%s: can't update shadow group file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, sgr_dbname ());
fail_exit (3);
}
if (gr_close () == 0) {
- fprintf (stderr, _("%s: can't update group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, gr_dbname ());
fail_exit (3);
}
if (unlink (SGROUP_FILE) != 0) {
- fprintf (stderr, _("%s: can't delete shadow group file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: cannot delete %s\n"),
+ Prog, SGROUP_FILE);
fail_exit (3);
}
exit (1);
}
#endif /* !SHADOWGRP */
+
{
if (sflg && !cflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-s", "-c");
usage ();
}
struct passwd *pampw;
pampw = getpwuid (getuid ()); /* local, no need for xgetpwuid */
- if (pampw == NULL) {
+ if (NULL == pampw) {
retval = PAM_USER_UNKNOWN;
}
- if (retval == PAM_SUCCESS) {
+ if (PAM_SUCCESS == retval) {
retval = pam_start ("newusers", pampw->pw_name, &conv, &pamh);
}
- if (retval == PAM_SUCCESS) {
+ if (PAM_SUCCESS == retval) {
retval = pam_authenticate (pamh, 0);
- if (retval != PAM_SUCCESS) {
- (void) pam_end (pamh, retval);
- }
}
- if (retval == PAM_SUCCESS) {
+ if (PAM_SUCCESS == retval) {
retval = pam_acct_mgmt (pamh, 0);
- if (retval != PAM_SUCCESS) {
- (void) pam_end (pamh, retval);
- }
}
- if (retval != PAM_SUCCESS) {
+ if (PAM_SUCCESS != retval) {
+ (void) pam_end (pamh, retval);
fprintf (stderr, _("%s: PAM authentication failed\n"), Prog);
fail_exit (1);
}
* it gets locked, assume the others can be locked right away.
*/
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock /etc/passwd.\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, pw_dbname ());
fail_exit (1);
}
passwd_locked = true;
if (is_shadow && (spw_lock () == 0)) {
- fprintf (stderr, _("%s: can't lock /etc/shadow.\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, spw_dbname ());
fail_exit (1);
}
shadow_locked = true;
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: can't lock /etc/group.\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, gr_dbname ());
fail_exit (1);
}
group_locked = true;
#ifdef SHADOWGRP
if (is_shadow_grp && (sgr_lock () == 0)) {
- fprintf (stderr, _("%s: can't lock /etc/gshadow.\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
fail_exit (1);
}
gshadow_locked = true;
pw = pw_locate (fields[0]);
if (NULL == pw) {
fprintf (stderr,
- _("%s: line %d: cannot find user %s\n"),
- Prog, line, fields[0]);
+ _("%s: line %d: user '%s' does not exist in %s\n"),
+ Prog, line, fields[0], pw_dbname ());
errors++;
continue;
}
struct passwd *npw;
if (pw_lock () == 0) {
- fputs (_("Cannot lock the password file; try again later.\n"),
- stderr);
- SYSLOG ((LOG_WARN, "can't lock password file"));
+ fprintf (stderr,
+ _("%s: cannot lock %s; try again later.\n"),
+ Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", pw_dbname ()));
exit (E_PWDBUSY);
}
if (pw_open (O_RDWR) == 0) {
- fputs (_("Cannot open the password file.\n"), stderr);
- SYSLOG ((LOG_ERR, "can't open password file"));
+ fprintf (stderr,
+ _("%s: cannot open %s\n"),
+ Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot open %s", pw_dbname ()));
fail_exit (E_MISSING);
}
pw = pw_locate (name);
if (NULL == pw) {
- fprintf (stderr, _("%s: %s not found in /etc/passwd\n"),
- Prog, name);
+ fprintf (stderr,
+ _("%s: user '%s' does not exist in %s\n"),
+ Prog, name, pw_dbname ());
fail_exit (E_NOPERM);
}
npw = __pw_dup (pw);
fail_exit (E_FAILURE);
}
if (pw_close () == 0) {
- fputs (_("Cannot commit password file changes.\n"), stderr);
- SYSLOG ((LOG_ERR, "can't rewrite password file"));
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, pw_dbname ());
+ SYSLOG ((LOG_ERR, "failure while writing changes to %s", pw_dbname ()));
fail_exit (E_FAILURE);
}
pw_unlock ();
struct spwd *nsp;
if (spw_lock () == 0) {
- fputs (_("Cannot lock the password file; try again later.\n"),
- stderr);
- SYSLOG ((LOG_WARN, "can't lock password file"));
+ fprintf (stderr,
+ _("%s: cannot lock %s; try again later.\n"),
+ Prog, spw_dbname ());
+ SYSLOG ((LOG_WARN, "cannot lock %s", spw_dbname ()));
exit (E_PWDBUSY);
}
if (spw_open (O_RDWR) == 0) {
- fputs (_("Cannot open the password file.\n"), stderr);
- SYSLOG ((LOG_ERR, "can't open password file"));
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_ERR, "cannot open %s", spw_dbname ()));
fail_exit (E_FAILURE);
}
sp = spw_locate (name);
fail_exit (E_FAILURE);
}
if (spw_close () == 0) {
- fputs (_("Cannot commit password file changes.\n"), stderr);
- SYSLOG ((LOG_ERR, "can't rewrite password file"));
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, spw_dbname ());
+ SYSLOG ((LOG_ERR, "failure while writing changes to %s", spw_dbname ()));
fail_exit (E_FAILURE);
}
spw_unlock ();
/* only "files" supported for now */
if (strcmp (optarg, "files") != 0) {
fprintf (stderr,
- _
- ("%s: repository %s not supported\n"),
+ _("%s: repository %s not supported\n"),
Prog, optarg);
exit (E_BAD_ARG);
}
pw = xgetpwnam (name);
if (NULL == pw) {
- fprintf (stderr, _("%s: unknown user %s\n"), Prog, name);
+ fprintf (stderr, _("%s: user '%s' does not exist\n"), Prog, name);
exit (E_NOPERM);
}
#ifdef WITH_SELINUX
*/
if (!amroot && (pw->pw_uid != getuid ())) {
fprintf (stderr,
- _
- ("%s: You may not view or modify password information for %s.\n"),
- Prog, name);
+ _("%s: You may not view or modify password information for %s.\n"),
+ Prog, name);
SYSLOG ((LOG_WARN,
"%s: can't view or modify password information for %s",
Prog, name));
*/
if (optind != argc) {
pwd_file = argv[optind];
- pw_name (pwd_file);
+ pw_setdbname (pwd_file);
use_system_pw_file = false;
}
if ((optind + 2) == argc) {
spw_file = argv[optind + 1];
- spw_name (spw_file);
+ spw_setdbname (spw_file);
is_shadow = true;
use_system_spw_file = false;
} else if (optind == argc) {
*/
if (!read_only) {
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: cannot lock file %s\n"),
+ fprintf (stderr, _("%s: cannot lock %s\n"),
Prog, pwd_file);
if (use_system_pw_file) {
SYSLOG ((LOG_WARN, "cannot lock %s", pwd_file));
exit (E_CANTLOCK);
}
if (is_shadow && (spw_lock () == 0)) {
- fprintf (stderr, _("%s: cannot lock file %s\n"),
+ fprintf (stderr, _("%s: cannot lock %s\n"),
Prog, spw_file);
if (use_system_spw_file) {
SYSLOG ((LOG_WARN, "cannot lock %s", spw_file));
* otherwise.
*/
if (pw_open (read_only ? O_RDONLY : O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open file %s\n"),
+ fprintf (stderr, _("%s: cannot open %s\n"),
Prog, pwd_file);
if (use_system_pw_file) {
SYSLOG ((LOG_WARN, "cannot open %s", pwd_file));
exit (E_CANTOPEN);
}
if (is_shadow && (spw_open (read_only ? O_RDONLY : O_RDWR) == 0)) {
- fprintf (stderr, _("%s: cannot open file %s\n"),
+ fprintf (stderr, _("%s: cannot open %s\n"),
Prog, spw_file);
if (use_system_spw_file) {
SYSLOG ((LOG_WARN, "cannot open %s", spw_file));
*/
if (changed) {
if (pw_close () == 0) {
- fprintf (stderr, _("%s: cannot update file %s\n"),
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"),
Prog, pwd_file);
- SYSLOG ((LOG_WARN, "cannot update %s", pwd_file));
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", pwd_file));
closelog ();
exit (E_CANTUPDATE);
}
if (is_shadow && (spw_close () == 0)) {
- fprintf (stderr, _("%s: cannot update file %s\n"),
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"),
Prog, spw_file);
- SYSLOG ((LOG_WARN, "cannot update %s", spw_file));
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", spw_file));
closelog ();
exit (E_CANTUPDATE);
}
(void) textdomain (PACKAGE);
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock passwd file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, pw_dbname ());
fail_exit (E_PWDBUSY);
}
passwd_locked = true;
if (pw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open passwd file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, pw_dbname ());
fail_exit (E_MISSING);
}
if (spw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock shadow file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, spw_dbname ());
fail_exit (E_PWDBUSY);
}
shadow_locked = true;
if (spw_open (O_CREAT | O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open shadow file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, spw_dbname ());
fail_exit (E_FAILURE);
}
* This shouldn't happen (the entry exists) but...
*/
fprintf (stderr,
- _
- ("%s: can't remove shadow entry for %s\n"),
- Prog, sp->sp_namp);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, sp->sp_namp, spw_dbname ());
fail_exit (E_FAILURE);
}
}
}
if (spw_close () == 0) {
- fprintf (stderr, _("%s: can't update shadow file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, spw_dbname ());
fail_exit (E_FAILURE);
}
if (pw_close () == 0) {
- fprintf (stderr, _("%s: can't update passwd file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, pw_dbname ());
fail_exit (E_FAILURE);
}
chmod (PASSWD_FILE "-", 0600); /* /etc/passwd- (backup file) */
}
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock passwd file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"),
+ Prog, pw_dbname ());
fail_exit (5);
}
passwd_locked = true;
if (pw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open passwd file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"),
+ Prog, pw_dbname ());
fail_exit (1);
}
if (spw_lock () == 0) {
- fprintf (stderr, _("%s: can't lock shadow file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"),
+ Prog, spw_dbname ());
fail_exit (5);
}
shadow_locked = true;
if (spw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: can't open shadow file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"),
+ Prog, spw_dbname ());
fail_exit (1);
}
if (spw_close () == 0) {
fprintf (stderr,
- _("%s: can't update shadow password file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"),
+ Prog, spw_dbname ());
fail_exit (3);
}
if (pw_close () == 0) {
- fprintf (stderr, _("%s: can't update password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, pw_dbname ());
fail_exit (3);
}
if (unlink (SHADOW) != 0) {
fprintf (stderr,
- _("%s: can't delete shadow password file\n"), Prog);
+ _("%s: cannot delete %s\n"), Prog, SHADOW);
fail_exit (3);
}
*/
static void fail_exit (int code)
{
- if (home_added)
+ if (home_added) {
rmdir (user_home);
+ }
if (shadow_locked) {
- spw_unlock ();
+ if (spw_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", spw_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking shadow file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
}
if (passwd_locked) {
- pw_unlock ();
+ if (pw_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", pw_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking passwd file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
}
if (group_locked) {
- gr_unlock ();
+ if (gr_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking group file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
}
#ifdef SHADOWGRP
if (gshadow_locked) {
- sgr_unlock ();
+ if (sgr_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking gshadow file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
}
#endif
def_gname = xstrdup (grp->gr_name);
} else {
fprintf (stderr,
- _("%s: unknown GID %s\n"),
+ _("%s: GID '%s' does not exist\n"),
Prog, cp);
}
/* local, no need for xgetgrnam */
def_gname = xstrdup (cp);
} else {
fprintf (stderr,
- _("%s: unknown group %s\n"), Prog, cp);
+ _("%s: group '%s' does not exist\n"), Prog, cp);
}
}
* string name.
*/
if (NULL == grp) {
- fprintf (stderr, _("%s: unknown group %s\n"),
+ fprintf (stderr, _("%s: group '%s' does not exist\n"),
Prog, list);
errors++;
}
{
memzero (pwent, sizeof *pwent);
pwent->pw_name = (char *) user_name;
- if (is_shadow_pwd)
+ if (is_shadow_pwd) {
pwent->pw_passwd = (char *) SHADOW_PASSWD_STRING;
- else
+ } else {
pwent->pw_passwd = (char *) user_pass;
+ }
pwent->pw_uid = user_id;
pwent->pw_gid = user_gid;
static long scale_age (long x)
{
- if (x <= 0)
+ if (x <= 0) {
return x;
+ }
return x * (DAY / SCALE);
}
* Scan through the entire group file looking for the groups that
* the user is a member of.
*/
- for (gr_rewind (), grp = gr_next (); grp; grp = gr_next ()) {
+ for (gr_rewind (), grp = gr_next (); NULL != grp; grp = gr_next ()) {
/*
* See if the user specified this group as one of their
* concurrent groups.
*/
- if (!is_on_list (user_groups, grp->gr_name))
+ if (!is_on_list (user_groups, grp->gr_name)) {
continue;
+ }
/*
* Make a copy - gr_update() will free() everything
* See if the user specified this group as one of their
* concurrent groups.
*/
- if (gr_locate (sgrp->sg_name) == NULL)
+ if (gr_locate (sgrp->sg_name) == NULL) {
continue;
+ }
- if (!is_on_list (user_groups, sgrp->sg_name))
+ if (!is_on_list (user_groups, sgrp->sg_name)) {
continue;
+ }
/*
* Make a copy - sgr_update() will free() everything
nsgrp = __sgr_dup (sgrp);
if (NULL == nsgrp) {
fprintf (stderr,
- _("%s: Out of memory. Cannot update the shadow group database.\n"),
- Prog);
+ _("%s: Out of memory. Cannot update %s.\n"),
+ Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE); /* XXX */
}
nsgrp->sg_mem = add_list (nsgrp->sg_mem, user_name);
if (sgr_update (nsgrp) == 0) {
fprintf (stderr,
- _("%s: error adding new group entry\n"), Prog);
+ _("%s: error adding new entry to %s\n"), Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
#ifdef WITH_AUDIT
long_options, NULL)) != -1) {
switch (c) {
case 'b':
- if (!VALID (optarg)
- || optarg[0] != '/') {
+ if ( ( !VALID (optarg) )
+ || ( optarg[0] != '/' )) {
fprintf (stderr,
- _
- ("%s: invalid base directory '%s'\n"),
- Prog, optarg);
+ _("%s: invalid base directory '%s'\n"),
+ Prog, optarg);
exit (E_BAD_ARG);
}
def_home = optarg;
case 'c':
if (!VALID (optarg)) {
fprintf (stderr,
- _
- ("%s: invalid comment '%s'\n"),
- Prog, optarg);
+ _("%s: invalid comment '%s'\n"),
+ Prog, optarg);
exit (E_BAD_ARG);
}
user_comment = optarg;
cflg = true;
break;
case 'd':
- if (!VALID (optarg)
- || optarg[0] != '/') {
+ if ( ( !VALID (optarg) )
+ || ( optarg[0] != '/' )) {
fprintf (stderr,
- _
- ("%s: invalid home directory '%s'\n"),
- Prog, optarg);
+ _("%s: invalid home directory '%s'\n"),
+ Prog, optarg);
exit (E_BAD_ARG);
}
user_home = optarg;
dflg = true;
break;
case 'D':
- if (anyflag)
+ if (anyflag) {
usage ();
+ }
Dflg = true;
break;
case 'e':
user_expire = strtoday (optarg);
if (user_expire == -1) {
fprintf (stderr,
- _
- ("%s: invalid date '%s'\n"),
- Prog, optarg);
+ _("%s: invalid date '%s'\n"),
+ Prog, optarg);
exit (E_BAD_ARG);
}
- } else
+ } else {
user_expire = -1;
+ }
/*
* -e "" is allowed - it's a no-op without /etc/shadow
*/
if (('\0' != *optarg) && !is_shadow_pwd) {
fprintf (stderr,
- _
- ("%s: shadow passwords required for -e\n"),
- Prog);
+ _("%s: shadow passwords required for -e\n"),
+ Prog);
exit (E_USAGE);
}
- if (Dflg)
+ if (Dflg) {
def_expire = optarg;
+ }
eflg = true;
break;
case 'f':
cp = strchr (optarg, '=');
if (NULL == cp) {
fprintf (stderr,
- _
- ("%s: -K requires KEY=VALUE\n"),
- Prog);
+ _("%s: -K requires KEY=VALUE\n"),
+ Prog);
exit (E_BAD_ARG);
}
/* terminate name, point to value */
*cp = '\0';
cp++;
- if (putdef_str (optarg, cp) < 0)
+ if (putdef_str (optarg, cp) < 0) {
exit (E_BAD_ARG);
+ }
break;
case 'l':
lflg = true;
case 'p': /* set encrypted password */
if (!VALID (optarg)) {
fprintf (stderr,
- _
- ("%s: invalid field '%s'\n"),
- Prog, optarg);
+ _("%s: invalid field '%s'\n"),
+ Prog, optarg);
exit (E_BAD_ARG);
}
user_pass = optarg;
rflg = true;
break;
case 's':
- if (!VALID (optarg)
+ if ( ( !VALID (optarg) )
|| ( ('\0' != optarg[0])
&& ('/' != optarg[0])
- && ('*' != optarg[0]))) {
+ && ('*' != optarg[0]) )) {
fprintf (stderr,
- _
- ("%s: invalid shell '%s'\n"),
- Prog, optarg);
+ _("%s: invalid shell '%s'\n"),
+ Prog, optarg);
exit (E_BAD_ARG);
}
user_shell = optarg;
*/
if (oflg && !uflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-o", "-u");
usage ();
}
if (kflg && !mflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-k", "-m");
usage ();
}
* for the -b, -e, -f, -g, -s options only.
*/
if (Dflg) {
- if (optind != argc)
+ if (optind != argc) {
usage ();
+ }
- if (uflg || oflg || Gflg || dflg || cflg || mflg)
+ if (uflg || oflg || Gflg || dflg || cflg || mflg) {
usage ();
+ }
} else {
- if (optind != argc - 1)
+ if (optind != argc - 1) {
usage ();
+ }
user_name = argv[optind];
if (!is_valid_user_name (user_name)) {
fprintf (stderr,
- _
- ("%s: invalid user name '%s'\n"),
- Prog, user_name);
+ _("%s: invalid user name '%s'\n"),
+ Prog, user_name);
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"adding user",
}
}
- if (!eflg)
+ if (!eflg) {
user_expire = strtoday (def_expire);
+ }
- if (!gflg)
+ if (!gflg) {
user_gid = def_group;
+ }
- if (!sflg)
+ if (!sflg) {
user_shell = def_shell;
+ }
/* TODO: add handle change default spool mail creation by
-K CREATE_MAIL_SPOOL={yes,no}. It need rewrite internal API for handle
static void close_files (void)
{
if (pw_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite password file\n"), Prog);
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", pw_dbname ()));
fail_exit (E_PW_UPDATE);
}
if (is_shadow_pwd && (spw_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite shadow password file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", spw_dbname ()));
fail_exit (E_PW_UPDATE);
}
if (do_grp_update) {
if (gr_close () == 0) {
fprintf (stderr,
- _("%s: cannot rewrite group file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp && (sgr_close () == 0)) {
fprintf (stderr,
- _
- ("%s: cannot rewrite shadow group file\n"),
- Prog);
+ _("%s: failure while writing changes to %s\n"),
+ Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failure while writing changes to %s", sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
#endif
}
if (is_shadow_pwd) {
- spw_unlock ();
+ if (spw_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, spw_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", spw_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking shadow file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
shadow_locked = false;
}
- pw_unlock ();
+ if (pw_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, pw_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", pw_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking passwd file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
passwd_locked = false;
- gr_unlock ();
+ if (gr_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, gr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", gr_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking group file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
group_locked = false;
#ifdef SHADOWGRP
if (is_shadow_grp) {
- sgr_unlock ();
+ if (sgr_unlock () == 0) {
+ fprintf (stderr, _("%s: failed to unlock %s\n"), Prog, sgr_dbname ());
+ SYSLOG ((LOG_WARN, "failed to unlock %s", sgr_dbname ()));
+#ifdef WITH_AUDIT
+ audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
+ "unlocking gshadow file",
+ user_name, AUDIT_NO_ID, 0);
+#endif
+ /* continue */
+ }
gshadow_locked = false;
}
#endif
static void open_files (void)
{
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: unable to lock password file\n"), Prog);
-#ifdef WITH_AUDIT
- audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
- "locking password file",
- user_name, (unsigned int) user_id, 0);
-#endif
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, pw_dbname ());
exit (E_PW_UPDATE);
}
passwd_locked = true;
if (pw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: unable to open password file\n"), Prog);
-#ifdef WITH_AUDIT
- audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
- "opening password file",
- user_name, (unsigned int) user_id, 0);
-#endif
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (is_shadow_pwd) {
if (spw_lock () == 0) {
fprintf (stderr,
- _("%s: cannot lock shadow password file\n"),
- Prog);
-#ifdef WITH_AUDIT
- audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
- "locking shadow password file",
- user_name, (unsigned int) user_id, 0);
-#endif
+ _("%s: cannot lock %s\n"),
+ Prog, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
shadow_locked = true;
if (spw_open (O_RDWR) == 0) {
fprintf (stderr,
- _("%s: cannot open shadow password file\n"),
- Prog);
-#ifdef WITH_AUDIT
- audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
- "opening shadow password file",
- user_name, (unsigned int) user_id, 0);
-#endif
+ _("%s: cannot open %s\n"),
+ Prog, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
}
* Lock and open the group file.
*/
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: error locking group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
group_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: error opening group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp) {
if (sgr_lock () == 0) {
fprintf (stderr,
- _("%s: error locking shadow group file\n"),
- Prog);
+ _("%s: cannot lock %s\n"),
+ Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
gshadow_locked = true;
if (sgr_open (O_RDWR) == 0) {
fprintf (stderr,
- _("%s: error opening shadow group file\n"),
- Prog);
+ _("%s: cannot open %s\n"),
+ Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
}
fprintf (stderr,
_("%s: failed to reset the faillog entry of UID %lu: %s\n"),
Prog, (unsigned long) uid, strerror (errno));
+ SYSLOG ((LOG_WARN, "failed to reset the faillog entry of UID %lu", (unsigned long) uid));
+ /* continue */
}
}
fprintf (stderr,
_("%s: failed to reset the lastlog entry of UID %lu: %s\n"),
Prog, (unsigned long) uid, strerror (errno));
+ SYSLOG ((LOG_WARN, "failed to reset the lastlog entry of UID %lu", (unsigned long) uid));
+ /* continue */
}
}
if (PAM_SUCCESS == retval) {
retval = pam_authenticate (pamh, 0);
- if (PAM_SUCCESS != retval) {
- (void) pam_end (pamh, retval);
- }
}
if (PAM_SUCCESS == retval) {
retval = pam_acct_mgmt (pamh, 0);
- if (PAM_SUCCESS != retval) {
- (void) pam_end (pamh, retval);
- }
}
if (PAM_SUCCESS != retval) {
+ (void) pam_end (pamh, retval);
fprintf (stderr, _("%s: PAM authentication failed\n"), Prog);
fail_exit (1);
}
* Start with a quick check to see if the user exists.
*/
if (getpwnam (user_name) != NULL) { /* local, no need for xgetpwnam */
- fprintf (stderr, _("%s: user %s exists\n"), Prog, user_name);
+ fprintf (stderr, _("%s: user '%s' already exists\n"), Prog, user_name);
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"adding user",
/* local, no need for xgetgrnam */
if (getgrnam (user_name) != NULL) {
fprintf (stderr,
- _
- ("%s: group %s exists - if you want to add this user to that group, use -g.\n"),
+ _("%s: group %s exists - if you want to add this user to that group, use -g.\n"),
Prog, user_name);
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
nscd_flush_cache ("group");
#ifdef USE_PAM
- if (PAM_SUCCESS == retval) {
- (void) pam_end (pamh, PAM_SUCCESS);
- }
+ (void) pam_end (pamh, PAM_SUCCESS);
#endif /* USE_PAM */
return E_SUCCESS;
* See if the user specified this group as one of their
* concurrent groups.
*/
- if (!is_on_list (grp->gr_mem, user_name))
+ if (!is_on_list (grp->gr_mem, user_name)) {
continue;
+ }
/*
* Delete the username from the list of group members and
ngrp = __gr_dup (grp);
if (NULL == ngrp) {
fprintf (stderr,
- _("%s: Out of memory. Cannot update the group database.\n"),
- Prog);
+ _("%s: Out of memory. Cannot update %s.\n"),
+ Prog, gr_dbname ());
exit (13); /* XXX */
}
ngrp->gr_mem = del_list (ngrp->gr_mem, user_name);
}
if (pwd->pw_gid == grp->gr_gid) {
fprintf (stderr,
- _
- ("%s: Cannot remove group %s which is a primary group for another user.\n"),
- Prog, grp->gr_name);
+ _("%s: Cannot remove group %s which is a primary group for another user.\n"),
+ Prog, grp->gr_name);
break;
}
}
nsgrp = __sgr_dup (sgrp);
if (NULL == nsgrp) {
fprintf (stderr,
- _("%s: Out of memory. Cannot update the shadow group database.\n"),
- Prog);
+ _("%s: Out of memory. Cannot update %s.\n"),
+ Prog, sgr_dbname ());
exit (13); /* XXX */
}
user_name, nsgrp->sg_name));
}
- if (deleted_user_group)
+ if (deleted_user_group) {
sgr_remove (user_name);
+ }
#endif /* SHADOWGRP */
}
*/
static void close_files (void)
{
- if (pw_close () == 0)
- fprintf (stderr, _("%s: cannot rewrite password file\n"), Prog);
- if (is_shadow_pwd && (spw_close () == 0))
+ if (pw_close () == 0) {
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
+ }
+ if (is_shadow_pwd && (spw_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite shadow password file\n"), Prog);
- if (gr_close () == 0)
- fprintf (stderr, _("%s: cannot rewrite group file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"), Prog, spw_dbname ());
+ }
+ if (gr_close () == 0) {
+ fprintf (stderr, _("%s: failure while writing changes to %s\n"), Prog, gr_dbname ());
+ }
gr_unlock ();
#ifdef SHADOWGRP
- if (is_shadow_grp && (sgr_close () == 0))
+ if (is_shadow_grp && (sgr_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite shadow group file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"), Prog, sgr_dbname ());
+ }
if (is_shadow_grp) {
sgr_unlock ();
static void open_files (void)
{
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: unable to lock password file\n"), Prog);
+ fprintf (stderr, _("%s: cannot lock %s\n"), Prog, pw_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking password file",
exit (E_PW_UPDATE);
}
if (pw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: unable to open password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, pw_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening password file",
}
if (is_shadow_pwd && (spw_lock () == 0)) {
fprintf (stderr,
- _("%s: cannot lock shadow password file\n"), Prog);
+ _("%s: cannot lock %s\n"), Prog, spw_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking shadow password file",
}
if (is_shadow_pwd && (spw_open (O_RDWR) == 0)) {
fprintf (stderr,
- _("%s: cannot open shadow password file\n"), Prog);
+ _("%s: cannot open %s\n"), Prog, spw_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening shadow password file",
fail_exit (E_PW_UPDATE);
}
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: unable to lock group file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, gr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking group file",
fail_exit (E_GRP_UPDATE);
}
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: cannot open group file\n"), Prog);
+ fprintf (stderr, _("%s: cannot open %s\n"), Prog, gr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening group file",
#ifdef SHADOWGRP
if (is_shadow_grp && (sgr_lock () == 0)) {
fprintf (stderr,
- _("%s: unable to lock shadow group file\n"), Prog);
+ _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"locking shadow group file",
fail_exit (E_GRP_UPDATE);
}
if (is_shadow_grp && (sgr_open (O_RDWR) == 0)) {
- fprintf (stderr, _("%s: cannot open shadow group file\n"),
- Prog);
+ fprintf (stderr, _("%s: cannot open %s\n"),
+ Prog, sgr_dbname ());
#ifdef WITH_AUDIT
audit_logger (AUDIT_USER_CHAUTHTOK, Prog,
"opening shadow group file",
{
if (pw_remove (user_name) == 0) {
fprintf (stderr,
- _("%s: error deleting password entry\n"), Prog);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, user_name, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (is_shadow_pwd && (spw_remove (user_name) == 0)) {
fprintf (stderr,
- _("%s: error deleting shadow password entry\n"), Prog);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, user_name, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
#ifdef WITH_AUDIT
}
}
- if (retval == PAM_SUCCESS) {
+ if (PAM_SUCCESS == retval) {
retval = pam_authenticate (pamh, 0);
- if (retval != PAM_SUCCESS) {
- (void) pam_end (pamh, retval);
- }
}
- if (retval == PAM_SUCCESS) {
+ if (PAM_SUCCESS == retval) {
retval = pam_acct_mgmt (pamh, 0);
- if (retval != PAM_SUCCESS) {
- (void) pam_end (pamh, retval);
- }
}
- if (retval != PAM_SUCCESS) {
+ if (PAM_SUCCESS != retval) {
+ (void) pam_end (pamh, retval);
fprintf (stderr, _("%s: PAM authentication failed\n"), Prog);
exit (E_PW_UPDATE);
}
nscd_flush_cache ("group");
#ifdef USE_PAM
- if (retval == PAM_SUCCESS) {
- (void) pam_end (pamh, PAM_SUCCESS);
- }
+ (void) pam_end (pamh, PAM_SUCCESS);
#endif /* USE_PAM */
#ifdef WITH_AUDIT
if (0 != errors) {
if (ngroups == sys_ngroups) {
fprintf (stderr,
- _
- ("%s: too many groups specified (max %d).\n"),
- Prog, ngroups);
+ _("%s: too many groups specified (max %d).\n"),
+ Prog, ngroups);
break;
}
if (pw_pass[1] == '\0') {
fprintf (stderr,
- _("%s: unlocking the user would result in a passwordless account.\n"
- "You should set a password with usermod -p to unlock this user account.\n"),
+ _("%s: unlocking the user's password would result in a passwordless account.\n"
+ "You should set a password with usermod -p to unlock this user's password.\n"),
Prog);
return pw_pass;
}
ngrp = __gr_dup (grp);
if (NULL == ngrp) {
fprintf (stderr,
- _("%s: Out of memory. Cannot update the group database.\n"),
- Prog);
+ _("%s: Out of memory. Cannot update %s.\n"),
+ Prog, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
changed = false;
if (gr_update (ngrp) == 0) {
fprintf (stderr,
- _("%s: error adding new group entry\n"), Prog);
- SYSLOG ((LOG_ERR, "error adding new group entry"));
+ _("%s: error adding new entry '%s' in %s\n"),
+ Prog, ngrp->gr_name, gr_dbname ());
+ SYSLOG ((LOG_ERR, "error adding new entry '%s' in %s", ngrp->gr_name, gr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
}
nsgrp = __sgr_dup (sgrp);
if (NULL == nsgrp) {
fprintf (stderr,
- _("%s: Out of memory. Cannot update the shadow group database.\n"),
- Prog);
+ _("%s: Out of memory. Cannot update %s.\n"),
+ Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
*/
if (sgr_update (nsgrp) == 0) {
fprintf (stderr,
- _("%s: error adding new shadow group entry\n"), Prog);
- SYSLOG ((LOG_ERR, "error adding shadow group entry"));
+ _("%s: error adding new entry '%s' in '%s\n"),
+ Prog, nsgrp->sg_name, sgr_dbname ());
+ SYSLOG ((LOG_ERR, "error adding new entry '%s' in %s",
+ nsgrp->sg_name, sgr_dbname ()));
fail_exit (E_GRP_UPDATE);
}
}
if (aflg && (!Gflg)) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-a", "-G");
usage ();
exit (E_USAGE);
if (oflg && !uflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-o", "-u");
usage ();
exit (E_USAGE);
if (mflg && !dflg) {
fprintf (stderr,
- _("%s: %s flag is ONLY allowed with the %s flag\n"),
+ _("%s: %s flag is only allowed with the %s flag\n"),
Prog, "-m", "-d");
usage ();
exit (E_USAGE);
/* local, no need for xgetpwnam */
if (lflg && (getpwnam (user_newname) != NULL)) {
- fprintf (stderr, _("%s: user %s exists\n"), Prog, user_newname);
+ fprintf (stderr, _("%s: user '%s' already exists\n"), Prog, user_newname);
exit (E_NAME_IN_USE);
}
/* local, no need for xgetpwuid */
if (uflg && !oflg && (getpwuid (user_newid) != NULL)) {
- fprintf (stderr, _("%s: uid %lu is not unique\n"),
+ fprintf (stderr, _("%s: UID '%lu' already exists\n"),
Prog, (unsigned long) user_newid);
exit (E_UID_IN_USE);
}
static void close_files (void)
{
if (pw_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"), Prog, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (is_shadow_pwd && (spw_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite shadow password file\n"), Prog);
+ _("%s: failure while writing changes to %s\n"), Prog, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (Gflg || lflg) {
if (gr_close () == 0) {
- fprintf (stderr, _("%s: cannot rewrite group file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: failure while writing changes to %s\n"),
+ Prog, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp && (sgr_close () == 0)) {
fprintf (stderr,
- _("%s: cannot rewrite shadow group file\n"),
- Prog);
+ _("%s: failure while writing changes to %s\n"),
+ Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
if (is_shadow_grp) {
static void open_files (void)
{
if (pw_lock () == 0) {
- fprintf (stderr, _("%s: unable to lock password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
pw_locked = true;
if (pw_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: unable to open password file\n"), Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (is_shadow_pwd && (spw_lock () == 0)) {
fprintf (stderr,
- _("%s: cannot lock shadow password file\n"), Prog);
+ _("%s: cannot lock %s\n"), Prog, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
spw_locked = true;
if (is_shadow_pwd && (spw_open (O_RDWR) == 0)) {
fprintf (stderr,
- _("%s: cannot open shadow password file\n"), Prog);
+ _("%s: cannot open %s\n"), Prog, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
* group entries.
*/
if (gr_lock () == 0) {
- fprintf (stderr, _("%s: error locking group file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: cannot lock %s\n"), Prog, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
gr_locked = true;
if (gr_open (O_RDWR) == 0) {
- fprintf (stderr, _("%s: error opening group file\n"),
- Prog);
+ fprintf (stderr,
+ _("%s: cannot open %s\n"), Prog, gr_dbname ());
fail_exit (E_GRP_UPDATE);
}
#ifdef SHADOWGRP
if (is_shadow_grp && (sgr_lock () == 0)) {
fprintf (stderr,
- _("%s: error locking shadow group file\n"),
- Prog);
+ _("%s: cannot lock %s\n"), Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
sgr_locked = true;
if (is_shadow_grp && (sgr_open (O_RDWR) == 0)) {
fprintf (stderr,
- _("%s: error opening shadow group file\n"),
- Prog);
+ _("%s: cannot open %s\n"), Prog, sgr_dbname ());
fail_exit (E_GRP_UPDATE);
}
#endif
*/
pwd = pw_locate (user_name);
if (NULL == pwd) {
- fprintf (stderr, _("%s: %s not found in /etc/passwd\n"),
- Prog, user_name);
+ fprintf (stderr, _("%s: user '%s' does not exist in %s\n"),
+ Prog, user_name, pw_dbname ());
fail_exit (E_NOTFOUND);
}
pwent = *pwd;
|| Lflg || Uflg) {
if (pw_update (&pwent) == 0) {
fprintf (stderr,
- _("%s: error changing password entry\n"),
- Prog);
+ _("%s: cannot add new entry '%s' in %s\n"),
+ Prog, pwent.pw_name, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (lflg && (pw_remove (user_name) == 0)) {
fprintf (stderr,
- _("%s: error removing password entry\n"),
- Prog);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, user_name, pw_dbname ());
fail_exit (E_PW_UPDATE);
}
}
if ((NULL != spwd) && (lflg || eflg || fflg || pflg || Lflg || Uflg)) {
if (spw_update (&spent) == 0) {
fprintf (stderr,
- _
- ("%s: error adding new shadow password entry\n"),
- Prog);
+ _("%s: cannot add new entry '%s' in %s\n"),
+ Prog, spent.sp_namp, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
if (lflg && (spw_remove (user_name) == 0)) {
fprintf (stderr,
- _
- ("%s: error removing shadow password entry\n"),
- Prog);
+ _("%s: cannot remove entry '%s' from %s\n"),
+ Prog, user_name, spw_dbname ());
fail_exit (E_PW_UPDATE);
}
}
if (errno == EXDEV) {
if (mkdir (user_newhome, sb.st_mode & 0777) != 0) {
fprintf (stderr,
- _
- ("%s: can't create %s\n"),
- Prog, user_newhome);
+ _("%s: can't create %s\n"),
+ Prog, user_newhome);
}
if (chown (user_newhome, sb.st_uid, sb.st_gid) != 0) {
fprintf (stderr,
(void) remove_tree (user_newhome);
}
fprintf (stderr,
- _
- ("%s: cannot rename directory %s to %s\n"),
- Prog, user_home, user_newhome);
+ _("%s: cannot rename directory %s to %s\n"),
+ Prog, user_home, user_newhome);
fail_exit (E_HOMEDIR);
}
#ifdef WITH_AUDIT
fd = open (mailfile, O_RDONLY | O_NONBLOCK, 0);
if (fd < 0) {
/* no need for warnings if the mailbox doesn't exist */
- if (errno != ENOENT)
+ if (errno != ENOENT) {
perror (mailfile);
+ }
return;
}
if (fstat (fd, &st) < 0) {
if (PAM_SUCCESS == retval) {
retval = pam_authenticate (pamh, 0);
- if (PAM_SUCCESS != retval) {
- (void) pam_end (pamh, retval);
- }
}
if (PAM_SUCCESS == retval) {
retval = pam_acct_mgmt (pamh, 0);
- if (PAM_SUCCESS != retval) {
- (void) pam_end (pamh, retval);
- }
}
if (PAM_SUCCESS != retval) {
+ (void) pam_end (pamh, retval);
fprintf (stderr, _("%s: PAM authentication failed\n"), Prog);
exit (1);
}
}
#ifdef USE_PAM
- if (PAM_SUCCESS == retval) {
- (void) pam_end (pamh, PAM_SUCCESS);
- }
+ (void) pam_end (pamh, PAM_SUCCESS);
#endif /* USE_PAM */
exit (E_SUCCESS);
projects / thirdparty / shadow.git / commitdiff
