/usr/src/sbin/isakmpd/monitor.c

Bug Summary

File:	src/sbin/isakmpd/monitor.c
Warning:	line 101, column 24 Access to field 'pw_dir' results in a dereference of a null pointer (loaded from variable 'pw')

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name monitor.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sbin/isakmpd/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sbin/isakmpd -I . -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/sbin/isakmpd/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/sbin/isakmpd/monitor.c

1/* $OpenBSD: monitor.c,v 1.83 2023/02/08 08:03:11 tb Exp $	 */

3/*
* Copyright (c) 2003 H�kan Olsson.  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.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 THE AUTHOR 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.
*/

27#include <sys/types.h>
28#include <sys/socket.h>
29#include <sys/ioctl.h>
30#include <sys/stat.h>
31#include <sys/wait.h>
32#include <netinet/in.h>

34#include <dirent.h>
35#include <errno(*__errno()).h>
36#include <fcntl.h>
37#include <pwd.h>
38#include <signal.h>
39#include <stdlib.h>
40#include <string.h>
41#include <unistd.h>
42#include <limits.h>

44#include <regex.h>
45#include <keynote.h>

47#include "conf.h"
48#include "log.h"
49#include "monitor.h"
50#include "policy.h"
51#include "ui.h"
52#include "util.h"
53#include "pf_key_v2.h"

55struct monitor_state {
pid_t           pid;
int             s;
char            root[PATH_MAX1024];
59} m_state;

61extern char *pid_file;

63extern void	set_slave_signals(void);

65/* Private functions.  */
66static void	must_read(void *, size_t);
67static void	must_write(const void *, size_t);

69static void	m_priv_getfd(void);
70static void	m_priv_setsockopt(void);
71static void	m_priv_req_readdir(void);
72static void	m_priv_bind(void);
73static void	m_priv_pfkey_open(void);
74static int	m_priv_local_sanitize_path(const char *, size_t, int);
75static int	m_priv_check_sockopt(int, int);
76static int	m_priv_check_bind(const struct sockaddr *, socklen_t);

78static void	set_monitor_signals(void);
79static void	sig_pass_to_chld(int);

81/*
* Public functions, unprivileged.
*/

85/* Setup monitor context, fork, drop child privs.  */
86pid_t
87monitor_init(int debug)
88{
struct passwd  *pw;
int             p[2];

bzero(&m_state, sizeof m_state);

if (socketpair(AF_UNIX1, SOCK_STREAM1, PF_UNSPEC0, p) != 0)
1
Assuming the condition is false→
2
←
Taking false branch→
log_fatal("monitor_init: socketpair() failed");

pw = getpwnam(ISAKMPD_PRIVSEP_USER"_isakmpd");
3
←
Value assigned to 'pw'→
if (pw == NULL((void *)0))
4
←
Assuming 'pw' is equal to NULL→
5
←
Taking true branch→
log_fatalx("monitor_init: getpwnam(\"%s\") failed",
    ISAKMPD_PRIVSEP_USER"_isakmpd");
strlcpy(m_state.root, pw->pw_dir, sizeof m_state.root);
6
←
Access to field 'pw_dir' results in a dereference of a null pointer (loaded from variable 'pw')

set_monitor_signals();
m_state.pid = fork();

if (m_state.pid == -1)
log_fatal("monitor_init: fork of unprivileged child failed");
if (m_state.pid == 0) {
/* The child process drops privileges. */
set_slave_signals();

if (chroot(pw->pw_dir) != 0 || chdir("/") != 0)
	log_fatal("monitor_init: chroot failed");

if (setgroups(1, &pw->pw_gid) == -1 ||
    setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
    setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
	log_fatal("monitor_init: can't drop privileges");

m_state.s = p[0];
close(p[1]);

LOG_DBG((LOG_MISC, 10,log_debug (LOG_MISC, 10, "monitor_init: privileges dropped for child process"
)
    "monitor_init: privileges dropped for child process"))log_debug (LOG_MISC, 10, "monitor_init: privileges dropped for child process"
);
} else {
/* Privileged monitor. */
setproctitle("monitor [priv]");

m_state.s = p[1];
close(p[0]);
}

/* With "-dd", stop and wait here. For gdb "attach" etc.  */
if (debug > 1) {
log_print("monitor_init: stopped %s PID %d fd %d%s",
    m_state.pid ? "priv" : "child", getpid(), m_state.s,
    m_state.pid ? ", waiting for SIGCONT" : "");
kill(getpid(), SIGSTOP17);	/* Wait here for SIGCONT.  */
if (m_state.pid)
	kill(m_state.pid, SIGCONT19); /* Continue child.  */
}

return m_state.pid;
144}

146void
147monitor_exit(int code)
148{
int status = 0, gotstatus = 0;
pid_t pid;

if (m_state.pid != 0) {
/* When called from the monitor, kill slave and wait for it  */
kill(m_state.pid, SIGTERM15);

do {
	pid = waitpid(m_state.pid, &status, 0);
} while (pid == -1 && errno(*__errno()) == EINTR4);
if (pid != -1)
	gotstatus = 1;

/* Remove FIFO and pid files.  */
unlink(ui_fifo);
unlink(pid_file);
}

close(m_state.s);
if (code == 0 && gotstatus)
exit(WIFEXITED(status)(((status) & 0177) == 0)? WEXITSTATUS(status)(int)(((unsigned)(status) >> 8) & 0xff) : 1);
else
exit(code);
172}

174int
175monitor_pf_key_v2_open(void)
176{
int	err, cmd;

cmd = MONITOR_PFKEY_OPEN;
must_write(&cmd, sizeof cmd);

must_read(&err, sizeof err);
if (err < 0) {
log_error("monitor_pf_key_v2_open: parent could not create "
    "PF_KEY socket");
return -1;
}
pf_key_v2_socket = mm_receive_fd(m_state.s);
if (pf_key_v2_socket < 0) {
log_error("monitor_pf_key_v2_open: mm_receive_fd() failed");
return -1;
}

return pf_key_v2_socket;
195}

197int
198monitor_open(const char *path, int flags, mode_t mode)
199{
size_t	len;
int	fd, err, cmd;
char	pathreal[PATH_MAX1024];

if (path[0] == '/')
strlcpy(pathreal, path, sizeof pathreal);
else
snprintf(pathreal, sizeof pathreal, "%s/%s", m_state.root,
    path);

cmd = MONITOR_GET_FD;
must_write(&cmd, sizeof cmd);

len = strlen(pathreal);
must_write(&len, sizeof len);
must_write(&pathreal, len);

must_write(&flags, sizeof flags);
must_write(&mode, sizeof mode);

must_read(&err, sizeof err);
if (err != 0) {
errno(*__errno()) = err;
return -1;
}

fd = mm_receive_fd(m_state.s);
if (fd < 0) {
log_error("monitor_open: mm_receive_fd () failed");
return -1;
}

return fd;
233}

235FILE *
236monitor_fopen(const char *path, const char *mode)
237{
FILE	*fp;
int	 fd, flags = 0, saved_errno;
mode_t	 mask, cur_umask;

/* Only the child process is supposed to run this.  */
if (m_state.pid)
log_fatal("[priv] bad call to monitor_fopen");

switch (mode[0]) {
case 'r':
flags = (mode[1] == '+' ? O_RDWR0x0002 : O_RDONLY0x0000);
break;
case 'w':
flags = (mode[1] == '+' ? O_RDWR0x0002 : O_WRONLY0x0001) | O_CREAT0x0200 |
    O_TRUNC0x0400;
break;
case 'a':
flags = (mode[1] == '+' ? O_RDWR0x0002 : O_WRONLY0x0001) | O_CREAT0x0200 |
    O_APPEND0x0008;
break;
default:
log_fatal("monitor_fopen: bad call");
}

cur_umask = umask(0);
(void)umask(cur_umask);
mask = S_IRUSR0000400 | S_IWUSR0000200 | S_IRGRP0000040 | S_IWGRP0000020 | S_IROTH0000004 | S_IWOTH0000002;
mask &= ~cur_umask;

fd = monitor_open(path, flags, mask);
if (fd < 0)
return NULL((void *)0);

/* Got the fd, attach a FILE * to it.  */
fp = fdopen(fd, mode);
if (!fp) {
log_error("monitor_fopen: fdopen() failed");
saved_errno = errno(*__errno());
close(fd);
errno(*__errno()) = saved_errno;
return NULL((void *)0);
}
return fp;
281}

283int
284monitor_stat(const char *path, struct stat *sb)
285{
int	fd, r, saved_errno;

/* O_NONBLOCK is needed for stat'ing fifos. */
fd = monitor_open(path, O_RDONLY0x0000 | O_NONBLOCK0x0004, 0);
if (fd < 0)
return -1;

r = fstat(fd, sb);
saved_errno = errno(*__errno());
close(fd);
errno(*__errno()) = saved_errno;
return r;
298}

300int
301monitor_setsockopt(int s, int level, int optname, const void *optval,
  socklen_t optlen)
303{
int	ret, err, cmd;

cmd = MONITOR_SETSOCKOPT;
must_write(&cmd, sizeof cmd);
if (mm_send_fd(m_state.s, s)) {
log_print("monitor_setsockopt: read/write error");
return -1;
}

must_write(&level, sizeof level);
must_write(&optname, sizeof optname);
must_write(&optlen, sizeof optlen);
must_write(optval, optlen);

must_read(&err, sizeof err);
must_read(&ret, sizeof ret);
if (err != 0)
errno(*__errno()) = err;
return ret;
323}

325int
326monitor_bind(int s, const struct sockaddr *name, socklen_t namelen)
327{
int	ret, err, cmd;

cmd = MONITOR_BIND;
must_write(&cmd, sizeof cmd);
if (mm_send_fd(m_state.s, s)) {
log_print("monitor_bind: read/write error");
return -1;
}

must_write(&namelen, sizeof namelen);
must_write(name, namelen);

must_read(&err, sizeof err);
must_read(&ret, sizeof ret);
if (err != 0)
errno(*__errno()) = err;
return ret;
345}

347int
348monitor_req_readdir(const char *filename)
349{
int cmd, err;
size_t len;

cmd = MONITOR_REQ_READDIR;
must_write(&cmd, sizeof cmd);

len = strlen(filename);
must_write(&len, sizeof len);
must_write(filename, len);

must_read(&err, sizeof err);
if (err == -1)
must_read(&errno(*__errno()), sizeof errno(*__errno()));

return err;
365}

367int
368monitor_readdir(char *file, size_t size)
369{
int fd;
size_t len;

must_read(&len, sizeof len);
if (len == 0)
return -1;
if (len >= size)
log_fatal("monitor_readdir: received bad length from monitor");
must_read(file, len);
file[len] = '\0';
fd = mm_receive_fd(m_state.s);
return fd;
382}

384void
385monitor_init_done(void)
386{
int	cmd;

cmd = MONITOR_INIT_DONE;
must_write(&cmd, sizeof cmd);
391}

393/*
* Start of code running with privileges (the monitor process).
*/

397static void
398set_monitor_signals(void)
399{
int n;

for (n = 1; n < _NSIG33; n++)
signal(n, SIG_DFL(void (*)(int))0);

/* Forward some signals to the child. */
signal(SIGTERM15, sig_pass_to_chld);
signal(SIGHUP1, sig_pass_to_chld);
signal(SIGUSR130, sig_pass_to_chld);
409}

411static void
412sig_pass_to_chld(int sig)
413{
int	oerrno = errno(*__errno());

if (m_state.pid > 0)
kill(m_state.pid, sig);
errno(*__errno()) = oerrno;
419}

421/* This function is where the privileged process waits(loops) indefinitely.  */
422void
423monitor_loop(int debug)
424{
int	 msgcode;

if (!debug)
log_to(0);

for (;;) {
must_read(&msgcode, sizeof msgcode);

switch (msgcode) {
case MONITOR_GET_FD:
	m_priv_getfd();
	break;

case MONITOR_PFKEY_OPEN:
	LOG_DBG((LOG_MISC, 80,log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_PFKEY_OPEN")
	    "monitor_loop: MONITOR_PFKEY_OPEN"))log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_PFKEY_OPEN");
	m_priv_pfkey_open();
	break;

case MONITOR_SETSOCKOPT:
	LOG_DBG((LOG_MISC, 80,log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_SETSOCKOPT")
	    "monitor_loop: MONITOR_SETSOCKOPT"))log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_SETSOCKOPT");
	m_priv_setsockopt();
	break;

case MONITOR_BIND:
	LOG_DBG((LOG_MISC, 80,log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_BIND")
	    "monitor_loop: MONITOR_BIND"))log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_BIND");
	m_priv_bind();
	break;

case MONITOR_REQ_READDIR:
	LOG_DBG((LOG_MISC, 80,log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_REQ_READDIR")
	    "monitor_loop: MONITOR_REQ_READDIR"))log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_REQ_READDIR");
	m_priv_req_readdir();
	break;

case MONITOR_INIT_DONE:
	LOG_DBG((LOG_MISC, 80,log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_INIT_DONE")
	    "monitor_loop: MONITOR_INIT_DONE"))log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_INIT_DONE");
	break;

case MONITOR_SHUTDOWN:
	LOG_DBG((LOG_MISC, 80,log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_SHUTDOWN")
	    "monitor_loop: MONITOR_SHUTDOWN"))log_debug (LOG_MISC, 80, "monitor_loop: MONITOR_SHUTDOWN");
	break;

default:
	log_print("monitor_loop: got unknown code %d",
	    msgcode);
}
}

exit(0);
479}


482/* Privileged: called by monitor_loop.  */
483static void
484m_priv_pfkey_open(void)
485{
int	fd, err = 0;

fd = pf_key_v2_open();
if (fd < 0)
err = -1;

must_write(&err, sizeof err);

if (fd > 0 && mm_send_fd(m_state.s, fd)) {
log_error("m_priv_pfkey_open: read/write operation failed");
close(fd);
return;
}
close(fd);
500}

502/* Privileged: called by monitor_loop.  */
503static void
504m_priv_getfd(void)
505{
char	path[PATH_MAX1024];
size_t	len;
int	v, flags, ret;
int	err = 0;
mode_t	mode;

must_read(&len, sizeof len);
if (len == 0 || len >= sizeof path)
log_fatal("m_priv_getfd: invalid pathname length");

must_read(path, len);
path[len] = '\0';
if (strlen(path) != len)
log_fatal("m_priv_getfd: invalid pathname");

must_read(&flags, sizeof flags);
must_read(&mode, sizeof mode);

if ((ret = m_priv_local_sanitize_path(path, sizeof path, flags))
   != 0) {
if (errno(*__errno()) != ENOENT2)
	log_print("m_priv_getfd: illegal path \"%s\"", path);
err = errno(*__errno());
v = -1;
} else {
if ((v = open(path, flags, mode)) == -1)
	err = errno(*__errno());
}

must_write(&err, sizeof err);

if (v != -1) {
if (mm_send_fd(m_state.s, v) == -1)
	log_error("m_priv_getfd: sending fd failed");
close(v);
}
542}

544/* Privileged: called by monitor_loop.  */
545static void
546m_priv_setsockopt(void)
547{
int		 sock, level, optname, v;
int		 err = 0;
char		*optval = 0;
socklen_t	 optlen;

sock = mm_receive_fd(m_state.s);
if (sock < 0) {
log_print("m_priv_setsockopt: read/write error");
return;
}

must_read(&level, sizeof level);
must_read(&optname, sizeof optname);
must_read(&optlen, sizeof optlen);

optval = malloc(optlen);
if (!optval) {
log_print("m_priv_setsockopt: malloc failed");
close(sock);
return;
}

must_read(optval, optlen);

if (m_priv_check_sockopt(level, optname) != 0) {
err = EACCES13;
v = -1;
} else {
v = setsockopt(sock, level, optname, optval, optlen);
if (v < 0)
	err = errno(*__errno());
}

close(sock);
sock = -1;

must_write(&err, sizeof err);
must_write(&v, sizeof v);

free(optval);
return;
589}

591/* Privileged: called by monitor_loop.  */
592static void
593m_priv_bind(void)
594{
int		 sock, v, err = 0;
struct sockaddr *name = 0;
socklen_t        namelen;

sock = mm_receive_fd(m_state.s);
if (sock < 0) {
log_print("m_priv_bind: read/write error");
return;
}

must_read(&namelen, sizeof namelen);
name = malloc(namelen);
if (!name) {
log_print("m_priv_bind: malloc failed");
close(sock);
return;
}
must_read((char *)name, namelen);

if (m_priv_check_bind(name, namelen) != 0) {
err = EACCES13;
v = -1;
} else {
v = bind(sock, name, namelen);
if (v == -1) {
	log_error("m_priv_bind: bind(%d,%p,%d) returned %d",
	    sock, name, namelen, v);
	err = errno(*__errno());
}
}

close(sock);
sock = -1;

must_write(&err, sizeof err);
must_write(&v, sizeof v);

free(name);
return;
634}

636/*
* Help functions, used by both privileged and unprivileged code
*/

640/*
* Read data with the assertion that it all must come through, or else abort
* the process.  Based on atomicio() from openssh.
*/
644static void
645must_read(void *buf, size_t n)
646{
      char *s = buf;
size_t pos = 0;
      ssize_t res;

      while (n > pos) {
              res = read(m_state.s, s + pos, n - pos);
              switch (res) {
              case -1:
                      if (errno(*__errno()) == EINTR4 || errno(*__errno()) == EAGAIN35)
                              continue;
              case 0:
	monitor_exit(0);
              default:
                      pos += res;
              }
      }
663}

665/*
* Write data with the assertion that it all has to be written, or else abort
* the process.  Based on atomicio() from openssh.
*/
669static void
670must_write(const void *buf, size_t n)
671{
      const char *s = buf;
size_t pos = 0;
ssize_t res;

      while (n > pos) {
              res = write(m_state.s, s + pos, n - pos);
              switch (res) {
              case -1:
                      if (errno(*__errno()) == EINTR4 || errno(*__errno()) == EAGAIN35)
                              continue;
              case 0:
	monitor_exit(0);
              default:
                      pos += res;
              }
      }
688}

690/* Check that path/mode is permitted.  */
691static int
692m_priv_local_sanitize_path(const char *path, size_t pmax, int flags)
693{
char new_path[PATH_MAX1024], var_run[PATH_MAX1024], *enddir;

/*
* We only permit paths starting with
*  /etc/isakmpd/	(read only)
*  /var/run/		(rw)
*/

if (realpath(path, new_path) == NULL((void *)0)) {
if (errno(*__errno()) != ENOENT2)
	return 1;
/*
 * It is ok if the directory exists,
 * but the file should be created.
 */
if (strlcpy(new_path, path, sizeof(new_path)) >=
    sizeof(new_path))
	return 1;
enddir = strrchr(new_path, '/');
if (enddir == NULL((void *)0) || enddir[1] == '\0')
	return 1;
enddir[1] = '\0';
if (realpath(new_path, new_path) == NULL((void *)0)) {
	errno(*__errno()) = ENOENT2;
	return 1;
}
enddir = strrchr(path, '/');
strlcat(new_path, enddir, sizeof(new_path));
}

if (realpath("/var/run/", var_run) == NULL((void *)0))
return 1;
strlcat(var_run, "/", sizeof(var_run));

if (strncmp(var_run, new_path, strlen(var_run)) == 0)
return 0;

if (strncmp(ISAKMPD_ROOT"/etc/isakmpd/", new_path, strlen(ISAKMPD_ROOT"/etc/isakmpd/")) == 0 &&
   (flags & O_ACCMODE0x0003) == O_RDONLY0x0000)
return 0;

errno(*__errno()) = EACCES13;
return 1;
737}

739/* Check setsockopt */
740static int
741m_priv_check_sockopt(int level, int name)
742{
switch (level) {
/* These are allowed */
case SOL_SOCKET0xffff:
case IPPROTO_IP0:
case IPPROTO_IPV641:
break;

default:
log_print("m_priv_check_sockopt: Illegal level %d", level);
return 1;
}

switch (name) {
/* These are allowed */
case SO_REUSEPORT0x0200:
case SO_REUSEADDR0x0004:
case IP_AUTH_LEVEL20:
case IP_ESP_TRANS_LEVEL21:
case IP_ESP_NETWORK_LEVEL22:
case IP_IPCOMP_LEVEL29:
case IPV6_AUTH_LEVEL53:
case IPV6_ESP_TRANS_LEVEL54:
case IPV6_ESP_NETWORK_LEVEL55:
case IPV6_IPCOMP_LEVEL60:
break;

default:
log_print("m_priv_check_sockopt: Illegal option name %d",
    name);
return 1;
}

return 0;
776}

778/* Check bind */
779static int
780m_priv_check_bind(const struct sockaddr *sa, socklen_t salen)
781{
in_port_t       port;

if (sa == NULL((void *)0)) {
log_print("NULL address");
return 1;
}
if (SA_LEN(sa)((sa)->sa_len) != salen) {
log_print("Length mismatch: %lu %lu", (unsigned long)sa->sa_len,
    (unsigned long)salen);
return 1;
}
switch (sa->sa_family) {
case AF_INET2:
if (salen != sizeof(struct sockaddr_in)) {
	log_print("Invalid inet address length");
	return 1;
}
port = ((const struct sockaddr_in *)sa)->sin_port;
break;
case AF_INET624:
if (salen != sizeof(struct sockaddr_in6)) {
	log_print("Invalid inet6 address length");
	return 1;
}
port = ((const struct sockaddr_in6 *)sa)->sin6_port;
break;
default:
log_print("Unknown address family");
return 1;
}

port = ntohs(port)(__uint16_t)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t
)(port) & 0xffU) << 8 | ((__uint16_t)(port) & 0xff00U
) >> 8) : __swap16md(port));

if (port != ISAKMP_PORT_DEFAULT500 && port < 1024) {
log_print("Disallowed port %u", port);
return 1;
}
return 0;
820}

822static void
823m_priv_req_readdir(void)
824{
size_t len;
char path[PATH_MAX1024];
DIR *dp;
struct dirent *file;
struct stat sb;
int off, size, fd, ret, serrno;

must_read(&len, sizeof len);
if (len == 0 || len >= sizeof path)
log_fatal("m_priv_req_readdir: invalid pathname length");
must_read(path, len);
path[len] = '\0';
if (strlen(path) != len)
log_fatal("m_priv_req_readdir: invalid pathname");

off = strlen(path);
size = sizeof path - off;

if ((dp = opendir(path)) == NULL((void *)0)) {
serrno = errno(*__errno());
ret = -1;
must_write(&ret, sizeof ret);
must_write(&serrno, sizeof serrno);
return;
}

/* report opendir() success */
ret = 0;
must_write(&ret, sizeof ret);

while ((file = readdir(dp)) != NULL((void *)0)) {
strlcpy(path + off, file->d_name, size);

if (m_priv_local_sanitize_path(path, sizeof path, O_RDONLY0x0000)
    != 0)
	continue;
fd = open(path, O_RDONLY0x0000);
if (fd == -1) {
	log_error("m_priv_req_readdir: open "
	    "(\"%s\", O_RDONLY, 0) failed", path);
	continue;
}
if ((fstat(fd, &sb) == -1) ||
    !(S_ISREG(sb.st_mode)((sb.st_mode & 0170000) == 0100000) || S_ISLNK(sb.st_mode)((sb.st_mode & 0170000) == 0120000))) {
	close(fd);
	continue;
}

len = strlen(path);
must_write(&len, sizeof len);
must_write(path, len);

mm_send_fd(m_state.s, fd);
close(fd);
}
closedir(dp);

len = 0;
must_write(&len, sizeof len);
884}