static void
_ipmi_dcmi_config_file_parse (struct ipmi_dcmi_arguments *cmd_args)
{
struct config_file_data_ipmi_dcmi config_file_data;
assert (cmd_args);
memset (&config_file_data,
'\0',
sizeof (struct config_file_data_ipmi_dcmi));
if (config_file_parse (cmd_args->common_args.config_file,
0,
&(cmd_args->common_args),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_TIME | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_IPMI_DCMI,
&config_file_data) < 0)
{
fprintf (stderr, "config_file_parse: %s\n", strerror (errno));
exit (EXIT_FAILURE);
}
if (config_file_data.interpret_oem_data_count)
cmd_args->interpret_oem_data = config_file_data.interpret_oem_data;
}
/****************************************************************************
* main
*
* @param argc argument count
* @param argv argument list
* @return int return code
***************************************************************************/
int
main(int argc, char *argv[])
{
config_t config;
char config_file[NAME_MAX+1];
bool fflag = false; /* option: config-file */
int opt; /* argument for getopt() as a single integer */
/* program without arguments */
if (argc == 1) {
usage(argc, argv, NULL);
}
/* first character ':' of getopt()'s optstring sets opterr=0 and
returns ':' to indicate a missing option argument
or '?' to indicate a unrecognised option */
while ((opt = getopt(argc, argv, ":l:df:")) != -1) {
switch (opt) {
/* option: config-file */
case 'f':
strcpy(config_file, optarg);
fflag = true;
break;
/* missing option argument */
case ':':
usage(argc, argv, OPT_REQUIRED);
break;
/* unrecognised option */
case '?':
usage(argc, argv, OPT_UNRECOGNISED);
break;
default:
usage(argc, argv, NULL);
}
}
log_init();
/* option: config-file */
if (!fflag) {
strcpy(config_file, CONFIG_FILE_NAME);
}
LOG_PRINTLN(LOG_SIM, LOG_INFO, ("Using config-file \"%s\"", config_file));
if (!config_file_parse(config_file, &config)) {
printf("Error in parsing the file!\n");
exit(EXIT_FAILURE);
}
do_simulation(&config);
fprintf(stderr, "Exit!\n");
return 0;
}
static void
_ipmi_fru_config_file_parse (struct ipmi_fru_arguments *cmd_args)
{
struct config_file_data_ipmi_fru config_file_data;
assert (cmd_args);
memset (&config_file_data,
'\0',
sizeof (struct config_file_data_ipmi_fru));
if (config_file_parse (cmd_args->common_args.config_file,
0,
&(cmd_args->common_args),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_SDR | CONFIG_FILE_TIME | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_IPMI_FRU,
&config_file_data) < 0)
{
fprintf (stderr, "config_file_parse: %s\n", strerror (errno));
exit (EXIT_FAILURE);
}
if (config_file_data.verbose_count_count)
cmd_args->verbose_count = config_file_data.verbose_count;
/* legacy */
if (config_file_data.skip_checks_count)
cmd_args->skip_checks = config_file_data.skip_checks;
if (config_file_data.bridge_fru_count)
cmd_args->bridge_fru = config_file_data.bridge_fru;
if (config_file_data.interpret_oem_data_count)
cmd_args->interpret_oem_data = config_file_data.interpret_oem_data;
}
static void
_ipmi_oem_config_file_parse (struct ipmi_oem_arguments *cmd_args)
{
struct config_file_data_ipmi_oem config_file_data;
assert (cmd_args);
memset (&config_file_data,
'\0',
sizeof (struct config_file_data_ipmi_oem));
if (config_file_parse (cmd_args->common_args.config_file,
0,
&(cmd_args->common_args),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_SDR | CONFIG_FILE_TIME | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_IPMI_OEM,
&config_file_data) < 0)
{
fprintf (stderr, "config_file_parse: %s\n", strerror (errno));
exit (EXIT_FAILURE);
}
if (config_file_data.verbose_count_count)
cmd_args->verbose_count = config_file_data.verbose_count;
}
static void
_ipmi_fru_config_file_parse(struct ipmi_fru_arguments *cmd_args)
{
struct config_file_data_ipmi_fru config_file_data;
memset(&config_file_data,
'\0',
sizeof(struct config_file_data_ipmi_fru));
if (config_file_parse (cmd_args->common.config_file,
0,
&(cmd_args->common),
&(cmd_args->sdr),
&(cmd_args->hostrange),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_SDR | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_IPMI_FRU,
&config_file_data) < 0)
{
fprintf(stderr, "config_file_parse: %s\n", strerror(errno));
exit(1);
}
if (config_file_data.skip_checks_count)
cmd_args->skip_checks = config_file_data.skip_checks;
}
static void
_ipmiconsole_config_file_parse (struct ipmiconsole_arguments *cmd_args)
{
struct config_file_data_ipmiconsole config_file_data;
assert (cmd_args);
memset (&config_file_data,
'\0',
sizeof (struct config_file_data_ipmiconsole));
if (!cmd_args->common_args.config_file)
{
/* try legacy file first */
if (!config_file_parse (IPMICONSOLE_CONFIG_FILE_LEGACY,
1, /* do not exit if file not found */
&(cmd_args->common_args),
CONFIG_FILE_OUTOFBAND,
CONFIG_FILE_TOOL_IPMICONSOLE,
&config_file_data))
goto out;
}
if (config_file_parse (cmd_args->common_args.config_file,
0,
&(cmd_args->common_args),
CONFIG_FILE_OUTOFBAND,
CONFIG_FILE_TOOL_IPMICONSOLE,
&config_file_data) < 0)
{
fprintf (stderr, "config_file_parse: %s\n", strerror (errno));
exit (EXIT_FAILURE);
}
out:
if (config_file_data.escape_char_count)
cmd_args->escape_char = config_file_data.escape_char;
if (config_file_data.dont_steal_count)
cmd_args->dont_steal = config_file_data.dont_steal;
if (config_file_data.serial_keepalive_count)
cmd_args->serial_keepalive = config_file_data.serial_keepalive;
if (config_file_data.serial_keepalive_empty_count)
cmd_args->serial_keepalive_empty = config_file_data.serial_keepalive_empty;
if (config_file_data.lock_memory_count)
cmd_args->lock_memory = config_file_data.lock_memory;
}
/**
* <EN>
* Load parameters from a jconf file and set to each configuration
* instances in jconf.
* </EN>
* <JA>
* jconf ファイルからパラメータを読み込み，jconf 内の各設定インスタンスに
* 値を格納する.
* </JA>
*
* @param jconf [i/o] glbal configuration instance
* @param filename [in] jconf filename
*
* @return 0 on sucess, or -1 on failure.
*
* @callgraph
* @callergraph
* @ingroup jconf
*/
int
j_config_load_file(Jconf *jconf, char *filename)
{
/* parse options and set variables */
if (config_file_parse(filename, jconf) == FALSE) {
return -1;
}
/* if multiple instances defined from init, remove initial one (id=0) */
j_config_remove_initial(jconf);
return 0;
}
static void command_environment(int argc, char **argv)
{
#ifndef CLEANUP_DESTRUCTOR
gchar *progname;
#endif
gchar *config_file = NULL;
gboolean quiet = FALSE, verbose = FALSE, lint = FALSE;
GOptionEntry optionsTable[] = {
{ "config", 'f', 0, G_OPTION_ARG_STRING, &config_file,
"specify configuration file", NULL },
{ "quiet", 'q', 0, G_OPTION_ARG_NONE, &quiet,
"show as little output as possible", NULL },
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"output to standard error (debug)", NULL },
{ "version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, show_version,
"print version information and exit", NULL },
{ "lint", 'l', 0, G_OPTION_ARG_NONE, &lint,
"check the configuration file for errors, then exit", NULL },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
GError *error = NULL;
GOptionContext *context = g_option_context_new("");
g_option_context_add_main_entries(context, optionsTable, PACKAGE_TARNAME);
g_option_context_parse(context, &argc, &argv, &error);
g_option_context_free(context);
if ( error != NULL ) {
fnc_log(FNC_LOG_FATAL, "%s", error->message);
exit(1);
}
if (!quiet && !lint) fncheader();
config_file_parse(config_file, lint);
g_free(config_file);
/* if we're doing a verbose run, make sure to output
everything directly on standard error.
*/
if ( verbose ) {
feng_srv.log_level = FNC_LOG_INFO;
feng_srv.error_log = "stderr";
}
progname = g_path_get_basename(argv[0]);
fnc_log_init(progname);
}
static void
_ipmi_chassis_config_file_parse (struct ipmi_chassis_arguments *cmd_args)
{
assert (cmd_args);
if (config_file_parse (cmd_args->common_args.config_file,
0,
&(cmd_args->common_args),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_IPMI_CHASSIS,
NULL) < 0)
{
fprintf (stderr, "config_file_parse: %s\n", strerror (errno));
exit (EXIT_FAILURE);
}
}
static void
_bmc_device_config_file_parse (struct bmc_device_arguments *cmd_args)
{
assert (cmd_args);
if (config_file_parse (cmd_args->common_args.config_file,
0,
&(cmd_args->common_args),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_SDR | CONFIG_FILE_TIME | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_BMC_DEVICE,
NULL) < 0)
{
fprintf (stderr, "config_file_parse: %s\n", strerror (errno));
exit (EXIT_FAILURE);
}
}
static void
_ipmi_sensors_config_file_parse(struct ipmi_sensors_arguments *cmd_args)
{
struct config_file_data_ipmi_sensors config_file_data;
memset(&config_file_data,
'\0',
sizeof(struct config_file_data_ipmi_sensors));
if (config_file_parse (cmd_args->common.config_file,
0,
&(cmd_args->common),
&(cmd_args->sdr),
&(cmd_args->hostrange),
CONFIG_FILE_INBAND | CONFIG_FILE_OUTOFBAND | CONFIG_FILE_SDR | CONFIG_FILE_HOSTRANGE,
CONFIG_FILE_TOOL_IPMI_SENSORS,
&config_file_data) < 0)
{
fprintf(stderr, "config_file_parse: %s\n", strerror(errno));
exit(1);
}
if (config_file_data.quiet_readings_count)
cmd_args->quiet_readings = config_file_data.quiet_readings;
if (config_file_data.groups_count && config_file_data.groups_length)
{
int i;
assert(IPMI_SENSORS_MAX_GROUPS == CONFIG_FILE_IPMI_SENSORS_MAX_GROUPS);
assert(IPMI_SENSORS_MAX_GROUPS_STRING_LENGTH == CONFIG_FILE_IPMI_SENSORS_MAX_GROUPS_STRING_LENGTH);
for (i = 0; i < config_file_data.groups_length; i++)
strncpy(cmd_args->groups[i],
config_file_data.groups[i],
IPMI_SENSORS_MAX_GROUPS_STRING_LENGTH);
cmd_args->groups_wanted++;
cmd_args->groups_length = config_file_data.groups_length;
}
if (config_file_data.bridge_sensors_count)
cmd_args->bridge_sensors = config_file_data.bridge_sensors;
}
static void parse_argument(int c, char* value, PCONFIGURATION config) {
switch (c) {
case 'a':
config->stream.width = 1280;
config->stream.height = 720;
break;
case 'b':
config->stream.width = 1920;
config->stream.height = 1080;
break;
case 'c':
config->stream.width = atoi(value);
break;
case 'd':
config->stream.height = atoi(value);
break;
case 'e':
config->stream.fps = 30;
break;
case 'f':
config->stream.fps = 60;
break;
case 'g':
config->stream.bitrate = atoi(value);
break;
case 'h':
config->stream.packetSize = atoi(value);
break;
case 'i':
config->app = value;
break;
case 'j':
if (config->inputsCount >= MAX_INPUTS) {
perror("Too many inputs specified");
exit(-1);
}
config->inputs[config->inputsCount].path = value;
config->inputs[config->inputsCount].mapping = value;
config->inputsCount++;
inputAdded = true;
mapped = true;
break;
case 'k':
config->mapping = get_path(value, getenv("XDG_DATA_DIRS"));
if (config->mapping == NULL) {
fprintf(stderr, "Unable to open custom mapping file: %s\n", value);
exit(-1);
}
mapped = false;
break;
case 'l':
config->sops = false;
break;
case 'm':
audio_device = value;
break;
case 'n':
config->localaudio = true;
break;
case 'o':
if (!config_file_parse(value, config))
exit(EXIT_FAILURE);
break;
case 'p':
config->platform = value;
break;
case 'q':
config->config_file = value;
break;
case 'r':
strcpy(config->key_dir, value);
break;
case 's':
config->stream.streamingRemotely = 1;
break;
case 1:
if (config->action == NULL)
config->action = value;
else if (config->address == NULL)
config->address = value;
else {
perror("Too many options");
exit(-1);
}
}
}
int main(int argc, char* argv[]) {
printf("Moonlight Embedded %d.%d.%d (%s)\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, COMPILE_OPTIONS);
CONFIGURATION config;
config_parse(argc, argv, &config);
if (config.action == NULL || strcmp("help", config.action) == 0)
help();
enum platform system = platform_check(config.platform);
if (system == 0) {
fprintf(stderr, "Platform '%s' not found\n", config.platform);
exit(-1);
}
config.stream.supportsHevc = config.stream.supportsHevc || platform_supports_hevc(system);
if (strcmp("map", config.action) == 0) {
if (config.address == NULL) {
perror("No filename for mapping");
exit(-1);
}
udev_init(!inputAdded, config.mapping);
for (int i=0;i<config.inputsCount;i++)
evdev_create(config.inputs[i].path, config.inputs[i].mapping);
evdev_map(config.address);
exit(0);
}
if (config.address == NULL) {
config.address = malloc(MAX_ADDRESS_SIZE);
if (config.address == NULL) {
perror("Not enough memory");
exit(-1);
}
config.address[0] = 0;
printf("Searching for server...\n");
gs_discover_server(config.address);
if (config.address[0] == 0) {
fprintf(stderr, "Autodiscovery failed. Specify an IP address next time.\n");
exit(-1);
}
}
char host_config_file[128];
sprintf(host_config_file, "hosts/%s.conf", config.address);
if (access(host_config_file, R_OK) != -1)
config_file_parse(host_config_file, &config);
SERVER_DATA server;
server.address = config.address;
printf("Connect to %s...\n", server.address);
int ret;
if ((ret = gs_init(&server, config.key_dir)) == GS_OUT_OF_MEMORY) {
fprintf(stderr, "Not enough memory\n");
exit(-1);
} else if (ret == GS_INVALID) {
fprintf(stderr, "Invalid data received from server: %s\n", config.address, gs_error);
exit(-1);
} else if (ret == GS_UNSUPPORTED_VERSION) {
if (!config.unsupported_version) {
fprintf(stderr, "Unsupported version: %s\n", gs_error);
exit(-1);
}
} else if (ret != GS_OK) {
fprintf(stderr, "Can't connect to server %s\n", config.address);
exit(-1);
}
printf("NVIDIA %s, GFE %s (protocol version %d)\n", server.gpuType, server.gfeVersion, server.serverMajorVersion);
if (strcmp("list", config.action) == 0) {
pair_check(&server);
applist(&server);
} else if (strcmp("stream", config.action) == 0) {
pair_check(&server);
if (IS_EMBEDDED(system)) {
for (int i=0;i<config.inputsCount;i++) {
printf("Add input %s (mapping %s)...\n", config.inputs[i].path, config.inputs[i].mapping);
evdev_create(config.inputs[i].path, config.inputs[i].mapping);
}
udev_init(!inputAdded, config.mapping);
evdev_init();
#ifdef HAVE_LIBCEC
cec_init();
#endif /* HAVE_LIBCEC */
}
#ifdef HAVE_SDL
else if (system == SDL)
sdl_init(config.stream.width, config.stream.height, config.fullscreen);
#endif
stream(&server, &config, system);
} else if (strcmp("pair", config.action) == 0) {
char pin[5];
sprintf(pin, "%d%d%d%d", (int)random() % 10, (int)random() % 10, (int)random() % 10, (int)random() % 10);
printf("Please enter the following PIN on the target PC: %s\n", pin);
if (gs_pair(&server, &pin[0]) != GS_OK) {
fprintf(stderr, "Failed to pair to server: %s\n", gs_error);
} else {
printf("Succesfully paired\n");
}
} else if (strcmp("unpair", config.action) == 0) {
if (gs_unpair(&server) != GS_OK) {
fprintf(stderr, "Failed to unpair to server: %s\n", gs_error);
} else {
printf("Succesfully unpaired\n");
}
} else if (strcmp("quit", config.action) == 0) {
pair_check(&server);
gs_quit_app(&server);
} else
fprintf(stderr, "%s is not a valid action\n", config.action);
}
void config_parse(int argc, char* argv[], PCONFIGURATION config) {
config->stream.width = 1280;
config->stream.height = 720;
config->stream.fps = 60;
config->stream.bitrate = -1;
config->stream.packetSize = 1024;
config->stream.streamingRemotely = 0;
config->platform = "default";
config->app = "Steam";
config->action = NULL;
config->address = NULL;
config->config_file = NULL;
config->sops = true;
config->localaudio = false;
config->inputsCount = 0;
config->mapping = get_path("mappings/default.conf", getenv("XDG_DATA_DIRS"));
config->key_dir[0] = 0;
char* config_file = get_path("moonlight.conf", "/etc");
if (config_file)
config_file_parse(config_file, config);
if (argc == 2 && access(argv[1], F_OK) == 0) {
config->action = "stream";
if (!config_file_parse(argv[1], config))
exit(EXIT_FAILURE);
} else {
int option_index = 0;
int c;
while ((c = getopt_long_only(argc, argv, "-abc:d:efg:h:i:j:k:lm:no:p:q:r:s", long_options, &option_index)) != -1) {
parse_argument(c, optarg, config);
}
}
if (config->config_file != NULL)
config_save(config->config_file, config);
if (config->key_dir[0] == 0x0) {
const char *xdg_cache_dir = getenv("XDG_CACHE_DIR");
if (xdg_cache_dir != NULL)
sprintf(config->key_dir, "%s" MOONLIGHT_PATH, xdg_cache_dir);
else {
const char *home_dir = getenv("HOME");
sprintf(config->key_dir, "%s" DEFAULT_CACHE_DIR MOONLIGHT_PATH, home_dir);
}
}
if (config->stream.bitrate == -1) {
if (config->stream.height >= 1080 && config->stream.fps >= 60)
config->stream.bitrate = 20000;
else if (config->stream.height >= 1080 || config->stream.fps >= 60)
config->stream.bitrate = 10000;
else
config->stream.bitrate = 5000;
}
if (inputAdded && !mapped) {
fprintf(stderr, "Mapping option should be followed by the input to be mapped.\n");
exit(-1);
}
}
static config_file_t *config_file_load_internal(config_file_t *parent, const char *filename)
{
struct stat sb;
FILE *fp;
size_t ret;
char *buf = NULL;
config_file_t *cfptr;
static int nestcnt;
if (nestcnt > MAX_INCLUDE_NESTING)
{
config_file_error(parent, "Includes nested too deep \"%s\"\n", filename);
return NULL;
}
fp = fopen(filename, "rb");
if (!fp)
{
config_file_error(parent, "Couldn't open \"%s\": %s\n", filename, strerror(errno));
return NULL;
}
if (stat(filename, &sb) == -1)
{
config_file_error(parent, "Couldn't fstat \"%s\": %s\n", filename, strerror(errno));
fclose(fp);
return NULL;
}
if (!S_ISREG(sb.st_mode))
{
config_file_error(parent, "Not a regular file: \"%s\"\n", filename);
fclose(fp);
return NULL;
}
if (sb.st_size > SSIZE_MAX - 1)
{
config_file_error(parent, "File too large: \"%s\"\n", filename);
fclose(fp);
return NULL;
}
buf = (char *) alloc(sb.st_size + 1);
memset(buf, 0, sb.st_size+1);
if (sb.st_size)
{
errno = 0;
ret = fread(buf, 1, sb.st_size, fp);
if (ret != (size_t)sb.st_size)
{
config_file_error(parent, "Error reading \"%s\": %s\n", filename, strerror(errno ? errno : EFAULT));
free(buf);
fclose(fp);
return NULL;
}
}
else
ret = 0;
buf[ret] = '\0';
fclose(fp);
nestcnt++;
cfptr = config_file_parse(filename, buf);
nestcnt--;
/* buf is owned by cfptr or freed now */
return cfptr;
}
void memory_typicall(void)
{
AbstractMemory *mem;
StatisticsInfo *info;
ConfigFile *cfg;
MemoryCell cells[8];
char conf_file[] = "test_config_file.txt";
FILE *cfg_f = NULL;
cfg_f = fopen(conf_file, "w");
fprintf(cfg_f, "memory_size = %d\n memory_read_time = 4\n memory_write_time = 8\n memory_width = 4\n", 16 * KiB);
fclose(cfg_f);
cfg = config_file_parse(conf_file, stderr);
unlink(conf_file);
info = statistics_create(cfg);
mem = memory_create(cfg, NULL, info);
CU_ASSERT_NOT_EQUAL(mem, NULL);
mem->ops->read(mem, 15, 1, cells);
CU_ASSERT_EQUAL(cells[0].flags, 0);
CU_ASSERT_EQUAL(info->clock_counter, 4);
mem->ops->read(mem, 13, 4, cells);
CU_ASSERT_EQUAL(cells[0].flags, 0);
CU_ASSERT_EQUAL(cells[1].flags, 0);
CU_ASSERT_EQUAL(cells[2].flags, 0);
CU_ASSERT_EQUAL(cells[3].flags, 0);
CU_ASSERT_EQUAL(info->clock_counter, 8);
mem->ops->read(mem, 13, 8, cells);
CU_ASSERT_EQUAL(info->clock_counter, 16);
cells[0].flags = 1;
cells[0].value = 0xFF;
cells[1].flags = 1;
cells[1].value = 183;
cells[2].flags = 0;
mem->ops->write(mem, 1, 2, cells);
CU_ASSERT_EQUAL(info->clock_counter, 24);
memset(cells, 0, sizeof(cells));
mem->ops->read(mem, 1, 2, cells);
CU_ASSERT_EQUAL(cells[0].value, 0xFF);
CU_ASSERT_EQUAL(cells[0].flags, 1);
CU_ASSERT_EQUAL(cells[1].value, 183);
CU_ASSERT_EQUAL(cells[1].flags, 1);
CU_ASSERT_EQUAL(cells[2].flags, 0);
CU_ASSERT_EQUAL(info->clock_counter, 28);
cells[0].flags = 1;
cells[0].value = 0;
cells[1].flags = 1;
cells[1].value = 73;
cells[2].flags = 0;
mem->ops->reveal(mem, 0, 2, cells);
CU_ASSERT_EQUAL(info->clock_counter, 28);
memset(cells, 0, sizeof(cells));
mem->ops->read(mem, 0, 4, cells);
CU_ASSERT_EQUAL(cells[0].value, 0);
CU_ASSERT_EQUAL(cells[0].flags, 1);
CU_ASSERT_EQUAL(cells[1].value, 73);
CU_ASSERT_EQUAL(cells[1].flags, 1);
CU_ASSERT_EQUAL(cells[2].value, 183);
CU_ASSERT_EQUAL(cells[2].flags, 1);
CU_ASSERT_EQUAL(cells[3].flags, 0);
CU_ASSERT_EQUAL(info->clock_counter, 32);
// FIXME: add tests
CU_ASSERT_EQUAL(mem->ops->free(mem), NULL);
}
void config_parse(int argc, char* argv[], PCONFIGURATION config) {
LiInitializeStreamConfiguration(&config->stream);
config->stream.width = 1280;
config->stream.height = 720;
config->stream.fps = -1;
config->stream.bitrate = -1;
config->stream.packetSize = 1024;
config->stream.streamingRemotely = 0;
config->stream.audioConfiguration = AUDIO_CONFIGURATION_STEREO;
config->stream.supportsHevc = false;
config->debug_level = 0;
config->platform = "auto";
config->app = "Steam";
config->action = NULL;
config->address = NULL;
config->config_file = NULL;
config->audio_device = NULL;
config->sops = true;
config->localaudio = false;
config->fullscreen = true;
config->unsupported = false;
config->codec = CODEC_UNSPECIFIED;
config->inputsCount = 0;
config->mapping = get_path("gamecontrollerdb.txt", getenv("XDG_DATA_DIRS"));
config->key_dir[0] = 0;
char* config_file = get_path("moonlight.conf", "/etc");
if (config_file)
config_file_parse(config_file, config);
if (argc == 2 && access(argv[1], F_OK) == 0) {
config->action = "stream";
if (!config_file_parse(argv[1], config))
exit(EXIT_FAILURE);
} else {
int option_index = 0;
int c;
while ((c = getopt_long_only(argc, argv, "-abc:d:efg:h:i:j:k:lm:no:p:q:r:stuv:w:xy", long_options, &option_index)) != -1) {
parse_argument(c, optarg, config);
}
}
if (config->config_file != NULL)
config_save(config->config_file, config);
if (config->key_dir[0] == 0x0) {
struct passwd *pw = getpwuid(getuid());
const char *dir;
if ((dir = getenv("XDG_CACHE_DIR")) != NULL)
sprintf(config->key_dir, "%s" MOONLIGHT_PATH, dir);
else if ((dir = getenv("HOME")) != NULL)
sprintf(config->key_dir, "%s" DEFAULT_CACHE_DIR MOONLIGHT_PATH, dir);
else
sprintf(config->key_dir, "%s" DEFAULT_CACHE_DIR MOONLIGHT_PATH, pw->pw_dir);
}
if (config->stream.fps == -1)
config->stream.fps = config->stream.height >= 1080 ? 30 : 60;
if (config->stream.bitrate == -1) {
if (config->stream.height >= 1080 && config->stream.fps >= 60)
config->stream.bitrate = 20000;
else if (config->stream.height >= 1080 || config->stream.fps >= 60)
config->stream.bitrate = 10000;
else
config->stream.bitrate = 5000;
}
}
int main(int argc, char* argv[]) {
CONFIGURATION config;
config_parse(argc, argv, &config);
if (config.action == NULL || strcmp("help", config.action) == 0)
help();
enum platform system = platform_check(config.platform);
if (system == 0) {
fprintf(stderr, "Platform '%s' not found\n", config.platform);
exit(-1);
}
if (strcmp("map", config.action) == 0) {
if (config.address == NULL) {
perror("No filename for mapping");
exit(-1);
}
udev_init(!inputAdded, config.mapping);
for (int i=0;i<config.inputsCount;i++)
evdev_create(config.inputs[i].path, config.inputs[i].mapping);
evdev_map(config.address);
exit(0);
}
if (config.address == NULL) {
config.address = malloc(MAX_ADDRESS_SIZE);
if (config.address == NULL) {
perror("Not enough memory");
exit(-1);
}
config.address[0] = 0;
gs_discover_server(config.address);
if (config.address[0] == 0) {
fprintf(stderr, "Autodiscovery failed. Specify an IP address next time.\n");
exit(-1);
}
}
char host_config_file[128];
sprintf(host_config_file, "hosts/%s.conf", config.address);
config_file_parse(host_config_file, &config);
SERVER_DATA server;
server.address = config.address;
int ret;
if ((ret = gs_init(&server, config.key_dir)) == GS_OUT_OF_MEMORY) {
fprintf(stderr, "Not enough memory\n");
exit(-1);
} else if (ret == GS_INVALID) {
fprintf(stderr, "Invalid data received from server: %s\n", config.address, gs_error);
exit(-1);
} else if (ret != GS_OK) {
fprintf(stderr, "Can't connect to server %s\n", config.address);
exit(-1);
}
if (strcmp("list", config.action) == 0) {
pair_check(&server);
applist(&server);
} else if (strcmp("stream", config.action) == 0) {
pair_check(&server);
if (IS_EMBEDDED(system)) {
for (int i=0;i<config.inputsCount;i++)
evdev_create(config.inputs[i].path, config.inputs[i].mapping);
udev_init(!inputAdded, config.mapping);
evdev_init();
#ifdef HAVE_LIBCEC
cec_init();
#endif /* HAVE_LIBCEC */
}
#ifdef HAVE_SDL
else if (system == SDL)
sdl_init(config.stream.width, config.stream.height);
#endif
stream(&server, &config, system);
} else if (strcmp("pair", config.action) == 0) {
char pin[5];
sprintf(pin, "%d%d%d%d", (int)random() % 10, (int)random() % 10, (int)random() % 10, (int)random() % 10);
printf("Please enter the following PIN on the target PC: %s\n", pin);
if (gs_pair(&server, &pin[0]) != GS_OK) {
fprintf(stderr, "Failed to pair to server: %s\n", gs_error);
} else {
printf("Succesfully paired\n");
}
} else if (strcmp("quit", config.action) == 0) {
pair_check(&server);
gs_quit_app(&server);
} else
fprintf(stderr, "%s is not a valid action\n", config.action);
}
void config_parse_cli(int argc, char **argv, stud_config *cfg) {
static int tls = 0, ssl = 0;
static int client = 0;
int c, i;
int test_only = 0;
char *prog;
struct option long_options[] = {
#ifndef NO_CONFIG_FILE
{ CFG_CONFIG, 1, NULL, CFG_PARAM_CFGFILE },
{ CFG_CONFIG_DEFAULT, 0, NULL, CFG_PARAM_DEFCFG },
#endif
{ "tls", 0, &tls, 1},
{ "ssl", 0, &ssl, 1},
{ "client", 0, &client, 1},
{ CFG_CIPHERS, 1, NULL, 'c' },
{ CFG_PREFER_SERVER_CIPHERS, 0, NULL, 'O' },
{ CFG_BACKEND, 1, NULL, 'b' },
{ CFG_FRONTEND, 1, NULL, 'f' },
{ CFG_WORKERS, 1, NULL, 'n' },
{ CFG_BACKLOG, 1, NULL, 'B' },
#ifdef USE_SHARED_CACHE
{ CFG_SHARED_CACHE, 1, NULL, 'C' },
{ CFG_SHARED_CACHE_LISTEN, 1, NULL, 'U' },
{ CFG_SHARED_CACHE_PEER, 1, NULL, 'P' },
{ CFG_SHARED_CACHE_MCASTIF, 1, NULL, 'M' },
#endif
{ CFG_KEEPALIVE, 1, NULL, 'k' },
{ CFG_CHROOT, 1, NULL, 'r' },
{ CFG_USER, 1, NULL, 'u' },
{ CFG_GROUP, 1, NULL, 'g' },
{ CFG_QUIET, 0, NULL, 'q' },
{ CFG_SYSLOG, 0, NULL, 's' },
{ CFG_SYSLOG_FACILITY, 1, NULL, CFG_PARAM_SYSLOG_FACILITY },
{ CFG_DAEMON, 0, &cfg->DAEMONIZE, 1 },
{ CFG_WRITE_IP, 0, &cfg->WRITE_IP_OCTET, 1 },
{ CFG_WRITE_PROXY, 0, &cfg->WRITE_PROXY_LINE, 1 },
{ CFG_PROXY_PROXY, 0, &cfg->PROXY_PROXY_LINE, 1 },
{ "test", 0, NULL, 't' },
{ "version", 0, NULL, 'V' },
{ "help", 0, NULL, 'h' },
{ 0, 0, 0, 0 }
};
while (1) {
int option_index = 0;
c = getopt_long(
argc, argv,
"c:e:Ob:f:n:B:C:U:P:M:k:r:u:g:qstVh",
long_options, &option_index
);
if (c == -1)
break;
switch (c) {
case 0:
break;
#ifndef NO_CONFIG_FILE
case CFG_PARAM_CFGFILE:
if (!config_file_parse(optarg, cfg))
config_die("%s", config_error_get());
break;
case CFG_PARAM_DEFCFG:
config_print_default(stdout, cfg);
exit(0);
break;
#endif
case CFG_PARAM_SYSLOG_FACILITY:
config_param_validate(CFG_SYSLOG_FACILITY, optarg, cfg, NULL, 0);
break;
case 'c':
config_param_validate(CFG_CIPHERS, optarg, cfg, NULL, 0);
break;
case 'e':
config_param_validate(CFG_SSL_ENGINE, optarg, cfg, NULL, 0);
break;
case 'O':
config_param_validate(CFG_PREFER_SERVER_CIPHERS, CFG_BOOL_ON, cfg, NULL, 0);
break;
case 'b':
config_param_validate(CFG_BACKEND, optarg, cfg, NULL, 0);
break;
case 'f':
config_param_validate(CFG_FRONTEND, optarg, cfg, NULL, 0);
break;
case 'n':
config_param_validate(CFG_WORKERS, optarg, cfg, NULL, 0);
break;
case 'B':
config_param_validate(CFG_BACKLOG, optarg, cfg, NULL, 0);
break;
#ifdef USE_SHARED_CACHE
case 'C':
config_param_validate(CFG_SHARED_CACHE, optarg, cfg, NULL, 0);
break;
case 'U':
config_param_validate(CFG_SHARED_CACHE_LISTEN, optarg, cfg, NULL, 0);
break;
case 'P':
config_param_validate(CFG_SHARED_CACHE_PEER, optarg, cfg, NULL, 0);
break;
case 'M':
config_param_validate(CFG_SHARED_CACHE_MCASTIF, optarg, cfg, NULL, 0);
break;
#endif
case 'k':
config_param_validate(CFG_KEEPALIVE, optarg, cfg, NULL, 0);
break;
case 'r':
config_param_validate(CFG_CHROOT, optarg, cfg, NULL, 0);
break;
case 'u':
config_param_validate(CFG_USER, optarg, cfg, NULL, 0);
break;
case 'g':
config_param_validate(CFG_GROUP, optarg, cfg, NULL, 0);
break;
case 'q':
config_param_validate(CFG_QUIET, CFG_BOOL_ON, cfg, NULL, 0);
break;
case 's':
config_param_validate(CFG_SYSLOG, CFG_BOOL_ON, cfg, NULL, 0);
break;
case 't':
test_only = 1;
break;
case 'V':
printf("%s %s\n", basename(argv[0]), STUD_VERSION);
exit(0);
break;
case 'h':
config_print_usage(argv[0], cfg);
exit(0);
break;
default:
config_die("Invalid command line parameters. Run %s --help for instructions.", basename(argv[0]));
}
}
prog = argv[0];
if (tls && ssl)
config_die("Options --tls and --ssl are mutually exclusive.");
else {
if (ssl)
cfg->ETYPE = ENC_SSL;
else if (tls)
cfg->ETYPE = ENC_TLS;
}
if (client) {
cfg->PMODE = SSL_CLIENT;
}
if (cfg->WRITE_IP_OCTET && cfg->WRITE_PROXY_LINE)
config_die("Options --write-ip and --write-proxy are mutually exclusive.");
if (cfg->WRITE_PROXY_LINE && cfg->PROXY_PROXY_LINE)
config_die("Options --write-proxy and --proxy-proxy are mutually exclusive.");
if (cfg->WRITE_IP_OCTET && cfg->PROXY_PROXY_LINE)
config_die("Options --write-ip and --proxy-proxy are mutually exclusive.");
if (cfg->DAEMONIZE) {
cfg->SYSLOG = 1;
cfg->QUIET = 1;
}
#ifdef USE_SHARED_CACHE
if (cfg->SHCUPD_IP != NULL && ! cfg->SHARED_CACHE)
config_die("Shared cache update listener is defined, but shared cache is disabled.");
#endif
// Any arguments left are presumed to be PEM files
argc -= optind;
argv += optind;
for (i = 0; i < argc; i++) {
config_param_validate(CFG_PEM_FILE, argv[i], cfg, NULL, 0);
}
/*
if (cfg->PMODE == SSL_SERVER && cfg->CERT_FILES == NULL) {
config_die("No x509 certificate PEM file specified!");
}
*/
// was this only a test?
/*
if (test_only) {
fprintf(stderr, "Trying to initialize SSL contexts with your certificates");
if (!init_openssl()) {
config_die("Error initializing OpenSSL.");
}
printf("%s configuration looks ok.\n", basename(prog));
exit(0);
}
*/
}
static void parse_argument(int c, char* value, PCONFIGURATION config) {
switch (c) {
case 'a':
config->stream.width = 1280;
config->stream.height = 720;
break;
case 'b':
config->stream.width = 1920;
config->stream.height = 1080;
break;
case '0':
config->stream.width = 3840;
config->stream.height = 2160;
break;
case 'c':
config->stream.width = atoi(value);
break;
case 'd':
config->stream.height = atoi(value);
break;
case 'g':
config->stream.bitrate = atoi(value);
break;
case 'h':
config->stream.packetSize = atoi(value);
break;
case 'i':
config->app = value;
break;
case 'j':
if (config->inputsCount >= MAX_INPUTS) {
perror("Too many inputs specified");
exit(-1);
}
config->inputs[config->inputsCount] = value;
config->inputsCount++;
inputAdded = true;
break;
case 'k':
config->mapping = get_path(value, getenv("XDG_DATA_DIRS"));
if (config->mapping == NULL) {
fprintf(stderr, "Unable to open custom mapping file: %s\n", value);
exit(-1);
}
break;
case 'l':
config->sops = false;
break;
case 'm':
config->audio_device = value;
break;
case 'n':
config->localaudio = true;
break;
case 'o':
if (!config_file_parse(value, config))
exit(EXIT_FAILURE);
break;
case 'p':
config->platform = value;
break;
case 'q':
config->config_file = value;
break;
case 'r':
strcpy(config->key_dir, value);
break;
case 's':
config->stream.streamingRemotely = 1;
break;
case 't':
config->fullscreen = false;
break;
case 'u':
config->stream.audioConfiguration = AUDIO_CONFIGURATION_51_SURROUND;
break;
case 'v':
config->stream.fps = atoi(value);
break;
case 'x':
if (strcasecmp(value, "auto") == 0)
config->codec = CODEC_UNSPECIFIED;
else if (strcasecmp(value, "h264") == 0)
config->codec = CODEC_H264;
if (strcasecmp(value, "h265") == 0 || strcasecmp(value, "hevc") == 0)
config->codec = CODEC_HEVC;
break;
case 'y':
config->unsupported = true;
break;
case 'z':
config->debug_level = 1;
break;
case 'Z':
config->debug_level = 2;
break;
case 1:
if (config->action == NULL)
config->action = value;
else if (config->address == NULL)
config->address = value;
else {
perror("Too many options");
exit(-1);
}
}
}
