1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*
* setpwnam.c --
* edit an entry in a password database.
*
* (c) 1994 Salvatore Valente <svalente@mit.edu>
* This file 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 file is distributed with no warranty.
*
* Usage:
* 1) get a struct passwd * from getpwnam().
* You should assume a struct passwd has an infinite number of fields,
* so you should not try to create one from scratch.
* 2) edit the fields you want to edit.
* 3) call setpwnam() with the edited struct passwd.
*
* You should never directly read from or write to /etc/passwd.
* All user database queries should be directed through
* getpwnam() and setpwnam().
*
* Thanks to "two guys named Ian".
*/
/* faith
* 1.1.1.1
* 1995/02/22 19:09:24
*/
#define DEBUG 0
/* because I use getpwent(), putpwent(), etc... */
#define _SVID_SOURCE
#include <sys/types.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <pwd.h>
#include <errno.h>
#ifdef BSD43
#include <sys/file.h>
#endif
extern int errno;
typedef int boolean;
#define false 0
#define true 1
#ifndef DEBUG
#define PASSWD_FILE "/etc/passwd"
#define PTMP_FILE "/etc/ptmp"
#else
#define PASSWD_FILE "/tmp/passwd"
#define PTMP_FILE "/tmp/ptmp"
#endif
static int copy_pwd (struct passwd *src, struct passwd *dest);
static char *xstrdup (char *str);
/*
* setpwnam () --
* takes a struct passwd in which every field is filled in and valid.
* If the given username exists in the passwd file, his entry is
* replaced with the given entry.
*/
int setpwnam (struct passwd *pwd)
{
char *passwd = PASSWD_FILE;
char *ptmp = PTMP_FILE;
FILE *fp;
int x, save_errno, fd;
struct passwd *entry;
boolean found;
char buf[50];
struct passwd spwd;
/* getpwent() returns a pointer to a static buffer.
* "pwd" might have some from getpwent(), so we have to copy it to
* some other buffer before calling getpwent().
*/
if (copy_pwd (pwd, &spwd) < 0)
return (-1);
/* sanity check */
for (x = 0; x < 3; x++) {
if (x > 0) sleep (1);
fd = open (ptmp, O_WRONLY|O_CREAT|O_EXCL, 00644);
if (fd >= 0) break;
}
if (fd < 0) return (-1);
/* ptmp should be owned by root.root or root.wheel */
if (chown (ptmp, (uid_t) 0, (gid_t) 0) < 0)
perror ("chown");
/* open ptmp for writing and passwd for reading */
fp = fdopen (fd, "w");
if (! fp) goto fail;
setpwent ();
/* parse the passwd file */
found = false;
while ((entry = getpwent ()) != NULL) {
if (! strcmp (spwd.pw_name, entry->pw_name)) {
entry = &spwd;
found = true;
}
if (putpwent (entry, fp) < 0) goto fail;
}
if (fclose (fp) < 0) goto fail;
close (fd);
endpwent ();
if (! found) {
errno = ENOENT; /* give me something better */
goto fail;
}
strcpy (buf, passwd);
strcat (buf, "~");
/* we don't care if we can't remove the backup file */
remove (buf);
/* we don't care if we can't create the backup file */
link (passwd, buf);
/* we DO care if we can't erase the passwd file */
if (remove (passwd) < 0) {
/* if the file is still there, fail */
if (access (passwd, F_OK) == 0) goto fail;
}
/* if we can't link ptmp to passwd, all is lost */
if (link (ptmp, passwd) < 0) {
/* reinstall_system (); */
return (-1);
}
/* if we can't erase the ptmp file, we simply lose */
if (remove (ptmp) < 0)
return (-1);
/* finally: success */
return 0;
fail:
save_errno = errno;
if (fp) fclose (fp);
if (fd >= 0) close (fd);
endpwent ();
remove (ptmp);
errno = save_errno;
return (-1);
}
#define memzero(ptr, size) memset((char *) ptr, 0, size)
static int failed;
static int copy_pwd (struct passwd *src, struct passwd *dest)
{
/* this routine destroys abstraction barriers. it's not portable
* across systems, or even across different versions of the C library
* on a given system. it's dangerous and evil and wrong and I dispise
* getpwent() for forcing me to write this.
*/
failed = 0;
memzero (dest, sizeof (struct passwd));
dest->pw_name = xstrdup (src->pw_name);
dest->pw_passwd = xstrdup (src->pw_passwd);
dest->pw_uid = src->pw_uid;
dest->pw_gid = src->pw_gid;
dest->pw_gecos = xstrdup (src->pw_gecos);
dest->pw_dir = xstrdup (src->pw_dir);
dest->pw_shell = xstrdup (src->pw_shell);
return (failed);
}
static char *xstrdup (char *str)
{
char *dup;
if (! str)
return NULL;
dup = (char *) malloc (strlen (str) + 1);
if (! dup) {
failed = -1;
return NULL;
}
strcpy (dup, str);
return dup;
}
#ifdef NO_PUTPWENT
int putpwent (const struct passwd *p, FILE *stream)
{
if (p == NULL || stream == NULL) {
errno = EINVAL;
return (-1);
}
if (fprintf (stream, "%s:%s:%u:%u:%s:%s:%s\n",
p->pw_name, p->pw_passwd, p->pw_uid, p->pw_gid,
p->pw_gecos, p->pw_dir, p->pw_shell) < 0)
return (-1);
return(0);
}
#endif
|
