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

Bigger patch for (partial) tinylogin integration

Browse Source 
- Made a new dir loginutils
- Moved all applets from pwd_grp to loginutils
- Added new applets su.c login.c to loginutils
- Made a new dir libpwdgrp
- Moved everything from pwd_grp/libpwd_grp there
- Added shadow.c to libpwdgrp
- Removed dir pwd_grp
- Added usage strings for login and su to usage.h
- Changed main Makefile to reflect the dir rearrangements
[Parts of this patch may overlap with my other two patches]
This commit is contained in:
Robert Griebl
2002-06-04 20:45:46 +00:00
parent ea1a63a201
commit 1fca558799
30 changed files with 4123 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@@ -22,8 +22,8 @@ include $(TOPDIR).config
include $(TOPDIR)Rules.mak include $(TOPDIR)Rules.mak
SUBDIRS:=applets archival archival/libunarchive console-tools \ SUBDIRS:=applets archival archival/libunarchive console-tools \
editors fileutils findutils init miscutils modutils networking \ editors fileutils findutils init miscutils modutils networking \
procps pwd_grp pwd_grp/libpwd_grp shell shellutils sysklogd \ procps loginutils shell shellutils sysklogd \
textutils util-linux libbb textutils util-linux libbb libpwdgrp
all: do-it-all all: do-it-all

16
include/usage.h
View File

@@ -978,6 +978,15 @@
#define logger_example_usage \ #define logger_example_usage \
"$ logger "hello"\n" "$ logger "hello"\n"
#define login_trivial_usage \
"[OPTION]... [username] [ENV=VAR ...]"
#define login_full_usage \
"Begin a new session on the system\n\n" \
"Options:\n" \
"\t-f\tDo not authenticate (user already authenticated)\n" \
"\t-h\tName of the remote host for this login.\n" \
"\t-p\tPreserve environment."
#define logname_trivial_usage \ #define logname_trivial_usage \
"" ""
#define logname_full_usage \ #define logname_full_usage \
@@ -1570,6 +1579,13 @@
"\n\t-g\t\tprint in stty-readable form" \ "\n\t-g\t\tprint in stty-readable form" \
"\n\t[SETTING]\tsee manpage" "\n\t[SETTING]\tsee manpage"
#define su_trivial_usage \
"[OPTION]... [-] [username]"
#define su_full_usage \
"Change user id or become root.\n" \
"Options:\n" \
"\t-p\tPreserve environment"
#define swapoff_trivial_usage \ #define swapoff_trivial_usage \
"[OPTION] [DEVICE]" "[OPTION] [DEVICE]"
#define swapoff_full_usage \ #define swapoff_full_usage \

30
libpwdgrp/Makefile Normal file
View File

@@ -0,0 +1,30 @@
# Makefile for busybox
#
# Copyright (C) 1999-2002 Erik Andersen <andersee@debian.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
TOPDIR:= ../
LIBPWDGRP_DIR:=./
include $(TOPDIR).config
include $(TOPDIR)Rules.mak
include Makefile.in
all: $(libraries-y)
-include $(TOPDIR).depend
clean:
rm -f *.o *.a $(AR_TARGET)

35
libpwdgrp/Makefile.in Normal file
View File

@@ -0,0 +1,35 @@
# Makefile for busybox
#
# Copyright (C) 1999-2002 Erik Andersen <andersee@debian.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
LIBPWDGRP_AR:=libpwdgrp.a
ifndef $(LIBPWDGRP_DIR)
LIBPWDGRP_DIR:=$(TOPDIR)libpwdgrp/
endif
LIBPWDGRP-y:=
LIBPWDGRP-$(CONFIG_USE_BB_PWD_GRP) += __getgrent.o __getgrent.o __getpwent.o\
fgetgrent.o fgetpwent.o getgrgid.o getgrnam.o getpw.o getpwnam.o \
getpwuid.o grent.o initgroups.o putpwent.o pwent.o setgroups.o
LIBPWDGRP-$(CONFIG_USE_BB_SHADOW) += shadow.o
libraries-y+=$(LIBPWDGRP_DIR)$(LIBPWDGRP_AR)
$(LIBPWDGRP_DIR)$(LIBPWDGRP_AR): $(patsubst %,$(LIBPWDGRP_DIR)%, $(LIBPWDGRP-y))
$(AR) -ro $@ $(patsubst %,$(LIBPWDGRP_DIR)%, $(LIBPWDGRP-y))

204
libpwdgrp/__getgrent.c Normal file
View File

@@ -0,0 +1,204 @@
/*
* __getgrent.c - This file is part of the libc-8086/grp package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include "grp.h"
/*
* Define GR_SCALE_DYNAMIC if you want grp to dynamically scale its read buffer
* so that lines of any length can be used. On very very small systems,
* you may want to leave this undefined becasue it will make the grp functions
* somewhat larger (because of the inclusion of malloc and the code necessary).
* On larger systems, you will want to define this, because grp will _not_
* deal with long lines gracefully (they will be skipped).
*/
#undef GR_SCALE_DYNAMIC
#ifndef GR_SCALE_DYNAMIC
/*
* If scaling is not dynamic, the buffers will be statically allocated, and
* maximums must be chosen. GR_MAX_LINE_LEN is the maximum number of
* characters per line in the group file. GR_MAX_MEMBERS is the maximum
* number of members of any given group.
*/
#define GR_MAX_LINE_LEN 128
/* GR_MAX_MEMBERS = (GR_MAX_LINE_LEN-(24+3+6))/9 */
#define GR_MAX_MEMBERS 11
#endif /* !GR_SCALE_DYNAMIC */
/*
* Define GR_DYNAMIC_GROUP_LIST to make initgroups() dynamically allocate
* space for it's GID array before calling setgroups(). This is probably
* unnecessary scalage, so it's undefined by default.
*/
#undef GR_DYNAMIC_GROUP_LIST
#ifndef GR_DYNAMIC_GROUP_LIST
/*
* GR_MAX_GROUPS is the size of the static array initgroups() uses for
* its static GID array if GR_DYNAMIC_GROUP_LIST isn't defined.
*/
#define GR_MAX_GROUPS 64
#endif /* !GR_DYNAMIC_GROUP_LIST */
/*
* This is the core group-file read function. It behaves exactly like
* getgrent() except that it is passed a file descriptor. getgrent()
* is just a wrapper for this function.
*/
struct group *__getgrent(int grp_fd)
{
#ifndef GR_SCALE_DYNAMIC
static char line_buff[GR_MAX_LINE_LEN];
static char *members[GR_MAX_MEMBERS];
#else
static char *line_buff = NULL;
static char **members = NULL;
short line_index;
short buff_size;
#endif
static struct group group;
register char *ptr;
char *field_begin;
short member_num;
char *endptr;
int line_len;
/* We use the restart label to handle malformatted lines */
restart:
#ifdef GR_SCALE_DYNAMIC
line_index = 0;
buff_size = 256;
#endif
#ifndef GR_SCALE_DYNAMIC
/* Read the line into the static buffer */
if ((line_len = read(grp_fd, line_buff, GR_MAX_LINE_LEN)) <= 0)
return NULL;
field_begin = strchr(line_buff, '\n');
if (field_begin != NULL)
lseek(grp_fd, (long) (1 + field_begin - (line_buff + line_len)),
SEEK_CUR);
else { /* The line is too long - skip it :-\ */
do {
if ((line_len = read(grp_fd, line_buff, GR_MAX_LINE_LEN)) <= 0)
return NULL;
} while (!(field_begin = strchr(line_buff, '\n')));
lseek(grp_fd, (long) ((field_begin - line_buff) - line_len + 1),
SEEK_CUR);
goto restart;
}
if (*line_buff == '#' || *line_buff == ' ' || *line_buff == '\n' ||
*line_buff == '\t')
goto restart;
*field_begin = '\0';
#else /* !GR_SCALE_DYNAMIC */
line_buff = realloc(line_buff, buff_size);
while (1) {
if ((line_len = read(grp_fd, line_buff + line_index,
buff_size - line_index)) <= 0)
return NULL;
field_begin = strchr(line_buff, '\n');
if (field_begin != NULL) {
lseek(grp_fd,
(long) (1 + field_begin -
(line_len + line_index + line_buff)), SEEK_CUR);
*field_begin = '\0';
if (*line_buff == '#' || *line_buff == ' '
|| *line_buff == '\n' || *line_buff == '\t')
goto restart;
break;
} else { /* Allocate some more space */
line_index = buff_size;
buff_size += 256;
line_buff = realloc(line_buff, buff_size);
}
}
#endif /* GR_SCALE_DYNAMIC */
/* Now parse the line */
group.gr_name = line_buff;
ptr = strchr(line_buff, ':');
if (ptr == NULL)
goto restart;
*ptr++ = '\0';
group.gr_passwd = ptr;
ptr = strchr(ptr, ':');
if (ptr == NULL)
goto restart;
*ptr++ = '\0';
field_begin = ptr;
ptr = strchr(ptr, ':');
if (ptr == NULL)
goto restart;
*ptr++ = '\0';
group.gr_gid = (gid_t) strtoul(field_begin, &endptr, 10);
if (*endptr != '\0')
goto restart;
member_num = 0;
field_begin = ptr;
#ifndef GR_SCALE_DYNAMIC
while ((ptr = strchr(ptr, ',')) != NULL) {
*ptr = '\0';
ptr++;
members[member_num] = field_begin;
field_begin = ptr;
member_num++;
}
if (*field_begin == '\0')
members[member_num] = NULL;
else {
members[member_num] = field_begin;
members[member_num + 1] = NULL;
}
#else /* !GR_SCALE_DYNAMIC */
if (members != NULL)
free(members);
members = (char **) malloc((member_num + 1) * sizeof(char *));
for ( ; field_begin && *field_begin != '\0'; field_begin = ptr) {
if ((ptr = strchr(field_begin, ',')) != NULL)
*ptr++ = '\0';
members[member_num++] = field_begin;
members = (char **) realloc(members,
(member_num + 1) * sizeof(char *));
}
members[member_num] = NULL;
#endif /* GR_SCALE_DYNAMIC */
group.gr_mem = members;
return &group;
}

115
libpwdgrp/__getpwent.c Normal file
View File

@@ -0,0 +1,115 @@
/*
* __getpwent.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include "pwd.h"
#define PWD_BUFFER_SIZE 256
/* This isn't as flash as my previous version -- it doesn't dynamically
scale down the gecos on too-long lines, but it also makes fewer syscalls,
so it's probably nicer. Write me if you want the old version. Maybe I
should include it as a build-time option... ?
-Nat <ndf@linux.mit.edu> */
struct passwd *__getpwent(int pwd_fd)
{
static char line_buff[PWD_BUFFER_SIZE];
static struct passwd passwd;
char *field_begin;
char *endptr;
char *gid_ptr=NULL;
char *uid_ptr=NULL;
int line_len;
int i;
/* We use the restart label to handle malformatted lines */
restart:
/* Read the passwd line into the static buffer using a minimal of
syscalls. */
if ((line_len = read(pwd_fd, line_buff, PWD_BUFFER_SIZE)) <= 0)
return NULL;
field_begin = strchr(line_buff, '\n');
if (field_begin != NULL)
lseek(pwd_fd, (long) (1 + field_begin - (line_buff + line_len)),
SEEK_CUR);
else { /* The line is too long - skip it. :-\ */
do {
if ((line_len = read(pwd_fd, line_buff, PWD_BUFFER_SIZE)) <= 0)
return NULL;
} while (!(field_begin = strchr(line_buff, '\n')));
lseek(pwd_fd, (long) (field_begin - line_buff) - line_len + 1,
SEEK_CUR);
goto restart;
}
if (*line_buff == '#' || *line_buff == ' ' || *line_buff == '\n' ||
*line_buff == '\t')
goto restart;
*field_begin = '\0';
/* We've read the line; now parse it. */
field_begin = line_buff;
for (i = 0; i < 7; i++) {
switch (i) {
case 0:
passwd.pw_name = field_begin;
break;
case 1:
passwd.pw_passwd = field_begin;
break;
case 2:
uid_ptr = field_begin;
break;
case 3:
gid_ptr = field_begin;
break;
case 4:
passwd.pw_gecos = field_begin;
break;
case 5:
passwd.pw_dir = field_begin;
break;
case 6:
passwd.pw_shell = field_begin;
break;
}
if (i < 6) {
field_begin = strchr(field_begin, ':');
if (field_begin == NULL)
goto restart;
*field_begin++ = '\0';
}
}
passwd.pw_gid = (gid_t) strtoul(gid_ptr, &endptr, 10);
if (*endptr != '\0')
goto restart;
passwd.pw_uid = (uid_t) strtoul(uid_ptr, &endptr, 10);
if (*endptr != '\0')
goto restart;
return &passwd;
}

35
libpwdgrp/fgetgrent.c Normal file
View File

@@ -0,0 +1,35 @@
/*
* fgetgrent.c - This file is part of the libc-8086/grp package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <stdio.h>
#include <errno.h>
#include "grp.h"
struct group *fgetgrent(FILE * file)
{
if (file == NULL) {
errno = EINTR;
return NULL;
}
return __getgrent(fileno(file));
}

35
libpwdgrp/fgetpwent.c Normal file
View File

@@ -0,0 +1,35 @@
/*
* fgetpwent.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <errno.h>
#include <stdio.h>
#include "pwd.h"
struct passwd *fgetpwent(FILE * file)
{
if (file == NULL) {
errno = EINTR;
return NULL;
}
return __getpwent(fileno(file));
}

44
libpwdgrp/getgrgid.c Normal file
View File

@@ -0,0 +1,44 @@
/*
* getgrgid.c - This file is part of the libc-8086/grp package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
#include "grp.h"
struct group *getgrgid(const gid_t gid)
{
struct group *group;
int grp_fd;
if ((grp_fd = open("/etc/group", O_RDONLY)) < 0)
return NULL;
while ((group = __getgrent(grp_fd)) != NULL)
if (group->gr_gid == gid) {
close(grp_fd);
return group;
}
close(grp_fd);
return NULL;
}

50
libpwdgrp/getgrnam.c Normal file
View File

@@ -0,0 +1,50 @@
/*
* getgrnam.c - This file is part of the libc-8086/grp package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include "grp.h"
struct group *getgrnam(const char *name)
{
int grp_fd;
struct group *group;
if (name == NULL) {
errno = EINVAL;
return NULL;
}
if ((grp_fd = open("/etc/group", O_RDONLY)) < 0)
return NULL;
while ((group = __getgrent(grp_fd)) != NULL)
if (!strcmp(group->gr_name, name)) {
close(grp_fd);
return group;
}
close(grp_fd);
return NULL;
}

47
libpwdgrp/getpw.c Normal file
View File

@@ -0,0 +1,47 @@
/*
* getpw.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include "pwd.h"
int getpw(uid_t uid, char *buf)
{
struct passwd *passwd;
if (buf == NULL) {
errno = EINVAL;
return -1;
}
if ((passwd = getpwuid(uid)) == NULL)
return -1;
if (sprintf (buf, "%s:%s:%u:%u:%s:%s:%s", passwd->pw_name, passwd->pw_passwd,
passwd->pw_gid, passwd->pw_uid, passwd->pw_gecos, passwd->pw_dir,
passwd->pw_shell) < 0) {
errno = ENOBUFS;
return -1;
}
return 0;
}

51
libpwdgrp/getpwnam.c Normal file
View File

@@ -0,0 +1,51 @@
/*
* getpwnam.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include "pwd.h"
struct passwd *getpwnam(const char *name)
{
int passwd_fd;
struct passwd *passwd;
if (name == NULL) {
errno = EINVAL;
return NULL;
}
if ((passwd_fd = open("/etc/passwd", O_RDONLY)) < 0)
return NULL;
while ((passwd = __getpwent(passwd_fd)) != NULL)
if (!strcmp(passwd->pw_name, name)) {
close(passwd_fd);
return passwd;
}
close(passwd_fd);
return NULL;
}

44
libpwdgrp/getpwuid.c Normal file
View File

@@ -0,0 +1,44 @@
/*
* getpwuid.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include "pwd.h"
struct passwd *getpwuid(uid_t uid)
{
int passwd_fd;
struct passwd *passwd;
if ((passwd_fd = open("/etc/passwd", O_RDONLY)) < 0)
return NULL;
while ((passwd = __getpwent(passwd_fd)) != NULL)
if (passwd->pw_uid == uid) {
close(passwd_fd);
return passwd;
}
close(passwd_fd);
return NULL;
}

54
libpwdgrp/grent.c Normal file
View File

@@ -0,0 +1,54 @@
/*
* grent.c - This file is part of the libc-8086/grp package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
/*
* setgrent(), endgrent(), and getgrent() are mutually-dependent functions,
* so they are all included in the same object file, and thus all linked
* in together.
*/
#include "busybox.h"
#include <unistd.h>
#include <fcntl.h>
#include "grp.h"
static int grp_fd = -1;
void setgrent(void)
{
if (grp_fd != -1)
close(grp_fd);
grp_fd = open("/etc/group", O_RDONLY);
}
void endgrent(void)
{
if (grp_fd != -1)
close(grp_fd);
grp_fd = -1;
}
struct group *getgrent(void)
{
if (grp_fd == -1)
return NULL;
return __getgrent(grp_fd);
}

115
libpwdgrp/initgroups.c Normal file
View File

@@ -0,0 +1,115 @@
/*
* initgroups.c - This file is part of the libc-8086/grp package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include "grp.h"
/*
* Define GR_SCALE_DYNAMIC if you want grp to dynamically scale its read buffer
* so that lines of any length can be used. On very very small systems,
* you may want to leave this undefined becasue it will make the grp functions
* somewhat larger (because of the inclusion of malloc and the code necessary).
* On larger systems, you will want to define this, because grp will _not_
* deal with long lines gracefully (they will be skipped).
*/
#undef GR_SCALE_DYNAMIC
#ifndef GR_SCALE_DYNAMIC
/*
* If scaling is not dynamic, the buffers will be statically allocated, and
* maximums must be chosen. GR_MAX_LINE_LEN is the maximum number of
* characters per line in the group file. GR_MAX_MEMBERS is the maximum
* number of members of any given group.
*/
#define GR_MAX_LINE_LEN 128
/* GR_MAX_MEMBERS = (GR_MAX_LINE_LEN-(24+3+6))/9 */
#define GR_MAX_MEMBERS 11
#endif /* !GR_SCALE_DYNAMIC */
/*
* Define GR_DYNAMIC_GROUP_LIST to make initgroups() dynamically allocate
* space for it's GID array before calling setgroups(). This is probably
* unnecessary scalage, so it's undefined by default.
*/
#undef GR_DYNAMIC_GROUP_LIST
#ifndef GR_DYNAMIC_GROUP_LIST
/*
* GR_MAX_GROUPS is the size of the static array initgroups() uses for
* its static GID array if GR_DYNAMIC_GROUP_LIST isn't defined.
*/
#define GR_MAX_GROUPS 64
#endif /* !GR_DYNAMIC_GROUP_LIST */
int initgroups(__const char *user, gid_t gid)
{
register struct group *group;
#ifndef GR_DYNAMIC_GROUP_LIST
gid_t group_list[GR_MAX_GROUPS];
#else
gid_t *group_list = NULL;
#endif
register char **tmp_mem;
int num_groups;
int grp_fd;
if ((grp_fd = open("/etc/group", O_RDONLY)) < 0)
return -1;
num_groups = 0;
#ifdef GR_DYNAMIC_GROUP_LIST
group_list = (gid_t *) realloc(group_list, 1);
#endif
group_list[num_groups] = gid;
#ifndef GR_DYNAMIC_GROUP_LIST
while (num_groups < GR_MAX_GROUPS &&
(group = __getgrent(grp_fd)) != NULL)
#else
while ((group = __getgrent(grp_fd)) != NULL)
#endif
{
if (group->gr_gid != gid);
{
tmp_mem = group->gr_mem;
while (*tmp_mem != NULL) {
if (!strcmp(*tmp_mem, user)) {
num_groups++;
#ifdef GR_DYNAMIC_GROUP_LIST
group_list = (gid_t *) realloc(group_list, num_groups *
sizeof(gid_t *));
#endif
group_list[num_groups] = group->gr_gid;
}
tmp_mem++;
}
}
}
close(grp_fd);
return setgroups(num_groups, group_list);
}

39
libpwdgrp/putpwent.c Normal file
View File

@@ -0,0 +1,39 @@
/*
* putpwent.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <stdio.h>
#include <errno.h>
#include "pwd.h"
int putpwent(const struct passwd *passwd, FILE * f)
{
if (passwd == NULL || f == NULL) {
errno = EINVAL;
return -1;
}
if (fprintf (f, "%s:%s:%u:%u:%s:%s:%s\n", passwd->pw_name, passwd->pw_passwd,
passwd->pw_gid, passwd->pw_uid, passwd->pw_gecos, passwd->pw_dir,
passwd->pw_shell) < 0)
return -1;
return 0;
}

58
libpwdgrp/pwent.c Normal file
View File

@@ -0,0 +1,58 @@
/*
* pwent.c - This file is part of the libc-8086/pwd package for ELKS,
* Copyright (C) 1995, 1996 Nat Friedman <ndf@linux.mit.edu>.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "busybox.h"
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
#include "pwd.h"
#include <fcntl.h>
/*
* setpwent(), endpwent(), and getpwent() are included in the same object
* file, since one cannot be used without the other two, so it makes sense to
* link them all in together.
*/
/* file descriptor for the password file currently open */
static int pw_fd = -1;
void setpwent(void)
{
if (pw_fd != -1)
close(pw_fd);
pw_fd = open("/etc/passwd", O_RDONLY);
}
void endpwent(void)
{
if (pw_fd != -1)
close(pw_fd);
pw_fd = -1;
}
struct passwd *getpwent(void)
{
if (pw_fd != -1)
return (__getpwent(pw_fd));
return NULL;
}

42
libpwdgrp/setgroups.c Normal file
View File

@@ -0,0 +1,42 @@
/* vi: set sw=4 ts=4: */
/*
* Taken from the set of syscalls for uClibc
*
* Copyright (C) 1999,2000,2001 by Erik Andersen <andersee@debian.org>
* <andersen@lineo.com>, <andersee@debian.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU Library General Public License as published by
* the Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License
* for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include "busybox.h"
#include <errno.h>
#include <unistd.h>
#include <features.h>
#include <sys/types.h>
/* Kernel headers before 2.1.mumble need this on the Alpha to get
_syscall* defined. */
#define __LIBRARY__
#include <sys/syscall.h>
#if __GNU_LIBRARY__ < 5
/* This is needed for libc5 */
#include <asm/unistd.h>
#endif
#include "grp.h"
//#define __NR_setgroups 81
_syscall2(int, setgroups, size_t, size, const gid_t *, list);

302
libpwdgrp/shadow.c Normal file
View File

@@ -0,0 +1,302 @@
/* vi: set sw=4 ts=4: */
/*
* Copyright 1989 - 1994, Julianne Frances Haugh
* <jockgrrl@austin.rr.com>, <jfh@austin.ibm.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Julianne F. Haugh nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY JULIE HAUGH AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL JULIE HAUGH OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/* TODO: fgetspent_r.c getspent_r.c getspnam_r.c sgetspent_r.c
* lckpwdf ulckpwdf
*/
#include "busybox.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "shadow.h"
static FILE *shadow;
static char spwbuf[BUFSIZ];
static struct spwd spwd;
#define FIELDS 9
#define OFIELDS 5
/* setspent - initialize access to shadow text and DBM files */
void setspent(void)
{
if (shadow) {
rewind(shadow);
} else {
if ((shadow = fopen("/etc/shadow", "r")) == NULL)
perror_msg_and_die("/etc/shadow");
}
}
/* endspent - terminate access to shadow text and DBM files */
void endspent(void)
{
if (shadow)
(void) fclose(shadow);
shadow = (FILE *) 0;
}
/* getspent - get a (struct spwd *) from the current shadow file */
struct spwd *getspent(void)
{
if (!shadow)
setspent();
return (fgetspent(shadow));
}
/* getspnam - get a shadow entry by name */
struct spwd *getspnam(const char *name)
{
struct spwd *sp;
if (!name || !strlen(name))
return NULL;
setspent();
while ((sp = getspent()) != NULL) {
if (strcmp(name, sp->sp_namp) == 0)
break;
}
endspent();
return (sp);
}
/* sgetspent - convert string in shadow file format to (struct spwd *) */
/* returns NULL on error */
struct spwd *sgetspent(const char *string)
{
char *fields[FIELDS];
char *cp;
char *cpp;
int i;
/*
* Copy string to local buffer. It has to be tokenized and we
* have to do that to our private copy.
*/
if (strlen(string) >= sizeof spwbuf)
/* return 0; */
return NULL;
strcpy(spwbuf, string);
if ((cp = strrchr(spwbuf, '\n')))
*cp = '\0';
/*
* Tokenize the string into colon separated fields. Allow up to
* FIELDS different fields.
*/
for (cp = spwbuf, i = 0; *cp && i < FIELDS; i++) {
fields[i] = cp;
while (*cp && *cp != ':')
cp++;
if (*cp)
*cp++ = '\0';
}
/*
* It is acceptable for the last SVR4 field to be blank. This
* results in the loop being terminated early. In which case,
* we just make the last field be blank and be done with it.
*/
if (i == (FIELDS - 1))
fields[i++] = cp;
if ((cp && *cp) || (i != FIELDS && i != OFIELDS))
/* return 0; */
return NULL;
/*
* Start populating the structure. The fields are all in
* static storage, as is the structure we pass back. If we
* ever see a name with '+' as the first character, we try
* to turn on NIS processing.
*/
spwd.sp_namp = fields[0];
spwd.sp_pwdp = fields[1];
/*
* Get the last changed date. For all of the integer fields,
* we check for proper format. It is an error to have an
* incorrectly formatted number, unless we are using NIS.
*/
if ((spwd.sp_lstchg = strtol(fields[2], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[2][0] == '\0')
spwd.sp_lstchg = -1;
/*
* Get the minimum period between password changes.
*/
if ((spwd.sp_min = strtol(fields[3], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[3][0] == '\0')
spwd.sp_min = -1;
/*
* Get the maximum number of days a password is valid.
*/
if ((spwd.sp_max = strtol(fields[4], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[4][0] == '\0')
spwd.sp_max = -1;
/*
* If there are only OFIELDS fields (this is a SVR3.2 /etc/shadow
* formatted file), initialize the other field members to -1.
*/
if (i == OFIELDS) {
spwd.sp_warn = spwd.sp_inact = spwd.sp_expire = spwd.sp_flag = -1;
return &spwd;
}
/*
* The rest of the fields are mandatory for SVR4, but optional
* for anything else. However, if one is present the others
* must be as well.
*/
/*
* Get the number of days of password expiry warning.
*/
if ((spwd.sp_warn = strtol(fields[5], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[5][0] == '\0')
spwd.sp_warn = -1;
/*
* Get the number of days of inactivity before an account is
* disabled.
*/
if ((spwd.sp_inact = strtol(fields[6], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[6][0] == '\0')
spwd.sp_inact = -1;
/*
* Get the number of days after the epoch before the account is
* set to expire.
*/
if ((spwd.sp_expire = strtol(fields[7], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[7][0] == '\0')
spwd.sp_expire = -1;
/*
* This field is reserved for future use. But it isn't supposed
* to have anything other than a valid integer in it.
*/
if ((spwd.sp_flag = strtol(fields[8], &cpp, 10)) == 0 && *cpp) {
/* return 0; */
return NULL;
} else if (fields[8][0] == '\0')
spwd.sp_flag = -1;
return (&spwd);
}
/* fgetspent - get an entry from an /etc/shadow formatted stream */
struct spwd *fgetspent(FILE *fp)
{
char buf[BUFSIZ];
char *cp;
if (!fp)
/* return (0); */
return NULL;
if (fgets(buf, sizeof buf, fp) != (char *) 0) {
if ((cp = strchr(buf, '\n')))
*cp = '\0';
return (sgetspent(buf));
}
/* return 0; */
return NULL;
}
/*
* putspent - put a (struct spwd *) into the (FILE *) you provide.
*
* this was described in shadow_.h but not implemented, so here
* I go. -beppu
*
*/
int putspent(const struct spwd *sp, FILE *fp)
{
int ret;
/* seek to end */
ret = fseek(fp, 0, SEEK_END);
if (ret == -1) {
/* return -1; */
return 1;
}
/* powered by fprintf */
fprintf(fp, "%s:%s:%ld:%ld:%ld:%ld:%ld:%ld:%s\n", sp->sp_namp, /* login name */
sp->sp_pwdp, /* encrypted password */
sp->sp_lstchg, /* date of last change */
sp->sp_min, /* minimum number of days between changes */
sp->sp_max, /* maximum number of days between changes */
sp->sp_warn, /* number of days of warning before password expires */
sp->sp_inact, /* number of days after password expires until
the account becomes unusable */
sp->sp_expire, /* days since 1/1/70 until account expires */
"");
return 0;
}

30
loginutils/Makefile Normal file
View File

@@ -0,0 +1,30 @@
# Makefile for busybox
#
# Copyright (C) 1999-2002 Erik Andersen <andersee@debian.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
TOPDIR:= ../
LOGINUTILS_DIR:=./
include $(TOPDIR).config
include $(TOPDIR)Rules.mak
include Makefile.in
all: $(libraries-y)
-include $(TOPDIR).depend
clean:
rm -f *.o *.a $(AR_TARGET)

45
loginutils/Makefile.in Normal file
View File

@@ -0,0 +1,45 @@
# Makefile for busybox
#
# Copyright (C) 1999-2002 Erik Andersen <andersee@debian.org>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
LOGINUTILS_AR:=loginutils.a
ifndef LOGINUTILS_DIR
LOGINUTILS_DIR:=$(TOPDIR)loginutils/
endif
LOGINUTILS-y:=
LOGINUTILS-$(CONFIG_ADDGROUP) += addgroup.o
LOGINUTILS-$(CONFIG_ADDUSER) += adduser.o
LOGINUTILS-$(CONFIG_DELUSER) += deluser.o
LOGINUTILS-$(CONFIG_GETTY) += getty.o
LOGINUTILS-$(CONFIG_LOGIN) += login.o tinylogin.o
LOGINUTILS-$(CONFIG_SU) += su.o tinylogin.o
libraries-y+=$(LOGINUTILS_DIR)$(LOGINUTILS_AR)
needcrypt-y:=
needcrypt-$(CONFIG_LOGIN) := y
needcrypt-$(CONFIG_SU) := y
ifeq ($(needcrypt-y),y)
libraries-y +=-lcrypt
endif
$(LOGINUTILS_DIR)$(LOGINUTILS_AR): $(patsubst %,$(LOGINUTILS_DIR)%, $(LOGINUTILS-y))
$(AR) -ro $@ $(patsubst %,$(LOGINUTILS_DIR)%, $(LOGINUTILS-y))

168
loginutils/addgroup.c Normal file
View File

@@ -0,0 +1,168 @@
/* vi: set sw=4 ts=4: */
/*
* addgroup - add users to /etc/passwd and /etc/shadow
*
* Copyright (C) 1999 by Lineo, inc. and John Beppu
* Copyright (C) 1999,2000,2001 by John Beppu <beppu@codepoet.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include "busybox.h"
#include "pwd.h"
#include "grp.h"
#define GROUP_FILE "/etc/group"
#define SHADOW_FILE "/etc/gshadow"
/* structs __________________________ */
/* data _____________________________ */
/* defaults : should this be in an external file? */
static const char default_passwd[] = "x";
/* make sure gr_name isn't taken, make sure gid is kosher
* return 1 on failure */
static int group_study(const char *filename, struct group *g)
{
FILE *etc_group;
gid_t desired;
struct group *grp;
const int max = 65000;
etc_group = xfopen(filename, "r");
/* make sure gr_name isn't taken, make sure gid is kosher */
desired = g->gr_gid;
while ((grp = fgetgrent(etc_group))) {
if ((strcmp(grp->gr_name, g->gr_name)) == 0) {
error_msg_and_die("%s: group already in use\n", g->gr_name);
}
if ((desired) && grp->gr_gid == desired) {
error_msg_and_die("%d: gid has already been allocated\n",
desired);
}
if ((grp->gr_gid > g->gr_gid) && (grp->gr_gid < max)) {
g->gr_gid = grp->gr_gid;
}
}
fclose(etc_group);
/* gid */
if (desired) {
g->gr_gid = desired;
} else {
g->gr_gid++;
}
/* return 1; */
return 0;
}
/* append a new user to the passwd file */
static int addgroup(const char *filename, char *group, gid_t gid)
{
FILE *etc_group;
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
FILE *etc_gshadow;
char *gshadow = SHADOW_FILE;
#endif
struct group gr;
/* group:passwd:gid:userlist */
static const char entryfmt[] = "%s:%s:%d:%s\n";
/* make sure gid and group haven't already been allocated */
gr.gr_gid = gid;
gr.gr_name = group;
if (group_study(filename, &gr))
return 1;
/* add entry to group */
etc_group = xfopen(filename, "a");
fprintf(etc_group, entryfmt, group, default_passwd, gr.gr_gid, "");
fclose(etc_group);
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* add entry to gshadow if necessary */
if (access(gshadow, F_OK|W_OK) == 0) {
etc_gshadow = xfopen(gshadow, "a");
fprintf(etc_gshadow, "%s:!::\n", group);
fclose(etc_gshadow);
}
#endif
/* return 1; */
return 0;
}
/*
* addgroup will take a login_name as its first parameter.
*
* gid
*
* can be customized via command-line parameters.
* ________________________________________________________________________ */
int addgroup_main(int argc, char **argv)
{
int opt;
char *group;
gid_t gid = 0;
/* get remaining args */
while ((opt = getopt (argc, argv, "g:")) != -1)
switch (opt) {
case 'g':
gid = strtol(optarg, NULL, 10);
break;
default:
show_usage();
break;
}
if (optind >= argc) {
show_usage();
} else {
group = argv[optind];
}
if (geteuid() != 0) {
error_msg_and_die
("Only root may add a group to the system.");
}
/* werk */
return addgroup(GROUP_FILE, group, gid);
}
/* $Id: addgroup.c,v 1.1 2002/06/04 20:45:05 sandman Exp $ */

352
loginutils/adduser.c Normal file
View File

@@ -0,0 +1,352 @@
/* vi: set sw=4 ts=4: */
/*
* adduser - add users to /etc/passwd and /etc/shadow
*
* Copyright (C) 1999 by Lineo, inc. and John Beppu
* Copyright (C) 1999,2000,2001 by John Beppu <beppu@codepoet.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <errno.h>
#include <fcntl.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "busybox.h"
#include "pwd.h"
#include "grp.h"
#define PASSWD_FILE "/etc/passwd"
#define SHADOW_FILE "/etc/shadow"
/* structs __________________________ */
typedef struct {
uid_t u;
gid_t g;
} Id;
/* data _____________________________ */
/* defaults : should this be in an external file? */
static const char default_passwd[] = "x";
static const char default_gecos[] = "Linux User,,,";
static const char default_home_prefix[] = "/home";
static const char default_shell[] = "/bin/sh";
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
#include "shadow.h"
/* shadow in use? */
static int shadow_enabled = 0;
#endif
/* remix */
/* EDR recoded such that the uid may be passed in *p */
static int passwd_study(const char *filename, struct passwd *p)
{
struct passwd *pw;
FILE *passwd;
const int min = 500;
const int max = 65000;
passwd = wfopen(filename, "r");
if (!passwd)
return 4;
/* EDR if uid is out of bounds, set to min */
if ((p->pw_uid > max) || (p->pw_uid < min))
p->pw_uid = min;
/* stuff to do:
* make sure login isn't taken;
* find free uid and gid;
*/
while ((pw = fgetpwent(passwd))) {
if (strcmp(pw->pw_name, p->pw_name) == 0) {
/* return 0; */
return 1;
}
if ((pw->pw_uid >= p->pw_uid) && (pw->pw_uid < max)
&& (pw->pw_uid >= min)) {
p->pw_uid = pw->pw_uid + 1;
}
}
/* EDR check for an already existing gid */
while (getgrgid(p->pw_uid) != NULL)
p->pw_uid++;
/* EDR also check for an existing group definition */
if (getgrnam(p->pw_name) != NULL)
return 3;
/* EDR bounds check */
if ((p->pw_uid > max) || (p->pw_uid < min))
return 2;
/* EDR create new gid always = uid */
p->pw_gid = p->pw_uid;
/* return 1; */
return 0;
}
static void addgroup_wrapper(const char *login, gid_t gid)
{
int argc = 3;
const char *argv0_save;
char group_id[8];
char group_name[32];
char *argv[] = { group_name, "-g", group_id };
argv0_save = applet_name;
applet_name = "addgroup";
safe_strncpy(group_name, login, 32);
sprintf(group_id, "%d", gid);
addgroup_main(argc, argv);
applet_name = argv0_save;
}
static void passwd_wrapper(const char *login)
{
static const char prog[] = "passwd";
execlp(prog, prog, login, NULL);
error_msg_and_die("Failed to execute 'passwd', you must set the password for '%s' manually", login);
}
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/*
* pwd_to_spwd - create entries for new spwd structure
*
* pwd_to_spwd() creates a new (struct spwd) containing the
* information in the pointed-to (struct passwd).
*/
#define DAY (24L*3600L)
#define WEEK (7*DAY)
#define SCALE DAY
static struct spwd *pwd_to_spwd(const struct passwd *pw)
{
static struct spwd sp;
/*
* Nice, easy parts first. The name and passwd map directly
* from the old password structure to the new one.
*/
sp.sp_namp = pw->pw_name;
sp.sp_pwdp = pw->pw_passwd;
/*
* Defaults used if there is no pw_age information.
*/
sp.sp_min = 0;
sp.sp_max = (10000L * DAY) / SCALE;
sp.sp_lstchg = time((time_t *) 0) / SCALE;
/*
* These fields have no corresponding information in the password
* file. They are set to uninitialized values.
*/
sp.sp_warn = -1;
sp.sp_expire = -1;
sp.sp_inact = -1;
sp.sp_flag = -1;
return &sp;
}
#endif
/* putpwent(3) remix */
static int adduser(const char *filename, struct passwd *p)
{
FILE *passwd;
int r;
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
FILE *shadow;
struct spwd *sp;
#endif
/* make sure everything is kosher and setup uid && gid */
passwd = wfopen(filename, "a");
if (passwd == NULL) {
/* return -1; */
return 1;
}
fseek(passwd, 0, SEEK_END);
/* if (passwd_study(filename, p) == 0) { */
r = passwd_study(filename, p);
if (r) {
if (r == 1)
error_msg("%s: login already in use", p->pw_name);
else if (r == 2)
error_msg("illegal uid or no uids left");
else if (r == 3)
error_msg("group name %s already in use", p->pw_name);
else
error_msg("generic error.");
/* return -1; */
return 1;
}
/* add to passwd */
if (putpwent(p, passwd) == -1) {
/* return -1; */
return 1;
}
fclose(passwd);
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* add to shadow if necessary */
if (shadow_enabled) {
shadow = wfopen(SHADOW_FILE, "a");
if (shadow == NULL) {
/* return -1; */
return 1;
}
fseek(shadow, 0, SEEK_END);
sp = pwd_to_spwd(p);
sp->sp_max = 99999; /* debianish */
sp->sp_warn = 7;
fprintf(shadow, "%s:!:%ld:%ld:%ld:%ld:::\n",
sp->sp_namp, sp->sp_lstchg, sp->sp_min, sp->sp_max,
sp->sp_warn);
fclose(shadow);
}
#endif
/* add to group */
/* addgroup should be responsible for dealing w/ gshadow */
addgroup_wrapper(p->pw_name, p->pw_gid);
/* Clear the umask for this process so it doesn't
* * screw up the permissions on the mkdir and chown. */
umask(0);
/* mkdir */
if (mkdir(p->pw_dir, 0755)) {
perror_msg("%s", p->pw_dir);
}
/* Set the owner and group so it is owned by the new user. */
if (chown(p->pw_dir, p->pw_uid, p->pw_gid)) {
perror_msg("%s", p->pw_dir);
}
/* Now fix up the permissions to 2755. Can't do it before now
* since chown will clear the setgid bit */
if (chmod(p->pw_dir, 02755)) {
perror_msg("%s", p->pw_dir);
}
/* interactively set passwd */
passwd_wrapper(p->pw_name);
return 0;
}
/* return current uid (root is always uid == 0, right?) */
static inline uid_t i_am_not_root(void)
{
return geteuid();
}
/*
* adduser will take a login_name as its first parameter.
*
* home
* shell
* gecos
*
* can be customized via command-line parameters.
* ________________________________________________________________________ */
int adduser_main(int argc, char **argv)
{
int i = 0;
char opt;
const char *login;
const char *gecos;
const char *home = NULL;
const char *shell;
struct passwd pw;
/* init */
if (argc < 2) {
show_usage();
}
gecos = default_gecos;
shell = default_shell;
/* get args */
while ((opt = getopt (argc, argv, "h:g:s:")) != -1)
switch (opt) {
case 'h':
home = argv[++i];
break;
case 'g':
gecos = argv[++i];
break;
case 's':
shell = argv[++i];
break;
default:
show_usage ();
break;
}
/* got root? */
if (i_am_not_root()) {
error_msg_and_die( "Only root may add a user or group to the system.");
}
/* get login */
if (optind >= argc) {
error_msg_and_die( "no user specified");
}
login = argv[optind];
/* create string for $HOME if not specified already */
if (!home) {
home = concat_path_file(default_home_prefix, login);
}
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
/* is /etc/shadow in use? */
shadow_enabled = (0 == access(SHADOW_FILE, F_OK));
#endif
/* create a passwd struct */
pw.pw_name = (char *)login;
pw.pw_passwd = (char *)default_passwd;
pw.pw_uid = 0;
pw.pw_gid = 0;
pw.pw_gecos = (char *)gecos;
pw.pw_dir = (char *)home;
pw.pw_shell = (char *)shell;
/* grand finale */
return adduser(PASSWD_FILE, &pw);
}
/* $Id: adduser.c,v 1.1 2002/06/04 20:45:05 sandman Exp $ */

25
loginutils/config.in Normal file
View File

@@ -0,0 +1,25 @@
#
# For a description of the syntax of this configuration file,
# see scripts/kbuild/config-language.txt.
#
mainmenu_option next_comment
comment 'Login/Password Management Utilities'
bool 'addgroup' CONFIG_ADDGROUP
bool 'adduser' CONFIG_ADDUSER
bool 'deluser' CONFIG_DELUSER
bool 'delgroup' CONFIG_DELUSER
bool 'getty' CONFIG_GETTY
bool 'login' CONFIG_LOGIN
if [ "$CONFIG_LOGIN" = "y" ]; then
bool ' Support for /etc/securetty' CONFIG_FEATURE_SECURETTY
fi
bool 'su' CONFIG_SU
if [ "$CONFIG_ADDUSER" = "y" -o "$CONFIG_DELUSER" = "y" -o "$CONFIG_LOGIN" = "y" -o "$CONFIG_SU" = "y" ]; then
bool 'Support for shadow passwords' CONFIG_FEATURE_SHADOWPASSWDS
fi
endmenu

183
loginutils/deluser.c Normal file
View File

@@ -0,0 +1,183 @@
/* vi: set sw=4 ts=4: */
/*
* deluser (remove lusers from the system ;) for TinyLogin
*
* Copyright (C) 1999 by Lineo, inc. and John Beppu
* Copyright (C) 1999,2000,2001 by John Beppu <beppu@codepoet.org>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#include <sys/stat.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "busybox.h"
#define PASSWD_FILE "/etc/passwd"
#define GROUP_FILE "/etc/group"
#define SHADOW_FILE "/etc/shadow"
#define GSHADOW_FILE "/etc/gshadow"
/* where to start and stop deletion */
typedef struct {
size_t start;
size_t stop;
} Bounds;
/* An interesting side-effect of boundary()'s
* implementation is that the first user (typically root)
* cannot be removed. Let's call it a feature. */
static inline Bounds boundary(const char *buffer, const char *login)
{
char needle[256];
char *start;
char *stop;
Bounds b;
snprintf(needle, 256, "\n%s:", login);
needle[255] = 0;
start = strstr(buffer, needle);
if (!start) {
b.start = 0;
b.stop = 0;
return b;
}
start++;
stop = index(start, '\n'); /* index is a BSD-ism */
b.start = start - buffer;
b.stop = stop - buffer;
return b;
}
/* grep -v ^login (except it only deletes the first match) */
/* ...in fact, I think I'm going to simplify this later */
static int del_line_matching(const char *login, const char *filename)
{
char *buffer;
FILE *passwd;
size_t len;
Bounds b;
struct stat statbuf;
/* load into buffer */
passwd = fopen(filename, "r");
if (!passwd) {
return 1;
}
stat(filename, &statbuf);
len = statbuf.st_size;
buffer = (char *) malloc(len * sizeof(char));
if (!buffer) {
fclose(passwd);
return 1;
}
fread(buffer, len, sizeof(char), passwd);
fclose(passwd);
/* find the user to remove */
b = boundary(buffer, login);
if (b.stop == 0) {
free(buffer);
return 1;
}
/* write the file w/o the user */
passwd = fopen(filename, "w");
if (!passwd) {
return 1;
}
fwrite(buffer, (b.start - 1), sizeof(char), passwd);
fwrite(&buffer[b.stop], (len - b.stop), sizeof(char), passwd);
fclose(passwd);
return 0;
}
/* ________________________________________________________________________ */
int delgroup_main(int argc, char **argv)
{
/* int successful; */
int failure;
if (argc != 2) {
show_usage();
} else {
failure = del_line_matching(argv[1], GROUP_FILE);
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
if (access(GSHADOW_FILE, W_OK) == 0) {
/* EDR the |= works if the error is not 0, so he had it wrong */
failure |= del_line_matching(argv[1], GSHADOW_FILE);
}
#endif /* CONFIG_FEATURE_SHADOWPASSWDS */
/* if (!successful) { */
if (failure) {
error_msg_and_die("%s: Group could not be removed\n", argv[1]);
}
}
return (EXIT_SUCCESS);
}
/* ________________________________________________________________________ */
int deluser_main(int argc, char **argv)
{
/* int successful; */
int failure;
if (argc != 2) {
show_usage();
} else {
failure = del_line_matching(argv[1], PASSWD_FILE);
/* if (!successful) { */
if (failure) {
error_msg_and_die("%s: User could not be removed from %s\n",
argv[1], PASSWD_FILE);
}
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
failure = del_line_matching(argv[1], SHADOW_FILE);
/* if (!successful) { */
if (failure) {
error_msg_and_die("%s: User could not be removed from %s\n",
argv[1], SHADOW_FILE);
}
failure = del_line_matching(argv[1], GSHADOW_FILE);
/* if (!successful) { */
if (failure) {
error_msg_and_die("%s: User could not be removed from %s\n",
argv[1], GSHADOW_FILE);
}
#endif /* CONFIG_FEATURE_SHADOWPASSWDS */
failure = del_line_matching(argv[1], GROUP_FILE);
/* if (!successful) { */
if (failure) {
error_msg_and_die("%s: User could not be removed from %s\n",
argv[1], GROUP_FILE);
}
}
return (EXIT_SUCCESS);
}
/* $Id: deluser.c,v 1.1 2002/06/04 20:45:05 sandman Exp $ */

1157
loginutils/getty.c Normal file
View File

File diff suppressed because it is too large Load Diff

459
loginutils/login.c Normal file
View File

@@ -0,0 +1,459 @@
/* vi: set sw=4 ts=4: */
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <termios.h>
#include <unistd.h>
#include <utmp.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <ctype.h>
#include <time.h>
#include "busybox.h"
#include "pwd.h"
#include "grp.h"
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
#include "shadow.h"
#endif
#include "tinylogin.h"
// import from utmp.c
static void checkutmp(int picky);
static void setutmp(const char *name, const char *line);
// import from encrypt.c
extern char *pw_encrypt(const char *clear, const char *salt);
// login defines
#define DEFAULT_USER "UNKNOWN"
#define DEFAULT_PWD "!"
#define DEFAULT_SHELL "/bin/sh"
#define TIMEOUT 60
#define FAIL_DELAY 3
#define MOTD_FILE "/etc/motd"
#define NOLOGIN_FILE "/etc/nologin"
#define SECURETTY_FILE "/etc/securetty"
/* Stuff global to this file */
struct utmp utent;
static int check_nologin ( int amroot );
#if defined CONFIG_FEATURE_SECURETTY
static int check_tty ( const char *tty );
#else
static inline int check_tty ( const char *tty ) { return 1; }
#endif
static int is_my_tty ( const char *tty );
static const char *login_prompt ( void );
static void motd ( void );
static void set_env(int argc, char *const *argv);
static void alarm_handler ( int sig )
{
error_msg ( "\nLogin timed out after %d seconds.\n", TIMEOUT );
exit ( EXIT_SUCCESS );
}
extern int login_main(int argc, char **argv)
{
char tty[BUFSIZ];
char full_tty[200];
char fromhost[512];
char *tmp;
int amroot;
int flag;
int failed;
int count=0;
struct passwd *pw, pw_copy;
int opt_preserve = 0;
int opt_fflag = 0;
char *opt_host = 0;
const char *username = 0;
int alarmstarted = 0;
amroot = ( getuid ( ) == 0 );
signal ( SIGALRM, alarm_handler );
if (( argc > 1 ) && ( TIMEOUT > 0 )) {
alarm ( TIMEOUT );
alarmstarted = 1;
}
while (( flag = getopt(argc, argv, "f:h:p")) != EOF ) {
switch ( flag ) {
case 'p':
printf ( "PRESERVE\n" );
opt_preserve = 1;
break;
case 'f':
/*
* username must be a seperate token
* (-f root, *NOT* -froot). --marekm
*/
if ( optarg != argv[optind-1] )
show_usage ( );
if ( !amroot ) /* Auth bypass only if real UID is zero */
error_msg_and_die ( "login: -f permission denied\n" );
printf ( "USERNAME: %s\n", optarg );
username = optarg;
opt_fflag = 1;
break;
case 'h':
opt_host = optarg;
break;
default:
show_usage ( );
}
}
if ( optind < argc ) // got a username
username = argv [optind++];
if ( !isatty ( 0 ) || !isatty ( 1 ) || !isatty ( 2 ))
return EXIT_FAILURE; /* Must be a terminal */
checkutmp ( !amroot );
tmp = ttyname ( 0 );
if ( tmp && ( strncmp ( tmp, "/dev/", 5 ) == 0 ))
safe_strncpy ( tty, tmp + 5, sizeof( tty ));
else
safe_strncpy ( tty, "UNKNOWN", sizeof( tty ));
if ( amroot )
memset ( utent.ut_host, 0, sizeof utent.ut_host );
if ( opt_host ) {
safe_strncpy ( utent.ut_host, opt_host, sizeof( utent. ut_host ));
snprintf ( fromhost, sizeof( fromhost ) - 1, " on `%.100s' from `%.200s'", tty, opt_host );
}
else
snprintf ( fromhost, sizeof( fromhost ) - 1, " on `%.100s'", tty );
openlog ( "login", LOG_PID | LOG_CONS | LOG_NOWAIT, LOG_AUTH );
while ( 1 ) {
failed = 0;
if ( !username || !username[0] )
username = login_prompt ( );
if ( !alarmstarted && ( TIMEOUT > 0 )) {
alarm ( TIMEOUT );
alarmstarted = 1;
}
if (!( pw = getpwnam ( username ))) {
pw_copy. pw_name = DEFAULT_USER;
pw_copy. pw_passwd = DEFAULT_PWD;
pw_copy. pw_shell = DEFAULT_SHELL;
opt_fflag = 0;
failed = 1;
} else
pw_copy = *pw;
pw = &pw_copy;
if (( pw-> pw_passwd [0] == '!' ) || ( pw-> pw_passwd[0] == '*' ))
failed = 1;
if ( opt_fflag ) {
opt_fflag = 0;
goto auth_ok;
}
if (( pw-> pw_uid == 0 ) && ( !check_tty ( tty )))
failed = 1;
/* Don't check the password if password entry is empty (!) */
if ( !pw-> pw_passwd[0] )
goto auth_ok;
/* authorization takes place here */
if ( correct_password ( pw ))
goto auth_ok;
syslog ( LOG_WARNING, "invalid password for `%s'%s\n", pw-> pw_name, fromhost);
failed = 1;
auth_ok:
if ( !failed)
break;
{ // delay next try
time_t start, now;
time ( &start );
now = start;
while ( difftime ( now, start ) < FAIL_DELAY) {
sleep ( FAIL_DELAY );
time ( &now );
}
}
puts("Login incorrect");
if ( ++count == 3 )
return EXIT_FAILURE;
}
alarm ( 0 );
if ( check_nologin ( pw-> pw_uid == 0 ))
return EXIT_FAILURE;
setutmp ( username, tty );
if ( *tty != '/' )
snprintf ( full_tty, sizeof( full_tty ) - 1, "/dev/%s", tty);
else
safe_strncpy ( full_tty, tty, sizeof( full_tty ) - 1 );
if ( !is_my_tty ( full_tty ))
syslog ( LOG_ERR, "unable to determine TTY name, got %s\n", full_tty );
/* Try these, but don't complain if they fail
* (for example when the root fs is read only) */
chown ( full_tty, pw-> pw_uid, pw-> pw_gid );
chmod ( full_tty, 0600 );
change_identity ( pw );
setup_environment ( pw-> pw_shell, 1, !opt_preserve, pw );
motd ( );
signal ( SIGALRM, SIG_DFL ); /* default alarm signal */
if ( pw-> pw_uid == 0 )
syslog ( LOG_INFO, "root login %s\n", fromhost );
run_shell ( pw-> pw_shell, 1, 0, 0 ); /* exec the shell finally. */
return EXIT_FAILURE;
}
static const char *login_prompt ( void )
{
char buf [1024];
char *sp, *ep;
gethostname ( buf, sizeof( buf ));
printf ( "\nBusyBox on %s login: ", buf );
fflush ( stdout );
if ( !fgets ( buf, sizeof( buf ) - 1, stdin ))
return 0;
if ( !strchr ( buf, '\n' ));
return 0;
for ( sp = buf; isspace ( *sp ); sp++ ) { }
for ( ep = sp; isgraph ( *ep ); ep++ ) { }
*ep = 0;
return sp;
}
static int check_nologin ( int amroot )
{
if ( access ( NOLOGIN_FILE, F_OK ) == 0 ) {
FILE *fp;
int c;
if (( fp = fopen ( NOLOGIN_FILE, "r" ))) {
while (( c = getc ( fp )) != EOF )
putchar (( c == '\n' ) ? '\r' : c );
fflush ( stdout );
fclose ( fp );
} else {
puts ( "\r\nSystem closed for routine maintenance.\r" );
}
if ( !amroot )
return 1;
puts ( "\r\n[Disconnect bypassed -- root login allowed.]\r" );
}
return 0;
}
#ifdef CONFIG_FEATURE_SECURETTY
static int check_tty ( const char *tty )
{
FILE *fp;
int i;
char buf[BUFSIZ];
if (( fp = fopen ( SECURETTY_FILE, "r" ))) {
while ( fgets ( buf, sizeof( buf ) - 1, fp )) {
for ( i = xstrlen( buf ) - 1; i >= 0; --i ) {
if ( !isspace ( buf[i] ))
break;
}
buf[++i] = '\0';
if (( buf [0] == '\0' ) || ( buf [0] == '#' ))
continue;
if ( strcmp ( buf, tty ) == 0 ) {
fclose ( fp );
return 1;
}
}
fclose(fp);
return 0;
}
else {
syslog ( LOG_WARNING, "cannot open securetty file.\n" );
return 1;
}
}
#endif
/* returns 1 if true */
static int is_my_tty ( const char *tty )
{
struct stat by_name, by_fd;
if ( stat ( tty, &by_name ) || fstat ( 0, &by_fd ))
return 0;
if ( by_name. st_rdev != by_fd. st_rdev )
return 0;
else
return 1;
}
static void motd ( )
{
FILE *fp;
register int c;
if (( fp = fopen ( MOTD_FILE, "r" ))) {
while (( c = getc ( fp )) != EOF )
putchar ( c );
fclose ( fp );
}
}
// vv Taken from tinylogin utmp.c vv
#define _WTMP_FILE "/var/log/wtmp"
#define NO_UTENT \
"No utmp entry. You must exec \"login\" from the lowest level \"sh\""
#define NO_TTY \
"Unable to determine your tty name."
/*
* checkutmp - see if utmp file is correct for this process
*
* System V is very picky about the contents of the utmp file
* and requires that a slot for the current process exist.
* The utmp file is scanned for an entry with the same process
* ID. If no entry exists the process exits with a message.
*
* The "picky" flag is for network and other logins that may
* use special flags. It allows the pid checks to be overridden.
* This means that getty should never invoke login with any
* command line flags.
*/
static void checkutmp(int picky)
{
char *line;
struct utmp *ut;
pid_t pid = getpid();
setutent();
/* First, try to find a valid utmp entry for this process. */
while ((ut = getutent()))
if (ut->ut_pid == pid && ut->ut_line[0] && ut->ut_id[0] &&
(ut->ut_type == LOGIN_PROCESS || ut->ut_type == USER_PROCESS))
break;
/* If there is one, just use it, otherwise create a new one. */
if (ut) {
utent = *ut;
} else {
if (picky) {
puts(NO_UTENT);
exit(1);
}
line = ttyname(0);
if (!line) {
puts(NO_TTY);
exit(1);
}
if (strncmp(line, "/dev/", 5) == 0)
line += 5;
memset((void *) &utent, 0, sizeof utent);
utent.ut_type = LOGIN_PROCESS;
utent.ut_pid = pid;
strncpy(utent.ut_line, line, sizeof utent.ut_line);
/* XXX - assumes /dev/tty?? */
strncpy(utent.ut_id, utent.ut_line + 3, sizeof utent.ut_id);
strncpy(utent.ut_user, "LOGIN", sizeof utent.ut_user);
time(&utent.ut_time);
}
}
#if __GNU_LIBRARY__ < 5
/*
* Some systems already have updwtmp() and possibly updwtmpx(). Others
* don't, so we re-implement these functions if necessary. --marekm
*/
static void updwtmp(const char *filename, const struct utmp *ut)
{
int fd;
fd = open(filename, O_APPEND | O_WRONLY, 0);
if (fd >= 0) {
write(fd, (const char *) ut, sizeof(*ut));
close(fd);
}
}
#endif
/*
* setutmp - put a USER_PROCESS entry in the utmp file
*
* setutmp changes the type of the current utmp entry to
* USER_PROCESS. the wtmp file will be updated as well.
*/
static void setutmp(const char *name, const char *line)
{
utent.ut_type = USER_PROCESS;
strncpy(utent.ut_user, name, sizeof utent.ut_user);
time(&utent.ut_time);
/* other fields already filled in by checkutmp above */
setutent();
pututline(&utent);
endutent();
updwtmp(_WTMP_FILE, &utent);
}

167
loginutils/su.c Normal file
View File

@@ -0,0 +1,167 @@
/* vi: set sw=4 ts=4: */
#include "busybox.h"
#include <fcntl.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <termios.h>
#include <unistd.h>
#include <utmp.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/types.h>
#include <ctype.h>
#include <time.h>
#include "pwd.h"
#include "grp.h"
#include "tinylogin.h"
/* The shell to run if none is given in the user's passwd entry. */
#define DEFAULT_SHELL "/bin/sh"
#define DEFAULT_USER "root"
//#define SYSLOG_SUCCESS
#define SYSLOG_FAILURE
#if defined( SYSLOG_SUCCESS ) || defined( SYSLOG_FAILURE )
/* Log the fact that someone has run su to the user given by PW;
if SUCCESSFUL is nonzero, they gave the correct password, etc. */
static void log_su ( const struct passwd *pw, int successful )
{
const char *old_user, *tty;
#if !defined( SYSLOG_SUCESS )
if ( successful )
return;
#endif
#if !defined( SYSLOG_FAILURE )
if ( !successful )
return;
#endif
if ( pw-> pw_uid ) // not to root -> ignored
return;
/* The utmp entry (via getlogin) is probably the best way to identify
the user, especially if someone su's from a su-shell. */
old_user = getlogin ( );
if ( !old_user ) {
/* getlogin can fail -- usually due to lack of utmp entry. Resort to getpwuid. */
struct passwd *pwd = getpwuid ( getuid ( ));
old_user = ( pwd ? pwd-> pw_name : "" );
}
tty = ttyname ( 2 );
openlog ( "su", 0, LOG_AUTH );
syslog ( LOG_NOTICE, "%s%s on %s", successful ? "" : "FAILED SU ", old_user, tty ? tty : "none" );
}
#endif
int su_main ( int argc, char **argv )
{
int flag;
int opt_preserve = 0;
int opt_loginshell = 0;
char *opt_shell = 0;
char *opt_command = 0;
char *opt_username = DEFAULT_USER;
char **opt_args = 0;
struct passwd *pw, pw_copy;
while (( flag = getopt ( argc, argv, "c:lmps:" )) != -1 ) {
switch ( flag ) {
case 'c':
opt_command = optarg;
break;
case 'm':
case 'p':
opt_preserve = 1;
break;
case 's':
opt_shell = optarg;
break;
case 'l':
opt_loginshell = 1;
break;
default:
show_usage ( );
break;
}
}
if (( optind < argc ) && ( argv [optind][0] == '-' ) && ( argv [optind][1] == 0 )) {
opt_loginshell = 1;
++optind;
}
/* get user if specified */
if ( optind < argc )
opt_username = argv [optind++];
if ( optind < argc )
opt_args = argv + optind;
pw = getpwnam ( opt_username );
if ( !pw )
error_msg_and_die ( "user %s does not exist", opt_username );
/* Make sure pw->pw_shell is non-NULL. It may be NULL when NEW_USER
is a username that is retrieved via NIS (YP), but that doesn't have
a default shell listed. */
if ( !pw-> pw_shell || !pw->pw_shell [0] )
pw-> pw_shell = (char *) DEFAULT_SHELL;
/* Make a copy of the password information and point pw at the local
copy instead. Otherwise, some systems (e.g. Linux) would clobber
the static data through the getlogin call from log_su. */
pw_copy = *pw;
pw = &pw_copy;
pw-> pw_name = xstrdup ( pw-> pw_name );
pw-> pw_dir = xstrdup ( pw-> pw_dir );
pw-> pw_shell = xstrdup ( pw-> pw_shell );
if (( getuid ( ) == 0 ) || correct_password ( pw ))
log_su ( pw, 1 );
else {
log_su ( pw, 0 );
error_msg_and_die ( "incorrect password" );
}
if ( !opt_shell && opt_preserve )
opt_shell = getenv ( "SHELL" );
if ( opt_shell && getuid ( ) && restricted_shell ( pw-> pw_shell ))
{
/* The user being su'd to has a nonstandard shell, and so is
probably a uucp account or has restricted access. Don't
compromise the account by allowing access with a standard
shell. */
fputs ( "using restricted shell\n", stderr );
opt_shell = 0;
}
if ( !opt_shell )
opt_shell = xstrdup ( pw-> pw_shell );
change_identity ( pw );
setup_environment ( opt_shell, opt_loginshell, !opt_preserve, pw );
run_shell ( opt_shell, opt_loginshell, opt_command, opt_args );
return EXIT_FAILURE;
}

209
loginutils/tinylogin.c Normal file
View File

@@ -0,0 +1,209 @@
/* vi: set sw=4 ts=4: */
/*
* Copyright 1989 - 1991, Julianne Frances Haugh <jockgrrl@austin.rr.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Julianne F. Haugh nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY JULIE HAUGH AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL JULIE HAUGH OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "busybox.h"
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <syslog.h>
#include <ctype.h>
#include "pwd.h"
#include "grp.h"
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
#include "shadow.h"
#endif
#define DEFAULT_LOGIN_PATH "/bin:/usr/bin"
#define DEFAULT_ROOT_LOGIN_PATH "/usr/sbin:/bin:/usr/bin:/sbin"
static void xsetenv ( const char *key, const char *value )
{
if ( setenv ( key, value, 1 ))
error_msg_and_die ( "out of memory" );
}
/* Become the user and group(s) specified by PW. */
void change_identity ( const struct passwd *pw )
{
if ( initgroups ( pw-> pw_name, pw-> pw_gid ) == -1 )
perror_msg_and_die ( "cannot set groups" );
endgrent ( );
if ( setgid ( pw-> pw_gid ))
perror_msg_and_die ( "cannot set group id" );
if ( setuid ( pw->pw_uid ))
perror_msg_and_die ( "cannot set user id" );
}
/* Run SHELL, or DEFAULT_SHELL if SHELL is empty.
If COMMAND is nonzero, pass it to the shell with the -c option.
If ADDITIONAL_ARGS is nonzero, pass it to the shell as more
arguments. */
void run_shell ( const char *shell, int loginshell, const char *command, const char **additional_args )
{
const char **args;
int argno = 1;
int additional_args_cnt = 0;
for ( args = additional_args; args && *args; args++ )
additional_args_cnt++;
if ( additional_args )
args = (const char **) xmalloc (sizeof (char *) * ( 4 + additional_args_cnt ));
else
args = (const char **) xmalloc (sizeof (char *) * 4 );
args [0] = get_last_path_component ( xstrdup ( shell ));
if ( loginshell ) {
char *args0 = xmalloc ( xstrlen ( args [0] ) + 2 );
args0 [0] = '-';
strcpy ( args0 + 1, args [0] );
args [0] = args0;
}
if ( command ) {
args [argno++] = "-c";
args [argno++] = command;
}
if ( additional_args ) {
for ( ; *additional_args; ++additional_args )
args [argno++] = *additional_args;
}
args [argno] = 0;
execv ( shell, (char **) args );
perror_msg_and_die ( "cannot run %s", shell );
}
/* Return 1 if SHELL is a restricted shell (one not returned by
getusershell), else 0, meaning it is a standard shell. */
int restricted_shell ( const char *shell )
{
char *line;
setusershell ( );
while (( line = getusershell ( ))) {
if (( *line != '#' ) && ( strcmp ( line, shell ) == 0 ))
break;
}
endusershell ( );
return line ? 0 : 1;
}
/* Update `environ' for the new shell based on PW, with SHELL being
the value for the SHELL environment variable. */
void setup_environment ( const char *shell, int loginshell, int changeenv, const struct passwd *pw )
{
if ( loginshell ) {
char *term;
/* Change the current working directory to be the home directory
* of the user. It is a fatal error for this process to be unable
* to change to that directory. There is no "default" home
* directory.
* Some systems default to HOME=/
*/
if ( chdir ( pw-> pw_dir )) {
if ( chdir ( "/" )) {
syslog ( LOG_WARNING, "unable to cd to %s' for user %s'\n", pw-> pw_dir, pw-> pw_name );
error_msg_and_die ( "cannot cd to home directory or /" );
}
fputs ( "warning: cannot change to home directory\n", stderr );
}
/* Leave TERM unchanged. Set HOME, SHELL, USER, LOGNAME, PATH.
Unset all other environment variables. */
term = getenv ("TERM");
clearenv ( );
if ( term )
xsetenv ( "TERM", term );
xsetenv ( "HOME", pw-> pw_dir );
xsetenv ( "SHELL", shell );
xsetenv ( "USER", pw-> pw_name );
xsetenv ( "LOGNAME", pw-> pw_name );
xsetenv ( "PATH", ( pw-> pw_uid ? DEFAULT_LOGIN_PATH : DEFAULT_ROOT_LOGIN_PATH ));
}
else if ( changeenv ) {
/* Set HOME, SHELL, and if not becoming a super-user,
USER and LOGNAME. */
xsetenv ( "HOME", pw-> pw_dir );
xsetenv ( "SHELL", shell );
if ( pw-> pw_uid ) {
xsetenv ( "USER", pw-> pw_name );
xsetenv ( "LOGNAME", pw-> pw_name );
}
}
}
/* Ask the user for a password.
Return 1 if the user gives the correct password for entry PW,
0 if not. Return 1 without asking for a password if run by UID 0
or if PW has an empty password. */
int correct_password ( const struct passwd *pw )
{
char *unencrypted, *encrypted, *correct;
#ifdef CONFIG_FEATURE_SHADOWPASSWDS
if (( strcmp ( pw-> pw_passwd, "x" ) == 0 ) || ( strcmp ( pw-> pw_passwd, "*" ) == 0 )) {
struct spwd *sp = getspnam ( pw-> pw_name );
if ( !sp )
error_msg_and_die ( "no valid shadow password" );
correct = sp-> sp_pwdp;
}
else
#endif
correct = pw-> pw_passwd;
if ( correct == 0 || correct[0] == '\0' )
return 1;
unencrypted = getpass ( "Password: " );
if ( !unencrypted )
{
fputs ( "getpass: cannot open /dev/tty\n", stderr );
return 0;
}
encrypted = crypt ( unencrypted, correct );
memset ( unencrypted, 0, xstrlen ( unencrypted ));
return ( strcmp ( encrypted, correct ) == 0 ) ? 1 : 0;
}

10
loginutils/tinylogin.h Normal file
View File

@@ -0,0 +1,10 @@
#ifndef BB_LOGINUTILS_SHELL_H
#define BB_LOGINUTILS_SHELL_H
extern void change_identity ( const struct passwd *pw );
extern void run_shell ( const char *shell, int loginshell, const char *command, char **additional_args );
extern int restricted_shell ( const char *shell );
extern void setup_environment ( const char *shell, int loginshell, int changeenv, const struct passwd *pw );
extern int correct_password ( const struct passwd *pw );
#endif