/usr/src/usr.sbin/vmd/vmd.c

Bug Summary

File:	src/usr.sbin/vmd/vmd.c
Warning:	line 530, column 18 Access to field 'vm_vmid' results in a dereference of a null pointer (loaded from variable 'vm')
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 vmd.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/usr.sbin/vmd/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/usr.sbin/vmd -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/usr.sbin/vmd/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/usr.sbin/vmd/vmd.c
1/*	$OpenBSD: vmd.c,v 1.152 2023/09/26 01:53:54 dv Exp $	*/

3/*
* Copyright (c) 2015 Reyk Floeter <reyk@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

19#include <sys/types.h>
20#include <sys/queue.h>
21#include <sys/wait.h>
22#include <sys/stat.h>
23#include <sys/sysctl.h>
24#include <sys/tty.h>
25#include <sys/ttycom.h>
26#include <sys/ioctl.h>

28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31#include <termios.h>
32#include <errno(*__errno()).h>
33#include <event.h>
34#include <fcntl.h>
35#include <pwd.h>
36#include <signal.h>
37#include <syslog.h>
38#include <unistd.h>
39#include <util.h>
40#include <ctype.h>
41#include <grp.h>

43#include <machine/specialreg.h>
44#include <machine/vmmvar.h>

46#include "proc.h"
47#include "atomicio.h"
48#include "vmd.h"

50__dead__attribute__((__noreturn__)) void usage(void);

52int	 main(int, char **);
53int	 vmd_configure(void);
54void	 vmd_sighdlr(int sig, short event, void *arg);
55void	 vmd_shutdown(void);
56int	 vmd_control_run(void);
57int	 vmd_dispatch_control(int, struct privsep_proc *, struct imsg *);
58int	 vmd_dispatch_vmm(int, struct privsep_proc *, struct imsg *);
59int	 vmd_dispatch_agentx(int, struct privsep_proc *, struct imsg *);
60int	 vmd_dispatch_priv(int, struct privsep_proc *, struct imsg *);
61int	 vmd_check_vmh(struct vm_dump_header *);

63int	 vm_instance(struct privsep *, struct vmd_vm **,
   struct vmop_create_params *, uid_t);
65int	 vm_checkinsflag(struct vmop_create_params *, unsigned int, uid_t);
66int	 vm_claimid(const char *, int, uint32_t *);
67void	 start_vm_batch(int, short, void*);

69static inline void vm_terminate(struct vmd_vm *, const char *);

71struct vmd	*env;

73static struct privsep_proc procs[] = {
/* Keep "priv" on top as procs[0] */
{ "priv",	PROC_PRIV,	vmd_dispatch_priv, priv },
{ "control",	PROC_CONTROL,	vmd_dispatch_control, control },
{ "vmm",	PROC_VMM,	vmd_dispatch_vmm, vmm,
 vmm_shutdown, "/" },
{ "agentx", 	PROC_AGENTX,	vmd_dispatch_agentx, vm_agentx,
 vm_agentx_shutdown, "/" }
81};

83enum privsep_procid privsep_process;

85struct event staggered_start_timer;

87/* For the privileged process */
88static struct privsep_proc *proc_priv = &procs[0];
89static struct passwd proc_privpw;
90static const uint8_t zero_mac[ETHER_ADDR_LEN6];

92const char		 default_conffile[] = VMD_CONF"/etc/vm.conf";
93const char		*conffile = default_conffile;

95int
96vmd_dispatch_control(int fd, struct privsep_proc *p, struct imsg *imsg)
97{
struct privsep			*ps = p->p_ps;
int				 res = 0, ret = 0, cmd = 0, verbose;
unsigned int			 v = 0, flags;
struct vmop_create_params	 vmc;
struct vmop_id			 vid;
struct vmop_result		 vmr;
struct vm_dump_header		 vmh;
struct vmd_vm			*vm = NULL((void *)0);
char				*str = NULL((void *)0);
uint32_t			 id = 0;
struct control_sock		*rcs;

switch (imsg->hdr.type) {
case IMSG_VMDOP_START_VM_REQUEST:
IMSG_SIZE_CHECK(imsg, &vmc)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmc)) fatalx("bad length imsg received (%s)", "&vmc"
); } while (0);
memcpy(&vmc, imsg->data, sizeof(vmc));
vmc.vmc_kernel = imsg->fd;

/* Try registering our VM in our list of known VMs. */
if (vm_register(ps, &vmc, &vm, 0, vmc.vmc_owner.uid)) {
	res = errno(*__errno());

	/* Did we have a failure during lookup of a parent? */
	if (vm == NULL((void *)0)) {
		cmd = IMSG_VMDOP_START_VM_RESPONSE;
		break;
	}

	/* Does the VM already exist? */
	if (res == EALREADY37) {
		/* Is it already running? */
		if (vm->vm_state & VM_STATE_RUNNING0x01) {
			cmd = IMSG_VMDOP_START_VM_RESPONSE;
			break;
		}

		/* If not running, are our flags ok? */
		if (vmc.vmc_flags &&
		    vmc.vmc_flags != VMOP_CREATE_KERNEL0x02) {
			cmd = IMSG_VMDOP_START_VM_RESPONSE;
			break;
		}
	}
	res = 0;
}

/* Try to start the launch of the VM. */
res = config_setvm(ps, vm, imsg->hdr.peerid,
    vm->vm_params.vmc_owner.uid);
if (res)
	cmd = IMSG_VMDOP_START_VM_RESPONSE;
break;
case IMSG_VMDOP_WAIT_VM_REQUEST:
case IMSG_VMDOP_TERMINATE_VM_REQUEST:
IMSG_SIZE_CHECK(imsg, &vid)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vid)) fatalx("bad length imsg received (%s)", "&vid"
); } while (0);
memcpy(&vid, imsg->data, sizeof(vid));
flags = vid.vid_flags;
cmd = IMSG_VMDOP_TERMINATE_VM_RESPONSE;

if ((id = vid.vid_id) == 0) {
	/* Lookup vm (id) by name */
	if ((vm = vm_getbyname(vid.vid_name)) == NULL((void *)0)) {
		res = ENOENT2;
		break;
	}
	id = vm->vm_vmid;
} else if ((vm = vm_getbyvmid(id)) == NULL((void *)0)) {
	res = ENOENT2;
	break;
}

/* Validate curent state of vm */
if ((vm->vm_state & VM_STATE_SHUTDOWN0x04) &&
	    (flags & VMOP_FORCE0x01) == 0) {
		res = EALREADY37;
		break;
} else if (!(vm->vm_state & VM_STATE_RUNNING0x01)) {
	res = EINVAL22;
	break;
} else if (vm_checkperm(vm, &vm->vm_params.vmc_owner, vid.vid_uid)) {
	res = EPERM1;
	break;
}

/* Only relay TERMINATION requests, not WAIT requests */
if (imsg->hdr.type == IMSG_VMDOP_TERMINATE_VM_REQUEST) {
	memset(&vid, 0, sizeof(vid));
	vid.vid_id = id;
	vid.vid_flags = flags;

	if (proc_compose_imsg(ps, PROC_VMM, -1, imsg->hdr.type,
		imsg->hdr.peerid, -1, &vid, sizeof(vid)) == -1)
		return (-1);
}
break;
case IMSG_VMDOP_GET_INFO_VM_REQUEST:
proc_forward_imsg(ps, imsg, PROC_VMM, -1);
break;
case IMSG_VMDOP_LOAD:
IMSG_SIZE_CHECK(imsg, str)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*str)) fatalx("bad length imsg received (%s)", "str"); } while
 (0); /* at least one byte for path */
str = get_string((uint8_t *)imsg->data,
    IMSG_DATA_SIZE(imsg)((imsg)->hdr.len - sizeof(struct imsg_hdr)));
case IMSG_VMDOP_RELOAD:
if (vmd_reload(0, str) == -1)
	cmd = IMSG_CTL_FAIL;
else
	cmd = IMSG_CTL_OK;
free(str);
break;
case IMSG_CTL_RESET:
IMSG_SIZE_CHECK(imsg, &v)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&v)) fatalx("bad length imsg received (%s)", "&v");
 } while (0);
memcpy(&v, imsg->data, sizeof(v));
if (vmd_reload(v, NULL((void *)0)) == -1)
	cmd = IMSG_CTL_FAIL;
else
	cmd = IMSG_CTL_OK;
break;
case IMSG_CTL_VERBOSE:
IMSG_SIZE_CHECK(imsg, &verbose)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&verbose)) fatalx("bad length imsg received (%s)", "&verbose"
); } while (0);
memcpy(&verbose, imsg->data, sizeof(verbose));
log_setverbose(verbose);

proc_forward_imsg(ps, imsg, PROC_VMM, -1);
proc_forward_imsg(ps, imsg, PROC_PRIV, -1);
cmd = IMSG_CTL_OK;
break;
case IMSG_VMDOP_PAUSE_VM:
case IMSG_VMDOP_UNPAUSE_VM:
IMSG_SIZE_CHECK(imsg, &vid)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vid)) fatalx("bad length imsg received (%s)", "&vid"
); } while (0);
memcpy(&vid, imsg->data, sizeof(vid));
if (vid.vid_id == 0) {
	if ((vm = vm_getbyname(vid.vid_name)) == NULL((void *)0)) {
		res = ENOENT2;
		cmd = imsg->hdr.type == IMSG_VMDOP_PAUSE_VM
		    ? IMSG_VMDOP_PAUSE_VM_RESPONSE
		    : IMSG_VMDOP_UNPAUSE_VM_RESPONSE;
		break;
	} else {
		vid.vid_id = vm->vm_vmid;
	}
} else if ((vm = vm_getbyid(vid.vid_id)) == NULL((void *)0)) {
	res = ENOENT2;
	cmd = imsg->hdr.type == IMSG_VMDOP_PAUSE_VM
	    ? IMSG_VMDOP_PAUSE_VM_RESPONSE
	    : IMSG_VMDOP_UNPAUSE_VM_RESPONSE;
	break;
}
if (vm_checkperm(vm, &vm->vm_params.vmc_owner,
    vid.vid_uid) != 0) {
	res = EPERM1;
	cmd = imsg->hdr.type == IMSG_VMDOP_PAUSE_VM
	    ? IMSG_VMDOP_PAUSE_VM_RESPONSE
	    : IMSG_VMDOP_UNPAUSE_VM_RESPONSE;
	break;
}
proc_compose_imsg(ps, PROC_VMM, -1, imsg->hdr.type,
    imsg->hdr.peerid, -1, &vid, sizeof(vid));
break;
case IMSG_VMDOP_SEND_VM_REQUEST:
IMSG_SIZE_CHECK(imsg, &vid)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vid)) fatalx("bad length imsg received (%s)", "&vid"
); } while (0);
memcpy(&vid, imsg->data, sizeof(vid));
id = vid.vid_id;
if (vid.vid_id == 0) {
	if ((vm = vm_getbyname(vid.vid_name)) == NULL((void *)0)) {
		res = ENOENT2;
		cmd = IMSG_VMDOP_SEND_VM_RESPONSE;
		close(imsg->fd);
		break;
	} else {
		vid.vid_id = vm->vm_vmid;
	}
} else if ((vm = vm_getbyvmid(vid.vid_id)) == NULL((void *)0)) {
	res = ENOENT2;
	cmd = IMSG_VMDOP_SEND_VM_RESPONSE;
	close(imsg->fd);
	break;
}
vmr.vmr_id = vid.vid_id;
log_debug("%s: sending fd to vmm", __func__);
proc_compose_imsg(ps, PROC_VMM, -1, imsg->hdr.type,
    imsg->hdr.peerid, imsg->fd, &vid, sizeof(vid));
break;
case IMSG_VMDOP_RECEIVE_VM_REQUEST:
IMSG_SIZE_CHECK(imsg, &vid)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vid)) fatalx("bad length imsg received (%s)", "&vid"
); } while (0);
memcpy(&vid, imsg->data, sizeof(vid));
if (imsg->fd == -1) {
	log_warnx("%s: invalid fd", __func__);
	return (-1);
}
if (atomicio(read, imsg->fd, &vmh, sizeof(vmh)) !=
    sizeof(vmh)) {
	log_warnx("%s: error reading vmh from received vm",
	    __func__);
	res = EIO5;
	close(imsg->fd);
	cmd = IMSG_VMDOP_START_VM_RESPONSE;
	break;
}

if (vmd_check_vmh(&vmh)) {
	res = ENOENT2;
	close(imsg->fd);
	cmd = IMSG_VMDOP_START_VM_RESPONSE;
	break;
}
if (atomicio(read, imsg->fd, &vmc, sizeof(vmc)) !=
    sizeof(vmc)) {
	log_warnx("%s: error reading vmc from received vm",
	    __func__);
	res = EIO5;
	close(imsg->fd);
	cmd = IMSG_VMDOP_START_VM_RESPONSE;
	break;
}
strlcpy(vmc.vmc_params.vcp_name, vid.vid_name,
    sizeof(vmc.vmc_params.vcp_name));
vmc.vmc_params.vcp_id = 0;

ret = vm_register(ps, &vmc, &vm, 0, vmc.vmc_owner.uid);
if (ret != 0) {
	res = errno(*__errno());
	cmd = IMSG_VMDOP_START_VM_RESPONSE;
	close(imsg->fd);
} else {
	vm->vm_state |= VM_STATE_RECEIVED0x08;
	config_setvm(ps, vm, imsg->hdr.peerid,
	    vmc.vmc_owner.uid);
	log_debug("%s: sending fd to vmm", __func__);
	proc_compose_imsg(ps, PROC_VMM, -1,
	    IMSG_VMDOP_RECEIVE_VM_END, vm->vm_vmid, imsg->fd,
	    NULL((void *)0), 0);
}
break;
case IMSG_VMDOP_DONE:
control_reset(&ps->ps_csock);
TAILQ_FOREACH(rcs, &ps->ps_rcsocks, cs_entry)for((rcs) = ((&ps->ps_rcsocks)->tqh_first); (rcs) !=
 ((void *)0); (rcs) = ((rcs)->cs_entry.tqe_next))
	control_reset(rcs);
cmd = 0;
break;
default:
return (-1);
}

switch (cmd) {
case 0:
break;
case IMSG_VMDOP_START_VM_RESPONSE:
case IMSG_VMDOP_TERMINATE_VM_RESPONSE:
memset(&vmr, 0, sizeof(vmr));
vmr.vmr_result = res;
vmr.vmr_id = id;
if (proc_compose_imsg(ps, PROC_CONTROL, -1, cmd,
    imsg->hdr.peerid, -1, &vmr, sizeof(vmr)) == -1)
	return (-1);
break;
default:
if (proc_compose_imsg(ps, PROC_CONTROL, -1, cmd,
    imsg->hdr.peerid, -1, &res, sizeof(res)) == -1)
	return (-1);
break;
}

return (0);
361}

363int
364vmd_dispatch_vmm(int fd, struct privsep_proc *p, struct imsg *imsg)
365{
struct vmop_result	 vmr;
struct privsep		*ps = p->p_ps;
int			 res = 0;
struct vmd_vm		*vm;
struct vm_create_params	*vcp;
struct vmop_info_result	 vir;

switch (imsg->hdr.type) {
1
Control jumps to 'case IMSG_VMDOP_GET_INFO_VM_DATA:'  at line 510→
case IMSG_VMDOP_PAUSE_VM_RESPONSE:
IMSG_SIZE_CHECK(imsg, &vmr)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmr)) fatalx("bad length imsg received (%s)", "&vmr"
); } while (0);
memcpy(&vmr, imsg->data, sizeof(vmr));
if ((vm = vm_getbyvmid(vmr.vmr_id)) == NULL((void *)0))
	break;
proc_compose_imsg(ps, PROC_CONTROL, -1,
    imsg->hdr.type, imsg->hdr.peerid, -1,
    imsg->data, sizeof(imsg->data));
log_info("%s: paused vm %d successfully",
    vm->vm_params.vmc_params.vcp_name,
    vm->vm_vmid);
vm->vm_state |= VM_STATE_PAUSED0x10;
break;
case IMSG_VMDOP_UNPAUSE_VM_RESPONSE:
IMSG_SIZE_CHECK(imsg, &vmr)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmr)) fatalx("bad length imsg received (%s)", "&vmr"
); } while (0);
memcpy(&vmr, imsg->data, sizeof(vmr));
if ((vm = vm_getbyvmid(vmr.vmr_id)) == NULL((void *)0))
	break;
proc_compose_imsg(ps, PROC_CONTROL, -1,
    imsg->hdr.type, imsg->hdr.peerid, -1,
    imsg->data, sizeof(imsg->data));
log_info("%s: unpaused vm %d successfully.",
    vm->vm_params.vmc_params.vcp_name,
    vm->vm_vmid);
vm->vm_state &= ~VM_STATE_PAUSED0x10;
break;
case IMSG_VMDOP_START_VM_RESPONSE:
IMSG_SIZE_CHECK(imsg, &vmr)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmr)) fatalx("bad length imsg received (%s)", "&vmr"
); } while (0);
memcpy(&vmr, imsg->data, sizeof(vmr));
if ((vm = vm_getbyvmid(imsg->hdr.peerid)) == NULL((void *)0))
	break;
vm->vm_pid = vmr.vmr_pid;
vcp = &vm->vm_params.vmc_params;
vcp->vcp_id = vmr.vmr_id;

/*
 * If the peerid is not -1, forward the response back to the
 * the control socket.  If it is -1, the request originated
 * from the parent, not the control socket.
 */
if (vm->vm_peerid != (uint32_t)-1) {
	(void)strlcpy(vmr.vmr_ttyname, vm->vm_ttyname,
	    sizeof(vmr.vmr_ttyname));
	if (proc_compose_imsg(ps, PROC_CONTROL, -1,
	    imsg->hdr.type, vm->vm_peerid, -1,
	    &vmr, sizeof(vmr)) == -1) {
		errno(*__errno()) = vmr.vmr_result;
		log_warn("%s: failed to forward vm result",
		    vcp->vcp_name);
		vm_terminate(vm, __func__);
		return (-1);
	}
}

if (vmr.vmr_result) {
	log_warnx("%s: failed to start vm", vcp->vcp_name);
	vm_terminate(vm, __func__);
	errno(*__errno()) = vmr.vmr_result;
	break;
}

/* Now configure all the interfaces */
if (vm_priv_ifconfig(ps, vm) == -1) {
	log_warn("%s: failed to configure vm", vcp->vcp_name);
	vm_terminate(vm, __func__);
	break;
}

log_info("started %s (vm %d) successfully, tty %s",
    vcp->vcp_name, vm->vm_vmid, vm->vm_ttyname);
break;
case IMSG_VMDOP_TERMINATE_VM_RESPONSE:
IMSG_SIZE_CHECK(imsg, &vmr)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmr)) fatalx("bad length imsg received (%s)", "&vmr"
); } while (0);
memcpy(&vmr, imsg->data, sizeof(vmr));

if (vmr.vmr_result) {
	DPRINTF("%s: forwarding TERMINATE VM for vm id %d",do {} while(0)
	    __func__, vmr.vmr_id)do {} while(0);
	proc_forward_imsg(ps, imsg, PROC_CONTROL, -1);
} else {
	if ((vm = vm_getbyvmid(vmr.vmr_id)) == NULL((void *)0))
		break;
	/* Mark VM as shutting down */
	vm->vm_state |= VM_STATE_SHUTDOWN0x04;
}
break;
case IMSG_VMDOP_SEND_VM_RESPONSE:
IMSG_SIZE_CHECK(imsg, &vmr)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmr)) fatalx("bad length imsg received (%s)", "&vmr"
); } while (0);
memcpy(&vmr, imsg->data, sizeof(vmr));
if ((vm = vm_getbyvmid(vmr.vmr_id)) == NULL((void *)0))
	break;
if (!vmr.vmr_result) {
	log_info("%s: sent vm %d successfully.",
	    vm->vm_params.vmc_params.vcp_name,
	    vm->vm_vmid);
	vm_terminate(vm, __func__);
}

/* Send a response if a control client is waiting for it */
if (imsg->hdr.peerid != (uint32_t)-1) {
	/* the error is meaningless for deferred responses */
	vmr.vmr_result = 0;

	if (proc_compose_imsg(ps, PROC_CONTROL, -1,
	    IMSG_VMDOP_SEND_VM_RESPONSE,
	    imsg->hdr.peerid, -1, &vmr, sizeof(vmr)) == -1)
		return (-1);
}
break;
case IMSG_VMDOP_TERMINATE_VM_EVENT:
IMSG_SIZE_CHECK(imsg, &vmr)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vmr)) fatalx("bad length imsg received (%s)", "&vmr"
); } while (0);
memcpy(&vmr, imsg->data, sizeof(vmr));
DPRINTF("%s: handling TERMINATE_EVENT for vm id %d ret %d",do {} while(0)
    __func__, vmr.vmr_id, vmr.vmr_result)do {} while(0);
if ((vm = vm_getbyvmid(vmr.vmr_id)) == NULL((void *)0)) {
	log_debug("%s: vm %d is no longer available",
	    __func__, vmr.vmr_id);
	break;
}
if (vmr.vmr_result != EAGAIN35 ||
    vm->vm_params.vmc_bootdevice) {
	vm_terminate(vm, __func__);
} else {
	/* Stop VM instance but keep the tty open */
	vm_stop(vm, 1, __func__);
	config_setvm(ps, vm, (uint32_t)-1, vm->vm_uid);
}

/* The error is meaningless for deferred responses */
vmr.vmr_result = 0;

if (proc_compose_imsg(ps, PROC_CONTROL, -1,
	IMSG_VMDOP_TERMINATE_VM_EVENT,
	imsg->hdr.peerid, -1, &vmr, sizeof(vmr)) == -1)
	return (-1);
break;
case IMSG_VMDOP_GET_INFO_VM_DATA:
IMSG_SIZE_CHECK(imsg, &vir)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&vir)) fatalx("bad length imsg received (%s)", "&vir"
); } while (0);
2
←
Assuming the condition is false→
3
←
Taking false branch→
4
←
Loop condition is false.  Exiting loop→
memcpy(&vir, imsg->data, sizeof(vir));
if ((vm = vm_getbyvmid(vir.vir_info.vir_id)) != NULL((void *)0)) {
5
←
Value assigned to 'vm'→
6
←
Assuming pointer value is null→
7
←
Taking false branch→
	memset(vir.vir_ttyname, 0, sizeof(vir.vir_ttyname));
	if (vm->vm_ttyname[0] != '\0')
		strlcpy(vir.vir_ttyname, vm->vm_ttyname,
		    sizeof(vir.vir_ttyname));
	log_debug("%s: running vm: %d, vm_state: 0x%x",
	    __func__, vm->vm_vmid, vm->vm_state);
	vir.vir_state = vm->vm_state;
	/* get the user id who started the vm */
	vir.vir_uid = vm->vm_uid;
	vir.vir_gid = vm->vm_params.vmc_owner.gid;
}
if (proc_compose_imsg(ps,
10
←
Assuming the condition is true→
11
←
Taking true branch→
    imsg->hdr.peerid == IMSG_AGENTX_PEERID(uint32_t)-2 ?
8
←
Assuming the condition is false→
9
←
'?' condition is false→
    PROC_AGENTX : PROC_CONTROL, -1, imsg->hdr.type,
    imsg->hdr.peerid, -1, &vir, sizeof(vir)) == -1) {
	log_debug("%s: GET_INFO_VM failed for vm %d, removing",
	    __func__, vm->vm_vmid);
12
←
Access to field 'vm_vmid' results in a dereference of a null pointer (loaded from variable 'vm')
	vm_terminate(vm, __func__);
	return (-1);
}
break;
case IMSG_VMDOP_GET_INFO_VM_END_DATA:
/*
 * PROC_VMM has responded with the *running* VMs, now we
 * append the others. These use the special value 0 for their
 * kernel id to indicate that they are not running.
 */
TAILQ_FOREACH(vm, env->vmd_vms, vm_entry)for((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void *
)0); (vm) = ((vm)->vm_entry.tqe_next)) {
	if (!(vm->vm_state & VM_STATE_RUNNING0x01)) {
		memset(&vir, 0, sizeof(vir));
		vir.vir_info.vir_id = vm->vm_vmid;
		strlcpy(vir.vir_info.vir_name,
		    vm->vm_params.vmc_params.vcp_name,
		    VMM_MAX_NAME_LEN64);
		vir.vir_info.vir_memory_size =
		    vm->vm_params.vmc_params.
		    vcp_memranges[0].vmr_size;
		vir.vir_info.vir_ncpus =
		    vm->vm_params.vmc_params.vcp_ncpus;
		/* get the configured user id for this vm */
		vir.vir_uid = vm->vm_params.vmc_owner.uid;
		vir.vir_gid = vm->vm_params.vmc_owner.gid;
		log_debug("%s: vm: %d, vm_state: 0x%x",
		    __func__, vm->vm_vmid, vm->vm_state);
		vir.vir_state = vm->vm_state;
		if (proc_compose_imsg(ps,
		    imsg->hdr.peerid == IMSG_AGENTX_PEERID(uint32_t)-2 ?
		    PROC_AGENTX : PROC_CONTROL, -1,
		    IMSG_VMDOP_GET_INFO_VM_DATA,
		    imsg->hdr.peerid, -1, &vir,
		    sizeof(vir)) == -1) {
			log_debug("%s: GET_INFO_VM_END failed",
			    __func__);
			vm_terminate(vm, __func__);
			return (-1);
		}
	}
}
IMSG_SIZE_CHECK(imsg, &res)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&res)) fatalx("bad length imsg received (%s)", "&res"
); } while (0);
proc_forward_imsg(ps, imsg,
    imsg->hdr.peerid == IMSG_AGENTX_PEERID(uint32_t)-2 ?
    PROC_AGENTX : PROC_CONTROL, -1);
break;
default:
return (-1);
}

return (0);
582}

584int
585vmd_dispatch_agentx(int fd, struct privsep_proc *p, struct imsg *imsg)
586{
struct privsep			*ps = p->p_ps;

switch (imsg->hdr.type) {
case IMSG_VMDOP_GET_INFO_VM_REQUEST:
proc_forward_imsg(ps, imsg, PROC_VMM, -1);
return (0);
default:
break;
}
return (-1);
597}

599int
600vmd_dispatch_priv(int fd, struct privsep_proc *p, struct imsg *imsg)
601{
struct vmop_addr_result	 var;

switch (imsg->hdr.type) {
case IMSG_VMDOP_PRIV_GET_ADDR_RESPONSE:
IMSG_SIZE_CHECK(imsg, &var)do { if (((imsg)->hdr.len - sizeof(struct imsg_hdr)) < sizeof
(*&var)) fatalx("bad length imsg received (%s)", "&var"
); } while (0);
memcpy(&var, imsg->data, sizeof(var));
proc_forward_imsg(p->p_ps, imsg, PROC_VMM, -1);
break;
default:
return (-1);
}

return (0);
615}

617int
618vmd_check_vmh(struct vm_dump_header *vmh)
619{
int i;
unsigned int code, leaf;
unsigned int a, b, c, d;

if (strncmp(vmh->vmh_signature, VM_DUMP_SIGNATURE"OpenBSDVMM58", strlen(VM_DUMP_SIGNATURE"OpenBSDVMM58")) != 0) {
log_warnx("%s: incompatible dump signature", __func__);
return (-1);
}

if (vmh->vmh_version != VM_DUMP_VERSION7) {
log_warnx("%s: incompatible dump version", __func__);
return (-1);
}

for (i = 0; i < VM_DUMP_HEADER_CPUID_COUNT5; i++) {
code = vmh->vmh_cpuids[i].code;
leaf = vmh->vmh_cpuids[i].leaf;
if (leaf != 0x00) {
	log_debug("%s: invalid leaf 0x%x for code 0x%x",
	    __func__, leaf, code);
	return (-1);
}

switch (code) {
case 0x00:
	CPUID_LEAF(code, leaf, a, b, c, d)__asm volatile("cpuid" : "=a" (a), "=b" (b), "=c" (c), "=d" (
d) : "a" (code), "c" (leaf));
	if (vmh->vmh_cpuids[i].a > a) {
		log_debug("%s: incompatible cpuid level",
		    __func__);
		return (-1);
	}
	if (!(vmh->vmh_cpuids[i].b == b &&
	    vmh->vmh_cpuids[i].c == c &&
	    vmh->vmh_cpuids[i].d == d)) {
		log_debug("%s: incompatible cpu brand",
		    __func__);
		return (-1);
	}
	break;

case 0x01:
	CPUID_LEAF(code, leaf, a, b, c, d)__asm volatile("cpuid" : "=a" (a), "=b" (b), "=c" (c), "=d" (
d) : "a" (code), "c" (leaf));
	if ((vmh->vmh_cpuids[i].c & c & VMM_CPUIDECX_MASK~(0x00000080 | 0x00000100 | 0x00000008 | 0x00008000 | 0x00000020
 | 0x00000004 | 0x00000010 | 0x00000040 | 0x00000400 | 0x00000800
 | 0x00004000 | 0x00020000 | 0x00040000 | 0x00200000 | 0x01000000
)) !=
	    (vmh->vmh_cpuids[i].c & VMM_CPUIDECX_MASK~(0x00000080 | 0x00000100 | 0x00000008 | 0x00008000 | 0x00000020
 | 0x00000004 | 0x00000010 | 0x00000040 | 0x00000400 | 0x00000800
 | 0x00004000 | 0x00020000 | 0x00040000 | 0x00200000 | 0x01000000
))) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: c", __func__,
		    code, leaf);
		return (-1);
	}
	if ((vmh->vmh_cpuids[i].d & d & VMM_CPUIDEDX_MASK~(0x00400000 | 0x20000000 | 0x10000000 | 0x00200000 | 0x00000200
 | 0x00040000 | 0x08000000 | 0x80000000 | 0x00001000 | 0x00000080
 | 0x00004000)) !=
	    (vmh->vmh_cpuids[i].d & VMM_CPUIDEDX_MASK~(0x00400000 | 0x20000000 | 0x10000000 | 0x00200000 | 0x00000200
 | 0x00040000 | 0x08000000 | 0x80000000 | 0x00001000 | 0x00000080
 | 0x00004000))) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: d", __func__,
		    code, leaf);
		return (-1);
	}
	break;

case 0x07:
	CPUID_LEAF(code, leaf, a, b, c, d)__asm volatile("cpuid" : "=a" (a), "=b" (b), "=c" (c), "=d" (
d) : "a" (code), "c" (leaf));
	if ((vmh->vmh_cpuids[i].b & b & VMM_SEFF0EBX_MASK~(0x00000002 | 0x00000004 | 0x00000010 | 0x00000400 | 0x00000800
 | 0x00001000 | 0x00004000 | 0x00400000 | 0x02000000 | 0x00010000
 | 0x00020000 | 0x00200000 | 0x04000000 | 0x08000000 | 0x10000000
 | 0x40000000 | 0x80000000)) !=
	    (vmh->vmh_cpuids[i].b & VMM_SEFF0EBX_MASK~(0x00000002 | 0x00000004 | 0x00000010 | 0x00000400 | 0x00000800
 | 0x00001000 | 0x00004000 | 0x00400000 | 0x02000000 | 0x00010000
 | 0x00020000 | 0x00200000 | 0x04000000 | 0x08000000 | 0x10000000
 | 0x40000000 | 0x80000000))) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: c", __func__,
		    code, leaf);
		return (-1);
	}
	if ((vmh->vmh_cpuids[i].c & c & VMM_SEFF0ECX_MASK(0x00000004)) !=
	    (vmh->vmh_cpuids[i].c & VMM_SEFF0ECX_MASK(0x00000004))) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: d", __func__,
		    code, leaf);
		return (-1);
	}
	break;

case 0x0d:
	CPUID_LEAF(code, leaf, a, b, c, d)__asm volatile("cpuid" : "=a" (a), "=b" (b), "=c" (c), "=d" (
d) : "a" (code), "c" (leaf));
	if (vmh->vmh_cpuids[i].b > b) {
		log_debug("%s: incompatible cpu: insufficient "
		    "max save area for enabled XCR0 features",
		    __func__);
		return (-1);
	}
	if (vmh->vmh_cpuids[i].c > c) {
		log_debug("%s: incompatible cpu: insufficient "
		    "max save area for supported XCR0 features",
		    __func__);
		return (-1);
	}
	break;

case 0x80000001:
	CPUID_LEAF(code, leaf, a, b, c, d)__asm volatile("cpuid" : "=a" (a), "=b" (b), "=c" (c), "=d" (
d) : "a" (code), "c" (leaf));
	if ((vmh->vmh_cpuids[i].a & a) !=
	    vmh->vmh_cpuids[i].a) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: a", __func__,
		    code, leaf);
		return (-1);
	}
	if ((vmh->vmh_cpuids[i].c & c) !=
	    vmh->vmh_cpuids[i].c) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: c", __func__,
		    code, leaf);
		return (-1);
	}
	if ((vmh->vmh_cpuids[i].d & d) !=
	    vmh->vmh_cpuids[i].d) {
		log_debug("%s: incompatible cpu features "
		    "code: 0x%x leaf: 0x%x  reg: d", __func__,
		    code, leaf);
		return (-1);
	}
	break;

default:
	log_debug("%s: unknown code 0x%x", __func__, code);
	return (-1);
}
}

return (0);
744}

746void
747vmd_sighdlr(int sig, short event, void *arg)
748{
if (privsep_process != PROC_PARENT)
return;
log_debug("%s: handling signal", __func__);

switch (sig) {
case SIGHUP1:
log_info("%s: reload requested with SIGHUP", __func__);

/*
 * This is safe because libevent uses async signal handlers
 * that run in the event loop and not in signal context.
 */
(void)vmd_reload(0, NULL((void *)0));
break;
case SIGPIPE13:
log_info("%s: ignoring SIGPIPE", __func__);
break;
case SIGUSR130:
log_info("%s: ignoring SIGUSR1", __func__);
break;
case SIGTERM15:
case SIGINT2:
vmd_shutdown();
break;
default:
fatalx("unexpected signal");
}
776}

778__dead__attribute__((__noreturn__)) void
779usage(void)
780{
extern char *__progname;
fprintf(stderr(&__sF[2]), "usage: %s [-dnv] [-D macro=value] [-f file]\n",
   __progname);
exit(1);
785}

787int
788main(int argc, char **argv)
789{
struct privsep		*ps;
int			 ch;
enum privsep_procid	 proc_id = PROC_PARENT;
int			 proc_instance = 0, vm_launch = 0;
int			 vmm_fd = -1, vm_fd = -1;
const char		*errp, *title = NULL((void *)0);
int			 argc0 = argc;
char			 dev_type = '\0';

log_init(0, LOG_DAEMON(3<<3));

if ((env = calloc(1, sizeof(*env))) == NULL((void *)0))
fatal("calloc: env");

while ((ch = getopt(argc, argv, "D:P:I:V:X:df:i:nt:vp:")) != -1) {
switch (ch) {
case 'D':
	if (cmdline_symset(optarg) < 0)
		log_warnx("could not parse macro definition %s",
		    optarg);
	break;
case 'd':
	env->vmd_debug = 2;
	break;
case 'f':
	conffile = optarg;
	break;
case 'v':
	env->vmd_verbose++;
	break;
/* vmd fork/exec */
case 'n':
	env->vmd_noaction = 1;
	break;
case 'P':
	title = optarg;
	proc_id = proc_getid(procs, nitems(procs)(sizeof((procs)) / sizeof((procs)[0])), title);
	if (proc_id == PROC_MAX)
		fatalx("invalid process name");
	break;
case 'I':
	proc_instance = strtonum(optarg, 0,
	    PROC_MAX_INSTANCES32, &errp);
	if (errp)
		fatalx("invalid process instance");
	break;
/* child vm and device fork/exec */
case 'p':
	title = optarg;
	break;
case 'V':
	vm_launch = VMD_LAUNCH_VM1;
	vm_fd = strtonum(optarg, 0, 128, &errp);
	if (errp)
		fatalx("invalid vm fd");
	break;
case 'X':
	vm_launch = VMD_LAUNCH_DEV2;
	vm_fd = strtonum(optarg, 0, 128, &errp);
	if (errp)
		fatalx("invalid device fd");
	break;
case 't':
	dev_type = *optarg;
	switch (dev_type) {
	case VMD_DEVTYPE_NET'n':
	case VMD_DEVTYPE_DISK'd':
		break;
	default: fatalx("invalid device type");
	}
	break;
case 'i':
	vmm_fd = strtonum(optarg, 0, 128, &errp);
	if (errp)
		fatalx("invalid vmm fd");
	break;
default:
	usage();
}
}

argc -= optind;
if (argc > 0)
usage();

if (env->vmd_noaction && !env->vmd_debug)
env->vmd_debug = 1;

log_init(env->vmd_debug, LOG_DAEMON(3<<3));
log_setverbose(env->vmd_verbose);

/* Re-exec from the vmm child process requires an absolute path. */
if (proc_id == PROC_PARENT && *argv[0] != '/' && !env->vmd_noaction)
fatalx("re-exec requires execution with an absolute path");
env->argv0 = argv[0];

/* check for root privileges */
if (env->vmd_noaction == 0 && !vm_launch) {
if (geteuid())
	fatalx("need root privileges");
}

ps = &env->vmd_ps;
ps->ps_env = env;
env->vmd_fd = vmm_fd;

if (config_init(env) == -1)
fatal("failed to initialize configuration");

if ((ps->ps_pw = getpwnam(VMD_USER"_vmd")) == NULL((void *)0))
fatal("unknown user %s", VMD_USER"_vmd");

/* First proc runs as root without pledge but in default chroot */
proc_priv->p_pw = &proc_privpw; /* initialized to all 0 */
proc_priv->p_chroot = ps->ps_pw->pw_dir; /* from VMD_USER */

/*
* If we're launching a new vm or its device, we short out here.
*/
if (vm_launch == VMD_LAUNCH_VM1) {
vm_main(vm_fd, vmm_fd);
/* NOTREACHED */
} else if (vm_launch == VMD_LAUNCH_DEV2) {
if (dev_type == VMD_DEVTYPE_NET'n') {
	log_procinit("vm/%s/vionet", title);
	vionet_main(vm_fd, vmm_fd);
	/* NOTREACHED */
} else if (dev_type == VMD_DEVTYPE_DISK'd') {
	log_procinit("vm/%s/vioblk", title);
	vioblk_main(vm_fd, vmm_fd);
	/* NOTREACHED */
}
fatalx("unsupported device type '%c'", dev_type);
}

/* Open /dev/vmm early. */
if (env->vmd_noaction == 0 && proc_id == PROC_PARENT) {
env->vmd_fd = open(VMM_NODE"/dev/vmm", O_RDWR0x0002);
if (env->vmd_fd == -1)
	fatal("%s", VMM_NODE"/dev/vmm");
}

/* Configure the control socket */
ps->ps_csock.cs_name = SOCKET_NAME"/var/run/vmd.sock";
TAILQ_INIT(&ps->ps_rcsocks)do { (&ps->ps_rcsocks)->tqh_first = ((void *)0); (&
ps->ps_rcsocks)->tqh_last = &(&ps->ps_rcsocks
)->tqh_first; } while (0);

/* Configuration will be parsed after forking the children */
env->vmd_conffile = conffile;

if (env->vmd_noaction)
ps->ps_noaction = 1;
ps->ps_instance = proc_instance;
if (title != NULL((void *)0))
ps->ps_title[proc_id] = title;

/* only the parent returns */
proc_init(ps, procs, nitems(procs)(sizeof((procs)) / sizeof((procs)[0])), env->vmd_debug, argc0, argv,
   proc_id);

if (!env->vmd_debug && daemon(0, 0) == -1)
fatal("can't daemonize");

if (ps->ps_noaction == 0)
log_info("startup");

event_init();

signal_set(&ps->ps_evsigint, SIGINT, vmd_sighdlr, ps)event_set(&ps->ps_evsigint, 2, 0x08|0x10, vmd_sighdlr,
 ps);
signal_set(&ps->ps_evsigterm, SIGTERM, vmd_sighdlr, ps)event_set(&ps->ps_evsigterm, 15, 0x08|0x10, vmd_sighdlr
, ps);
signal_set(&ps->ps_evsighup, SIGHUP, vmd_sighdlr, ps)event_set(&ps->ps_evsighup, 1, 0x08|0x10, vmd_sighdlr,
 ps);
signal_set(&ps->ps_evsigpipe, SIGPIPE, vmd_sighdlr, ps)event_set(&ps->ps_evsigpipe, 13, 0x08|0x10, vmd_sighdlr
, ps);
signal_set(&ps->ps_evsigusr1, SIGUSR1, vmd_sighdlr, ps)event_set(&ps->ps_evsigusr1, 30, 0x08|0x10, vmd_sighdlr
, ps);

signal_add(&ps->ps_evsigint, NULL)event_add(&ps->ps_evsigint, ((void *)0));
signal_add(&ps->ps_evsigterm, NULL)event_add(&ps->ps_evsigterm, ((void *)0));
signal_add(&ps->ps_evsighup, NULL)event_add(&ps->ps_evsighup, ((void *)0));
signal_add(&ps->ps_evsigpipe, NULL)event_add(&ps->ps_evsigpipe, ((void *)0));
signal_add(&ps->ps_evsigusr1, NULL)event_add(&ps->ps_evsigusr1, ((void *)0));

if (!env->vmd_noaction)
proc_connect(ps);

if (vmd_configure() == -1)
fatalx("configuration failed");

event_dispatch();

log_debug("exiting");

return (0);
980}

982void
983start_vm_batch(int fd, short type, void *args)
984{
int		i = 0;
struct vmd_vm	*vm;

log_debug("%s: starting batch of %d vms", __func__,
   env->vmd_cfg.parallelism);
TAILQ_FOREACH(vm, env->vmd_vms, vm_entry)for((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void *
)0); (vm) = ((vm)->vm_entry.tqe_next)) {
if (!(vm->vm_state & VM_STATE_WAITING0x20)) {
	log_debug("%s: not starting vm %s (disabled)",
	    __func__,
	    vm->vm_params.vmc_params.vcp_name);
	continue;
}
i++;
if (i > env->vmd_cfg.parallelism) {
	evtimer_add(&staggered_start_timer,event_add(&staggered_start_timer, &env->vmd_cfg.delay
)
	    &env->vmd_cfg.delay)event_add(&staggered_start_timer, &env->vmd_cfg.delay
);
	break;
}
vm->vm_state &= ~VM_STATE_WAITING0x20;
config_setvm(&env->vmd_ps, vm, -1, vm->vm_params.vmc_owner.uid);
}
log_debug("%s: done starting vms", __func__);
1007}

1009int
1010vmd_configure(void)
1011{
int			ncpus;
struct vmd_switch	*vsw;
int ncpu_mib[] = {CTL_HW6, HW_NCPUONLINE25};
size_t ncpus_sz = sizeof(ncpus);

if ((env->vmd_ptmfd = open(PATH_PTMDEV"/dev/ptm", O_RDWR0x0002|O_CLOEXEC0x10000)) == -1)
fatal("open %s", PATH_PTMDEV"/dev/ptm");

/*
* pledge in the parent process:
* stdio - for malloc and basic I/O including events.
* rpath - for reload to open and read the configuration files.
* wpath - for opening disk images and tap devices.
* tty - for openpty and TIOCUCNTL.
* proc - run kill to terminate its children safely.
* sendfd - for disks, interfaces and other fds.
* recvfd - for send and receive.
* getpw - lookup user or group id by name.
* chown, fattr - change tty ownership
* flock - locking disk files
*/
if (pledge("stdio rpath wpath proc tty recvfd sendfd getpw"
   " chown fattr flock", NULL((void *)0)) == -1)
fatal("pledge");

if (parse_config(env->vmd_conffile) == -1) {
proc_kill(&env->vmd_ps);
exit(1);
}

if (env->vmd_noaction) {
fprintf(stderr(&__sF[2]), "configuration OK\n");
proc_kill(&env->vmd_ps);
exit(0);
}

/* Send VMM device fd to vmm proc. */
proc_compose_imsg(&env->vmd_ps, PROC_VMM, -1,
   IMSG_VMDOP_RECEIVE_VMM_FD, -1, env->vmd_fd, NULL((void *)0), 0);

/* Send shared global configuration to all children */
if (config_setconfig(env) == -1)
return (-1);

TAILQ_FOREACH(vsw, env->vmd_switches, sw_entry)for((vsw) = ((env->vmd_switches)->tqh_first); (vsw) != (
(void *)0); (vsw) = ((vsw)->sw_entry.tqe_next)) {
if (vsw->sw_running)
	continue;
if (vm_priv_brconfig(&env->vmd_ps, vsw) == -1) {
	log_warn("%s: failed to create switch %s",
	    __func__, vsw->sw_name);
	switch_remove(vsw);
	return (-1);
}
}

if (!(env->vmd_cfg.cfg_flags & VMD_CFG_STAGGERED_START0x04)) {
env->vmd_cfg.delay.tv_sec = VMD_DEFAULT_STAGGERED_START_DELAY30;
if (sysctl(ncpu_mib, nitems(ncpu_mib)(sizeof((ncpu_mib)) / sizeof((ncpu_mib)[0])), &ncpus, &ncpus_sz, NULL((void *)0), 0) == -1)
	ncpus = 1;
env->vmd_cfg.parallelism = ncpus;
log_debug("%s: setting staggered start configuration to "
    "parallelism: %d and delay: %lld",
    __func__, ncpus, (long long) env->vmd_cfg.delay.tv_sec);
}

log_debug("%s: starting vms in staggered fashion", __func__);
evtimer_set(&staggered_start_timer, start_vm_batch, NULL)event_set(&staggered_start_timer, -1, 0, start_vm_batch, (
(void *)0));
/* start first batch */
start_vm_batch(0, 0, NULL((void *)0));

return (0);
1083}

1085int
1086vmd_reload(unsigned int reset, const char *filename)
1087{
struct vmd_vm		*vm, *next_vm;
struct vmd_switch	*vsw;
int			 reload = 0;

/* Switch back to the default config file */
if (filename == NULL((void *)0) || *filename == '\0') {
filename = env->vmd_conffile;
reload = 1;
}

log_debug("%s: level %d config file %s", __func__, reset, filename);

if (reset) {
/* Purge the configuration */
config_purge(env, reset);
config_setreset(env, reset);
} else {
/*
 * Load or reload the configuration.
 *
 * Reloading removes all non-running VMs before processing the
 * config file, whereas loading only adds to the existing list
 * of VMs.
 */

if (reload) {
	TAILQ_FOREACH_SAFE(vm, env->vmd_vms, vm_entry,for ((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void
 *)0) && ((next_vm) = ((vm)->vm_entry.tqe_next), 1
); (vm) = (next_vm))
	    next_vm)for ((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void
 *)0) && ((next_vm) = ((vm)->vm_entry.tqe_next), 1
); (vm) = (next_vm)) {
		if (!(vm->vm_state & VM_STATE_RUNNING0x01)) {
			DPRINTF("%s: calling vm_remove",do {} while(0)
			    __func__)do {} while(0);
			vm_remove(vm, __func__);
		}
	}
}

if (parse_config(filename) == -1) {
	log_debug("%s: failed to load config file %s",
	    __func__, filename);
	return (-1);
}

if (reload) {
	/* Update shared global configuration in all children */
	if (config_setconfig(env) == -1)
		return (-1);
}

TAILQ_FOREACH(vsw, env->vmd_switches, sw_entry)for((vsw) = ((env->vmd_switches)->tqh_first); (vsw) != (
(void *)0); (vsw) = ((vsw)->sw_entry.tqe_next)) {
	if (vsw->sw_running)
		continue;
	if (vm_priv_brconfig(&env->vmd_ps, vsw) == -1) {
		log_warn("%s: failed to create switch %s",
		    __func__, vsw->sw_name);
		switch_remove(vsw);
		return (-1);
	}
}

log_debug("%s: starting vms in staggered fashion", __func__);
evtimer_set(&staggered_start_timer, start_vm_batch, NULL)event_set(&staggered_start_timer, -1, 0, start_vm_batch, (
(void *)0));
/* start first batch */
start_vm_batch(0, 0, NULL((void *)0));

}

return (0);
1155}

1157void
1158vmd_shutdown(void)
1159{
struct vmd_vm *vm, *vm_next;

log_debug("%s: performing shutdown", __func__);

TAILQ_FOREACH_SAFE(vm, env->vmd_vms, vm_entry, vm_next)for ((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void
 *)0) && ((vm_next) = ((vm)->vm_entry.tqe_next), 1
); (vm) = (vm_next)) {
vm_remove(vm, __func__);
}

proc_kill(&env->vmd_ps);
free(env);

log_warnx("terminating");
exit(0);
1173}

1175struct vmd_vm *
1176vm_getbyvmid(uint32_t vmid)
1177{
struct vmd_vm	*vm;

if (vmid == 0)
return (NULL((void *)0));
TAILQ_FOREACH(vm, env->vmd_vms, vm_entry)for((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void *
)0); (vm) = ((vm)->vm_entry.tqe_next)) {
if (vm->vm_vmid == vmid)
	return (vm);
}

return (NULL((void *)0));
1188}

1190struct vmd_vm *
1191vm_getbyid(uint32_t id)
1192{
struct vmd_vm	*vm;

if (id == 0)
return (NULL((void *)0));
TAILQ_FOREACH(vm, env->vmd_vms, vm_entry)for((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void *
)0); (vm) = ((vm)->vm_entry.tqe_next)) {
if (vm->vm_params.vmc_params.vcp_id == id)
	return (vm);
}

return (NULL((void *)0));
1203}

1205uint32_t
1206vm_id2vmid(uint32_t id, struct vmd_vm *vm)
1207{
if (vm == NULL((void *)0) && (vm = vm_getbyid(id)) == NULL((void *)0))
return (0);
DPRINTF("%s: vmm id %u is vmid %u", __func__,do {} while(0)
   id, vm->vm_vmid)do {} while(0);
return (vm->vm_vmid);
1213}

1215uint32_t
1216vm_vmid2id(uint32_t vmid, struct vmd_vm *vm)
1217{
if (vm == NULL((void *)0) && (vm = vm_getbyvmid(vmid)) == NULL((void *)0))
return (0);
DPRINTF("%s: vmid %u is vmm id %u", __func__,do {} while(0)
   vmid, vm->vm_params.vmc_params.vcp_id)do {} while(0);
return (vm->vm_params.vmc_params.vcp_id);
1223}

1225struct vmd_vm *
1226vm_getbyname(const char *name)
1227{
struct vmd_vm	*vm;

if (name == NULL((void *)0))
return (NULL((void *)0));
TAILQ_FOREACH(vm, env->vmd_vms, vm_entry)for((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void *
)0); (vm) = ((vm)->vm_entry.tqe_next)) {
if (strcmp(vm->vm_params.vmc_params.vcp_name, name) == 0)
	return (vm);
}

return (NULL((void *)0));
1238}

1240struct vmd_vm *
1241vm_getbypid(pid_t pid)
1242{
struct vmd_vm	*vm;

TAILQ_FOREACH(vm, env->vmd_vms, vm_entry)for((vm) = ((env->vmd_vms)->tqh_first); (vm) != ((void *
)0); (vm) = ((vm)->vm_entry.tqe_next)) {
if (vm->vm_pid == pid)
	return (vm);
}

return (NULL((void *)0));
1251}

1253void
1254vm_stop(struct vmd_vm *vm, int keeptty, const char *caller)
1255{
struct privsep	*ps = &env->vmd_ps;
unsigned int	 i, j;

if (vm == NULL((void *)0))
return;

log_debug("%s: %s %s stopping vm %d%s",
   __func__, ps->ps_title[privsep_process], caller,
   vm->vm_vmid, keeptty ? ", keeping tty open" : "");

vm->vm_state &= ~(VM_STATE_RECEIVED0x08 | VM_STATE_RUNNING0x01
   | VM_STATE_SHUTDOWN0x04);

if (vm->vm_iev.ibuf.fd != -1) {
event_del(&vm->vm_iev.ev);
close(vm->vm_iev.ibuf.fd);
}
for (i = 0; i < VM_MAX_DISKS_PER_VM4; i++) {
for (j = 0; j < VM_MAX_BASE_PER_DISK4; j++) {
	if (vm->vm_disks[i][j] != -1) {
		close(vm->vm_disks[i][j]);
		vm->vm_disks[i][j] = -1;
	}
}
}
for (i = 0; i < VM_MAX_NICS_PER_VM4; i++) {
if (vm->vm_ifs[i].vif_fd != -1) {
	close(vm->vm_ifs[i].vif_fd);
	vm->vm_ifs[i].vif_fd = -1;
}
free(vm->vm_ifs[i].vif_name);
free(vm->vm_ifs[i].vif_switch);
free(vm->vm_ifs[i].vif_group);
vm->vm_ifs[i].vif_name = NULL((void *)0);
vm->vm_ifs[i].vif_switch = NULL((void *)0);
vm->vm_ifs[i].vif_group = NULL((void *)0);
}
if (vm->vm_kernel != -1) {
close(vm->vm_kernel);
vm->vm_kernel = -1;
}
if (vm->vm_cdrom != -1) {
close(vm->vm_cdrom);
vm->vm_cdrom = -1;
}
if (!keeptty) {
vm_closetty(vm);
vm->vm_uid = 0;
}
1305}

1307void
1308vm_remove(struct vmd_vm *vm, const char *caller)
1309{
struct privsep	*ps = &env->vmd_ps;

if (vm == NULL((void *)0))
return;

log_debug("%s: %s %s removing vm %d from running config",
   __func__, ps->ps_title[privsep_process], caller,
   vm->vm_vmid);

TAILQ_REMOVE(env->vmd_vms, vm, vm_entry)do { if (((vm)->vm_entry.tqe_next) != ((void *)0)) (vm)->
vm_entry.tqe_next->vm_entry.tqe_prev = (vm)->vm_entry.tqe_prev
; else (env->vmd_vms)->tqh_last = (vm)->vm_entry.tqe_prev
; *(vm)->vm_entry.tqe_prev = (vm)->vm_entry.tqe_next; ;
 ; } while (0);

vm_stop(vm, 0, caller);
if (vm->vm_kernel_path != NULL((void *)0) && !vm->vm_from_config)
free(vm->vm_kernel_path);
free(vm);
1325}

1327int
1328vm_claimid(const char *name, int uid, uint32_t *id)
1329{
struct name2id *n2i = NULL((void *)0);

TAILQ_FOREACH(n2i, env->vmd_known, entry)for((n2i) = ((env->vmd_known)->tqh_first); (n2i) != ((void
 *)0); (n2i) = ((n2i)->entry.tqe_next))
if (strcmp(n2i->name, name) == 0 && n2i->uid == uid)
	goto out;

if (++env->vmd_nvm == 0) {
log_warnx("too many vms");
return (-1);
}
if ((n2i = calloc(1, sizeof(struct name2id))) == NULL((void *)0)) {
log_warnx("could not alloc vm name");
return (-1);
}
n2i->id = env->vmd_nvm;
n2i->uid = uid;
if (strlcpy(n2i->name, name, sizeof(n2i->name)) >= sizeof(n2i->name)) {
log_warnx("vm name too long");
free(n2i);
return (-1);
}
TAILQ_INSERT_TAIL(env->vmd_known, n2i, entry)do { (n2i)->entry.tqe_next = ((void *)0); (n2i)->entry.
tqe_prev = (env->vmd_known)->tqh_last; *(env->vmd_known
)->tqh_last = (n2i); (env->vmd_known)->tqh_last = &
(n2i)->entry.tqe_next; } while (0);

1353out:
*id = n2i->id;
return (0);
1356}

1358int
1359vm_register(struct privsep *ps, struct vmop_create_params *vmc,
  struct vmd_vm **ret_vm, uint32_t id, uid_t uid)
1361{
struct vmd_vm		*vm = NULL((void *)0), *vm_parent = NULL((void *)0);
struct vm_create_params	*vcp = &vmc->vmc_params;
struct vmop_owner	*vmo = NULL((void *)0);
uint32_t		 nid, rng;
unsigned int		 i, j;
struct vmd_switch	*sw;
char			*s;
int			 ret = 0;

/* Check if this is an instance of another VM */
if ((ret = vm_instance(ps, &vm_parent, vmc, uid)) != 0) {
errno(*__errno()) = ret; /* XXX might set invalid errno */
return (-1);
}

errno(*__errno()) = 0;
*ret_vm = NULL((void *)0);

if ((vm = vm_getbyname(vcp->vcp_name)) != NULL((void *)0) ||
   (vm = vm_getbyvmid(vcp->vcp_id)) != NULL((void *)0)) {
if (vm_checkperm(vm, &vm->vm_params.vmc_owner,
    uid) != 0) {
	errno(*__errno()) = EPERM1;
	goto fail;
}
vm->vm_kernel = vmc->vmc_kernel;
*ret_vm = vm;
errno(*__errno()) = EALREADY37;
goto fail;
}

if (vm_parent != NULL((void *)0))
vmo = &vm_parent->vm_params.vmc_insowner;

/* non-root users can only start existing VMs or instances */
if (vm_checkperm(NULL((void *)0), vmo, uid) != 0) {
log_warnx("permission denied");
errno(*__errno()) = EPERM1;
goto fail;
}
if (vmc->vmc_flags == 0) {
log_warnx("invalid configuration, no devices");
errno(*__errno()) = VMD_DISK_MISSING1002;
goto fail;
}
if (vcp->vcp_ncpus == 0)
vcp->vcp_ncpus = 1;
if (vcp->vcp_memranges[0].vmr_size == 0)
vcp->vcp_memranges[0].vmr_size = VM_DEFAULT_MEMORY512 * 1024 * 1024;
if (vcp->vcp_ncpus > VMM_MAX_VCPUS_PER_VM64) {
log_warnx("invalid number of CPUs");
goto fail;
} else if (vmc->vmc_ndisks > VM_MAX_DISKS_PER_VM4) {
log_warnx("invalid number of disks");
goto fail;
} else if (vmc->vmc_nnics > VM_MAX_NICS_PER_VM4) {
log_warnx("invalid number of interfaces");
goto fail;
} else if (vmc->vmc_kernel == -1 && vmc->vmc_ndisks == 0
   && strlen(vmc->vmc_cdrom) == 0) {
log_warnx("no kernel or disk/cdrom specified");
goto fail;
} else if (strlen(vcp->vcp_name) == 0) {
log_warnx("invalid VM name");
goto fail;
} else if (*vcp->vcp_name == '-' || *vcp->vcp_name == '.' ||
   *vcp->vcp_name == '_') {
log_warnx("invalid VM name");
goto fail;
} else {
for (s = vcp->vcp_name; *s != '\0'; ++s) {
	if (!(isalnum((unsigned char)*s) || *s == '.' || \
	    *s == '-' || *s == '_')) {
		log_warnx("invalid VM name");
		goto fail;
	}
}
}

if ((vm = calloc(1, sizeof(*vm))) == NULL((void *)0))
goto fail;

memcpy(&vm->vm_params, vmc, sizeof(vm->vm_params));
vmc = &vm->vm_params;
vcp = &vmc->vmc_params;
vm->vm_pid = -1;
vm->vm_tty = -1;
vm->vm_receive_fd = -1;
vm->vm_kernel = -1;
vm->vm_state &= ~VM_STATE_PAUSED0x10;

if (vmc->vmc_kernel > -1)
vm->vm_kernel = vmc->vmc_kernel;

for (i = 0; i < VM_MAX_DISKS_PER_VM4; i++)
for (j = 0; j < VM_MAX_BASE_PER_DISK4; j++)
	vm->vm_disks[i][j] = -1;
for (i = 0; i < VM_MAX_NICS_PER_VM4; i++)
vm->vm_ifs[i].vif_fd = -1;
for (i = 0; i < vmc->vmc_nnics; i++) {
if ((sw = switch_getbyname(vmc->vmc_ifswitch[i])) != NULL((void *)0)) {
	/* inherit per-interface flags from the switch */
	vmc->vmc_ifflags[i] |= (sw->sw_flags & VMIFF_OPTMASK(0x02|0x04|0x08));
}

/*
 * If the MAC address is zero, always randomize it in vmd(8)
 * because we cannot rely on the guest OS to do the right
 * thing like OpenBSD does.  Based on ether_fakeaddr()
 * from the kernel, incremented by one to differentiate
 * the source.
 */
if (memcmp(zero_mac, &vmc->vmc_macs[i], ETHER_ADDR_LEN6) == 0) {
	rng = arc4random();
	vmc->vmc_macs[i][0] = 0xfe;
	vmc->vmc_macs[i][1] = 0xe1;
	vmc->vmc_macs[i][2] = 0xba + 1;
	vmc->vmc_macs[i][3] = 0xd0 | ((i + 1) & 0xf);
	vmc->vmc_macs[i][4] = rng;
	vmc->vmc_macs[i][5] = rng >> 8;
}
}
vm->vm_cdrom = -1;
vm->vm_iev.ibuf.fd = -1;

/*
* Assign a new internal Id if not specified and we succeed in
* claiming a new Id.
*/
if (id != 0)
vm->vm_vmid = id;
else if (vm_claimid(vcp->vcp_name, uid, &nid) == -1)
goto fail;
else
vm->vm_vmid = nid;

log_debug("%s: registering vm %d", __func__, vm->vm_vmid);
TAILQ_INSERT_TAIL(env->vmd_vms, vm, vm_entry)do { (vm)->vm_entry.tqe_next = ((void *)0); (vm)->vm_entry
.tqe_prev = (env->vmd_vms)->tqh_last; *(env->vmd_vms
)->tqh_last = (vm); (env->vmd_vms)->tqh_last = &
(vm)->vm_entry.tqe_next; } while (0);

*ret_vm = vm;
return (0);
fail:
if (errno(*__errno()) == 0)
errno(*__errno()) = EINVAL22;
return (-1);
1507}

1509int
1510vm_instance(struct privsep *ps, struct vmd_vm **vm_parent,
  struct vmop_create_params *vmc, uid_t uid)
1512{
char			*name;
struct vm_create_params	*vcp = &vmc->vmc_params;
struct vmop_create_params *vmcp;
struct vm_create_params	*vcpp;
unsigned int		 i, j;

/* return without error if the parent is NULL (nothing to inherit) */
if ((vmc->vmc_flags & VMOP_CREATE_INSTANCE0x40) == 0 ||
   vmc->vmc_instance[0] == '\0')
return (0);

if ((*vm_parent = vm_getbyname(vmc->vmc_instance)) == NULL((void *)0)) {
return (VMD_PARENT_INVALID1007);
}

vmcp = &(*vm_parent)->vm_params;
vcpp = &vmcp->vmc_params;

/* Are we allowed to create an instance from this VM? */
if (vm_checkperm(NULL((void *)0), &vmcp->vmc_insowner, uid) != 0) {
log_warnx("vm \"%s\" no permission to create vm instance",
    vcpp->vcp_name);
return (ENAMETOOLONG63);
}

name = vcp->vcp_name;

if (vm_getbyname(vcp->vcp_name) != NULL((void *)0) ||
   vm_getbyvmid(vcp->vcp_id) != NULL((void *)0)) {
return (EPROCLIM67);
}

/* CPU */
if (vcp->vcp_ncpus == 0)
vcp->vcp_ncpus = vcpp->vcp_ncpus;
if (vm_checkinsflag(vmcp, VMOP_CREATE_CPU0x01, uid) != 0 &&
   vcp->vcp_ncpus != vcpp->vcp_ncpus) {
log_warnx("vm \"%s\" no permission to set cpus", name);
return (EPERM1);
}

/* memory */
if (vcp->vcp_memranges[0].vmr_size == 0)
vcp->vcp_memranges[0].vmr_size =
    vcpp->vcp_memranges[0].vmr_size;
if (vm_checkinsflag(vmcp, VMOP_CREATE_MEMORY0x04, uid) != 0 &&
   vcp->vcp_memranges[0].vmr_size !=
   vcpp->vcp_memranges[0].vmr_size) {
log_warnx("vm \"%s\" no permission to set memory", name);
return (EPERM1);
}

/* disks cannot be inherited */
if (vm_checkinsflag(vmcp, VMOP_CREATE_DISK0x10, uid) != 0 &&
   vmc->vmc_ndisks) {
log_warnx("vm \"%s\" no permission to set disks", name);
return (EPERM1);
}
for (i = 0; i < vmc->vmc_ndisks; i++) {
/* Check if this disk is already used in the parent */
for (j = 0; j < vmcp->vmc_ndisks; j++) {
	if (strcmp(vmc->vmc_disks[i],
	    vmcp->vmc_disks[j]) == 0) {
		log_warnx("vm \"%s\" disk %s cannot be reused",
		    name, vmc->vmc_disks[i]);
		return (EBUSY16);
	}
}
vmc->vmc_checkaccess |= VMOP_CREATE_DISK0x10;
}

/* interfaces */
if (vmc->vmc_nnics > 0 &&
   vm_checkinsflag(vmcp, VMOP_CREATE_NETWORK0x08, uid) != 0 &&
   vmc->vmc_nnics != vmcp->vmc_nnics) {
log_warnx("vm \"%s\" no permission to set interfaces", name);
return (EPERM1);
}
for (i = 0; i < vmcp->vmc_nnics; i++) {
/* Interface got overwritten */
if (i < vmc->vmc_nnics)
	continue;

/* Copy interface from parent */
vmc->vmc_ifflags[i] = vmcp->vmc_ifflags[i];
(void)strlcpy(vmc->vmc_ifnames[i], vmcp->vmc_ifnames[i],
    sizeof(vmc->vmc_ifnames[i]));
(void)strlcpy(vmc->vmc_ifswitch[i], vmcp->vmc_ifswitch[i],
    sizeof(vmc->vmc_ifswitch[i]));
(void)strlcpy(vmc->vmc_ifgroup[i], vmcp->vmc_ifgroup[i],
    sizeof(vmc->vmc_ifgroup[i]));
memcpy(vmc->vmc_macs[i], vmcp->vmc_macs[i],
    sizeof(vmc->vmc_macs[i]));
vmc->vmc_ifrdomain[i] = vmcp->vmc_ifrdomain[i];
vmc->vmc_nnics++;
}
for (i = 0; i < vmc->vmc_nnics; i++) {
for (j = 0; j < vmcp->vmc_nnics; j++) {
	if (memcmp(zero_mac, vmc->vmc_macs[i],
	    sizeof(vmc->vmc_macs[i])) != 0 &&
	    memcmp(vmcp->vmc_macs[i], vmc->vmc_macs[i],
	    sizeof(vmc->vmc_macs[i])) != 0) {
		log_warnx("vm \"%s\" lladdr cannot be reused",
		    name);
		return (EBUSY16);
	}
	if (strlen(vmc->vmc_ifnames[i]) &&
	    strcmp(vmc->vmc_ifnames[i],
	    vmcp->vmc_ifnames[j]) == 0) {
		log_warnx("vm \"%s\" %s cannot be reused",
		    vmc->vmc_ifnames[i], name);
		return (EBUSY16);
	}
}
}

/* kernel */
if (vmc->vmc_kernel > -1 || ((*vm_parent)->vm_kernel_path != NULL((void *)0) &&
strnlen((*vm_parent)->vm_kernel_path, PATH_MAX1024) < PATH_MAX1024)) {
if (vm_checkinsflag(vmcp, VMOP_CREATE_KERNEL0x02, uid) != 0) {
	log_warnx("vm \"%s\" no permission to set boot image",
	    name);
	return (EPERM1);
}
vmc->vmc_checkaccess |= VMOP_CREATE_KERNEL0x02;
}

/* cdrom */
if (strlen(vmc->vmc_cdrom) > 0) {
if (vm_checkinsflag(vmcp, VMOP_CREATE_CDROM0x20, uid) != 0) {
	log_warnx("vm \"%s\" no permission to set cdrom", name);
	return (EPERM1);
}
vmc->vmc_checkaccess |= VMOP_CREATE_CDROM0x20;
} else if (strlcpy(vmc->vmc_cdrom, vmcp->vmc_cdrom,
   sizeof(vmc->vmc_cdrom)) >= sizeof(vmc->vmc_cdrom)) {
log_warnx("vm \"%s\" cdrom name too long", name);
return (EINVAL22);
}

/* user */
if (vmc->vmc_owner.uid == 0)
vmc->vmc_owner.uid = vmcp->vmc_owner.uid;
else if (vmc->vmc_owner.uid != uid &&
   vmc->vmc_owner.uid != vmcp->vmc_owner.uid) {
log_warnx("vm \"%s\" user mismatch", name);
return (EPERM1);
}

/* group */
if (vmc->vmc_owner.gid == 0)
vmc->vmc_owner.gid = vmcp->vmc_owner.gid;
else if (vmc->vmc_owner.gid != vmcp->vmc_owner.gid) {
log_warnx("vm \"%s\" group mismatch", name);
return (EPERM1);
}

/* child instances */
if (vmc->vmc_insflags) {
log_warnx("vm \"%s\" cannot change instance permissions", name);
return (EPERM1);
}
if (vmcp->vmc_insflags & VMOP_CREATE_INSTANCE0x40) {
vmc->vmc_insowner.gid = vmcp->vmc_insowner.gid;
vmc->vmc_insowner.uid = vmcp->vmc_insowner.gid;
vmc->vmc_insflags = vmcp->vmc_insflags;
} else {
vmc->vmc_insowner.gid = 0;
vmc->vmc_insowner.uid = 0;
vmc->vmc_insflags = 0;
}

/* finished, remove instance flags */
vmc->vmc_flags &= ~VMOP_CREATE_INSTANCE0x40;

return (0);
1689}

1691/*
* vm_checkperm
*
* Checks if the user represented by the 'uid' parameter is allowed to
* manipulate the VM described by the 'vm' parameter (or connect to said VM's
* console.)
*
* Parameters:
*  vm: the VM whose permission is to be checked
*  vmo: the required uid/gid to be checked
*  uid: the user ID of the user making the request
*
* Return values:
*   0: the permission should be granted
*  -1: the permission check failed (also returned if vm == null)
*/
1707int
1708vm_checkperm(struct vmd_vm *vm, struct vmop_owner *vmo, uid_t uid)
1709{
struct group	*gr;
struct passwd	*pw;
char		**grmem;

/* root has no restrictions */
if (uid == 0)
return (0);

if (vmo == NULL((void *)0))
return (-1);

/* check user */
if (vm == NULL((void *)0)) {
if  (vmo->uid == uid)
	return (0);
} else {
/*
 * check user of running vm (the owner of a running vm can
 * be different to (or more specific than) the configured owner.
 */
if (((vm->vm_state & VM_STATE_RUNNING0x01) && vm->vm_uid == uid) ||
    (!(vm->vm_state & VM_STATE_RUNNING0x01) && vmo->uid == uid))
	return (0);
}

/* check groups */
if (vmo->gid != -1) {
if ((pw = getpwuid(uid)) == NULL((void *)0))
	return (-1);
if (pw->pw_gid == vmo->gid)
	return (0);
if ((gr = getgrgid(vmo->gid)) != NULL((void *)0)) {
	for (grmem = gr->gr_mem; *grmem; grmem++)
		if (strcmp(*grmem, pw->pw_name) == 0)
			return (0);
}
}

return (-1);
1749}

1751/*
* vm_checkinsflag
*
* Checks whether the non-root user is allowed to set an instance option.
*
* Parameters:
*  vmc: the VM create parameters
*  flag: the flag to be checked
*  uid: the user ID of the user making the request
*
* Return values:
*   0: the permission should be granted
*  -1: the permission check failed (also returned if vm == null)
*/
1765int
1766vm_checkinsflag(struct vmop_create_params *vmc, unsigned int flag, uid_t uid)
1767{
/* root has no restrictions */
if (uid == 0)
return (0);

if ((vmc->vmc_insflags & flag) == 0)
return (-1);

return (0);
1776}

1778/*
* vm_checkaccess
*
* Checks if the user represented by the 'uid' parameter is allowed to
* access the file described by the 'path' parameter.
*
* Parameters:
*  fd: the file descriptor of the opened file
*  uflag: check if the userid has access to the file
*  uid: the user ID of the user making the request
*  amode: the access flags of R_OK and W_OK
*
* Return values:
*   0: the permission should be granted
*  -1: the permission check failed
*/
1794int
1795vm_checkaccess(int fd, unsigned int uflag, uid_t uid, int amode)
1796{
struct group	*gr;
struct passwd	*pw;
char		**grmem;
struct stat	 st;
mode_t		 mode;

if (fd == -1)
return (-1);

/*
* File has to be accessible and a regular file
*/
if (fstat(fd, &st) == -1 || !S_ISREG(st.st_mode)((st.st_mode & 0170000) == 0100000))
return (-1);

/* root has no restrictions */
if (uid == 0 || uflag == 0)
return (0);

/* check other */
mode = amode & W_OK0x02 ? S_IWOTH0000002 : 0;
mode |= amode & R_OK0x04 ? S_IROTH0000004 : 0;
if ((st.st_mode & mode) == mode)
return (0);

/* check user */
mode = amode & W_OK0x02 ? S_IWUSR0000200 : 0;
mode |= amode & R_OK0x04 ? S_IRUSR0000400 : 0;
if (uid == st.st_uid && (st.st_mode & mode) == mode)
return (0);

/* check groups */
mode = amode & W_OK0x02 ? S_IWGRP0000020 : 0;
mode |= amode & R_OK0x04 ? S_IRGRP0000040 : 0;
if ((st.st_mode & mode) != mode)
return (-1);
if ((pw = getpwuid(uid)) == NULL((void *)0))
return (-1);
if (pw->pw_gid == st.st_gid)
return (0);
if ((gr = getgrgid(st.st_gid)) != NULL((void *)0)) {
for (grmem = gr->gr_mem; *grmem; grmem++)
	if (strcmp(*grmem, pw->pw_name) == 0)
		return (0);
}

return (-1);
1844}

1846int
1847vm_opentty(struct vmd_vm *vm)
1848{
struct ptmget		 ptm;
struct stat		 st;
struct group		*gr;
uid_t			 uid;
gid_t			 gid;
mode_t			 mode;
int			 on;

/*
* Open tty with pre-opened PTM fd
*/
if ((ioctl(env->vmd_ptmfd, PTMGET((unsigned long)0x40000000 | ((sizeof(struct ptmget) & 0x1fff
) << 16) | ((('t')) << 8) | ((1))), &ptm) == -1))
return (-1);

/*
* We use user ioctl(2) mode to pass break commands.
*/
on = 1;
if (ioctl(ptm.cfd, TIOCUCNTL((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
 16) | ((('t')) << 8) | ((102))), &on) == -1)
fatal("could not enable user ioctl mode");

vm->vm_tty = ptm.cfd;
close(ptm.sfd);
if (strlcpy(vm->vm_ttyname, ptm.sn, sizeof(vm->vm_ttyname))
   >= sizeof(vm->vm_ttyname)) {
log_warnx("%s: truncated ttyname", __func__);
goto fail;
}

uid = vm->vm_uid;
gid = vm->vm_params.vmc_owner.gid;

if (vm->vm_params.vmc_owner.gid != -1) {
mode = 0660;
} else if ((gr = getgrnam("tty")) != NULL((void *)0)) {
gid = gr->gr_gid;
mode = 0620;
} else {
mode = 0600;
gid = 0;
}

log_debug("%s: vm %s tty %s uid %d gid %d mode %o",
   __func__, vm->vm_params.vmc_params.vcp_name,
   vm->vm_ttyname, uid, gid, mode);

/*
* Change ownership and mode of the tty as required.
* Loosely based on the implementation of sshpty.c
*/
if (stat(vm->vm_ttyname, &st) == -1)
goto fail;

if (st.st_uid != uid || st.st_gid != gid) {
if (chown(vm->vm_ttyname, uid, gid) == -1) {
	log_warn("chown %s %d %d failed, uid %d",
	    vm->vm_ttyname, uid, gid, getuid());

	/* Ignore failure on read-only filesystems */
	if (!((errno(*__errno()) == EROFS30) &&
	    (st.st_uid == uid || st.st_uid == 0)))
		goto fail;
}
}

if ((st.st_mode & (S_IRWXU0000700|S_IRWXG0000070|S_IRWXO0000007)) != mode) {
if (chmod(vm->vm_ttyname, mode) == -1) {
	log_warn("chmod %s %o failed, uid %d",
	    vm->vm_ttyname, mode, getuid());

	/* Ignore failure on read-only filesystems */
	if (!((errno(*__errno()) == EROFS30) &&
	    (st.st_uid == uid || st.st_uid == 0)))
		goto fail;
}
}

return (0);
fail:
vm_closetty(vm);
return (-1);
1930}

1932void
1933vm_closetty(struct vmd_vm *vm)
1934{
if (vm->vm_tty != -1) {
/* Release and close the tty */
if (fchown(vm->vm_tty, 0, 0) == -1)
	log_warn("chown %s 0 0 failed", vm->vm_ttyname);
if (fchmod(vm->vm_tty, 0666) == -1)
	log_warn("chmod %s 0666 failed", vm->vm_ttyname);
close(vm->vm_tty);
vm->vm_tty = -1;
}
memset(&vm->vm_ttyname, 0, sizeof(vm->vm_ttyname));
1945}

1947void
1948switch_remove(struct vmd_switch *vsw)
1949{
if (vsw == NULL((void *)0))
return;

TAILQ_REMOVE(env->vmd_switches, vsw, sw_entry)do { if (((vsw)->sw_entry.tqe_next) != ((void *)0)) (vsw)->
sw_entry.tqe_next->sw_entry.tqe_prev = (vsw)->sw_entry.
tqe_prev; else (env->vmd_switches)->tqh_last = (vsw)->
sw_entry.tqe_prev; *(vsw)->sw_entry.tqe_prev = (vsw)->sw_entry
.tqe_next; ; ; } while (0);

free(vsw->sw_group);
free(vsw->sw_name);
free(vsw);
1958}

1960struct vmd_switch *
1961switch_getbyname(const char *name)
1962{
struct vmd_switch	*vsw;

if (name == NULL((void *)0))
return (NULL((void *)0));
TAILQ_FOREACH(vsw, env->vmd_switches, sw_entry)for((vsw) = ((env->vmd_switches)->tqh_first); (vsw) != (
(void *)0); (vsw) = ((vsw)->sw_entry.tqe_next)) {
if (strcmp(vsw->sw_name, name) == 0)
	return (vsw);
}

return (NULL((void *)0));
1973}

1975char *
1976get_string(uint8_t *ptr, size_t len)
1977{
size_t	 i;

for (i = 0; i < len; i++)
if (!isprint((unsigned char)ptr[i]))
	break;

return strndup(ptr, i);
1985}

1987uint32_t
1988prefixlen2mask(uint8_t prefixlen)
1989{
if (prefixlen == 0)
return (0);

if (prefixlen > 32)
prefixlen = 32;

return (htonl(0xffffffff << (32 - prefixlen))(__uint32_t)(__builtin_constant_p(0xffffffff << (32 - prefixlen
)) ? (__uint32_t)(((__uint32_t)(0xffffffff << (32 - prefixlen
)) & 0xff) << 24 | ((__uint32_t)(0xffffffff <<
 (32 - prefixlen)) & 0xff00) << 8 | ((__uint32_t)(0xffffffff
 << (32 - prefixlen)) & 0xff0000) >> 8 | ((__uint32_t
)(0xffffffff << (32 - prefixlen)) & 0xff000000) >>
 24) : __swap32md(0xffffffff << (32 - prefixlen))));
1997}

1999void
2000prefixlen2mask6(uint8_t prefixlen, struct in6_addr *mask)
2001{
struct in6_addr	 s6;
int		 i;

if (prefixlen > 128)
prefixlen = 128;

memset(&s6, 0, sizeof(s6));
for (i = 0; i < prefixlen / 8; i++)
s6.s6_addr__u6_addr.__u6_addr8[i] = 0xff;
i = prefixlen % 8;
if (i)
s6.s6_addr__u6_addr.__u6_addr8[prefixlen / 8] = 0xff00 >> i;

memcpy(mask, &s6, sizeof(s6));
2016}

2018void
2019getmonotime(struct timeval *tv)
2020{
struct timespec	 ts;

if (clock_gettime(CLOCK_MONOTONIC3, &ts))
fatal("clock_gettime");

TIMESPEC_TO_TIMEVAL(tv, &ts)do { (tv)->tv_sec = (&ts)->tv_sec; (tv)->tv_usec
 = (&ts)->tv_nsec / 1000; } while (0);
2027}

2029static inline void
2030vm_terminate(struct vmd_vm *vm, const char *caller)
2031{
if (vm->vm_from_config)
vm_stop(vm, 0, caller);
else {
/* vm_remove calls vm_stop */
vm_remove(vm, caller);
}
2038}

2040/*
* Utility function for closing vm file descriptors. Assumes an fd of -1 was
* already closed or never opened.
*
* Returns 0 on success, otherwise -1 on failure.
*/
2046int
2047close_fd(int fd)
2048{
int	ret;

if (fd == -1)
return (0);

2054#ifdef POSIX_CLOSE_RESTART
do { ret = close(fd); } while (ret == -1 && errno(*__errno()) == EINTR4);
2056#else
ret = close(fd);
2058#endif /* POSIX_CLOSE_RESTART */

if (ret == -1 && errno(*__errno()) == EIO5)
log_warn("%s(%d)", __func__, fd);

return (ret);
2064}