config.c

一个Windows下的Linux专用虚拟机

	return CO_RC(OK);
}

static co_rc_t parse_args_networking_device_slirp(co_config_t *conf, int index, const char *param)
{
	co_netdev_desc_t *net_dev = &conf->net_devs[index];
	char mac_address[40];
	co_rc_t rc;

	comma_buffer_t array [] = {
		{ sizeof(mac_address), mac_address },
		{ sizeof(net_dev->redir), net_dev->redir },
		{ 0, NULL }
	};

	split_comma_separated(param, array);

	net_dev->type = CO_NETDEV_TYPE_SLIRP;
	net_dev->enabled = PTRUE;

	co_debug_info("configured Slirp as eth%d", index);

	rc = config_parse_mac_address(mac_address, net_dev);
	if (!CO_OK(rc))
		return rc;

	if (*net_dev->redir)
		co_debug_info("redirections %s", net_dev->redir);

	return CO_RC(OK);
}

static co_rc_t parse_args_networking_device(co_config_t *conf, int index, const char *param)
{
	const char *next = NULL;

	if (strmatch_identifier(param, "tuntap", &next)) {
		return parse_args_networking_device_tap(conf, index, next);
	} else if (strmatch_identifier(param, "pcap-bridge", &next)) {
		return parse_args_networking_device_pcap(conf, index, next);
	} else if (strmatch_identifier(param, "slirp", &next)) {
		return parse_args_networking_device_slirp(conf, index, next);
	} else {
		co_terminal_print("unsupported network transport type: %s\n", param);
		co_terminal_print("supported types are: tuntap, pcap-bridge, slirp\n");
		return CO_RC(INVALID_PARAMETER);
	}

	return CO_RC(OK);
}

static co_rc_t parse_args_networking(co_command_line_params_t cmdline, co_config_t *conf)
{
	bool_t exists;
	char *param;
	co_rc_t rc;

	do {
		int index;

		rc = co_cmdline_get_next_equality_int_prefix(cmdline, "eth", 
							     &index, CO_MODULE_MAX_CONET, 
							     &param, &exists);
		if (!CO_OK(rc))
			return rc;
		
		if (!exists)
			break;

		if (conf->net_devs[index].enabled) {
			co_terminal_print("eth%d double defined\n", index);
			return CO_RC(INVALID_PARAMETER);
		}

		rc = parse_args_networking_device(conf, index, param);
		if (!CO_OK(rc))
			return rc;
	} while (1);

	return CO_RC(OK);
}

static co_rc_t parse_args_cofs_device(co_config_t *conf, int index, const char *param)
{
	co_cofsdev_desc_t *cofs = &conf->cofs_devs[index];

	if (cofs->enabled) {
		co_terminal_print("warning cofs%d double defined\n", index);
		return CO_RC(INVALID_PARAMETER);
	}
	cofs->enabled = PTRUE;

	co_snprintf(cofs->pathname, sizeof(cofs->pathname), "%s", param);
	co_canonize_cobd_path(&cofs->pathname);
	co_debug_info("mapping cofs%d to %s", index, cofs->pathname);

	return CO_RC(OK);
}

static co_rc_t parse_args_config_cofs(co_command_line_params_t cmdline, co_config_t *conf)
{
	int index;
	bool_t exists;
	char *param;
	co_rc_t rc;

	do {
		rc = co_cmdline_get_next_equality_int_prefix(cmdline, "cofs", 
							     &index, CO_MODULE_MAX_COFS, 
							     &param, &exists);
		if (!CO_OK(rc))
			return rc;
		
		if (!exists)
			break;

		rc = parse_args_cofs_device(conf, index, param);
		if (!CO_OK(rc))
			return rc;
	} while (1);

	return CO_RC(OK);
}

static co_rc_t parse_args_serial_device(co_config_t *conf, int index, const char *param)
{
	co_serialdev_desc_t *serial = &conf->serial_devs[index];
	char name [CO_SERIAL_DESC_STR_SIZE];
	char mode [CO_SERIAL_MODE_STR_SIZE];

	comma_buffer_t array [] = {
		{ sizeof(name), name },
		{ sizeof(mode), mode },
		{ 0, NULL }
	};

	if (serial->enabled) {
		co_terminal_print("ttys%d double defined\n", index);
		return CO_RC(INVALID_PARAMETER);
	}
	serial->enabled = PTRUE;

	split_comma_separated(param, array);

	if (!*name) {
		co_terminal_print("missing host serial device name for ttys%d\n", index);
		return CO_RC(INVALID_PARAMETER);
	}

	co_debug_info("mapping ttys%d to %s", index, name);
	serial->desc = strdup(name);
	if (!serial->desc)
		return CO_RC(OUT_OF_MEMORY);
	
	if (*mode) {
		co_debug("mode: %s", mode);
		serial->mode = strdup(mode);
		if (!serial->mode)
			return CO_RC(OUT_OF_MEMORY);
	}

	return CO_RC(OK);
}

static co_rc_t parse_args_config_serial(co_command_line_params_t cmdline, co_config_t *conf)
{
	bool_t exists;
	char *param;
	co_rc_t rc;

	do {
		int index;

		rc = co_cmdline_get_next_equality_int_prefix(cmdline, "ttys", 
							     &index, CO_MODULE_MAX_SERIAL, 
							     &param, &exists);
		if (!CO_OK(rc)) 
			return rc;

		if (!exists)
			break;

		rc = parse_args_serial_device(conf, index, param);
		if (!CO_OK(rc)) 
			return rc;
	} while (1);

	return CO_RC(OK);
}

static co_rc_t parse_args_execute(co_config_t *conf, int index, const char *param)
{
	co_execute_desc_t *execute = &conf->executes[index];
	char prog [CO_EXECUTE_PROG_STR_SIZE];
	char args [CO_EXECUTE_ARGS_STR_SIZE];

	comma_buffer_t array [] = {
		{ sizeof(prog), prog },
		{ sizeof(args), args },
		{ 0, NULL }
	};

	if (execute->enabled) {
		co_terminal_print("exec%d double defined\n", index);
		return CO_RC(INVALID_PARAMETER);
	}
	execute->enabled = PTRUE;
	execute->pid = 0;

	split_comma_separated(param, array);

	if (!*prog) {
		co_terminal_print("missing program path for exec%d\n", index);
		return CO_RC(INVALID_PARAMETER);
	}

	co_debug("exec%d: '%s'", index, prog);
	execute->prog = strdup(prog);
	if (!execute->prog)
		return CO_RC(OUT_OF_MEMORY);
	
	if (*args) {
		co_debug("args%d: %s", index, args);
		execute->args = strdup(args);
		if (!execute->args)
			return CO_RC(OUT_OF_MEMORY);
	}

	return CO_RC(OK);
}

static co_rc_t parse_args_config_execute(co_command_line_params_t cmdline, co_config_t *conf)
{
	bool_t exists;
	char *param;
	co_rc_t rc;

	do {
		int index;

		rc = co_cmdline_get_next_equality_int_prefix(cmdline, "exec", 
							     &index, CO_MODULE_MAX_EXECUTE, 
							     &param, &exists);
		if (!CO_OK(rc)) 
			return rc;

		if (!exists)
			break;

		rc = parse_args_execute(conf, index, param);
		if (!CO_OK(rc)) 
			return rc;
	} while (1);

	return CO_RC(OK);
}

static co_rc_t parse_config_args(co_command_line_params_t cmdline, co_config_t *conf)
{
	co_rc_t rc;
	bool_t exists;

	rc = co_cmdline_get_next_equality_int_value(cmdline, "mem", (int *)&conf->ram_size, &exists);
	if (!CO_OK(rc)) 
		return rc;

	if (exists)
		co_debug_info("configuring %ld MB of virtual RAM", conf->ram_size);

	rc = parse_args_config_cobd(cmdline, conf);
	if (!CO_OK(rc))
		return rc;

	rc = parse_args_config_aliases(cmdline, conf);
	if (!CO_OK(rc))
		return rc;

	rc = parse_args_networking(cmdline, conf);
	if (!CO_OK(rc))
		return rc;

	rc = parse_args_config_cofs(cmdline, conf);
	if (!CO_OK(rc))
		return rc;

	rc = co_cmdline_get_next_equality(cmdline, "initrd", 0, NULL, 0, 
					  conf->initrd_path, sizeof(conf->initrd_path),
					  &conf->initrd_enabled);
	if (!CO_OK(rc)) 
		return rc;

	if (conf->initrd_enabled) {
		co_remove_quotation_marks(conf->initrd_path);
		co_debug_info("using '%s' as initrd image", conf->initrd_path);

		/* Is last cofs free for automatic set? */
		if (!conf->cofs_devs[CO_MODULE_MAX_COFS-1].enabled) {
			char *param;

			/* copy path from initrd file */
			param = strdup(conf->initrd_path);
			if (!param)
				return CO_RC(OUT_OF_MEMORY);

			/* get only the directory */
			co_dirname(param);

			if (*param)
				rc = parse_args_cofs_device(conf, CO_MODULE_MAX_COFS-1, param);

			co_os_free (param);

			if (!CO_OK(rc))
				return rc;
		}
	}

	rc = parse_args_config_serial(cmdline, conf);
	if (!CO_OK(rc))
		return rc;

	rc = parse_args_config_execute(cmdline, conf);
	if (!CO_OK(rc))
		return rc;

	return rc;
}

co_rc_t co_parse_config_args(co_command_line_params_t cmdline, co_start_parameters_t *start_parameters)
{
	co_rc_t rc, rc_;
	co_config_t *conf = &start_parameters->config;

	start_parameters->cmdline_config = PFALSE;

	rc = co_cmdline_get_next_equality(cmdline, "kernel", 0, NULL, 0, 
					  conf->vmlinux_path, sizeof(conf->vmlinux_path),
					  &start_parameters->cmdline_config);
	if (!CO_OK(rc))
		return rc;

	if (!start_parameters->cmdline_config)
		return CO_RC(OK);

	co_remove_quotation_marks(conf->vmlinux_path);
	co_debug_info("using '%s' as kernel image", conf->vmlinux_path);

	rc = parse_config_args(cmdline, conf);
	
	rc_ = co_cmdline_params_format_remaining_parameters(cmdline, conf->boot_parameters_line,
							    sizeof(conf->boot_parameters_line));
	if (!CO_OK(rc_))
		return rc_;
	
	if (CO_OK(rc)) {
		co_debug_info("kernel boot parameters: '%s'", conf->boot_parameters_line);
		start_parameters->config_specified = PTRUE;
	}

	return rc;
}