/* vi: set sw=4 ts=4: */
-/* Copyright (C) 2003 Manuel Novoa III
+/* Copyright (C) 2003 Manuel Novoa III
*
- * Licensed under GPL v2, or later. See file LICENSE in this tarball.
+ * Licensed under GPLv2 or later, see file LICENSE in this source tree.
*/
-/* Nov 6, 2003 Initial version.
+/* Nov 6, 2003 Initial version.
*
- * NOTE: This implementation is quite strict about requiring all
+ * NOTE: This implementation is quite strict about requiring all
* field seperators. It also does not allow leading whitespace
* except when processing the numeric fields. glibc is more
* lenient. See the various glibc difference comments below.
*
- * TODO:
+ * TODO:
* Move to dynamic allocation of (currently statically allocated)
* buffers; especially for the group-related functions since
* large group member lists will cause error returns.
- *
*/
#include "libbb.h"
#include <assert.h>
-#ifndef _PATH_SHADOW
-#define _PATH_SHADOW "/etc/shadow"
-#endif
-#ifndef _PATH_PASSWD
-#define _PATH_PASSWD "/etc/passwd"
-#endif
-#ifndef _PATH_GROUP
-#define _PATH_GROUP "/etc/group"
-#endif
-
/**********************************************************************/
/* Sizes for statically allocated buffers. */
-/* If you change these values, also change _SC_GETPW_R_SIZE_MAX and
- * _SC_GETGR_R_SIZE_MAX in libc/unistd/sysconf.c to match */
#define PWD_BUFFER_SIZE 256
#define GRP_BUFFER_SIZE 256
struct statics {
/* Smaller things first */
- struct passwd getpwuid_resultbuf;
- struct group getgrgid_resultbuf;
- struct passwd getpwnam_resultbuf;
- struct group getgrnam_resultbuf;
-
- char getpwuid_buffer[PWD_BUFFER_SIZE];
- char getgrgid_buffer[GRP_BUFFER_SIZE];
- char getpwnam_buffer[PWD_BUFFER_SIZE];
- char getgrnam_buffer[GRP_BUFFER_SIZE];
-#if 0
- struct passwd fgetpwent_resultbuf;
- struct group fgetgrent_resultbuf;
- struct spwd fgetspent_resultbuf;
- char fgetpwent_buffer[PWD_BUFFER_SIZE];
- char fgetgrent_buffer[GRP_BUFFER_SIZE];
- char fgetspent_buffer[PWD_BUFFER_SIZE];
-#endif
+ /* It's ok to use one buffer for getpwuid and getpwnam. Manpage says:
+ * "The return value may point to a static area, and may be overwritten
+ * by subsequent calls to getpwent(), getpwnam(), or getpwuid()."
+ */
+ struct passwd getpw_resultbuf;
+ struct group getgr_resultbuf;
+
+ char getpw_buffer[PWD_BUFFER_SIZE];
+ char getgr_buffer[GRP_BUFFER_SIZE];
#if 0 //ENABLE_USE_BB_SHADOW
- struct spwd getspuid_resultbuf;
- struct spwd getspnam_resultbuf;
- char getspuid_buffer[PWD_BUFFER_SIZE];
- char getspnam_buffer[PWD_BUFFER_SIZE];
+ struct spwd getsp_resultbuf;
+ char getsp_buffer[PWD_BUFFER_SIZE];
#endif
// Not converted - too small to bother
//pthread_mutex_t mylock = PTHREAD_MUTEX_INITIALIZER;
//FILE *pwf /*= NULL*/;
//FILE *grf /*= NULL*/;
//FILE *spf /*= NULL*/;
-#if 0
- struct passwd getpwent_pwd;
- struct group getgrent_gr;
- char getpwent_line_buff[PWD_BUFFER_SIZE];
- char getgrent_line_buff[GRP_BUFFER_SIZE];
-#endif
-#if 0 //ENABLE_USE_BB_SHADOW
- struct spwd getspent_spwd;
- struct spwd sgetspent_spwd;
- char getspent_line_buff[PWD_BUFFER_SIZE];
- char sgetspent_line_buff[PWD_BUFFER_SIZE];
-#endif
};
static struct statics *ptr_to_statics;
}
#if ENABLE_USE_BB_SHADOW
+#ifdef UNUSED_FOR_NOW
int fgetspent_r(FILE *__restrict stream, struct spwd *__restrict resultbuf,
char *__restrict buffer, size_t buflen,
struct spwd **__restrict result)
return rv;
}
#endif
+#endif
/**********************************************************************/
/* For the various fget??ent funcs, return NULL on failure and a
struct passwd *fgetpwent(FILE *stream)
{
struct statics *S;
- struct passwd *resultbuf = RESULTBUF(fgetpwent);
- char *buffer = BUFFER(fgetpwent);
+ struct passwd *resultbuf = RESULTBUF(getpw);
+ char *buffer = BUFFER(getpw);
struct passwd *result;
- fgetpwent_r(stream, resultbuf, buffer, sizeof(BUFFER(fgetpwent)), &result);
+ fgetpwent_r(stream, resultbuf, buffer, sizeof(BUFFER(getpw)), &result);
return result;
}
struct group *fgetgrent(FILE *stream)
{
struct statics *S;
- struct group *resultbuf = RESULTBUF(fgetgrent);
- char *buffer = BUFFER(fgetgrent);
+ struct group *resultbuf = RESULTBUF(getgr);
+ char *buffer = BUFFER(getgr);
struct group *result;
- fgetgrent_r(stream, resultbuf, buffer, sizeof(BUFFER(fgetgrent)), &result);
+ fgetgrent_r(stream, resultbuf, buffer, sizeof(BUFFER(getgr)), &result);
return result;
}
#endif
#if ENABLE_USE_BB_SHADOW
-#if 0
+#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
struct spwd *fgetspent(FILE *stream)
{
struct statics *S;
- struct spwd *resultbuf = RESULTBUF(fgetspent);
- char *buffer = BUFFER(fgetspent);
+ struct spwd *resultbuf = RESULTBUF(getsp);
+ char *buffer = BUFFER(getsp);
struct spwd *result;
- fgetspent_r(stream, resultbuf, buffer, sizeof(BUFFER(fgetspent)), &result);
+ fgetspent_r(stream, resultbuf, buffer, sizeof(BUFFER(getsp)), &result);
return result;
}
#endif
+#ifdef UNUSED_FOR_NOW
int sgetspent_r(const char *string, struct spwd *result_buf,
char *buffer, size_t buflen, struct spwd **result)
{
return rv;
}
#endif
+#endif /* ENABLE_USE_BB_SHADOW */
/**********************************************************************/
struct passwd *getpwuid(uid_t uid)
{
struct statics *S;
- struct passwd *resultbuf = RESULTBUF(getpwuid);
- char *buffer = BUFFER(getpwuid);
+ struct passwd *resultbuf = RESULTBUF(getpw);
+ char *buffer = BUFFER(getpw);
struct passwd *result;
- getpwuid_r(uid, resultbuf, buffer, sizeof(BUFFER(getpwuid)), &result);
+ getpwuid_r(uid, resultbuf, buffer, sizeof(BUFFER(getpw)), &result);
return result;
}
struct group *getgrgid(gid_t gid)
{
struct statics *S;
- struct group *resultbuf = RESULTBUF(getgrgid);
- char *buffer = BUFFER(getgrgid);
+ struct group *resultbuf = RESULTBUF(getgr);
+ char *buffer = BUFFER(getgr);
struct group *result;
- getgrgid_r(gid, resultbuf, buffer, sizeof(BUFFER(getgrgid)), &result);
+ getgrgid_r(gid, resultbuf, buffer, sizeof(BUFFER(getgr)), &result);
return result;
}
* to have been created as a reentrant version of the non-standard
* functions getspuid. Why getspuid was added, I do not know. */
int getspuid_r(uid_t uid, struct spwd *__restrict resultbuf,
- char *__restrict buffer, size_t buflen,
- struct spwd **__restrict result)
+ char *__restrict buffer, size_t buflen,
+ struct spwd **__restrict result)
{
int rv;
struct passwd *pp;
struct spwd *getspuid(uid_t uid)
{
struct statics *S;
- struct spwd *resultbuf = RESULTBUF(getspuid);
- char *buffer = BUFFER(getspuid);
+ struct spwd *resultbuf = RESULTBUF(getsp);
+ char *buffer = BUFFER(getsp);
struct spwd *result;
- getspuid_r(uid, resultbuf, buffer, sizeof(BUFFER(getspuid)), &result);
+ getspuid_r(uid, resultbuf, buffer, sizeof(BUFFER(getsp)), &result);
return result;
}
#endif
struct passwd *getpwnam(const char *name)
{
struct statics *S;
- struct passwd *resultbuf = RESULTBUF(getpwnam);
- char *buffer = BUFFER(getpwnam);
+ struct passwd *resultbuf = RESULTBUF(getpw);
+ char *buffer = BUFFER(getpw);
struct passwd *result;
- getpwnam_r(name, resultbuf, buffer, sizeof(BUFFER(getpwnam)), &result);
+ getpwnam_r(name, resultbuf, buffer, sizeof(BUFFER(getpw)), &result);
return result;
}
struct group *getgrnam(const char *name)
{
struct statics *S;
- struct group *resultbuf = RESULTBUF(getgrnam);
- char *buffer = BUFFER(getgrnam);
+ struct group *resultbuf = RESULTBUF(getgr);
+ char *buffer = BUFFER(getgr);
struct group *result;
- getgrnam_r(name, resultbuf, buffer, sizeof(BUFFER(getgrnam)), &result);
+ getgrnam_r(name, resultbuf, buffer, sizeof(BUFFER(getgr)), &result);
return result;
}
struct spwd *getspnam(const char *name)
{
struct statics *S;
- struct spwd *resultbuf = RESULTBUF(getspnam);
- char *buffer = BUFFER(getspnam);
+ struct spwd *resultbuf = RESULTBUF(getsp);
+ char *buffer = BUFFER(getsp);
struct spwd *result;
- getspnam_r(name, resultbuf, buffer, sizeof(BUFFER(getspnam)), &result);
+ getspnam_r(name, resultbuf, buffer, sizeof(BUFFER(getsp)), &result);
return result;
}
#endif
int getpwent_r(struct passwd *__restrict resultbuf,
- char *__restrict buffer, size_t buflen,
- struct passwd **__restrict result)
+ char *__restrict buffer, size_t buflen,
+ struct passwd **__restrict result)
{
int rv;
rv = errno;
goto ERR;
}
+ close_on_exec_on(fileno(pwf));
}
rv = bb__pgsreader(bb__parsepwent, resultbuf, buffer, buflen, pwf);
}
int getgrent_r(struct group *__restrict resultbuf,
- char *__restrict buffer, size_t buflen,
- struct group **__restrict result)
+ char *__restrict buffer, size_t buflen,
+ struct group **__restrict result)
{
int rv;
rv = errno;
goto ERR;
}
+ close_on_exec_on(fileno(grf));
}
rv = bb__pgsreader(bb__parsegrent, resultbuf, buffer, buflen, grf);
return rv;
}
+#ifdef UNUSED_FOR_NOW
#if ENABLE_USE_BB_SHADOW
static FILE *spf /*= NULL*/;
void setspent(void)
}
int getspent_r(struct spwd *resultbuf, char *buffer,
- size_t buflen, struct spwd **result)
+ size_t buflen, struct spwd **result)
{
int rv;
rv = errno;
goto ERR;
}
+ close_on_exec_on(fileno(spf));
}
rv = bb__pgsreader(bb__parsespent, resultbuf, buffer, buflen, spf);
return rv;
}
#endif
+#endif /* UNUSED_FOR_NOW */
#ifdef UNUSED_SINCE_WE_AVOID_STATIC_BUFS
struct passwd *getpwent(void)
getgrent_r(&gr, line_buff, sizeof(line_buff), &result);
return result;
}
-#endif
-#if 0 //ENABLE_USE_BB_SHADOW
+#if ENABLE_USE_BB_SHADOW
struct spwd *getspent(void)
{
static char line_buff[PWD_BUFFER_SIZE];
return result;
}
#endif
+#endif /* UNUSED_SINCE_WE_AVOID_STATIC_BUFS */
static gid_t *getgrouplist_internal(int *ngroups_ptr, const char *user, gid_t gid)
{
{
int rv = -1;
+#if 0
+ /* glibc does this check */
if (!p || !f) {
errno = EINVAL;
return rv;
}
+#endif
/* No extra thread locking is needed above what fprintf does. */
if (fprintf(f, "%s:%s:%lu:%lu:%s:%s:%s\n",
{
int rv = -1;
- if (!p || !f) { /* Sigh... glibc checks. */
+#if 0
+ /* glibc does this check */
+ if (!p || !f) {
errno = EINVAL;
return rv;
}
+#endif
if (fprintf(f, "%s:%s:%lu:",
p->gr_name, p->gr_passwd,
#endif
#if ENABLE_USE_BB_SHADOW
+#ifdef UNUSED_FOR_NOW
static const unsigned char put_sp_off[] ALIGN1 = {
offsetof(struct spwd, sp_lstchg), /* 2 - not a char ptr */
offsetof(struct spwd, sp_min), /* 3 - not a char ptr */
return rv;
}
#endif
+#endif /* USE_BB_SHADOW */
/**********************************************************************/
-/* Internal uClibc functions. */
+/* Internal functions */
/**********************************************************************/
static const unsigned char pw_off[] ALIGN1 = {
if (p[1]) { /* We have a member list to process. */
/* Overwrite the last ':' with a ',' before counting.
- * This allows us to test for initial ',' and adds
- * one ',' so that the ',' count equals the member
- * count. */
+ * This allows us to (1) test for initial ','
+ * and (2) adds one ',' so that the number of commas
+ * equals the member count. */
*p = ',';
do {
/* NOTE: glibc difference - glibc allows and trims leading
/**********************************************************************/
-/* Reads until if EOF, or until if finds a line which fits in the buffer
+/* Reads until EOF, or until it finds a line which fits in the buffer
* and for which the parser function succeeds.
*
- * Returns 0 on success and ENOENT for end-of-file (glibc concession).
+ * Returns 0 on success and ENOENT for end-of-file (glibc convention).
*/
static int bb__pgsreader(
int FAST_FUNC (*parserfunc)(void *d, char *line),
projects / platform / upstream / busybox.git / blobdiff