float options_get_float_range(const char *name, float minval, float maxval)
{
options_data *data = find_entry_data(name, FALSE);
float value = 0;
if (data == NULL)
mame_printf_error("Unexpected float option %s queried\n", name);
else if (data->data == NULL || sscanf(data->data, "%f", &value) != 1)
{
if (data->defdata != NULL)
{
options_set_string(name, data->defdata);
value = options_get_float(name);
}
if (!data->error_reported)
{
mame_printf_error("Illegal float value for %s; reverting to %f\n", data->names[0], (double)value);
data->error_reported = TRUE;
}
}
else if (value < minval || value > maxval)
{
options_set_string(name, data->defdata);
value = options_get_float(name);
if (!data->error_reported)
{
mame_printf_error("Invalid %s value (must be between %f and %f); reverting to %f\n", data->names[0], (double)minval, (double)maxval, (double)value);
data->error_reported = TRUE;
}
}
return value;
}
int options_get_int_range(const char *name, int minval, int maxval)
{
options_data *data = find_entry_data(name, FALSE);
int value = 0;
if (data == NULL)
mame_printf_error("Unexpected integer option %s queried\n", name);
else if (data->data == NULL || sscanf(data->data, "%d", &value) != 1)
{
if (data->defdata != NULL)
{
options_set_string(name, data->defdata);
value = options_get_int(name);
}
if (!data->error_reported)
{
mame_printf_error("Illegal integer value for %s; reverting to %d\n", data->names[0], value);
data->error_reported = TRUE;
}
}
else if (value < minval || value > maxval)
{
options_set_string(name, data->defdata);
value = options_get_int(name);
if (!data->error_reported)
{
mame_printf_error("Invalid %s value (must be between %d and %d); reverting to %d\n", data->names[0], minval, maxval, value);
data->error_reported = TRUE;
}
}
return value;
}
void capplet_set_string(Options * options, const char *name,
const char *value)
{
options_set_string(options, name, value);
capplet_save_file(options);
optsdbus_send_string_opt_signal(options->name, name, value);
}
void options_set_double(Options * options, const char *key, double value)
{
char *str_val = g_strdup_printf("%f", value);
options_set_string(options, key, str_val);
g_free(str_val);
}
void
cmd_set_option_string(struct cmd_ctx *ctx, struct options *oo,
const struct set_option_entry *entry, char *value, int append)
{
struct options_entry *o;
char *oldvalue, *newvalue;
if (value == NULL) {
ctx->error(ctx, "empty value");
return;
}
if (append) {
oldvalue = options_get_string(oo, entry->name);
xasprintf(&newvalue, "%s%s", oldvalue, value);
} else
newvalue = value;
o = options_set_string(oo, entry->name, "%s", newvalue);
ctx->info(ctx,
"set option: %s -> %s", o->name, cmd_set_option_print(entry, o));
if (newvalue != value)
xfree(newvalue);
}
void options_set_bool(const char *name, int value)
{
char temp[4];
assert(value == TRUE || value == FALSE);
sprintf(temp, "%d", value);
options_set_string(name, temp);
}
/* Set user option. */
enum cmd_retval
cmd_set_option_user(struct cmd *self, struct cmd_ctx *ctx, const char* optstr,
const char *valstr)
{
struct args *args = self->args;
struct session *s;
struct winlink *wl;
struct options *oo;
if (args_has(args, 's'))
oo = &global_options;
else if (args_has(self->args, 'w') ||
self->entry == &cmd_set_window_option_entry) {
if (args_has(self->args, 'g'))
oo = &global_w_options;
else {
wl = cmd_find_window(ctx, args_get(args, 't'), NULL);
if (wl == NULL)
return (CMD_RETURN_ERROR);
oo = &wl->window->options;
}
} else {
if (args_has(self->args, 'g'))
oo = &global_s_options;
else {
s = cmd_find_session(ctx, args_get(args, 't'), 0);
if (s == NULL)
return (CMD_RETURN_ERROR);
oo = &s->options;
}
}
if (args_has(args, 'u')) {
if (options_find1(oo, optstr) == NULL) {
ctx->error(ctx, "unknown option: %s", optstr);
return (CMD_RETURN_ERROR);
}
if (valstr != NULL) {
ctx->error(ctx, "value passed to unset option: %s",
optstr);
return (CMD_RETURN_ERROR);
}
options_remove(oo, optstr);
} else {
if (valstr == NULL) {
ctx->error(ctx, "empty value");
return (CMD_RETURN_ERROR);
}
options_set_string(oo, optstr, "%s", valstr);
if (!args_has(args, 'q'))
ctx->info(ctx, "set option: %s -> %s", optstr, valstr);
}
return (CMD_RETURN_NORMAL);
}
/* Populate an options tree from a table. */
void
options_table_populate_tree(
const struct options_table_entry *table, struct options *oo)
{
const struct options_table_entry *oe;
for (oe = table; oe->name != NULL; oe++) {
if (oe->default_str != NULL)
options_set_string(oo, oe->name, "%s", oe->default_str);
else
options_set_number(oo, oe->name, oe->default_num);
}
}
static void colour_scheme_set_colour(Options *opts, ColourScheme *scheme,
GdkRGBA **colour, const char *key, const char *colour_name)
{
if (!*colour)
*colour = g_new(GdkRGBA, 1);
if (!colour_name || colour_scheme_parse(scheme, *colour, colour_name))
options_set_string(opts, key, colour_name);
if (!colour_name)
{
g_free(*colour);
*colour = NULL;
}
}
void tmux_server_init(void)
{
global_hooks = hooks_create(NULL);
global_environ = environ_create();
global_options = options_create(NULL);
options_table_populate_tree(OPTIONS_TABLE_SERVER, global_options);
global_s_options = options_create(NULL);
options_table_populate_tree(OPTIONS_TABLE_SESSION, global_s_options);
options_set_string(global_s_options, "default-shell", "%s", "/bin/false");
global_w_options = options_create(NULL);
options_table_populate_tree(OPTIONS_TABLE_WINDOW, global_w_options);
options_set_number(global_s_options, "status-keys", MODEKEY_VI);
options_set_number(global_w_options, "mode-keys", MODEKEY_VI);
}
/* Set a string option. */
struct options_entry *
cmd_set_option_string(struct cmd *self, unused struct cmd_q *cmdq,
const struct options_table_entry *oe, struct options *oo, const char *value)
{
struct args *args = self->args;
struct options_entry *o;
char *oldval, *newval;
if (args_has(args, 'a')) {
oldval = options_get_string(oo, oe->name);
xasprintf(&newval, "%s%s", oldval, value);
} else
newval = xstrdup(value);
o = options_set_string(oo, oe->name, "%s", newval);
free(newval);
return (o);
}
void running_machine::schedule_exit()
{
// if we are in-game but we started with the select game menu, return to that instead
if (m_exit_to_game_select && options_get_string(&m_options, OPTION_GAMENAME)[0] != 0)
{
options_set_string(&m_options, OPTION_GAMENAME, "", OPTION_PRIORITY_CMDLINE);
ui_menu_force_game_select(this, render_container_get_ui());
}
// otherwise, exit for real
else
m_exit_pending = true;
// if we're executing, abort out immediately
m_scheduler.eat_all_cycles();
// if we're autosaving on exit, schedule a save as well
if (options_get_bool(&m_options, OPTION_AUTOSAVE) && (m_game.flags & GAME_SUPPORTS_SAVE))
schedule_save("auto");
}
/* Populate an options tree from a table. */
void
options_table_populate_tree(
const struct options_table_entry *table, struct options *oo)
{
const struct options_table_entry *oe;
for (oe = table; oe->name != NULL; oe++) {
switch (oe->type) {
case OPTIONS_TABLE_STRING:
options_set_string(oo, oe->name, "%s", oe->default_str);
break;
case OPTIONS_TABLE_STYLE:
options_set_style(oo, oe->name, oe->default_str, 0);
break;
default:
options_set_number(oo, oe->name, oe->default_num);
break;
}
}
}
/* Set a string option. */
struct options_entry *
cmd_set_option_string(struct cmd *self, unused struct cmd_ctx *ctx,
const struct options_table_entry *oe, struct options *oo)
{
struct cmd_target_data *data = self->data;
struct options_entry *o;
char *oldval, *newval;
if (cmd_check_flag(data->chflags, 'a')) {
oldval = options_get_string(oo, oe->name);
xasprintf(&newval, "%s%s", oldval, data->arg2);
} else
newval = data->arg2;
o = options_set_string(oo, oe->name, "%s", newval);
if (newval != data->arg2)
xfree(newval);
return (o);
}
int options_get_bool(const char *name)
{
options_data *data = find_entry_data(name, FALSE);
int value = FALSE;
if (data == NULL)
mame_printf_error("Unexpected boolean option %s queried\n", name);
else if (data->data == NULL || sscanf(data->data, "%d", &value) != 1 || value < 0 || value > 1)
{
if (data->defdata != NULL)
{
options_set_string(name, data->defdata);
sscanf(data->data, "%d", &value);
}
if (!data->error_reported)
{
mame_printf_error("Illegal boolean value for %s; reverting to %d\n", data->names[0], value);
data->error_reported = TRUE;
}
}
return value;
}
float options_get_float(const char *name)
{
options_data *data = find_entry_data(name, FALSE);
float value = 0;
if (data == NULL)
mame_printf_error("Unexpected float option %s queried\n", name);
else if (data->data == NULL || sscanf(data->data, "%f", &value) != 1)
{
if (data->defdata != NULL)
{
options_set_string(name, data->defdata);
sscanf(data->data, "%f", &value);
}
if (!data->error_reported)
{
mame_printf_error("Illegal float value for %s; reverting to %f\n", data->names[0], (double)value);
data->error_reported = TRUE;
}
}
return value;
}
static void image_options_extract(running_machine *machine)
{
/* only extract the device options if we've added them */
if (options_get_bool(machine->options(), OPTION_ADDED_DEVICE_OPTIONS)) {
int index = 0;
device_image_interface *image = NULL;
for (bool gotone = machine->m_devicelist.first(image); gotone; gotone = image->next(image))
{
const char *filename = image->filename();
/* and set the option */
options_set_string(machine->options(), image->image_config().instance_name() , filename ? filename : "", OPTION_PRIORITY_CMDLINE);
index++;
}
}
/* write the config, if appropriate */
if (options_get_bool(machine->options(), OPTION_WRITECONFIG))
write_config(NULL, machine->gamedrv);
}
/* Populate an options tree from a table. */
void
options_table_populate_tree(enum options_table_scope scope, struct options *oo)
{
const struct options_table_entry *oe;
for (oe = options_table; oe->name != NULL; oe++) {
if (oe->scope == OPTIONS_TABLE_NONE)
fatalx("no scope for %s", oe->name);
if (oe->scope != scope)
continue;
switch (oe->type) {
case OPTIONS_TABLE_STRING:
options_set_string(oo, oe->name, "%s", oe->default_str);
break;
case OPTIONS_TABLE_STYLE:
options_set_style(oo, oe->name, oe->default_str, 0);
break;
default:
options_set_number(oo, oe->name, oe->default_num);
break;
}
}
}
int
main(int argc, char **argv)
{
struct passwd *pw;
char *s, *path, *label, *home, **var;
int opt, flags, quiet, keys;
#if defined(DEBUG) && defined(__OpenBSD__)
malloc_options = (char *) "AFGJPX";
#endif
flags = IDENTIFY_256COLOURS | IDENTIFY_UTF8;
quiet = 0;
label = path = NULL;
login_shell = (**argv == '-');
while ((opt = getopt(argc, argv, "28c:Cdf:lL:qS:uUvV")) != -1) {
switch (opt) {
case '2':
flags |= IDENTIFY_256COLOURS;
flags &= ~IDENTIFY_88COLOURS;
break;
case '8':
flags |= IDENTIFY_88COLOURS;
flags &= ~IDENTIFY_256COLOURS;
break;
case 'c':
free(shell_cmd);
shell_cmd = xstrdup(optarg);
break;
case 'C':
if (flags & IDENTIFY_CONTROL)
flags |= IDENTIFY_TERMIOS;
else
flags |= IDENTIFY_CONTROL;
break;
case 'V':
printf("%s %s\n", __progname, VERSION);
exit(0);
case 'f':
free(cfg_file);
cfg_file = xstrdup(optarg);
break;
case 'l':
login_shell = 1;
break;
case 'L':
free(label);
label = xstrdup(optarg);
break;
case 'q':
quiet = 1;
break;
case 'S':
free(path);
path = xstrdup(optarg);
break;
case 'u':
flags |= IDENTIFY_UTF8;
break;
case 'v':
debug_level++;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (shell_cmd != NULL && argc != 0)
usage();
if (!(flags & IDENTIFY_UTF8)) {
/*
* If the user has set whichever of LC_ALL, LC_CTYPE or LANG
* exist (in that order) to contain UTF-8, it is a safe
* assumption that either they are using a UTF-8 terminal, or
* if not they know that output from UTF-8-capable programs may
* be wrong.
*/
if ((s = getenv("LC_ALL")) == NULL || *s == '\0') {
if ((s = getenv("LC_CTYPE")) == NULL || *s == '\0')
s = getenv("LANG");
}
if (s != NULL && (strcasestr(s, "UTF-8") != NULL ||
strcasestr(s, "UTF8") != NULL))
flags |= IDENTIFY_UTF8;
}
environ_init(&global_environ);
for (var = environ; *var != NULL; var++)
environ_put(&global_environ, *var);
options_init(&global_options, NULL);
options_table_populate_tree(server_options_table, &global_options);
options_set_number(&global_options, "quiet", quiet);
options_init(&global_s_options, NULL);
options_table_populate_tree(session_options_table, &global_s_options);
options_set_string(&global_s_options, "default-shell", "%s", getshell());
options_init(&global_w_options, NULL);
options_table_populate_tree(window_options_table, &global_w_options);
/* Enable UTF-8 if the first client is on UTF-8 terminal. */
if (flags & IDENTIFY_UTF8) {
options_set_number(&global_s_options, "status-utf8", 1);
options_set_number(&global_s_options, "mouse-utf8", 1);
options_set_number(&global_w_options, "utf8", 1);
}
/* Override keys to vi if VISUAL or EDITOR are set. */
if ((s = getenv("VISUAL")) != NULL || (s = getenv("EDITOR")) != NULL) {
if (strrchr(s, '/') != NULL)
s = strrchr(s, '/') + 1;
if (strstr(s, "vi") != NULL)
keys = MODEKEY_VI;
else
keys = MODEKEY_EMACS;
options_set_number(&global_s_options, "status-keys", keys);
options_set_number(&global_w_options, "mode-keys", keys);
}
/* Locate the configuration file. */
if (cfg_file == NULL) {
home = getenv("HOME");
if (home == NULL || *home == '\0') {
pw = getpwuid(getuid());
if (pw != NULL)
home = pw->pw_dir;
}
xasprintf(&cfg_file, "%s/%s", home, DEFAULT_CFG);
if (access(cfg_file, R_OK) != 0 && errno == ENOENT) {
free(cfg_file);
cfg_file = NULL;
}
}
/*
* Figure out the socket path. If specified on the command-line with -S
* or -L, use it, otherwise try $TMUX or assume -L default.
*/
parseenvironment();
if (path == NULL) {
/* If no -L, use the environment. */
if (label == NULL) {
if (environ_path != NULL)
path = xstrdup(environ_path);
}
/* -L or default set. */
if (!path) {
if ((path = makesocketpath(label)) == NULL) {
fprintf(stderr, "can't create socket\n");
exit(1);
}
}
}
free(label);
strlcpy(socket_path, path, sizeof socket_path);
free(path);
#ifdef HAVE_SETPROCTITLE
/* Set process title. */
setproctitle("%s (%s)", __progname, socket_path);
#endif
/* Pass control to the client. */
ev_base = osdep_event_init();
exit(client_main(argc, argv, flags));
}
int
main(int argc, char **argv)
{
char *path, *label, **var, tmp[PATH_MAX], *shellcmd = NULL;
const char *s;
int opt, flags, keys;
#if defined(DEBUG) && defined(__OpenBSD__)
malloc_options = (char *) "AFGJPX";
#endif
setlocale(LC_TIME, "");
tzset();
if (**argv == '-')
flags = CLIENT_LOGIN;
else
flags = 0;
#ifdef TMATE
tmate_catch_sigsegv();
flags |= CLIENT_256COLOURS | CLIENT_UTF8;
#endif
label = path = NULL;
while ((opt = getopt(argc, argv, "2c:Cdf:lL:qS:uUVv")) != -1) {
switch (opt) {
case '2':
flags |= CLIENT_256COLOURS;
break;
case 'c':
free(shellcmd);
shellcmd = xstrdup(optarg);
break;
case 'C':
if (flags & CLIENT_CONTROL)
flags |= CLIENT_CONTROLCONTROL;
else
flags |= CLIENT_CONTROL;
break;
case 'V':
printf("%s %s\n", __progname, VERSION);
exit(0);
case 'f':
set_cfg_file(optarg);
break;
case 'l':
flags |= CLIENT_LOGIN;
break;
case 'L':
free(label);
label = xstrdup(optarg);
break;
case 'q':
break;
case 'S':
free(path);
path = xstrdup(optarg);
break;
case 'u':
flags |= CLIENT_UTF8;
break;
case 'v':
log_add_level();
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (shellcmd != NULL && argc != 0)
usage();
#ifdef __OpenBSD__
if (pledge("stdio rpath wpath cpath flock fattr unix getpw sendfd "
"recvfd proc exec tty ps", NULL) != 0)
err(1, "pledge");
#endif
/*
* tmux is a UTF-8 terminal, so if TMUX is set, assume UTF-8.
* Otherwise, if the user has set LC_ALL, LC_CTYPE or LANG to contain
* UTF-8, it is a safe assumption that either they are using a UTF-8
* terminal, or if not they know that output from UTF-8-capable
* programs may be wrong.
*/
if (getenv("TMUX") != NULL)
flags |= CLIENT_UTF8;
else {
s = getenv("LC_ALL");
if (s == NULL || *s == '\0')
s = getenv("LC_CTYPE");
if (s == NULL || *s == '\0')
s = getenv("LANG");
if (s == NULL || *s == '\0')
s = "";
if (strcasestr(s, "UTF-8") != NULL ||
strcasestr(s, "UTF8") != NULL)
flags |= CLIENT_UTF8;
}
global_hooks = hooks_create(NULL);
global_environ = environ_create();
for (var = environ; *var != NULL; var++)
environ_put(global_environ, *var);
if (getcwd(tmp, sizeof tmp) != NULL)
environ_set(global_environ, "PWD", "%s", tmp);
global_options = options_create(NULL);
options_table_populate_tree(OPTIONS_TABLE_SERVER, global_options);
global_s_options = options_create(NULL);
options_table_populate_tree(OPTIONS_TABLE_SESSION, global_s_options);
options_set_string(global_s_options, "default-shell", "%s", getshell());
global_w_options = options_create(NULL);
options_table_populate_tree(OPTIONS_TABLE_WINDOW, global_w_options);
/* Override keys to vi if VISUAL or EDITOR are set. */
if ((s = getenv("VISUAL")) != NULL || (s = getenv("EDITOR")) != NULL) {
if (strrchr(s, '/') != NULL)
s = strrchr(s, '/') + 1;
if (strstr(s, "vi") != NULL)
keys = MODEKEY_VI;
else
keys = MODEKEY_EMACS;
options_set_number(global_s_options, "status-keys", keys);
options_set_number(global_w_options, "mode-keys", keys);
}
/*
* If socket is specified on the command-line with -S or -L, it is
* used. Otherwise, $TMUX is checked and if that fails "default" is
* used.
*/
if (path == NULL && label == NULL) {
s = getenv("TMUX");
if (s != NULL && *s != '\0' && *s != ',') {
path = xstrdup(s);
path[strcspn (path, ",")] = '\0';
}
}
if (path == NULL && (path = make_label(label)) == NULL) {
fprintf(stderr, "can't create socket: %s\n", strerror(errno));
exit(1);
}
socket_path = path;
free(label);
/* Pass control to the client. */
exit(client_main(event_init(), argc, argv, flags, shellcmd));
}
void options_set_int(const char *name, int value)
{
char temp[20];
sprintf(temp, "%d", value);
options_set_string(name, temp);
}
void options_set_float(const char *name, float value)
{
char temp[100];
sprintf(temp, "%f", value);
options_set_string(name, temp);
}
static messtest_result_t run_test(int flags, messtest_results *results)
{
const game_driver *driver;
messtest_result_t rc;
clock_t begin_time;
double real_run_time;
astring *fullpath = NULL;
const char *device_opt;
const char *fake_argv[2];
core_options *opts;
/* lookup driver */
driver = driver_get_name(current_testcase.driver);
/* cannot find driver? */
if (driver == NULL)
{
report_message(MSG_FAILURE, "Cannot find driver '%s'", current_testcase.driver);
return MESSTEST_RESULT_STARTFAILURE;
}
/* prepare testing state */
current_command = current_testcase.commands;
state = STATE_READY;
test_flags = flags;
screenshot_num = 0;
runtime_hash = 0;
had_failure = FALSE;
//videoram = NULL;
//videoram_size = 0;
/* set up options */
opts = mame_options_init(win_mess_opts);
options_set_string(opts, OPTION_GAMENAME, driver->name, OPTION_PRIORITY_CMDLINE);
if( current_testcase.bios )
options_set_string(opts, OPTION_BIOS, current_testcase.bios, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_SKIP_GAMEINFO, TRUE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_THROTTLE, FALSE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_DEBUG, FALSE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_DEBUG_INTERNAL, FALSE, OPTION_PRIORITY_CMDLINE);
options_set_bool(opts, OPTION_WRITECONFIG, FALSE, OPTION_PRIORITY_CMDLINE);
if (current_testcase.ram != 0)
{
options_set_int(opts, OPTION_RAMSIZE, current_testcase.ram, OPTION_PRIORITY_CMDLINE);
}
/* ugh... hideous ugly fake arguments */
fake_argv[0] = "MESSTEST";
fake_argv[1] = driver->name;
options_parse_command_line(opts, ARRAY_LENGTH(fake_argv), (char **) fake_argv, OPTION_PRIORITY_CMDLINE,TRUE);
/* preload any needed images */
while(current_command->command_type == MESSTEST_COMMAND_IMAGE_PRELOAD)
{
/* get the path */
fullpath = assemble_software_path(astring_alloc(), driver, current_command->u.image_args.filename);
/* get the option name */
device_opt = device_config_image_interface::device_typename(current_command->u.image_args.device_ident.type);
/* set the option */
options_set_string(opts, device_opt, astring_c(fullpath), OPTION_PRIORITY_CMDLINE);
/* cleanup */
astring_free(fullpath);
fullpath = NULL;
/* next command */
current_command++;
}
/* perform the test */
report_message(MSG_INFO, "Beginning test (driver '%s')", current_testcase.driver);
begin_time = clock();
mame_set_output_channel(OUTPUT_CHANNEL_ERROR, messtest_output_error, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_WARNING, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_INFO, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_DEBUG, mame_null_output_callback, NULL, NULL, NULL);
mame_set_output_channel(OUTPUT_CHANNEL_LOG, mame_null_output_callback, NULL, NULL, NULL);
test_osd_interface osd;
mame_execute(osd, opts);
real_run_time = ((double) (clock() - begin_time)) / CLOCKS_PER_SEC;
/* what happened? */
switch(state)
{
case STATE_ABORTED:
report_message(MSG_FAILURE, "Test aborted");
rc = MESSTEST_RESULT_RUNTIMEFAILURE;
break;
case STATE_DONE:
if (had_failure)
{
report_message(MSG_FAILURE, "Test failed (real time %.2f; emu time %.2f [%i%%])",
real_run_time, final_time.as_double(), (int) ((final_time.as_double() / real_run_time) * 100));
rc = MESSTEST_RESULT_RUNTIMEFAILURE;
}
else
{
report_message(MSG_INFO, "Test succeeded (real time %.2f; emu time %.2f [%i%%])",
real_run_time, final_time.as_double(), (int) ((final_time.as_double() / real_run_time) * 100));
rc = MESSTEST_RESULT_SUCCESS;
}
break;
default:
state = STATE_ABORTED;
report_message(MSG_FAILURE, "Abnormal termination");
rc = MESSTEST_RESULT_STARTFAILURE;
break;
}
if (results)
{
results->rc = rc;
results->runtime_hash = runtime_hash;
}
options_free(opts);
return rc;
}
int
main(int argc, char **argv)
{
char *s, *path, *label, **var, tmp[PATH_MAX];
int opt, flags, keys;
#if defined(DEBUG) && defined(__OpenBSD__)
malloc_options = (char *) "AFGJPX";
#endif
setlocale(LC_TIME, "");
if (**argv == '-')
flags = CLIENT_LOGIN;
else
flags = 0;
label = path = NULL;
while ((opt = getopt(argc, argv, "2c:Cdf:lL:qS:uUVv")) != -1) {
switch (opt) {
case '2':
flags |= CLIENT_256COLOURS;
break;
case 'c':
free(shell_cmd);
shell_cmd = xstrdup(optarg);
break;
case 'C':
if (flags & CLIENT_CONTROL)
flags |= CLIENT_CONTROLCONTROL;
else
flags |= CLIENT_CONTROL;
break;
case 'V':
printf("%s %s\n", __progname, VERSION);
exit(0);
case 'f':
set_cfg_file(optarg);
break;
case 'l':
flags |= CLIENT_LOGIN;
break;
case 'L':
free(label);
label = xstrdup(optarg);
break;
case 'q':
break;
case 'S':
free(path);
path = xstrdup(optarg);
break;
case 'u':
flags |= CLIENT_UTF8;
break;
case 'v':
debug_level++;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (shell_cmd != NULL && argc != 0)
usage();
if (!(flags & CLIENT_UTF8)) {
/*
* If the user has set whichever of LC_ALL, LC_CTYPE or LANG
* exist (in that order) to contain UTF-8, it is a safe
* assumption that either they are using a UTF-8 terminal, or
* if not they know that output from UTF-8-capable programs may
* be wrong.
*/
if ((s = getenv("LC_ALL")) == NULL || *s == '\0') {
if ((s = getenv("LC_CTYPE")) == NULL || *s == '\0')
s = getenv("LANG");
}
if (s != NULL && (strcasestr(s, "UTF-8") != NULL ||
strcasestr(s, "UTF8") != NULL))
flags |= CLIENT_UTF8;
}
environ_init(&global_environ);
for (var = environ; *var != NULL; var++)
environ_put(&global_environ, *var);
if (getcwd(tmp, sizeof tmp) != NULL)
environ_set(&global_environ, "PWD", tmp);
options_init(&global_options, NULL);
options_table_populate_tree(server_options_table, &global_options);
options_init(&global_s_options, NULL);
options_table_populate_tree(session_options_table, &global_s_options);
options_set_string(&global_s_options, "default-shell", "%s",
getshell());
options_init(&global_w_options, NULL);
options_table_populate_tree(window_options_table, &global_w_options);
/* Enable UTF-8 if the first client is on UTF-8 terminal. */
if (flags & CLIENT_UTF8) {
options_set_number(&global_s_options, "status-utf8", 1);
options_set_number(&global_s_options, "mouse-utf8", 1);
options_set_number(&global_w_options, "utf8", 1);
}
/* Override keys to vi if VISUAL or EDITOR are set. */
if ((s = getenv("VISUAL")) != NULL || (s = getenv("EDITOR")) != NULL) {
if (strrchr(s, '/') != NULL)
s = strrchr(s, '/') + 1;
if (strstr(s, "vi") != NULL)
keys = MODEKEY_VI;
else
keys = MODEKEY_EMACS;
options_set_number(&global_s_options, "status-keys", keys);
options_set_number(&global_w_options, "mode-keys", keys);
}
/*
* Figure out the socket path. If specified on the command-line with -S
* or -L, use it, otherwise try $TMUX or assume -L default.
*/
if (path == NULL) {
/* If no -L, use the environment. */
if (label == NULL) {
s = getenv("TMUX");
if (s != NULL) {
path = xstrdup(s);
path[strcspn (path, ",")] = '\0';
if (*path == '\0') {
free(path);
label = xstrdup("default");
}
} else
label = xstrdup("default");
}
/* -L or default set. */
if (label != NULL) {
if ((path = makesocketpath(label)) == NULL) {
fprintf(stderr, "can't create socket: %s\n",
strerror(errno));
exit(1);
}
}
}
free(label);
if (strlcpy(socket_path, path, sizeof socket_path) >=
sizeof socket_path) {
fprintf(stderr, "socket path too long: %s\n", path);
exit(1);
}
free(path);
#ifdef HAVE_SETPROCTITLE
/* Set process title. */
setproctitle("%s (%s)", __progname, socket_path);
#endif
/* Pass control to the client. */
exit(client_main(event_init(), argc, argv, flags));
}
int
main(int argc, char **argv)
{
char *path, *label, tmp[PATH_MAX];
char *shellcmd = NULL, **var;
const char *s, *shell;
int opt, flags, keys;
const struct options_table_entry *oe;
if (setlocale(LC_CTYPE, "en_US.UTF-8") == NULL) {
if (setlocale(LC_CTYPE, "") == NULL)
errx(1, "invalid LC_ALL, LC_CTYPE or LANG");
s = nl_langinfo(CODESET);
if (strcasecmp(s, "UTF-8") != 0 && strcasecmp(s, "UTF8") != 0)
errx(1, "need UTF-8 locale (LC_CTYPE) but have %s", s);
}
setlocale(LC_TIME, "");
tzset();
if (**argv == '-')
flags = CLIENT_LOGIN;
else
flags = 0;
label = path = NULL;
while ((opt = getopt(argc, argv, "2c:Cdf:lL:qS:uUVv")) != -1) {
switch (opt) {
case '2':
flags |= CLIENT_256COLOURS;
break;
case 'c':
free(shellcmd);
shellcmd = xstrdup(optarg);
break;
case 'C':
if (flags & CLIENT_CONTROL)
flags |= CLIENT_CONTROLCONTROL;
else
flags |= CLIENT_CONTROL;
break;
case 'V':
printf("%s %s\n", getprogname(), VERSION);
exit(0);
case 'f':
set_cfg_file(optarg);
break;
case 'l':
flags |= CLIENT_LOGIN;
break;
case 'L':
free(label);
label = xstrdup(optarg);
break;
case 'q':
break;
case 'S':
free(path);
path = xstrdup(optarg);
break;
case 'u':
flags |= CLIENT_UTF8;
break;
case 'v':
log_add_level();
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (shellcmd != NULL && argc != 0)
usage();
if ((ptm_fd = getptmfd()) == -1)
err(1, "getptmfd");
if (pledge("stdio rpath wpath cpath flock fattr unix getpw sendfd "
"recvfd proc exec tty ps", NULL) != 0)
err(1, "pledge");
/*
* tmux is a UTF-8 terminal, so if TMUX is set, assume UTF-8.
* Otherwise, if the user has set LC_ALL, LC_CTYPE or LANG to contain
* UTF-8, it is a safe assumption that either they are using a UTF-8
* terminal, or if not they know that output from UTF-8-capable
* programs may be wrong.
*/
if (getenv("TMUX") != NULL)
flags |= CLIENT_UTF8;
else {
s = getenv("LC_ALL");
if (s == NULL || *s == '\0')
s = getenv("LC_CTYPE");
if (s == NULL || *s == '\0')
s = getenv("LANG");
if (s == NULL || *s == '\0')
s = "";
if (strcasestr(s, "UTF-8") != NULL ||
strcasestr(s, "UTF8") != NULL)
flags |= CLIENT_UTF8;
}
global_hooks = hooks_create(NULL);
global_environ = environ_create();
for (var = environ; *var != NULL; var++)
environ_put(global_environ, *var);
if (getcwd(tmp, sizeof tmp) != NULL)
environ_set(global_environ, "PWD", "%s", tmp);
global_options = options_create(NULL);
global_s_options = options_create(NULL);
global_w_options = options_create(NULL);
for (oe = options_table; oe->name != NULL; oe++) {
if (oe->scope == OPTIONS_TABLE_SERVER)
options_default(global_options, oe);
if (oe->scope == OPTIONS_TABLE_SESSION)
options_default(global_s_options, oe);
if (oe->scope == OPTIONS_TABLE_WINDOW)
options_default(global_w_options, oe);
}
/*
* The default shell comes from SHELL or from the user's passwd entry
* if available.
*/
shell = getshell();
options_set_string(global_s_options, "default-shell", 0, "%s", shell);
/* Override keys to vi if VISUAL or EDITOR are set. */
if ((s = getenv("VISUAL")) != NULL || (s = getenv("EDITOR")) != NULL) {
if (strrchr(s, '/') != NULL)
s = strrchr(s, '/') + 1;
if (strstr(s, "vi") != NULL)
keys = MODEKEY_VI;
else
keys = MODEKEY_EMACS;
options_set_number(global_s_options, "status-keys", keys);
options_set_number(global_w_options, "mode-keys", keys);
}
/*
* If socket is specified on the command-line with -S or -L, it is
* used. Otherwise, $TMUX is checked and if that fails "default" is
* used.
*/
if (path == NULL && label == NULL) {
s = getenv("TMUX");
if (s != NULL && *s != '\0' && *s != ',') {
path = xstrdup(s);
path[strcspn(path, ",")] = '\0';
}
}
if (path == NULL && (path = make_label(label)) == NULL) {
fprintf(stderr, "can't create socket: %s\n", strerror(errno));
exit(1);
}
socket_path = path;
free(label);
/* Pass control to the client. */
exit(client_main(osdep_event_init(), argc, argv, flags, shellcmd));
}
BOOL LoadDIB(LPCTSTR filename, HGLOBAL *phDIB, HPALETTE *pPal, int pic_type)
{
mame_file_error filerr;
mame_file *mfile = NULL;
char *fname;
BOOL success;
const char *zip_name = NULL;
char *pngfilename = NULL;
char tmp[MAX_PATH];
strcpy(tmp, filename);
strcat(tmp, ".png");
pngfilename = mame_strdup(tmp);
switch (pic_type)
{
case TAB_SCREENSHOT :
options_set_string(SEARCHPATH_ARTWORK,GetImgDir());
zip_name = "snap";
break;
case TAB_FLYER :
options_set_string(SEARCHPATH_ARTWORK,GetFlyerDir());
zip_name = "flyers";
break;
case TAB_CABINET :
options_set_string(SEARCHPATH_ARTWORK,GetCabinetDir());
zip_name = "cabinets";
break;
case TAB_MARQUEE :
options_set_string(SEARCHPATH_ARTWORK,GetMarqueeDir());
zip_name = "marquees";
break;
case TAB_TITLE :
options_set_string(SEARCHPATH_ARTWORK,GetTitlesDir());
zip_name = "titles";
break;
case TAB_CONTROL_PANEL :
options_set_string(SEARCHPATH_ARTWORK,GetControlPanelDir());
zip_name = "cpanel";
break;
case BACKGROUND :
options_set_string(SEARCHPATH_ARTWORK,GetBgDir());
zip_name = "bkground";
break;
default :
// in case a non-image tab gets here, which can happen
return FALSE;
}
// look for the raw file
filerr = mame_fopen(SEARCHPATH_ARTWORK, pngfilename, OPEN_FLAG_READ, &mfile);
if (filerr != FILERR_NONE)
{
// and look for the zip
fname = assemble_3_strings(zip_name, PATH_SEPARATOR, pngfilename);
filerr = mame_fopen(SEARCHPATH_ARTWORK, fname, OPEN_FLAG_READ, &mfile);
free(fname);
}
if (filerr != FILERR_NONE)
return FALSE;
success = png_read_bitmap(mfile, phDIB, pPal);
mame_fclose(mfile);
return success;
}
/* Parse all CLI arguments */
int options_parse(struct options_t **opt, int argc, char **argv, int error_check, char **optarg) {
logprintf(LOG_STACK, "%s(...)", __FUNCTION__);
int c = 0;
int itmp = 0;
#ifndef __FreeBSD__
char *mask;
regex_t regex;
int reti;
#endif
char *ctmp = NULL;
/* If have read all arguments, exit and reset */
if(getOptPos>=(argc-1)) {
getOptPos=0;
if(*optarg) {
FREE(*optarg);
*optarg = NULL;
}
return -1;
} else {
getOptPos++;
/* Reserve enough memory to store all variables */
longarg = REALLOC(longarg, 4);
shortarg = REALLOC(shortarg, 2);
*optarg = REALLOC(*optarg, 4);
if(!longarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
if(!shortarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
if(!*optarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
/* The memory to null */
memset(*optarg, '\0', 4);
memset(shortarg, '\0', 2);
memset(longarg, '\0', 4);
/* Check if the CLI character contains an equals to (=) sign.
If it does, we have probably encountered a long argument */
if(strchr(argv[getOptPos],'=')) {
/* Copy all characters until the equals to sign.
This will probably be the name of the argument */
longarg = REALLOC(longarg, strcspn(argv[getOptPos],"=")+1);
if(!longarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
memset(longarg, '\0', strcspn(argv[getOptPos],"=")+1);
memcpy(longarg, &argv[getOptPos][0], strcspn(argv[getOptPos],"="));
/* Then copy everything after the equals sign.
This will probably be the value of the argument */
size_t i = strlen(&argv[getOptPos][strcspn(argv[getOptPos],"=")+1]);
*optarg = REALLOC(*optarg, i+1);
if(!*optarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
memset(*optarg, '\0', i+1);
memcpy(*optarg, &argv[getOptPos][strcspn(argv[getOptPos],"=")+1], i);
} else {
/* If the argument does not contain a equals sign.
Store the argument to check later if it's a long argument */
longarg = REALLOC(longarg, strlen(argv[getOptPos])+1);
if(!longarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(longarg, argv[getOptPos]);
}
/* A short argument only contains of two characters.
So only store the first two characters */
shortarg = REALLOC(shortarg, strlen(argv[getOptPos])+1);
if(!shortarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
memset(shortarg, '\0', 3);
strncpy(shortarg, argv[getOptPos], 2);
/* Check if the short argument and the long argument are equal,
then we probably encountered a short argument. Only store the
identifier character. If there are more CLI characters
after the current one, store it as the CLI value. However, only
do this if the first character of the argument doesn't contain*/
if(strcmp(longarg, shortarg) == 0 && (getOptPos+1)<argc && argv[getOptPos+1][0] != '-') {
*optarg = REALLOC(*optarg, strlen(argv[getOptPos+1])+1);
if(!*optarg) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(*optarg, argv[getOptPos+1]);
c = shortarg[1];
getOptPos++;
} else {
/* If the short argument and the long argument are not equal,
then we probably encountered a long argument. */
if(longarg[0] == '-' && longarg[1] == '-') {
if((gctmp = REALLOC(gctmp, strlen(&longarg[2])+1)) == NULL) {
logprintf(LOG_ERR, "out of memory");
exit(EXIT_FAILURE);
}
strcpy(gctmp, &longarg[2]);
/* Retrieve the short identifier for the long argument */
if(options_get_id(opt, gctmp, &itmp) == 0) {
c = itmp;
} else if(argv[getOptPos][0] == '-') {
c = shortarg[1];
}
} else if(argv[getOptPos][0] == '-' && strstr(shortarg, longarg) != 0) {
c = shortarg[1];
}
}
/* Check if the argument was expected */
if(options_get_name(opt, c, &ctmp) != 0 && c > 0) {
if(error_check == 1) {
if(strcmp(longarg,shortarg) == 0) {
if(shortarg[0] == '-') {
logprintf(LOG_ERR, "invalid option -- '-%c'", c);
} else {
logprintf(LOG_ERR, "invalid option -- '%s'", longarg);
}
} else {
logprintf(LOG_ERR, "invalid option -- '%s'", longarg);
}
goto gc;
} else {
return 0;
}
/* Check if an argument cannot have an argument that was set */
} else if(strlen(*optarg) != 0 && options_get_argtype(opt, c, &itmp) == 0 && itmp == 1) {
if(error_check == 1) {
if(strcmp(longarg,shortarg) == 0) {
logprintf(LOG_ERR, "option '-%c' doesn't take an argument", c);
} else {
logprintf(LOG_ERR, "option '%s' doesn't take an argument", longarg);
}
goto gc;
} else {
return 0;
}
/* Check if an argument required a value that wasn't set */
} else if(strlen(*optarg) == 0 && options_get_argtype(opt, c, &itmp) == 0 && itmp == 2) {
if(error_check == 1) {
if(strcmp(longarg, shortarg) == 0) {
logprintf(LOG_ERR, "option '-%c' requires an argument", c);
} else {
logprintf(LOG_ERR, "option '%s' requires an argument", longarg);
}
goto gc;
} else {
return 0;
}
/* Check if we have a valid argument */
} else if(c == 0) {
if(error_check == 1) {
if(shortarg[0] == '-' && strstr(shortarg, longarg) != 0) {
logprintf(LOG_ERR, "invalid option -- '-%c'", c);
} else {
logprintf(LOG_ERR, "invalid option -- '%s'", longarg);
}
goto gc;
} else {
return 0;
}
} else {
/* If the argument didn't have a value, set it to 1 */
if(strlen(*optarg) == 0) {
options_set_string(opt, c, "1");
} else {
#ifndef __FreeBSD__
if(error_check != 2) {
/* If the argument has a regex mask, check if it passes */
if(options_get_mask(opt, c, &mask) == 0) {
reti = regcomp(®ex, mask, REG_EXTENDED);
if(reti) {
logprintf(LOG_ERR, "could not compile regex");
goto gc;
}
reti = regexec(®ex, *optarg, 0, NULL, 0);
if(reti == REG_NOMATCH || reti != 0) {
if(error_check == 1) {
if(shortarg[0] == '-') {
logprintf(LOG_ERR, "invalid format -- '-%c'", c);
} else {
logprintf(LOG_ERR, "invalid format -- '%s'", longarg);
}
logprintf(LOG_ERR, "requires %s", mask);
}
regfree(®ex);
goto gc;
}
regfree(®ex);
}
}
#endif
options_set_string(opt, c, *optarg);
}
return c;
}
}
gc:
getOptPos=0;
FREE(*optarg);
return -2;
}
int
main(int argc, char **argv)
{
struct client_ctx cctx;
struct msg_command_data cmddata;
struct buffer *b;
struct cmd_list *cmdlist;
struct cmd *cmd;
struct pollfd pfd;
struct hdr hdr;
const char *shell;
struct passwd *pw;
char *path, *label, *cause, *home, *pass = NULL;
char cwd[MAXPATHLEN];
int retcode, opt, flags, unlock, start_server;
unlock = flags = 0;
label = path = NULL;
while ((opt = getopt(argc, argv, "28df:L:qS:uUVv")) != -1) {
switch (opt) {
case '2':
flags |= IDENTIFY_256COLOURS;
flags &= ~IDENTIFY_88COLOURS;
break;
case '8':
flags |= IDENTIFY_88COLOURS;
flags &= ~IDENTIFY_256COLOURS;
break;
case 'f':
cfg_file = xstrdup(optarg);
break;
case 'L':
if (path != NULL) {
log_warnx("-L and -S cannot be used together");
exit(1);
}
if (label != NULL)
xfree(label);
label = xstrdup(optarg);
break;
case 'S':
if (label != NULL) {
log_warnx("-L and -S cannot be used together");
exit(1);
}
if (path != NULL)
xfree(path);
path = xstrdup(optarg);
break;
case 'q':
be_quiet = 1;
break;
case 'u':
flags |= IDENTIFY_UTF8;
break;
case 'U':
unlock = 1;
break;
case 'd':
flags |= IDENTIFY_HASDEFAULTS;
break;
case 'v':
debug_level++;
break;
case 'V':
printf("%s " BUILD "\n", __progname);
exit(0);
default:
usage();
}
}
argc -= optind;
argv += optind;
log_open_tty(debug_level);
siginit();
options_init(&global_options, NULL);
options_set_number(&global_options, "bell-action", BELL_ANY);
options_set_number(&global_options, "buffer-limit", 9);
options_set_number(&global_options, "display-time", 750);
options_set_number(&global_options, "history-limit", 2000);
options_set_number(&global_options, "message-bg", 3);
options_set_number(&global_options, "message-fg", 0);
options_set_number(&global_options, "message-attr", GRID_ATTR_REVERSE);
options_set_number(&global_options, "prefix", META);
options_set_number(&global_options, "repeat-time", 500);
options_set_number(&global_options, "set-titles", 1);
options_set_number(&global_options, "lock-after-time", 0);
options_set_number(&global_options, "set-remain-on-exit", 0);
options_set_number(&global_options, "status", 1);
options_set_number(&global_options, "status-bg", 2);
options_set_number(&global_options, "status-fg", 0);
options_set_number(&global_options, "status-attr", GRID_ATTR_REVERSE);
options_set_number(&global_options, "status-interval", 15);
options_set_number(&global_options, "status-left-length", 10);
options_set_number(&global_options, "status-right-length", 40);
options_set_string(&global_options, "status-left", "[#S]");
options_set_string(
&global_options, "status-right", "\"#24T\" %%H:%%M %%d-%%b-%%y");
options_set_number(&global_options, "status-keys", MODEKEY_EMACS);
options_init(&global_window_options, NULL);
options_set_number(&global_window_options, "aggressive-resize", 0);
options_set_number(&global_window_options, "clock-mode-colour", 4);
options_set_number(&global_window_options, "clock-mode-style", 1);
options_set_number(&global_window_options, "force-height", 0);
options_set_number(&global_window_options, "force-width", 0);
options_set_number(&global_window_options, "automatic-rename", 1);
options_set_number(&global_window_options, "mode-bg", 3);
options_set_number(&global_window_options, "mode-fg", 0);
options_set_number(
&global_window_options, "mode-attr", GRID_ATTR_REVERSE);
options_set_number(&global_window_options, "mode-keys", MODEKEY_EMACS);
options_set_number(&global_window_options, "monitor-activity", 0);
options_set_number(&global_window_options, "utf8", 0);
options_set_number(&global_window_options, "xterm-keys", 0);
options_set_number(&global_window_options, "remain-on-exit", 0);
options_set_number(&global_window_options, "window-status-bg", 8);
options_set_number(&global_window_options, "window-status-fg", 8);
options_set_number(&global_window_options, "window-status-attr", 0);
if (cfg_file == NULL) {
home = getenv("HOME");
if (home == NULL || *home == '\0') {
pw = getpwuid(getuid());
if (pw != NULL)
home = pw->pw_dir;
endpwent();
}
xasprintf(&cfg_file, "%s/%s", home, DEFAULT_CFG);
if (access(cfg_file, R_OK) != 0) {
xfree(cfg_file);
cfg_file = NULL;
}
} else {
if (access(cfg_file, R_OK) != 0) {
log_warn("%s", cfg_file);
exit(1);
}
}
if (label == NULL)
label = xstrdup("default");
if (path == NULL && (path = makesockpath(label)) == NULL) {
log_warn("can't create socket");
exit(1);
}
xfree(label);
shell = getenv("SHELL");
if (shell == NULL || *shell == '\0') {
pw = getpwuid(getuid());
if (pw != NULL)
shell = pw->pw_shell;
endpwent();
if (shell == NULL || *shell == '\0')
shell = _PATH_BSHELL;
}
options_set_string(
&global_options, "default-command", "exec %s", shell);
if (getcwd(cwd, sizeof cwd) == NULL) {
log_warn("getcwd");
exit(1);
}
options_set_string(&global_options, "default-path", "%s", cwd);
if (unlock) {
if (argc != 0) {
log_warnx("can't specify a command when unlocking");
exit(1);
}
cmdlist = NULL;
if ((pass = getpass("Password: "******"%s", cause);
exit(1);
}
}
start_server = 0;
TAILQ_FOREACH(cmd, cmdlist, qentry) {
if (cmd->entry->flags & CMD_STARTSERVER) {
start_server = 1;
break;
}
}
}
memset(&cctx, 0, sizeof cctx);
if (client_init(path, &cctx, start_server, flags) != 0)
exit(1);
xfree(path);
b = buffer_create(BUFSIZ);
if (unlock) {
cmd_send_string(b, pass);
client_write_server(
&cctx, MSG_UNLOCK, BUFFER_OUT(b), BUFFER_USED(b));
} else {
cmd_list_send(cmdlist, b);
cmd_list_free(cmdlist);
client_fill_session(&cmddata);
client_write_server2(&cctx, MSG_COMMAND,
&cmddata, sizeof cmddata, BUFFER_OUT(b), BUFFER_USED(b));
}
buffer_destroy(b);
retcode = 0;
for (;;) {
pfd.fd = cctx.srv_fd;
pfd.events = POLLIN;
if (BUFFER_USED(cctx.srv_out) > 0)
pfd.events |= POLLOUT;
if (poll(&pfd, 1, INFTIM) == -1) {
if (errno == EAGAIN || errno == EINTR)
continue;
fatal("poll failed");
}
if (buffer_poll(&pfd, cctx.srv_in, cctx.srv_out) != 0)
goto out;
restart:
if (BUFFER_USED(cctx.srv_in) < sizeof hdr)
continue;
memcpy(&hdr, BUFFER_OUT(cctx.srv_in), sizeof hdr);
if (BUFFER_USED(cctx.srv_in) < (sizeof hdr) + hdr.size)
continue;
buffer_remove(cctx.srv_in, sizeof hdr);
switch (hdr.type) {
case MSG_EXIT:
case MSG_SHUTDOWN:
goto out;
case MSG_ERROR:
retcode = 1;
/* FALLTHROUGH */
case MSG_PRINT:
if (hdr.size > INT_MAX - 1)
fatalx("bad MSG_PRINT size");
log_info("%.*s",
(int) hdr.size, BUFFER_OUT(cctx.srv_in));
if (hdr.size != 0)
buffer_remove(cctx.srv_in, hdr.size);
goto restart;
case MSG_READY:
retcode = client_main(&cctx);
goto out;
default:
fatalx("unexpected command");
}
}
out:
options_free(&global_options);
options_free(&global_window_options);
close(cctx.srv_fd);
buffer_destroy(cctx.srv_in);
buffer_destroy(cctx.srv_out);
#ifdef DEBUG
xmalloc_report(getpid(), "client");
#endif
return (retcode);
}
