static void _list(menu_ptr menu, char *keys)
{
char temp[255];
int i;
int y = 1;
int x = 13;
Term_erase(x, y, 255);
if (menu->heading)
put_str(format(" %s", menu->heading), y++, x);
for (i = 0; i < menu->count; i++)
{
byte attr = TERM_WHITE;
variant key, text, color;
var_init(&key);
var_init(&text);
var_init(&color);
menu->fn(MENU_KEY, i, menu->cookie, &key);
if (var_is_null(&key))
keys[i] = I2A(i);
else
keys[i] = (char)var_get_int(&key);
if (menu->count <= 26)
keys[i] = tolower(keys[i]);
menu->fn(MENU_TEXT, i, menu->cookie, &text);
if (var_is_null(&text))
var_set_string(&text, "");
menu->fn(MENU_COLOR, i, menu->cookie, &color);
if (!var_is_null(&color))
attr = var_get_int(&color);
if (attr == TERM_DARK)
keys[i] = '\0';
sprintf(temp, " %c) %s", keys[i], var_get_string(&text));
c_prt(attr, temp, y + i, x);
var_clear(&key);
var_clear(&text);
var_clear(&color);
}
Term_erase(x, y + menu->count, 255);
}
/** Screen display function for watcher-related data */
void print_data (const char *meterid, const char *trig, var *v) {
const char *origin = var_get_str_forkey (v, "origin");
if (! origin) origin = "default";
char valst[64];
var *val = var_find_key (v, "val");
if (! val) return;
switch (val->type) {
case VAR_INT:
sprintf (valst, "%llu", var_get_int (val));
break;
case VAR_DOUBLE:
sprintf (valst, "%.2f", var_get_double (val));
break;
case VAR_STR:
strncpy (valst, var_get_str (val), 63);
valst[63] = 0;
break;
default:
strcpy (valst, "<error %i>");
break;
}
printf ("%-8s %-12s %-9s %-6s %21s %18.1f\n", origin, meterid,
trig, var_get_str_forkey (v, "cmp"), valst,
var_get_double_forkey (v, "weight"));
}
static gboolean s_download_slots(guint64 hub, const char *key, const char *val, GError **err) {
int old = var_get_int(hub, VAR_download_slots);
db_vars_set(hub, key, val);
if(int_raw(val) > old)
dl_queue_start();
return TRUE;
}
int get_spell_fail_min(ang_spell spell)
{
int n;
variant res;
var_init(&res);
spell(SPELL_FAIL_MIN, &res);
n = var_get_int(&res);
var_clear(&res);
return n;
}
int get_spell_cost_extra(ang_spell spell)
{
int n;
variant res;
var_init(&res);
spell(SPELL_COST_EXTRA, &res);
n = var_get_int(&res);
var_clear(&res);
return n;
}
int get_spell_energy(ang_spell spell)
{
int n;
variant res;
var_init(&res);
spell(SPELL_ENERGY, &res);
n = var_get_int(&res);
var_clear(&res);
return n;
}
void dump_spells_aux(FILE *fff, spell_info *table, int ct)
{
int i;
variant vn, vd, vc, vfm;
if (!ct) return;
var_init(&vn);
var_init(&vd);
var_init(&vc);
var_init(&vfm);
if (character_dump_hack)
{
fprintf(fff, "=================================== Spells ====================================\n\n");
fprintf(fff, "%-20.20s Lvl Cost Fail %-15.15s Cast Fail\n", "", "Desc");
}
else
{
fprintf(fff, "\n[[[[r|%-20.20s Lvl Cost Fail %-15.15s Cast Fail\n", "Spells", "Desc");
}
for (i = 0; i < ct; i++)
{
spell_info *spell = &table[i];
spell_stats_ptr stats = spell_stats(spell);
spell->fn(SPELL_NAME, &vn);
spell->fn(SPELL_INFO, &vd);
spell->fn(SPELL_COST_EXTRA, &vc);
spell->fn(SPELL_FAIL_MIN, &vfm);
fprintf(fff, "%-20.20s %3d %4d %3d%% %-15.15s %4d %4d %3d%%\n",
var_get_string(&vn),
spell->level, calculate_cost(spell->cost + var_get_int(&vc)), MAX(spell->fail, var_get_int(&vfm)),
var_get_string(&vd),
stats->ct_cast, stats->ct_fail,
spell_stats_fail(stats)
);
}
var_clear(&vn);
var_clear(&vd);
var_clear(&vc);
var_clear(&vfm);
}
static void _list_spells(spell_info* spells, int ct, int max_cost)
{
char temp[140];
int i;
rect_t display = ui_menu_rect();
int col_height = _col_height(ct);
int col_width;
variant name, info, color;
var_init(&name);
var_init(&info);
var_init(&color);
Term_erase(display.x, display.y, display.cx);
if (col_height == ct)
{
put_str("Lvl Cost Fail Desc", display.y, display.x + 29);
}
else
{
col_width = 42;
put_str("Lvl Cost Fail", display.y, display.x + 29);
put_str("Lvl Cost Fail", display.y, display.x + col_width + 29);
}
for (i = 0; i < ct; i++)
{
char letter = '\0';
byte attr = TERM_WHITE;
spell_info* spell = &spells[i];
var_set_int(&color, TERM_WHITE);
(spell->fn)(SPELL_NAME, &name);
(spell->fn)(SPELL_INFO, &info);
(spell->fn)(SPELL_COLOR, &color);
attr = var_get_int(&color);
if (i < 26)
letter = I2A(i);
else if (i < 52)
letter = 'A' + i - 26;
else
letter = '0' + i - 52;
sprintf(temp, " %c) ", letter);
strcat(temp, format("%-23.23s %3d %4d %3d%%",
var_get_string(&name),
spell->level,
spell->cost,
spell->fail));
if (col_height == ct)
strcat(temp, format(" %s", var_get_string(&info)));
if (spell->fail == 100)
attr = TERM_L_DARK;
if (spell->cost > max_cost)
attr = TERM_L_DARK;
if (spell->level > p_ptr->lev)
attr = TERM_L_DARK;
if (i < col_height)
{
Term_erase(display.x, display.y + i + 1, display.cx);
c_put_str(attr, temp, display.y + i + 1, display.x);
}
else
{
c_put_str(attr, temp, display.y + (i - col_height) + 1, display.x + col_width);
}
}
Term_erase(display.x, display.y + col_height + 1, display.cx);
var_clear(&name);
var_clear(&info);
var_clear(&color);
}
static void
wiki_handle_save()
{
char * user;
char * name;
char * title;
char * text;
char * userid; /* user's shortname */
char * password; /* users password */
char * group; /* name of a group page */
char * type; /* type of a group page */
char * topic; /* topic of a page */
int seqno;
bool saved;
bool priv;
bool hidden;
if (!user_is_authenticated()) {
html_login_page();
return;
}
if (!wiki_check_method(HTTP_POST))
return;
/* If page was submitted, then try to save it */
name = var_get_val(server->variables, "page");
if (name == NULL) {
out_write_error("406", /* not acceptable */
"There is no page name in the POST data!",
"How can you save a not named page?");
return;
}
if (!is_wikiword(name)) {
out_write_error("406", /* not acceptable */
"This is no valid page title!",
"The page title must be a WikiWord!");
return;
}
/* if the text was empty, then delete the page */
text = var_get_val(server->variables, "text");
if (text == NULL || strlen(text) == 0) {
if (page_del(pagelist_find_page(name))) {
out_write_page("DeletePage", MODE_HTML);
}
return;
}
user = user_get_logname();
title = var_get_val(server->variables, "title");
group = var_get_val(server->variables, "group");
type = var_get_val(server->variables, "pagetype");
topic = var_get_val(server->variables, "topic");
password = var_get_val(server->variables, "password");
userid = var_get_val(server->variables, "userid");
seqno = var_get_int(server->variables, "seqno");
priv = var_get_bool(server->variables, "private");
hidden = var_get_bool(server->variables, "hidden");
/* now really change the page, given all the data */
saved = page_edit(name, title, text, topic, user, userid, password,
group, type, seqno, priv, hidden);
if (saved)
out_write_page(name, MODE_HTML);
else
out_write_error("500", /* internal error */
"Could not save the page!",
"Maybe, somebody other has changed it in the meantime?");
}
/** Parse /collector/port */
int conf_collector_port (const char *id, var *v, updatetype tp) {
if (tp == UPDATE_REMOVE) exit (0);
APP.collectorport = var_get_int (v);
return 1;
}
int main(int argc, char **argv) {
setlocale(LC_ALL, "");
// Early logging goes to stderr
stderrlog = stderr;
// parse commandline options
GOptionContext *optx = g_option_context_new("- NCurses Direct Connect");
g_option_context_add_main_entries(optx, cli_options, NULL);
GError *err = NULL;
if(!g_option_context_parse(optx, &argc, &argv, &err)) {
puts(err->message);
exit(1);
}
g_option_context_free(optx);
// check that the current locale is UTF-8. Things aren't going to work otherwise
if(!g_get_charset(NULL)) {
puts("WARNING: Your current locale is not set to UTF-8.");
puts("Non-ASCII characters may not display correctly.");
puts("Hit Ctrl+c to abort ncdc, or the return key to continue anyway.");
getchar();
}
// init stuff
init_crypt();
g_thread_init(NULL);
// Create main loop
main_loop = g_main_loop_new(NULL, FALSE);
// setup logging
g_log_set_handler(NULL, G_LOG_FATAL_MASK | G_LOG_FLAG_FATAL | G_LOG_LEVEL_ERROR, log_fatal, NULL);
g_log_set_default_handler(log_redirect, NULL);
// Init database & variables
db_init();
vars_init();
// open log file
char *errlog = g_build_filename(db_dir, "stderr.log", NULL);
if(!(stderrlog = fopen(errlog, "w"))) {
fprintf(stderr, "ERROR: Couldn't open %s for writing: %s\n", errlog, strerror(errno));
exit(1);
}
g_free(errlog);
// Init more stuff
hub_init_global();
net_init_global();
listen_global_init();
cc_global_init();
dl_init_global();
ui_cmdhist_init("history");
ui_init(bracketed_paste);
geoip_reinit(4);
geoip_reinit(6);
// setup SIGWINCH
struct sigaction act;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_RESTART;
act.sa_handler = catch_sigwinch;
if(sigaction(SIGWINCH, &act, NULL) < 0)
g_error("Can't setup SIGWINCH: %s", g_strerror(errno));
// setup SIGTERM
act.sa_handler = catch_sigterm;
if(sigaction(SIGTERM, &act, NULL) < 0)
g_error("Can't setup SIGTERM: %s", g_strerror(errno));
// setup SIGHUP
act.sa_handler = catch_sighup;
if(sigaction(SIGHUP, &act, NULL) < 0)
g_error("Can't setup SIGHUP: %s", g_strerror(errno));
// setup SIGUSR1
act.sa_handler = catch_sigusr1;
if(sigaction(SIGUSR1, &act, NULL) < 0)
g_error("Can't setup SIGUSR1: %s", g_strerror(errno));
// setup SIGPIPE
act.sa_handler = catch_sigpipe;
if(sigaction(SIGPIPE, &act, NULL) < 0)
g_error("Can't setup SIGPIPE: %s", g_strerror(errno));
fl_init();
if(auto_open)
open_autoconnect();
// add some watches and start the main loop
GIOChannel *in = g_io_channel_unix_new(STDIN_FILENO);
g_io_add_watch(in, G_IO_IN, stdin_read, NULL);
GSource *sighandle = g_source_new(&sighandle_funcs, sizeof(GSource));
g_source_set_priority(sighandle, G_PRIORITY_HIGH);
g_source_set_callback(sighandle, sighandle_sourcefunc, NULL, NULL);
g_source_attach(sighandle, NULL);
g_source_unref(sighandle);
g_timeout_add_seconds_full(G_PRIORITY_HIGH, 1, one_second_timer, NULL, NULL);
g_timeout_add(100, screen_update_check, NULL);
int maxage = var_get_int(0, VAR_filelist_maxage);
g_timeout_add_seconds_full(G_PRIORITY_LOW, CLAMP(maxage, 3600, 24*3600), dl_fl_clean, NULL, NULL);
g_main_loop_run(main_loop);
// cleanup
if(!main_noterm) {
erase();
refresh();
endwin();
if(bracketed_paste)
ui_set_bracketed_paste(0);
printf("Flushing unsaved data to disk...");
fflush(stdout);
}
ui_cmdhist_close();
cc_global_close();
fl_flush(NULL);
dl_close_global();
db_close();
gnutls_global_deinit();
if(!main_noterm)
printf(" Done!\n");
g_debug("Clean shutdown.");
return 0;
}
/** Deep copy another var into one. The new structure will share no memory
* with the original.
* \param self The destination var
* \param orig The original var
*/
void var_copy (var *self, var *orig) {
if (self->type == VAR_STR) {
free (self->value.sval);
self->value.sval = NULL;
}
if (self->type == VAR_ARRAY || self->type == VAR_DICT) {
var *c = self->value.arr.first;
var *nc;
while (c) {
nc = c->next;
var_free (c);
c = nc;
}
self->value.arr.first = self->value.arr.last = NULL;
self->value.arr.cachepos = -1;
self->value.arr.cachenode = NULL;
self->value.arr.count = 0;
}
self->type = VAR_NULL;
var *crsr;
switch (orig->type) {
case VAR_NULL:
break;
case VAR_INT:
var_set_int (self, var_get_int (orig));
break;
case VAR_DOUBLE:
var_set_double (self, var_get_double (orig));
break;
case VAR_STR:
var_set_str (self, var_get_str (orig));
break;
case VAR_ARRAY:
self->type = VAR_ARRAY;
self->value.arr.first = self->value.arr.last = NULL;
self->value.arr.cachepos = -1;
self->value.arr.cachenode = NULL;
self->value.arr.count = 0;
crsr = orig->value.arr.first;
while (crsr) {
var *nvar = var_alloc();
nvar->id[0] = 0;
nvar->hashcode = 0;
var_copy (nvar, crsr);
var_link (nvar, self);
crsr = crsr->next;
}
break;
case VAR_DICT:
self->type = VAR_DICT;
self->value.arr.first = self->value.arr.last = NULL;
self->value.arr.cachepos = -1;
self->value.arr.cachenode = NULL;
self->value.arr.count = 0;
crsr = orig->value.arr.first;
while (crsr) {
var *nvar = var_alloc();
strcpy (nvar->id, crsr->id);
nvar->hashcode = crsr->hashcode;
var_copy (nvar, crsr);
var_link (nvar, self);
crsr = crsr->next;
}
break;
}
}
/** Extract the time out of a variable. There are two options here.
* If the type is VAR_INT, the value is treated as a unix timestamp
* and just typecast. If the type is VAR_STR, the value is parsed
* as a UTC iso timestring.
* \param self The var with the alleged time value
* \return Timestamp, 0 if none could be extracted.
*/
time_t var_get_time (var *self) {
if (self->type == VAR_INT) return (time_t) var_get_int (self);
if (self->type == VAR_STR) return utcstr2time (var_get_str (self));
return 0;
}
