1 /*- 2 * Copyright (c) 2004 Dag-Erling Coïdan Smørgrav 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer 10 * in this position and unchanged. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * $FreeBSD$ 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <err.h> 35 #include <grp.h> 36 #include <pwd.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <string.h> 40 #include <time.h> 41 #include <unistd.h> 42 43 struct xpasswd { 44 char *pw_name; 45 char *pw_passwd; 46 uid_t pw_uid; 47 gid_t pw_gid; 48 time_t pw_change; 49 char *pw_class; 50 char *pw_gecos; 51 char *pw_dir; 52 char *pw_shell; 53 time_t pw_expire; 54 int pw_selected; 55 }; 56 57 struct xgroup { 58 char *gr_name; 59 char *gr_passwd; 60 gid_t gr_gid; 61 char *gr_mem; 62 }; 63 64 static int everything = 1; 65 static int a_flag; 66 static int d_flag; 67 static const char *g_args; 68 static const char *l_args; 69 static int m_flag; 70 static int o_flag; 71 static int p_flag; 72 static int s_flag; 73 static int t_flag; 74 static int u_flag; 75 static int x_flag; 76 77 static int 78 member(const char *elem, const char *list) 79 { 80 char *p; 81 int len; 82 83 p = strstr(list, elem); 84 len = strlen(elem); 85 86 return (p != NULL && 87 (p == list || p[-1] == ',') && 88 (p[len] == '\0' || p[len] == ',')); 89 } 90 91 static void * 92 xmalloc(size_t size) 93 { 94 void *newptr; 95 96 if ((newptr = malloc(size)) == NULL) 97 err(1, "malloc()"); 98 return (newptr); 99 } 100 101 static void * 102 xrealloc(void *ptr, size_t size) 103 { 104 void *newptr; 105 106 if ((newptr = realloc(ptr, size)) == NULL) 107 err(1, "realloc()"); 108 return (newptr); 109 } 110 111 static char * 112 xstrdup(const char *str) 113 { 114 char *dupstr; 115 116 if ((dupstr = strdup(str)) == NULL) 117 err(1, "strdup()"); 118 return (dupstr); 119 } 120 121 static struct xgroup *grps; 122 static size_t grpsz; 123 static size_t ngrps; 124 125 static void 126 get_groups(void) 127 { 128 struct group *grp; 129 size_t len; 130 int i; 131 132 setgrent(); 133 for (;;) { 134 if (ngrps == grpsz) { 135 grpsz += grpsz ? grpsz : 128; 136 grps = xrealloc(grps, grpsz * sizeof *grps); 137 } 138 if ((grp = getgrent()) == NULL) 139 break; 140 grps[ngrps].gr_name = xstrdup(grp->gr_name); 141 grps[ngrps].gr_passwd = xstrdup(grp->gr_passwd); 142 grps[ngrps].gr_gid = grp->gr_gid; 143 grps[ngrps].gr_mem = xstrdup(""); 144 for (i = 0, len = 1; grp->gr_mem[i] != NULL; ++i) 145 len += strlen(grp->gr_mem[i]) + 1; 146 grps[ngrps].gr_mem = xmalloc(len); 147 for (i = 0, len = 0; grp->gr_mem[i] != NULL; ++i) 148 len += sprintf(grps[ngrps].gr_mem + len, 149 i ? ",%s" : "%s", grp->gr_mem[i]); 150 grps[ngrps].gr_mem[len] = '\0'; 151 ngrps++; 152 } 153 endgrent(); 154 } 155 156 static struct xgroup * 157 find_group_bygid(gid_t gid) 158 { 159 unsigned int i; 160 161 for (i = 0; i < ngrps; ++i) 162 if (grps[i].gr_gid == gid) 163 return (&grps[i]); 164 return (NULL); 165 } 166 167 #if 0 168 static struct xgroup * 169 find_group_byname(const char *name) 170 { 171 unsigned int i; 172 173 for (i = 0; i < ngrps; ++i) 174 if (strcmp(grps[i].gr_name, name) == 0) 175 return (&grps[i]); 176 return (NULL); 177 } 178 #endif 179 180 static struct xpasswd *pwds; 181 static size_t pwdsz; 182 static size_t npwds; 183 184 static int 185 pwd_cmp_byname(const void *ap, const void *bp) 186 { 187 const struct passwd *a = ap; 188 const struct passwd *b = bp; 189 190 return (strcmp(a->pw_name, b->pw_name)); 191 } 192 193 static int 194 pwd_cmp_byuid(const void *ap, const void *bp) 195 { 196 const struct passwd *a = ap; 197 const struct passwd *b = bp; 198 199 return (a->pw_uid - b->pw_uid); 200 } 201 202 static void 203 get_users(void) 204 { 205 struct passwd *pwd; 206 207 setpwent(); 208 for (;;) { 209 if (npwds == pwdsz) { 210 pwdsz += pwdsz ? pwdsz : 128; 211 pwds = xrealloc(pwds, pwdsz * sizeof *pwds); 212 } 213 if ((pwd = getpwent()) == NULL) 214 break; 215 pwds[npwds].pw_name = xstrdup(pwd->pw_name); 216 pwds[npwds].pw_passwd = xstrdup(pwd->pw_passwd); 217 pwds[npwds].pw_uid = pwd->pw_uid; 218 pwds[npwds].pw_gid = pwd->pw_gid; 219 pwds[npwds].pw_change = pwd->pw_change; 220 pwds[npwds].pw_class = xstrdup(pwd->pw_class); 221 pwds[npwds].pw_gecos = xstrdup(pwd->pw_gecos); 222 pwds[npwds].pw_dir = xstrdup(pwd->pw_dir); 223 pwds[npwds].pw_shell = xstrdup(pwd->pw_shell); 224 pwds[npwds].pw_expire = pwd->pw_expire; 225 pwds[npwds].pw_selected = 0; 226 npwds++; 227 } 228 endpwent(); 229 } 230 231 static void 232 select_users(void) 233 { 234 unsigned int i, j; 235 struct xgroup *grp; 236 struct xpasswd *pwd; 237 238 for (i = 0, pwd = pwds; i < npwds; ++i, ++pwd) { 239 if (everything) { 240 pwd->pw_selected = 1; 241 continue; 242 } 243 if (d_flag) 244 if ((i > 0 && pwd->pw_uid == pwd[-1].pw_uid) || 245 (i < npwds - 1 && pwd->pw_uid == pwd[1].pw_uid)) { 246 pwd->pw_selected = 1; 247 continue; 248 } 249 if (g_args) { 250 for (j = 0, grp = grps; j < ngrps; ++j, ++grp) { 251 if (member(grp->gr_name, g_args) && 252 member(pwd->pw_name, grp->gr_mem)) { 253 pwd->pw_selected = 1; 254 break; 255 } 256 } 257 if (pwd->pw_selected) 258 continue; 259 } 260 if (l_args) 261 if (member(pwd->pw_name, l_args)) { 262 pwd->pw_selected = 1; 263 continue; 264 } 265 if (p_flag) 266 if (pwd->pw_passwd[0] == '\0') { 267 pwd->pw_selected = 1; 268 continue; 269 } 270 if (s_flag) 271 if (pwd->pw_uid < 1000 || pwd->pw_uid == 65534) { 272 pwd->pw_selected = 1; 273 continue; 274 } 275 if (u_flag) 276 if (pwd->pw_uid >= 1000 && pwd->pw_uid != 65534) { 277 pwd->pw_selected = 1; 278 continue; 279 } 280 } 281 } 282 283 static void 284 sort_users(void) 285 { 286 if (t_flag) 287 mergesort(pwds, npwds, sizeof *pwds, pwd_cmp_byname); 288 else 289 mergesort(pwds, npwds, sizeof *pwds, pwd_cmp_byuid); 290 } 291 292 static void 293 display_user(struct xpasswd *pwd) 294 { 295 struct xgroup *grp; 296 unsigned int i; 297 char cbuf[16], ebuf[16]; 298 struct tm *tm; 299 300 grp = find_group_bygid(pwd->pw_gid); 301 printf(o_flag ? "%s:%ld:%s:%ld:%s" : "%-15s %-7ld %-15s %-7ld %s\n", 302 pwd->pw_name, (long)pwd->pw_uid, grp ? grp->gr_name : "", 303 (long)pwd->pw_gid, pwd->pw_gecos); 304 if (m_flag) { 305 for (i = 0, grp = grps; i < ngrps; ++i, ++grp) { 306 if (grp->gr_gid == pwd->pw_gid || 307 !member(pwd->pw_name, grp->gr_mem)) 308 continue; 309 printf(o_flag ? "%s:%s:%ld" : "%24s%-15s %-7ld\n", 310 "", grp->gr_name, (long)grp->gr_gid); 311 } 312 } 313 if (x_flag) { 314 printf(o_flag ? "%s:%s" : "%24s%s\n", "", pwd->pw_dir); 315 printf(o_flag ? "%s:%s" : "%24s%s\n", "", pwd->pw_shell); 316 } 317 if (a_flag) { 318 tm = gmtime(&pwd->pw_change); 319 strftime(cbuf, sizeof(cbuf), pwd->pw_change ? "%F" : "0", tm); 320 tm = gmtime(&pwd->pw_expire); 321 strftime(ebuf, sizeof(ebuf), pwd->pw_expire ? "%F" : "0", tm); 322 printf(o_flag ? "%s:%s:%s" : "%24s%s %s\n", "", cbuf, ebuf); 323 } 324 if (o_flag) 325 printf("\n"); 326 } 327 328 static void 329 list_users(void) 330 { 331 struct xpasswd *pwd; 332 unsigned int i; 333 334 for (i = 0, pwd = pwds; i < npwds; ++i, ++pwd) 335 if (pwd->pw_selected) 336 display_user(pwd); 337 } 338 339 static void 340 usage(void) 341 { 342 fprintf(stderr, "usage: logins [-admopstux] [-g group] [-l login]\n"); 343 exit(1); 344 } 345 346 int 347 main(int argc, char * const argv[]) 348 { 349 int o; 350 351 while ((o = getopt(argc, argv, "adg:l:mopstux")) != -1) 352 switch (o) { 353 case 'a': 354 a_flag = 1; 355 break; 356 case 'd': 357 everything = 0; 358 d_flag = 1; 359 break; 360 case 'g': 361 everything = 0; 362 g_args = optarg; 363 break; 364 case 'l': 365 everything = 0; 366 l_args = optarg; 367 break; 368 case 'm': 369 m_flag = 1; 370 break; 371 case 'o': 372 o_flag = 1; 373 break; 374 case 'p': 375 everything = 0; 376 p_flag = 1; 377 break; 378 case 's': 379 everything = 0; 380 s_flag = 1; 381 break; 382 case 't': 383 t_flag = 1; 384 break; 385 case 'u': 386 everything = 0; 387 u_flag = 1; 388 break; 389 case 'x': 390 x_flag = 1; 391 break; 392 default: 393 usage(); 394 } 395 396 argc -= optind; 397 argv += optind; 398 399 if (argc > 0) 400 usage(); 401 402 get_groups(); 403 get_users(); 404 select_users(); 405 sort_users(); 406 list_users(); 407 exit(0); 408 } 409