diff options
author | guenther <> | 2009-11-18 07:43:22 +0000 |
---|---|---|
committer | guenther <> | 2009-11-18 07:43:22 +0000 |
commit | e9648d2ce662fb0d79072496682efb0718c01e66 (patch) | |
tree | 69cb2944835feb73c511d3d6141bf71d95163b13 /src/lib/libc/net/rcmd.c | |
parent | fe6c9378da6c3c76e86e1fa03619eda8e4da9408 (diff) | |
download | openbsd-e9648d2ce662fb0d79072496682efb0718c01e66.tar.gz openbsd-e9648d2ce662fb0d79072496682efb0718c01e66.tar.bz2 openbsd-e9648d2ce662fb0d79072496682efb0718c01e66.zip |
More shrinkage, a bit for ramdisks but mostly for static binaries:
- wrap with #ifndef NO_LOG_BAD_DNS_RESPONSES libc code that uses
p_class() and p_type() for diagnostics, then add that define to
libstub to avoid pulling in res_debug_syms.o
- split rcmd() and ruserok() into separate files, as nothing uses both
- split readdir_r() to its own file
- split syslog_r() from syslog(), as the latter needs localtime(); many
binaries no longer need to pull in all the time code after this; switch
from usleep() to nanosleep() while we're at it
(The profit of analysis of -Wl,-M,--cref output)
Chops 888kB from /bin and /sbin on i386
ok deraadt@, miod@
Diffstat (limited to 'src/lib/libc/net/rcmd.c')
-rw-r--r-- | src/lib/libc/net/rcmd.c | 388 |
1 files changed, 0 insertions, 388 deletions
diff --git a/src/lib/libc/net/rcmd.c b/src/lib/libc/net/rcmd.c index 30ca6710c4..d566e0ca4c 100644 --- a/src/lib/libc/net/rcmd.c +++ b/src/lib/libc/net/rcmd.c | |||
@@ -46,13 +46,6 @@ | |||
46 | #include <string.h> | 46 | #include <string.h> |
47 | #include <syslog.h> | 47 | #include <syslog.h> |
48 | #include <stdlib.h> | 48 | #include <stdlib.h> |
49 | #include <netgroup.h> | ||
50 | |||
51 | int __ivaliduser(FILE *, in_addr_t, const char *, const char *); | ||
52 | int __ivaliduser_sa(FILE *, struct sockaddr *, socklen_t, | ||
53 | const char *, const char *); | ||
54 | static int __icheckhost(struct sockaddr *, socklen_t, const char *); | ||
55 | static char *__gethostloop(struct sockaddr *, socklen_t); | ||
56 | 49 | ||
57 | int | 50 | int |
58 | rcmd(char **ahost, int rport, const char *locuser, const char *remuser, | 51 | rcmd(char **ahost, int rport, const char *locuser, const char *remuser, |
@@ -308,384 +301,3 @@ bad: | |||
308 | return (-1); | 301 | return (-1); |
309 | } | 302 | } |
310 | 303 | ||
311 | int __check_rhosts_file = 1; | ||
312 | char *__rcmd_errstr; | ||
313 | |||
314 | int | ||
315 | ruserok(const char *rhost, int superuser, const char *ruser, const char *luser) | ||
316 | { | ||
317 | struct addrinfo hints, *res, *r; | ||
318 | int error; | ||
319 | |||
320 | memset(&hints, 0, sizeof(hints)); | ||
321 | hints.ai_family = PF_UNSPEC; | ||
322 | hints.ai_socktype = SOCK_DGRAM; /*dummy*/ | ||
323 | error = getaddrinfo(rhost, "0", &hints, &res); | ||
324 | if (error) | ||
325 | return (-1); | ||
326 | |||
327 | for (r = res; r; r = r->ai_next) { | ||
328 | if (iruserok_sa(r->ai_addr, r->ai_addrlen, superuser, ruser, | ||
329 | luser) == 0) { | ||
330 | freeaddrinfo(res); | ||
331 | return (0); | ||
332 | } | ||
333 | } | ||
334 | freeaddrinfo(res); | ||
335 | return (-1); | ||
336 | } | ||
337 | |||
338 | /* | ||
339 | * New .rhosts strategy: We are passed an ip address. We spin through | ||
340 | * hosts.equiv and .rhosts looking for a match. When the .rhosts only | ||
341 | * has ip addresses, we don't have to trust a nameserver. When it | ||
342 | * contains hostnames, we spin through the list of addresses the nameserver | ||
343 | * gives us and look for a match. | ||
344 | * | ||
345 | * Returns 0 if ok, -1 if not ok. | ||
346 | */ | ||
347 | int | ||
348 | iruserok(u_int32_t raddr, int superuser, const char *ruser, const char *luser) | ||
349 | { | ||
350 | struct sockaddr_in sin; | ||
351 | |||
352 | memset(&sin, 0, sizeof(sin)); | ||
353 | sin.sin_family = AF_INET; | ||
354 | sin.sin_len = sizeof(struct sockaddr_in); | ||
355 | memcpy(&sin.sin_addr, &raddr, sizeof(sin.sin_addr)); | ||
356 | return iruserok_sa(&sin, sizeof(struct sockaddr_in), superuser, ruser, | ||
357 | luser); | ||
358 | } | ||
359 | |||
360 | int | ||
361 | iruserok_sa(const void *raddr, int rlen, int superuser, const char *ruser, | ||
362 | const char *luser) | ||
363 | { | ||
364 | struct sockaddr *sa; | ||
365 | char *cp; | ||
366 | struct stat sbuf; | ||
367 | struct passwd *pwd; | ||
368 | FILE *hostf; | ||
369 | uid_t uid; | ||
370 | int first; | ||
371 | char pbuf[MAXPATHLEN]; | ||
372 | |||
373 | sa = (struct sockaddr *)raddr; | ||
374 | first = 1; | ||
375 | hostf = superuser ? NULL : fopen(_PATH_HEQUIV, "r"); | ||
376 | again: | ||
377 | if (hostf) { | ||
378 | if (__ivaliduser_sa(hostf, sa, rlen, luser, ruser) == 0) { | ||
379 | (void)fclose(hostf); | ||
380 | return (0); | ||
381 | } | ||
382 | (void)fclose(hostf); | ||
383 | } | ||
384 | if (first == 1 && (__check_rhosts_file || superuser)) { | ||
385 | int len; | ||
386 | |||
387 | first = 0; | ||
388 | if ((pwd = getpwnam(luser)) == NULL) | ||
389 | return (-1); | ||
390 | len = snprintf(pbuf, sizeof pbuf, "%s/.rhosts", pwd->pw_dir); | ||
391 | if (len < 0 || len >= sizeof pbuf) | ||
392 | return (-1); | ||
393 | |||
394 | /* | ||
395 | * Change effective uid while opening .rhosts. If root and | ||
396 | * reading an NFS mounted file system, can't read files that | ||
397 | * are protected read/write owner only. | ||
398 | */ | ||
399 | uid = geteuid(); | ||
400 | (void)seteuid(pwd->pw_uid); | ||
401 | hostf = fopen(pbuf, "r"); | ||
402 | (void)seteuid(uid); | ||
403 | |||
404 | if (hostf == NULL) | ||
405 | return (-1); | ||
406 | /* | ||
407 | * If not a regular file, or is owned by someone other than | ||
408 | * user or root or if writeable by anyone but the owner, quit. | ||
409 | */ | ||
410 | cp = NULL; | ||
411 | if (lstat(pbuf, &sbuf) < 0) | ||
412 | cp = ".rhosts lstat failed"; | ||
413 | else if (!S_ISREG(sbuf.st_mode)) | ||
414 | cp = ".rhosts not regular file"; | ||
415 | else if (fstat(fileno(hostf), &sbuf) < 0) | ||
416 | cp = ".rhosts fstat failed"; | ||
417 | else if (sbuf.st_uid && sbuf.st_uid != pwd->pw_uid) | ||
418 | cp = "bad .rhosts owner"; | ||
419 | else if (sbuf.st_mode & (S_IWGRP|S_IWOTH)) | ||
420 | cp = ".rhosts writable by other than owner"; | ||
421 | /* If there were any problems, quit. */ | ||
422 | if (cp) { | ||
423 | __rcmd_errstr = cp; | ||
424 | (void)fclose(hostf); | ||
425 | return (-1); | ||
426 | } | ||
427 | goto again; | ||
428 | } | ||
429 | return (-1); | ||
430 | } | ||
431 | |||
432 | /* | ||
433 | * XXX | ||
434 | * Don't make static, used by lpd(8). | ||
435 | * | ||
436 | * Returns 0 if ok, -1 if not ok. | ||
437 | */ | ||
438 | int | ||
439 | __ivaliduser(FILE *hostf, in_addr_t raddrl, const char *luser, | ||
440 | const char *ruser) | ||
441 | { | ||
442 | struct sockaddr_in sin; | ||
443 | |||
444 | memset(&sin, 0, sizeof(sin)); | ||
445 | sin.sin_family = AF_INET; | ||
446 | sin.sin_len = sizeof(struct sockaddr_in); | ||
447 | memcpy(&sin.sin_addr, &raddrl, sizeof(sin.sin_addr)); | ||
448 | return __ivaliduser_sa(hostf, (struct sockaddr *)&sin, sin.sin_len, | ||
449 | luser, ruser); | ||
450 | } | ||
451 | |||
452 | int | ||
453 | __ivaliduser_sa(FILE *hostf, struct sockaddr *raddr, socklen_t salen, | ||
454 | const char *luser, const char *ruser) | ||
455 | { | ||
456 | char *user, *p; | ||
457 | char *buf; | ||
458 | const char *auser, *ahost; | ||
459 | int hostok, userok; | ||
460 | char *rhost = (char *)-1; | ||
461 | char domain[MAXHOSTNAMELEN]; | ||
462 | size_t buflen; | ||
463 | |||
464 | getdomainname(domain, sizeof(domain)); | ||
465 | |||
466 | while ((buf = fgetln(hostf, &buflen))) { | ||
467 | p = buf; | ||
468 | if (*p == '#') | ||
469 | continue; | ||
470 | while (p < buf + buflen && *p != '\n' && *p != ' ' && *p != '\t') { | ||
471 | if (!isprint(*p)) | ||
472 | goto bail; | ||
473 | *p = isupper(*p) ? tolower(*p) : *p; | ||
474 | p++; | ||
475 | } | ||
476 | if (p >= buf + buflen) | ||
477 | continue; | ||
478 | if (*p == ' ' || *p == '\t') { | ||
479 | *p++ = '\0'; | ||
480 | while (p < buf + buflen && (*p == ' ' || *p == '\t')) | ||
481 | p++; | ||
482 | if (p >= buf + buflen) | ||
483 | continue; | ||
484 | user = p; | ||
485 | while (p < buf + buflen && *p != '\n' && *p != ' ' && | ||
486 | *p != '\t') { | ||
487 | if (!isprint(*p)) | ||
488 | goto bail; | ||
489 | p++; | ||
490 | } | ||
491 | } else | ||
492 | user = p; | ||
493 | *p = '\0'; | ||
494 | |||
495 | if (p == buf) | ||
496 | continue; | ||
497 | |||
498 | auser = *user ? user : luser; | ||
499 | ahost = buf; | ||
500 | |||
501 | if (strlen(ahost) >= MAXHOSTNAMELEN) | ||
502 | continue; | ||
503 | |||
504 | /* | ||
505 | * innetgr() must lookup a hostname (we do not attempt | ||
506 | * to change the semantics so that netgroups may have | ||
507 | * #.#.#.# addresses in the list.) | ||
508 | */ | ||
509 | if (ahost[0] == '+') | ||
510 | switch (ahost[1]) { | ||
511 | case '\0': | ||
512 | hostok = 1; | ||
513 | break; | ||
514 | case '@': | ||
515 | if (rhost == (char *)-1) | ||
516 | rhost = __gethostloop(raddr, salen); | ||
517 | hostok = 0; | ||
518 | if (rhost) | ||
519 | hostok = innetgr(&ahost[2], rhost, | ||
520 | NULL, domain); | ||
521 | break; | ||
522 | default: | ||
523 | hostok = __icheckhost(raddr, salen, &ahost[1]); | ||
524 | break; | ||
525 | } | ||
526 | else if (ahost[0] == '-') | ||
527 | switch (ahost[1]) { | ||
528 | case '\0': | ||
529 | hostok = -1; | ||
530 | break; | ||
531 | case '@': | ||
532 | if (rhost == (char *)-1) | ||
533 | rhost = __gethostloop(raddr, salen); | ||
534 | hostok = 0; | ||
535 | if (rhost) | ||
536 | hostok = -innetgr(&ahost[2], rhost, | ||
537 | NULL, domain); | ||
538 | break; | ||
539 | default: | ||
540 | hostok = -__icheckhost(raddr, salen, &ahost[1]); | ||
541 | break; | ||
542 | } | ||
543 | else | ||
544 | hostok = __icheckhost(raddr, salen, ahost); | ||
545 | |||
546 | |||
547 | if (auser[0] == '+') | ||
548 | switch (auser[1]) { | ||
549 | case '\0': | ||
550 | userok = 1; | ||
551 | break; | ||
552 | case '@': | ||
553 | userok = innetgr(&auser[2], NULL, ruser, | ||
554 | domain); | ||
555 | break; | ||
556 | default: | ||
557 | userok = strcmp(ruser, &auser[1]) ? 0 : 1; | ||
558 | break; | ||
559 | } | ||
560 | else if (auser[0] == '-') | ||
561 | switch (auser[1]) { | ||
562 | case '\0': | ||
563 | userok = -1; | ||
564 | break; | ||
565 | case '@': | ||
566 | userok = -innetgr(&auser[2], NULL, ruser, | ||
567 | domain); | ||
568 | break; | ||
569 | default: | ||
570 | userok = strcmp(ruser, &auser[1]) ? 0 : -1; | ||
571 | break; | ||
572 | } | ||
573 | else | ||
574 | userok = strcmp(ruser, auser) ? 0 : 1; | ||
575 | |||
576 | /* Check if one component did not match */ | ||
577 | if (hostok == 0 || userok == 0) | ||
578 | continue; | ||
579 | |||
580 | /* Check if we got a forbidden pair */ | ||
581 | if (userok <= -1 || hostok <= -1) | ||
582 | return (-1); | ||
583 | |||
584 | /* Check if we got a valid pair */ | ||
585 | if (hostok >= 1 && userok >= 1) | ||
586 | return (0); | ||
587 | } | ||
588 | bail: | ||
589 | return (-1); | ||
590 | } | ||
591 | |||
592 | /* | ||
593 | * Returns "true" if match, 0 if no match. If we do not find any | ||
594 | * semblance of an A->PTR->A loop, allow a simple #.#.#.# match to work. | ||
595 | */ | ||
596 | static int | ||
597 | __icheckhost(struct sockaddr *raddr, socklen_t salen, const char *lhost) | ||
598 | { | ||
599 | struct addrinfo hints, *res, *r; | ||
600 | char h1[NI_MAXHOST], h2[NI_MAXHOST]; | ||
601 | int error; | ||
602 | const int niflags = NI_NUMERICHOST; | ||
603 | |||
604 | h1[0] = '\0'; | ||
605 | if (getnameinfo(raddr, salen, h1, sizeof(h1), NULL, 0, | ||
606 | niflags) != 0) | ||
607 | return (0); | ||
608 | |||
609 | /* Resolve laddr into sockaddr */ | ||
610 | memset(&hints, 0, sizeof(hints)); | ||
611 | hints.ai_family = raddr->sa_family; | ||
612 | hints.ai_socktype = SOCK_DGRAM; /*dummy*/ | ||
613 | res = NULL; | ||
614 | error = getaddrinfo(lhost, "0", &hints, &res); | ||
615 | if (error) | ||
616 | return (0); | ||
617 | |||
618 | /* | ||
619 | * Try string comparisons between raddr and laddr. | ||
620 | */ | ||
621 | for (r = res; r; r = r->ai_next) { | ||
622 | h2[0] = '\0'; | ||
623 | if (getnameinfo(r->ai_addr, r->ai_addrlen, h2, sizeof(h2), | ||
624 | NULL, 0, niflags) != 0) | ||
625 | continue; | ||
626 | if (strcmp(h1, h2) == 0) { | ||
627 | freeaddrinfo(res); | ||
628 | return (1); | ||
629 | } | ||
630 | } | ||
631 | |||
632 | /* No match. */ | ||
633 | freeaddrinfo(res); | ||
634 | return (0); | ||
635 | } | ||
636 | |||
637 | /* | ||
638 | * Return the hostname associated with the supplied address. | ||
639 | * Do a reverse lookup as well for security. If a loop cannot | ||
640 | * be found, pack the result of inet_ntoa() into the string. | ||
641 | */ | ||
642 | static char * | ||
643 | __gethostloop(struct sockaddr *raddr, socklen_t salen) | ||
644 | { | ||
645 | static char remotehost[NI_MAXHOST]; | ||
646 | char h1[NI_MAXHOST], h2[NI_MAXHOST]; | ||
647 | struct addrinfo hints, *res, *r; | ||
648 | int error; | ||
649 | const int niflags = NI_NUMERICHOST; | ||
650 | |||
651 | h1[0] = remotehost[0] = '\0'; | ||
652 | if (getnameinfo(raddr, salen, remotehost, sizeof(remotehost), | ||
653 | NULL, 0, NI_NAMEREQD) != 0) | ||
654 | return (NULL); | ||
655 | if (getnameinfo(raddr, salen, h1, sizeof(h1), NULL, 0, | ||
656 | niflags) != 0) | ||
657 | return (NULL); | ||
658 | |||
659 | /* | ||
660 | * Look up the name and check that the supplied | ||
661 | * address is in the list | ||
662 | */ | ||
663 | memset(&hints, 0, sizeof(hints)); | ||
664 | hints.ai_family = raddr->sa_family; | ||
665 | hints.ai_socktype = SOCK_DGRAM; /*dummy*/ | ||
666 | hints.ai_flags = AI_CANONNAME; | ||
667 | res = NULL; | ||
668 | error = getaddrinfo(remotehost, "0", &hints, &res); | ||
669 | if (error) | ||
670 | return (NULL); | ||
671 | |||
672 | for (r = res; r; r = r->ai_next) { | ||
673 | h2[0] = '\0'; | ||
674 | if (getnameinfo(r->ai_addr, r->ai_addrlen, h2, sizeof(h2), | ||
675 | NULL, 0, niflags) != 0) | ||
676 | continue; | ||
677 | if (strcmp(h1, h2) == 0) { | ||
678 | freeaddrinfo(res); | ||
679 | return (remotehost); | ||
680 | } | ||
681 | } | ||
682 | |||
683 | /* | ||
684 | * either the DNS adminstrator has made a configuration | ||
685 | * mistake, or someone has attempted to spoof us | ||
686 | */ | ||
687 | syslog(LOG_NOTICE, "rcmd: address %s not listed for host %s", | ||
688 | h1, res->ai_canonname ? res->ai_canonname : remotehost); | ||
689 | freeaddrinfo(res); | ||
690 | return (NULL); | ||
691 | } | ||