Annotation of dgamelaunch-openbsd/dgamelaunch.c, Revision 1.1
1.1 ! rubenllo 1: /* dgamelaunch.c
! 2: *
! 3: * (c)2001-4 M. Drew Streib <dtype@dtype.org>
! 4: * also parts (c) 2003-4 Joshua Kwan <joshk@triplehelix.org>,
! 5: * Brett Carrington <brettcar@segvio.org>,
! 6: * Jilles Tjoelker <jilles@stack.nl>
! 7: *
! 8: * This program is free software; you can redistribute it and/or modify
! 9: * it under the terms of the GNU General Public License as published by
! 10: * the Free Software Foundation; either version 2 of the License, or
! 11: * (at your option) any later version.
! 12: *
! 13: * This program is distributed in the hope that it will be useful,
! 14: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 15: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 16: * GNU General Public License for more details.
! 17: *
! 18: * You should have received a copy of the GNU General Public License
! 19: * along with this program; if not, write to the Free Software
! 20: * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
! 21: */
! 22:
! 23: /*
! 24: * See this program in action at http://alt.org/nethack/
! 25: *
! 26: * This is a little wrapper for nethack (and soon other programs) that
! 27: * will allow them to be run from a telnetd session, chroot, shed privs,
! 28: * make a simple login, then play the game.
! 29: */
! 30:
! 31: #define _GNU_SOURCE
! 32:
! 33: #include "dgamelaunch.h"
! 34: #include "config.h"
! 35: #include "ttyplay.h"
! 36: #include "ttyrec.h"
! 37:
! 38: /* a request from the author: please leave some remnance of
! 39: * 'based on dgamelaunch version xxx' in any derivative works, or
! 40: * even keep the line the same altogether. I'm probably happy
! 41: * to make any changes you need. */
! 42:
! 43: /* ************************************************************* */
! 44:
! 45: /* program stuff */
! 46: #include <sys/types.h>
! 47: #include <sys/time.h>
! 48: #include <sys/wait.h>
! 49: #include <sys/ioctl.h> /* ttyrec */
! 50: #include <sys/stat.h>
! 51: #ifdef USE_RLIMIT
! 52: #include <sys/resource.h>
! 53: #endif
! 54:
! 55: #ifdef USE_SHMEM
! 56: #include <sys/ipc.h>
! 57: #include <sys/shm.h>
! 58: #endif
! 59:
! 60: #include <libgen.h>
! 61: #include <stdlib.h>
! 62: #include <curses.h>
! 63: #include <locale.h>
! 64:
! 65: #ifdef USE_SQLITE3
! 66: # include <sqlite3.h>
! 67: #endif
! 68:
! 69: #if defined(__FreeBSD__)
! 70: # include <libutil.h>
! 71: #elif defined(__NetBSD__)
! 72: # include <util.h>
! 73: #elif defined(__APPLE__)
! 74: # include <unistd.h>
! 75: #else
! 76: # include <crypt.h>
! 77: #endif
! 78:
! 79: #ifdef __linux__
! 80: # include <pty.h>
! 81: #endif
! 82:
! 83: #include <fcntl.h>
! 84: #include <pwd.h>
! 85: #include <grp.h>
! 86: #include <time.h>
! 87: #include <errno.h>
! 88: #include <dirent.h>
! 89: #include <string.h>
! 90: #include <signal.h>
! 91: #include <assert.h>
! 92: #include <ctype.h>
! 93: #include <unistd.h>
! 94: #include <termios.h>
! 95:
! 96: extern FILE* yyin;
! 97: extern int yyparse ();
! 98:
! 99: /* global variables */
! 100:
! 101: char * __progname;
! 102: int g_idle_alarm_enabled = 0;
! 103: int showplayers = 0;
! 104: int initplayer = 0;
! 105: void (*g_chain_winch)(int);
! 106:
! 107: #ifndef USE_SQLITE3
! 108: int f_num = 0;
! 109: struct dg_user **users = NULL;
! 110: #endif
! 111: struct dg_user *me = NULL;
! 112: struct dg_banner banner;
! 113:
! 114: static struct dg_watchcols default_watchcols[] = {
! 115: {SORTMODE_NONE, SORTMODE_NONE, 1, "", "%s)"},
! 116: {SORTMODE_USERNAME, SORTMODE_USERNAME, 4, "Username", "%-15s"},
! 117: {SORTMODE_GAMENUM, SORTMODE_GAMENUM, 21, "Game", "%-5s"},
! 118: {SORTMODE_WINDOWSIZE, SORTMODE_WINDOWSIZE, 28, " Size", "%s"},
! 119: {SORTMODE_STARTTIME, SORTMODE_STARTTIME, 37, "Start date & time", "%s"},
! 120: {SORTMODE_IDLETIME, SORTMODE_IDLETIME, 58, "Idle time", "%-10s"},
! 121: #ifdef USE_SHMEM
! 122: {SORTMODE_WATCHERS, SORTMODE_WATCHERS, 70, "Watchers", "%s"},
! 123: #endif
! 124: };
! 125:
! 126: int color_remap[16] = {
! 127: COLOR_PAIR(9) | A_NORMAL,
! 128: COLOR_PAIR(COLOR_BLUE) | A_NORMAL,
! 129: COLOR_PAIR(COLOR_GREEN) | A_NORMAL,
! 130: COLOR_PAIR(COLOR_CYAN) | A_NORMAL,
! 131: COLOR_PAIR(COLOR_RED) | A_NORMAL,
! 132: COLOR_PAIR(COLOR_MAGENTA) | A_NORMAL,
! 133: COLOR_PAIR(COLOR_YELLOW) | A_NORMAL,
! 134: COLOR_PAIR(COLOR_BLACK) | A_NORMAL,
! 135: COLOR_PAIR(10) | A_BOLD,
! 136: COLOR_PAIR(COLOR_BLUE) | A_BOLD,
! 137: COLOR_PAIR(COLOR_GREEN) | A_BOLD,
! 138: COLOR_PAIR(COLOR_CYAN) | A_BOLD,
! 139: COLOR_PAIR(COLOR_RED) | A_BOLD,
! 140: COLOR_PAIR(COLOR_MAGENTA) | A_BOLD,
! 141: COLOR_PAIR(COLOR_YELLOW) | A_BOLD,
! 142: COLOR_PAIR(COLOR_WHITE) | A_BOLD,
! 143: };
! 144:
! 145: static struct dg_watchcols *default_watchcols_list[DGL_MAXWATCHCOLS + 1];
! 146:
! 147: struct dg_user *
! 148: cpy_me(struct dg_user *me)
! 149: {
! 150: struct dg_user *tmp = malloc(sizeof(struct dg_user));
! 151:
! 152: if (tmp && me) {
! 153: #ifdef USE_SQLITE3
! 154: tmp->id = me->id;
! 155: #endif
! 156: if (me->username) tmp->username = strdup(me->username);
! 157: if (me->email) tmp->email = strdup(me->email);
! 158: if (me->env) tmp->env = strdup(me->env);
! 159: if (me->password) tmp->password = strdup(me->password);
! 160: tmp->flags = me->flags;
! 161: }
! 162: return tmp;
! 163: }
! 164:
! 165: #ifndef HAVE_SETENV
! 166: int
! 167: mysetenv (const char* name, const char* value, int overwrite)
! 168: {
! 169: int retval;
! 170: char *buf = NULL;
! 171:
! 172: if (getenv(name) == NULL || overwrite)
! 173: {
! 174: size_t len = strlen(name) + 1 + strlen(value) + 1; /* NAME=VALUE\0 */
! 175: buf = malloc(len);
! 176: snprintf(buf, len, "%s=%s", name, value);
! 177: retval = putenv(buf);
! 178: }
! 179: else
! 180: retval = -1;
! 181:
! 182: return retval;
! 183: }
! 184: #else /* use native setenv */
! 185: # define mysetenv setenv
! 186: #endif
! 187:
! 188: /* ************************************************************* */
! 189: /* for ttyrec */
! 190:
! 191: void
! 192: ttyrec_getpty ()
! 193: {
! 194: #ifdef HAVE_OPENPTY
! 195: if (openpty (&master, &slave, NULL, NULL, NULL) == -1) {
! 196: debug_write("cannot openpty");
! 197: graceful_exit (61);
! 198: }
! 199: #else
! 200: if ((master = open ("/dev/ptmx", O_RDWR)) < 0) {
! 201: debug_write("cannot open /dev/ptmx");
! 202: graceful_exit (62);
! 203: }
! 204: grantpt (master);
! 205: unlockpt (master);
! 206: if ((slave = open ((const char *) ptsname (master), O_RDWR)) < 0)
! 207: {
! 208: debug_write("cannot open master ptsname");
! 209: graceful_exit (65);
! 210: }
! 211: #endif
! 212: ioctl (slave, TIOCSWINSZ, (char *) &win);
! 213: tcsetattr(slave, TCSANOW, &tt);
! 214: }
! 215:
! 216: /* ************************************************************* */
! 217:
! 218: static int dgl_signal_blocked = 0;
! 219: static sigset_t dgl_signal_blockmask;
! 220: static sigset_t dgl_signal_oldmask;
! 221:
! 222: void
! 223: signals_block()
! 224: {
! 225: if (!dgl_signal_blocked) {
! 226: sigemptyset(&dgl_signal_blockmask);
! 227: sigaddset(&dgl_signal_blockmask, SIGHUP);
! 228: sigaddset(&dgl_signal_blockmask, SIGINT);
! 229: sigaddset(&dgl_signal_blockmask, SIGQUIT);
! 230: sigaddset(&dgl_signal_blockmask, SIGTERM);
! 231: sigprocmask(SIG_BLOCK, &dgl_signal_blockmask, &dgl_signal_oldmask);
! 232: dgl_signal_blocked = 1;
! 233: }
! 234: }
! 235:
! 236: void
! 237: signals_release()
! 238: {
! 239: if (dgl_signal_blocked) {
! 240: sigprocmask(SIG_SETMASK, &dgl_signal_oldmask, NULL);
! 241: dgl_signal_blocked = 0;
! 242: }
! 243: }
! 244:
! 245:
! 246: /* ************************************************************* */
! 247:
! 248: char *
! 249: get_mainmenu_name()
! 250: {
! 251: if (loggedin) {
! 252: if (me && (me->flags & DGLACCT_ADMIN)) return "mainmenu_admin";
! 253: return "mainmenu_user";
! 254: }
! 255: return "mainmenu_anon";
! 256: }
! 257:
! 258:
! 259: char*
! 260: gen_ttyrec_filename ()
! 261: {
! 262: time_t rawtime;
! 263: struct tm *ptm;
! 264: char *ttyrec_filename = calloc(100, sizeof(char));
! 265:
! 266: /* append time to filename */
! 267: time (&rawtime);
! 268: ptm = gmtime (&rawtime);
! 269: snprintf (ttyrec_filename, 100, "%04i-%02i-%02i.%02i:%02i:%02i.ttyrec",
! 270: ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday,
! 271: ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
! 272: return ttyrec_filename;
! 273: }
! 274:
! 275: /* ************************************************************* */
! 276:
! 277: char*
! 278: gen_inprogress_lock (int game, pid_t pid, char* ttyrec_filename)
! 279: {
! 280: char *lockfile = NULL, filebuf[80];
! 281: int fd;
! 282: size_t len, wrlen;
! 283: struct flock fl = { 0 };
! 284:
! 285: snprintf (filebuf, sizeof(filebuf), "%d\n%d\n%d\n",
! 286: pid, win.ws_row, win.ws_col);
! 287:
! 288: wrlen = strlen(filebuf);
! 289:
! 290: fl.l_type = F_WRLCK;
! 291: fl.l_whence = SEEK_SET;
! 292: fl.l_start = 0;
! 293: fl.l_len = 0;
! 294:
! 295: len = strlen(dgl_format_str(game, me, myconfig[game]->inprogressdir, NULL)) + strlen(me->username) + strlen(ttyrec_filename) + 13;
! 296: lockfile = calloc(len, sizeof(char));
! 297:
! 298: snprintf (lockfile, len, "%s%s:%s", dgl_format_str(game, me, myconfig[game]->inprogressdir, NULL),
! 299: me->username, ttyrec_filename);
! 300:
! 301: fd = open (lockfile, O_WRONLY | O_CREAT, 0644);
! 302: if (fcntl (fd, F_SETLKW, &fl) == -1) {
! 303: debug_write("cannot fnctl inprogress-lock");
! 304: graceful_exit (68);
! 305: }
! 306:
! 307: if (write (fd, filebuf, wrlen) != wrlen) {
! 308: debug_write("inprogress-lock write");
! 309: graceful_exit(70);
! 310: }
! 311:
! 312: return lockfile;
! 313: }
! 314:
! 315: /* ************************************************************* */
! 316:
! 317: #ifdef USE_SHMEM
! 318: int hup_shm_idx = -1;
! 319: char *hup_shm_ttyrec_fn = NULL;
! 320: #endif
! 321:
! 322: void
! 323: catch_sighup (int signum)
! 324: {
! 325: if (child)
! 326: {
! 327: sleep (10);
! 328: kill (child, SIGHUP);
! 329: sleep (5);
! 330: }
! 331: #ifdef USE_SHMEM
! 332: signals_block();
! 333: if (hup_shm_idx != -1) {
! 334: struct dg_shm *shm_dg_data = NULL;
! 335: struct dg_shm_game *shm_dg_game = NULL;
! 336: shm_init(&shm_dg_data, &shm_dg_game);
! 337:
! 338: shm_sem_wait(shm_dg_data);
! 339: if (shm_dg_game[hup_shm_idx].in_use &&
! 340: !strcmp(shm_dg_game[hup_shm_idx].ttyrec_fn, hup_shm_ttyrec_fn) &&
! 341: (shm_dg_game[hup_shm_idx].nwatchers > 0)) {
! 342: shm_dg_game[hup_shm_idx].nwatchers--;
! 343: }
! 344: shm_sem_post(shm_dg_data);
! 345: hup_shm_idx = -1;
! 346: free(hup_shm_ttyrec_fn);
! 347: }
! 348: signals_release();
! 349: #endif
! 350: debug_write("catchup sighup");
! 351: graceful_exit (7);
! 352: }
! 353:
! 354: /* ************************************************************* */
! 355:
! 356: int
! 357: dgl_getch(void)
! 358: {
! 359: const int c = getch();
! 360: idle_alarm_reset();
! 361: return c;
! 362: }
! 363:
! 364: /* ************************************************************* */
! 365:
! 366: static void
! 367: dgl_idle_kill(int signal)
! 368: {
! 369: kill(0, SIGHUP);
! 370: }
! 371:
! 372: void
! 373: idle_alarm_set_enabled(int enabled)
! 374: {
! 375: signal(SIGALRM, SIG_IGN);
! 376: g_idle_alarm_enabled = enabled;
! 377: idle_alarm_reset();
! 378: if (enabled)
! 379: signal(SIGALRM, dgl_idle_kill);
! 380: }
! 381:
! 382: void
! 383: idle_alarm_reset(void)
! 384: {
! 385: if (g_idle_alarm_enabled && globalconfig.menu_max_idle_time > 0)
! 386: alarm(globalconfig.menu_max_idle_time);
! 387: }
! 388:
! 389: /* ************************************************************* */
! 390:
! 391:
! 392: char *
! 393: bannerstrmangle(char *buf, char *bufnew, int buflen, char *fromstr, char *tostr)
! 394: {
! 395: char *loc;
! 396: char *b = buf;
! 397:
! 398: memset (bufnew, 0, buflen);
! 399:
! 400: if (strstr(b, fromstr)) {
! 401: int i = 0;
! 402: while ((loc = strstr (b, fromstr)) != NULL) {
! 403: for (; i < buflen; i++) {
! 404: if (loc != b)
! 405: bufnew[i] = *(b++);
! 406: else {
! 407: strlcat (bufnew, tostr, buflen);
! 408: b += strlen(fromstr);
! 409: i += strlen(tostr);
! 410: break;
! 411: }
! 412:
! 413: if (strlen (b) == 0)
! 414: break;
! 415: }
! 416: }
! 417:
! 418: if (*b)
! 419: strlcat(bufnew, b, buflen);
! 420: } else strncpy(bufnew, buf, buflen);
! 421: return bufnew;
! 422: }
! 423:
! 424: void
! 425: banner_var_add(char *name, char *value, int special)
! 426: {
! 427: struct dg_banner_var *tmp = (struct dg_banner_var *)malloc(sizeof(struct dg_banner_var));
! 428:
! 429: if (!tmp) return;
! 430:
! 431: tmp->name = strdup(name);
! 432: tmp->value = strdup(value);
! 433: tmp->special = special;
! 434: tmp->next = globalconfig.banner_var_list;
! 435: globalconfig.banner_var_list = tmp;
! 436: }
! 437:
! 438: void
! 439: banner_var_free()
! 440: {
! 441: struct dg_banner_var *tmp;
! 442: struct dg_banner_var *bv = globalconfig.banner_var_list;
! 443: while (bv) {
! 444: tmp = bv->next;
! 445: free(bv->name);
! 446: free(bv->value);
! 447: free(bv);
! 448: bv = tmp;
! 449: }
! 450: globalconfig.banner_var_list = NULL;
! 451: }
! 452:
! 453: char *
! 454: banner_var_resolve(struct dg_banner_var *bv)
! 455: {
! 456: static char tmpbuf[DGL_BANNER_LINELEN+1];
! 457: time_t tstamp;
! 458: struct tm *ptm;
! 459: if (!bv) return NULL;
! 460: if (!bv->special) return bv->value;
! 461: time(&tstamp);
! 462: ptm = gmtime(&tstamp);
! 463: strftime(tmpbuf, DGL_BANNER_LINELEN, bv->value, ptm);
! 464: return tmpbuf;
! 465: }
! 466:
! 467: char *
! 468: banner_var_value(char *name)
! 469: {
! 470: struct dg_banner_var *bv = globalconfig.banner_var_list;
! 471: while (bv) {
! 472: if (!strcmp(bv->name, name)) return banner_var_resolve(bv);
! 473: bv = bv->next;
! 474: }
! 475: return NULL;
! 476: }
! 477:
! 478: void
! 479: freebanner(struct dg_banner *ban)
! 480: {
! 481: unsigned int l;
! 482: if (!ban) return;
! 483: l = ban->len;
! 484:
! 485: while (l > 0) {
! 486: l--;
! 487: free(ban->lines[l]);
! 488: }
! 489: free(ban->lines);
! 490: ban->len = 0;
! 491: ban->lines = NULL;
! 492: }
! 493:
! 494: void
! 495: banner_addline(struct dg_banner *ban, char *line)
! 496: {
! 497: size_t len = strlen(line);
! 498: if (!ban) return;
! 499: ban->len++;
! 500: ban->lines = realloc (ban->lines, sizeof (char *) * ban->len);
! 501: if (len >= DGL_BANNER_LINELEN) {
! 502: len = DGL_BANNER_LINELEN;
! 503: ban->lines[ban->len - 1] = malloc(len);
! 504: strncpy(ban->lines[ban->len - 1], line, len);
! 505: ban->lines[ban->len - 1][len-1] = '\0';
! 506: } else
! 507: ban->lines[ban->len - 1] = strdup(line);
! 508: }
! 509:
! 510: void
! 511: loadbanner (char *fname, struct dg_banner *ban)
! 512: {
! 513: FILE *bannerfile;
! 514: char buf[DGL_BANNER_LINELEN+1];
! 515: if (ban->len > 23) return;
! 516:
! 517: memset (buf, 0, DGL_BANNER_LINELEN);
! 518:
! 519: bannerfile = fopen (fname, "r");
! 520:
! 521: if (!bannerfile)
! 522: {
! 523: if (ban->len == 0)
! 524: banner_addline(ban, "### dgamelaunch " PACKAGE_VERSION " - network console game launcher");
! 525: snprintf(buf, DGL_BANNER_LINELEN, "### NOTE: administrator has not installed a %s file", fname);
! 526: banner_addline(ban, buf);
! 527: return;
! 528: }
! 529:
! 530: while (fgets (buf, DGL_BANNER_LINELEN, bannerfile) != NULL)
! 531: {
! 532: char bufnew[DGL_BANNER_LINELEN+1];
! 533: int slen;
! 534:
! 535: memset (bufnew, 0, DGL_BANNER_LINELEN);
! 536:
! 537: slen = strlen(buf);
! 538: if ((slen > 0) && (buf[slen-1] == '\n')) buf[slen-1] = '\0';
! 539:
! 540: strncpy(bufnew, buf, DGL_BANNER_LINELEN);
! 541: if (strstr(bufnew, "$INCLUDE(")) {
! 542: char *fn = bufnew + 9;
! 543: char *fn_end = strchr(fn, ')');
! 544: if (fn_end) {
! 545: *fn_end = '\0';
! 546: if (strcmp(fname, fn)) {
! 547: loadbanner(fn, ban);
! 548: }
! 549: }
! 550: } else {
! 551: char tmpbufnew[DGL_BANNER_LINELEN+1];
! 552: struct dg_banner_var *bv = globalconfig.banner_var_list;
! 553: while (bv) {
! 554: strncpy(bufnew, bannerstrmangle(bufnew, tmpbufnew, DGL_BANNER_LINELEN, bv->name, banner_var_resolve(bv)), DGL_BANNER_LINELEN);
! 555: bv = bv->next;
! 556: }
! 557: strncpy(bufnew, bannerstrmangle(bufnew, tmpbufnew, DGL_BANNER_LINELEN, "$VERSION", PACKAGE_STRING), DGL_BANNER_LINELEN);
! 558: if (me && loggedin) {
! 559: strncpy(bufnew, bannerstrmangle(bufnew, tmpbufnew, DGL_BANNER_LINELEN, "$USERNAME", me->username), DGL_BANNER_LINELEN);
! 560: } else {
! 561: strncpy(bufnew, bannerstrmangle(bufnew, tmpbufnew, DGL_BANNER_LINELEN, "$USERNAME", "[Anonymous]"), DGL_BANNER_LINELEN);
! 562: }
! 563: banner_addline(ban, bufnew);
! 564: }
! 565:
! 566: memset (buf, 0, DGL_BANNER_LINELEN);
! 567:
! 568: if (ban->len >= 24)
! 569: break;
! 570: }
! 571:
! 572: fclose (bannerfile);
! 573: }
! 574:
! 575: void
! 576: drawbanner (struct dg_banner *ban)
! 577: {
! 578: unsigned int i;
! 579: char *tmpch, *tmpch2, *splch;
! 580: int attr = 0, oattr = 0;
! 581:
! 582: if (!ban) return;
! 583:
! 584: for (i = 0; i < ban->len; i++) {
! 585: char *tmpbuf = strdup(ban->lines[i]);
! 586: char *tmpbuf2 = tmpbuf;
! 587: int ok = 0;
! 588: int x = 1;
! 589: do {
! 590: ok = 0;
! 591: if ((tmpch = strstr(tmpbuf2, "$ATTR("))) {
! 592: if ((tmpch2 = strstr(tmpch, ")"))) {
! 593: int spl = 0;
! 594: char *nxttmpch;
! 595: ok = 1;
! 596: oattr = attr;
! 597: attr = A_NORMAL;
! 598: *tmpch = *tmpch2 = '\0';
! 599: tmpch += 6;
! 600: nxttmpch = tmpch;
! 601: do {
! 602: spl = 0;
! 603: splch = strchr(tmpch, ';');
! 604: if (splch && *splch) {
! 605: spl = 1;
! 606: nxttmpch = splch;
! 607: *nxttmpch = '\0';
! 608: nxttmpch++;
! 609: }
! 610: if (tmpch && *tmpch) {
! 611: switch (*tmpch) {
! 612: default: break;
! 613: case '0': case '1': case '2': case '3': case '4':
! 614: case '5': case '6': case '7': case '8': case '9':
! 615: {
! 616: int num = atoi(tmpch);
! 617: if (num >= 0 && num <= 15)
! 618: attr |= color_remap[num];
! 619: }
! 620: break;
! 621: case 'b': attr |= A_BOLD; break;
! 622: case 's': attr |= A_STANDOUT; break;
! 623: case 'u': attr |= A_UNDERLINE; break;
! 624: case 'r': attr |= A_REVERSE; break;
! 625: case 'd': attr |= A_DIM; break;
! 626: }
! 627: } else attr = A_NORMAL;
! 628: tmpch = nxttmpch;
! 629: } while (spl);
! 630:
! 631: mvaddstr(1 + i, x, tmpbuf2);
! 632: if (oattr) attroff(oattr);
! 633: if (attr) attron(attr);
! 634: x += strlen(tmpbuf2);
! 635: tmpch2++;
! 636: tmpbuf2 = tmpch2;
! 637: } else
! 638: mvaddstr (1 + i, x, tmpbuf2);
! 639: } else
! 640: mvaddstr (1 + i, x, tmpbuf2);
! 641: } while (ok);
! 642: free(tmpbuf);
! 643: }
! 644: }
! 645:
! 646: void
! 647: shm_sem_wait(struct dg_shm *shm_dg_data)
! 648: {
! 649: #ifdef USE_SHMEM
! 650: if (sem_wait(&(shm_dg_data->dg_sem)) == -1) {
! 651: debug_write("sem_wait");
! 652: graceful_exit(77);
! 653: }
! 654: #endif
! 655: }
! 656:
! 657: void
! 658: shm_sem_post(struct dg_shm *shm_dg_data)
! 659: {
! 660: #ifdef USE_SHMEM
! 661: if (sem_post(&(shm_dg_data->dg_sem)) == -1) {
! 662: debug_write("sem_post");
! 663: graceful_exit(78);
! 664: }
! 665: #endif
! 666: }
! 667:
! 668: void
! 669: shm_update(struct dg_shm *shm_dg_data, struct dg_game **games, int len)
! 670: {
! 671: #ifdef USE_SHMEM
! 672: int di, i;
! 673: struct dg_shm_game *shm_dg_game = (struct dg_shm_game *)(shm_dg_data + sizeof(struct dg_shm));
! 674:
! 675: signals_block();
! 676: shm_sem_wait(shm_dg_data);
! 677:
! 678: for (di = 0; di < shm_dg_data->max_n_games; di++)
! 679: if (shm_dg_game[di].in_use) {
! 680: int delgame = 1;
! 681: for (i = 0; i < len; i++) {
! 682: if (!strcmp(games[i]->ttyrec_fn, shm_dg_game[di].ttyrec_fn)) {
! 683: delgame = 0;
! 684: games[i]->is_in_shm = 1;
! 685: games[i]->shm_idx = di;
! 686: games[i]->nwatchers = shm_dg_game[di].nwatchers;
! 687: break;
! 688: }
! 689: }
! 690: if (delgame) {
! 691: shm_dg_game[di].in_use = 0;
! 692: if (shm_dg_data->cur_n_games > 0) shm_dg_data->cur_n_games--;
! 693: }
! 694: }
! 695:
! 696: if (shm_dg_data->cur_n_games < shm_dg_data->max_n_games) {
! 697: for (i = 0; i < len; i++)
! 698: if (!games[i]->is_in_shm) {
! 699: for (di = 0; di < shm_dg_data->max_n_games; di++)
! 700: if (!shm_dg_game[di].in_use) {
! 701: shm_dg_game[di].in_use = 1;
! 702: shm_dg_game[di].nwatchers = 0;
! 703: games[i]->nwatchers = 0;
! 704: games[i]->is_in_shm = 1;
! 705: games[i]->shm_idx = di;
! 706: shm_dg_data->cur_n_games++;
! 707: strncpy(shm_dg_game[di].ttyrec_fn, games[i]->ttyrec_fn, 150);
! 708: break;
! 709: }
! 710: }
! 711: }
! 712:
! 713: shm_sem_post(shm_dg_data);
! 714: signals_release();
! 715: #endif
! 716: }
! 717:
! 718: void
! 719: shm_mk_keys(key_t *shm_key, key_t *shm_sem_key)
! 720: {
! 721: #ifdef USE_SHMEM
! 722: if ((*shm_key = ftok(globalconfig.passwd, 'R')) == -1) {
! 723: debug_write("ftok shm_key");
! 724: graceful_exit(71);
! 725: }
! 726: if ((*shm_sem_key = ftok(globalconfig.passwd, 'S')) == -1) {
! 727: debug_write("ftok shm_sem_key");
! 728: graceful_exit(72);
! 729: }
! 730: #endif
! 731: }
! 732:
! 733: #ifdef USE_SHMEM
! 734: int
! 735: shm_free()
! 736: {
! 737: key_t shm, sem;
! 738: int shm_id;
! 739: int shm_size = sizeof(struct dg_shm) + shm_n_games * sizeof(struct dg_shm_game);
! 740: shm_mk_keys(&shm, &sem);
! 741: if ((shm_id = shmget(shm, shm_size, 0644)) != -1) {
! 742: shmctl(shm_id, IPC_RMID, NULL);
! 743: return 0;
! 744: }
! 745: return 1;
! 746: }
! 747: #endif
! 748:
! 749: void
! 750: shm_init(struct dg_shm **shm_dg_data, struct dg_shm_game **shm_dg_game)
! 751: {
! 752: #ifdef USE_SHMEM
! 753: key_t shm_key;
! 754: key_t shm_sem_key;
! 755: int shm_id;
! 756: int shm_size;
! 757: void *shm_data = NULL;
! 758: int shm_data_existed = 0;
! 759:
! 760: shm_mk_keys(&shm_key, &shm_sem_key);
! 761:
! 762: /* max. shm_n_games simultaneous games recorded in the shared memory */
! 763: shm_size = sizeof(struct dg_shm) + shm_n_games * sizeof(struct dg_shm_game);
! 764:
! 765: /* connect to (and possibly create) the segment */
! 766: if ((shm_id = shmget(shm_key, shm_size, 0644 | IPC_CREAT | IPC_EXCL)) == -1) {
! 767: /* creation failed, so it already exists. attach to it */
! 768: shm_data_existed = 1;
! 769: if ((shm_id = shmget(shm_key, shm_size, 0644)) == -1) {
! 770: debug_write("shmget");
! 771: graceful_exit(73);
! 772: }
! 773: }
! 774:
! 775: /* attach to the segment to get a pointer to it: */
! 776: shm_data = shmat(shm_id, (void *)0, 0);
! 777: if (shm_data == (char *)(-1)) {
! 778: debug_write("shmat");
! 779: graceful_exit(74);
! 780: }
! 781: if (!shm_data) {
! 782: debug_write("shm_data == null");
! 783: graceful_exit(75);
! 784: }
! 785:
! 786: (*shm_dg_data) = (struct dg_shm *)shm_data;
! 787: (*shm_dg_game) = (struct dg_shm_game *)((*shm_dg_data) + sizeof(struct dg_shm));
! 788:
! 789: if (!shm_data_existed && shm_data) {
! 790: memset(*shm_dg_game, 0, shm_n_games*sizeof(struct dg_shm_game));
! 791: (*shm_dg_data)->max_n_games = shm_n_games;
! 792: (*shm_dg_data)->cur_n_games = 0;
! 793: if (sem_init(&((*shm_dg_data)->dg_sem), 1,1) == -1) {
! 794: debug_write("sem_init");
! 795: graceful_exit(76);
! 796: }
! 797: }
! 798: #endif /* USE_SHMEM */
! 799: }
! 800:
! 801: #ifdef USE_SHMEM
! 802: void
! 803: shm_dump()
! 804: {
! 805: struct dg_shm *shm_dg_data = NULL;
! 806: struct dg_shm_game *shm_dg_game = NULL;
! 807: int di, unused = -1;
! 808: shm_init(&shm_dg_data, &shm_dg_game);
! 809: shm_sem_wait(shm_dg_data);
! 810: for (di = 0; di < shm_dg_data->max_n_games; di++) {
! 811: if (shm_dg_game[di].in_use) {
! 812: if (unused != -1) {
! 813: if (unused != di-1)
! 814: fprintf(stderr, "%i-%i:\tunused\n", unused, di-1);
! 815: else
! 816: fprintf(stderr, "%i:\tunused\n", unused);
! 817: unused = -1;
! 818: }
! 819: fprintf(stderr, "%i:\t\"%s\"\twatchers:%li\n", di, shm_dg_game[di].ttyrec_fn, shm_dg_game[di].nwatchers);
! 820: } else {
! 821: if (unused == -1) unused = di;
! 822: }
! 823: }
! 824: if (unused != -1) {
! 825: if (unused != di-1)
! 826: fprintf(stderr, "%i-%i:\tunused\n", unused, di-1);
! 827: else
! 828: fprintf(stderr, "%i:\tunused\n", unused);
! 829: unused = -1;
! 830: }
! 831: shm_sem_post(shm_dg_data);
! 832: shmdt(shm_dg_data);
! 833: }
! 834: #endif
! 835:
! 836: static
! 837: struct dg_watchcols **
! 838: globalconfig_watch_columns()
! 839: {
! 840: if (globalconfig.n_watch_columns)
! 841: return globalconfig.watch_columns;
! 842:
! 843: if (!*default_watchcols_list) {
! 844: int i;
! 845: for (i = 0; i < ARRAY_SIZE(default_watchcols); ++i)
! 846: default_watchcols_list[i] = &default_watchcols[i];
! 847: }
! 848: return default_watchcols_list;
! 849: }
! 850:
! 851: static
! 852: int
! 853: watchcol_find_index(struct dg_watchcols **watchcols,
! 854: int sortmode)
! 855: {
! 856: int i;
! 857: for (i = 0; watchcols[i]; ++i)
! 858: if (watchcols[i]->sortmode == sortmode)
! 859: return i;
! 860: return -1;
! 861: }
! 862:
! 863: static
! 864: void
! 865: sortmode_increment(struct dg_watchcols **watchcols,
! 866: dg_sortmode *sortmode,
! 867: int direction)
! 868: {
! 869: int watch_column_index = watchcol_find_index(watchcols, *sortmode);
! 870: int n_watchcols;
! 871: int wrap_count = 0;
! 872: const dg_sortmode old_sortmode = *sortmode;
! 873:
! 874: for (n_watchcols = 0; watchcols[n_watchcols]; ++n_watchcols)
! 875: ;
! 876:
! 877: if (watch_column_index == -1 || !n_watchcols)
! 878: return;
! 879:
! 880: do {
! 881: watch_column_index += direction;
! 882:
! 883: if (watch_column_index < 0) {
! 884: watch_column_index = n_watchcols - 1;
! 885: ++wrap_count;
! 886: } else if (watch_column_index >= n_watchcols) {
! 887: watch_column_index = 0;
! 888: ++wrap_count;
! 889: }
! 890:
! 891: *sortmode = watchcols[watch_column_index]->sortmode;
! 892: } while (wrap_count < 2 && !*sortmode);
! 893:
! 894: if (!*sortmode)
! 895: *sortmode = old_sortmode;
! 896: }
! 897:
! 898: char *
! 899: get_timediff(time_t ctime, long seconds)
! 900: {
! 901: static char data[32];
! 902: long secs, mins, hours;
! 903:
! 904: secs = (ctime - seconds);
! 905:
! 906: if (showplayers) {
! 907: snprintf(data, 10, "%ld", secs);
! 908: return data;
! 909: }
! 910:
! 911: hours = (secs / 3600);
! 912: secs -= (hours * 3600);
! 913: mins = (secs / 60) % 60;
! 914: secs -= (mins*60);
! 915: if (hours)
! 916: snprintf(data, 10, "%ldh %ldm", hours, mins);
! 917: else if (mins)
! 918: snprintf(data, 10, "%ldm %lds", mins, secs);
! 919: else if (secs > 4)
! 920: snprintf(data, 30, "%lds", secs);
! 921: else
! 922: snprintf(data, 10, " ");
! 923: return data;
! 924: }
! 925:
! 926: static
! 927: void
! 928: game_get_column_data(struct dg_game *game,
! 929: char selectorchar,
! 930: time_t ctime, struct dg_shm_game *shm_dg_game,
! 931: char *data, int bufsz, int *hilite,
! 932: dg_sortmode which_data)
! 933: {
! 934: *data = 0;
! 935:
! 936: switch (which_data) {
! 937: default: break;
! 938: case SORTMODE_NONE:
! 939: data[0] = selectorchar; data[1] = '\0';
! 940: break;
! 941:
! 942: case SORTMODE_USERNAME:
! 943: snprintf(data, bufsz, "%s", game->name);
! 944: break;
! 945:
! 946: case SORTMODE_GAMENUM:
! 947: snprintf(data, bufsz, "%s",
! 948: myconfig[game->gamenum]->shortname);
! 949: break;
! 950:
! 951: case SORTMODE_WINDOWSIZE:
! 952: snprintf(data, bufsz, "%3dx%3d", game->ws_col, game->ws_row);
! 953: if (showplayers)
! 954: snprintf(data, bufsz, "%dx%d", game->ws_col, game->ws_row);
! 955: else
! 956: snprintf(data, bufsz, "%3dx%3d", game->ws_col, game->ws_row);
! 957: if ((game->ws_col > COLS || game->ws_row > LINES))
! 958: *hilite = CLR_RED;
! 959: break;
! 960:
! 961: case SORTMODE_STARTTIME:
! 962: snprintf(data, bufsz, "%s %s", game->date,
! 963: game->time);
! 964: break;
! 965:
! 966: case SORTMODE_DURATION:
! 967: {
! 968: /* TODO: populate_games() should put st_ctime into game struct */
! 969: struct tm timetm;
! 970: char tmptimebuf[32];
! 971: snprintf(tmptimebuf, 30, "%s %s", game->date, game->time);
! 972: tmptimebuf[31] = '\0';
! 973: strptime(tmptimebuf, "%Y-%m-%d %H:%M:%S", &timetm);
! 974: snprintf(data, 10, "%s", get_timediff(ctime, mktime(&timetm)));
! 975: }
! 976: break;
! 977:
! 978: case SORTMODE_IDLETIME:
! 979: snprintf(data, 10, "%s", get_timediff(ctime, game->idle_time));
! 980: break;
! 981:
! 982: case SORTMODE_EXTRA_INFO:
! 983: if (game->extra_info)
! 984: strlcpy(data, game->extra_info, bufsz);
! 985: break;
! 986:
! 987: #ifdef USE_SHMEM
! 988: case SORTMODE_WATCHERS:
! 989: snprintf(data, bufsz, "%li",
! 990: (game->is_in_shm ?
! 991: shm_dg_game[game->shm_idx].nwatchers : -1));
! 992: break;
! 993: #endif
! 994: }
! 995: data[bufsz - 1] = '\0';
! 996: }
! 997:
! 998: void
! 999: inprogressmenu (int gameid)
! 1000: {
! 1001: const char *selectorchars = "abcdefghijklmnoprstuvwxyzABCDEFGHIJKLMNOPRSTUVWXYZ";
! 1002: int i, menuchoice, len = 20, offset = 0;
! 1003: static dg_sortmode sortmode = NUM_SORTMODES;
! 1004: struct dg_game **games = NULL;
! 1005: char ttyrecname[130], gametype[10], idletime[10];
! 1006: sigset_t oldmask, toblock;
! 1007: int idx = -1;
! 1008: int shm_idx = -1;
! 1009: int max_height = -1;
! 1010: int selected = -1;
! 1011:
! 1012: int resizex = -1;
! 1013: int resizey = -1;
! 1014:
! 1015: char *selectedgame = NULL;
! 1016:
! 1017: int abs_max_height;
! 1018: int top_banner_hei = 5;
! 1019: int btm_banner_hei = 3;
! 1020: int btm;
! 1021:
! 1022: int title_attr = A_STANDOUT;
! 1023: int selected_attr = A_BOLD;
! 1024:
! 1025: int require_enter = 0; /* TODO: make configurable */
! 1026:
! 1027: time_t ctime;
! 1028:
! 1029: struct dg_shm *shm_dg_data = NULL;
! 1030: struct dg_shm_game *shm_dg_game = NULL;
! 1031:
! 1032: struct dg_watchcols **watchcols = globalconfig_watch_columns();
! 1033: struct dg_watchcols **curr_watchcol;
! 1034:
! 1035: if (sortmode == NUM_SORTMODES)
! 1036: sortmode = globalconfig.sortmode;
! 1037:
! 1038: abs_max_height = strlen(selectorchars);
! 1039:
! 1040: shm_init(&shm_dg_data, &shm_dg_game);
! 1041:
! 1042: games = populate_games (gameid, &len, NULL); /* FIXME: should be 'me' instead of 'NULL' */
! 1043: shm_update(shm_dg_data, games, len);
! 1044: games = sort_games (games, len, sortmode);
! 1045:
! 1046: while (1)
! 1047: {
! 1048: term_resize_check();
! 1049: max_height = dgl_local_LINES - (top_banner_hei + btm_banner_hei) - 1;
! 1050: if (max_height < 2) {
! 1051: free_populated_games(games, len);
! 1052: return;
! 1053: }
! 1054: if (max_height > abs_max_height) max_height = abs_max_height;
! 1055:
! 1056: if (len == 0)
! 1057: offset = 0;
! 1058:
! 1059: erase ();
! 1060: drawbanner (&banner);
! 1061:
! 1062: if (len > 0) {
! 1063: while (offset >= len) { offset -= max_height; }
! 1064: if (offset < 0) offset = 0;
! 1065: mvaddstr (3, 1, "The following games are in progress:");
! 1066:
! 1067: for (curr_watchcol = watchcols; *curr_watchcol; ++curr_watchcol) {
! 1068: struct dg_watchcols *wcol = *curr_watchcol;
! 1069: char *col = wcol->colname;
! 1070: int x = wcol->x;
! 1071: while (*col == ' ') { x++; col++; }
! 1072: if (sortmode == wcol->sortmode) attron(title_attr);
! 1073: mvprintw(top_banner_hei, x, col);
! 1074: if (sortmode == wcol->sortmode) attroff(title_attr);
! 1075: }
! 1076: }
! 1077:
! 1078: signals_block();
! 1079: shm_sem_wait(shm_dg_data);
! 1080:
! 1081: (void) time(&ctime);
! 1082:
! 1083: for (i = 0; i < max_height; i++)
! 1084: {
! 1085: if (i + offset >= len)
! 1086: break;
! 1087:
! 1088: if (i + offset == selected) attron(selected_attr);
! 1089:
! 1090: for (curr_watchcol = watchcols; *curr_watchcol; ++curr_watchcol) {
! 1091: struct dg_watchcols *col = *curr_watchcol;
! 1092: char tmpbuf[80];
! 1093: int hilite = 0;
! 1094: game_get_column_data(games[i + offset],
! 1095: selectorchars[i],
! 1096: ctime, shm_dg_game,
! 1097: tmpbuf, sizeof tmpbuf, &hilite,
! 1098: (dg_sortmode)col->dat);
! 1099: if (hilite) attron(hilite);
! 1100: mvprintw(top_banner_hei + 1 + i, col->x, col->fmt, tmpbuf);
! 1101: if (hilite) {
! 1102: attron(CLR_NORMAL);
! 1103: hilite = 0;
! 1104: }
! 1105: }
! 1106:
! 1107: if (i + offset == selected) attroff(selected_attr);
! 1108:
! 1109: }
! 1110:
! 1111: shm_sem_post(shm_dg_data);
! 1112: signals_release();
! 1113:
! 1114: btm = dgl_local_LINES-btm_banner_hei-top_banner_hei;
! 1115: if (len <= max_height)
! 1116: btm = i+1;
! 1117:
! 1118: if (len > 0) {
! 1119: mvprintw ((btm+top_banner_hei), 1, "(%d-%d of %d)", offset + 1, offset + i, len);
! 1120: mvaddstr ((btm+2+top_banner_hei), 1, "Watch which game? ('?' for help) => ");
! 1121: } else {
! 1122: mvprintw(top_banner_hei,4,"Sorry, no games available for viewing.");
! 1123: mvaddstr((btm+2+top_banner_hei), 1, "Press 'q' to return, or '?' for help => ");
! 1124: }
! 1125:
! 1126: refresh ();
! 1127:
! 1128: switch ((menuchoice = dgl_getch ()))
! 1129: {
! 1130: case KEY_DOWN:
! 1131: selected++;
! 1132: if (selected >= len) selected = 0;
! 1133: while (selected < offset) offset -= max_height;
! 1134: while (selected >= offset+max_height) offset += max_height;
! 1135: break;
! 1136: case KEY_UP:
! 1137: if (selected != -1) {
! 1138: if (selected == 0) selected = len;
! 1139: selected--;
! 1140: } else selected = len-1;
! 1141: while (selected < offset) offset -= max_height;
! 1142: while (selected >= offset+max_height) offset += max_height;
! 1143: break;
! 1144: case '*':
! 1145: if (len > 0) {
! 1146: int cnt = 20;
! 1147: (void) time(&ctime);
! 1148: do {
! 1149: idx = random() % len;
! 1150: } while ((--cnt > 0) ||
! 1151: !((games[idx]->ws_col <= COLS) &&
! 1152: (games[idx]->ws_row <= LINES) &&
! 1153: ((ctime - games[idx]->idle_time) < 15)));
! 1154: selected = idx;
! 1155: goto watchgame;
! 1156: }
! 1157: break;
! 1158: case '?':
! 1159: (void) runmenuloop(dgl_find_menu("watchmenu_help"));
! 1160: break;
! 1161: case '/':
! 1162: {
! 1163: int match = -1;
! 1164: int firstmatch = -1;
! 1165: int nmatches = 0;
! 1166: char findname[DGL_PLAYERNAMELEN+1];
! 1167: if (len <= 0) break;
! 1168: findname[0] = '\0';
! 1169: mvprintw ((btm+2+top_banner_hei), 1, "Watch which player? => "); /* stupid... */
! 1170: mvaddstr ((btm+2+top_banner_hei), 1, "Watch which player? => ");
! 1171: if ((mygetnstr(findname, DGL_PLAYERNAMELEN, 1) == OK) && (strlen(findname) > 1)) {
! 1172: int mlen = strlen(findname);
! 1173: for (i = 0; i < len; i++)
! 1174: if (!strncasecmp(games[i]->name, findname, mlen)) {
! 1175: if (firstmatch == -1) firstmatch = i;
! 1176: match = i;
! 1177: nmatches++;
! 1178: }
! 1179: if (nmatches > 1)
! 1180: match = firstmatch;
! 1181: if (match > -1) {
! 1182: idx = match;
! 1183: selected = idx;
! 1184: goto watchgame;
! 1185: }
! 1186: }
! 1187: }
! 1188: break;
! 1189: case KEY_NPAGE:
! 1190: case '>':
! 1191: if ((offset + max_height) < len) offset += max_height;
! 1192: break;
! 1193: case KEY_PPAGE:
! 1194: case '<':
! 1195: if ((offset - max_height) < 0)
! 1196: offset = 0;
! 1197: else
! 1198: offset -= max_height;
! 1199: break;
! 1200:
! 1201: case ERR:
! 1202: case 'q': case 'Q':
! 1203: case '\x1b':
! 1204: goto leavewatchgame;
! 1205: case KEY_RIGHT:
! 1206: case '.':
! 1207: sortmode_increment(watchcols, &sortmode, 1);
! 1208: break;
! 1209: case KEY_LEFT:
! 1210: case ',':
! 1211: sortmode_increment(watchcols, &sortmode, -1);
! 1212: break;
! 1213:
! 1214: case 12: case 18: /* ^L, ^R */
! 1215: if (globalconfig.utf8esc) (void) write(1, "\033%G", 3);
! 1216: clear ();
! 1217: break;
! 1218:
! 1219: case 13:
! 1220: case 10:
! 1221: case KEY_ENTER:
! 1222: if (selected >= 0 && selected < len) {
! 1223: idx = selected;
! 1224: goto watchgame;
! 1225: }
! 1226: break;
! 1227:
! 1228: default:
! 1229: if (strchr(selectorchars, menuchoice) && (len > 0)) {
! 1230: int sidx = strchr(selectorchars, menuchoice) - selectorchars;
! 1231:
! 1232: if ((sidx > max_height) || (sidx >= len)) {
! 1233: selected = -1;
! 1234: break;
! 1235: }
! 1236:
! 1237: idx = sidx + offset;
! 1238: if (require_enter) {
! 1239: if (selected == idx) selected = -1;
! 1240: else selected = idx;
! 1241: break;
! 1242: } else selected = idx;
! 1243: watchgame:
! 1244: if (!(idx >= 0 && idx < len && games[idx] && games[idx]->name))
! 1245: goto leavewatchgame;
! 1246: /* valid choice has been made */
! 1247: chosen_name = strdup (games[idx]->name);
! 1248: snprintf (ttyrecname, 130, "%s",
! 1249: games[idx]->ttyrec_fn);
! 1250:
! 1251: clear ();
! 1252: refresh ();
! 1253: endwin ();
! 1254: if (globalconfig.utf8esc) (void) write(1, "\033%G", 3);
! 1255: #ifdef USE_SHMEM
! 1256: signals_block();
! 1257: if (games[idx]->is_in_shm) {
! 1258: shm_idx = games[idx]->shm_idx;
! 1259: shm_sem_wait(shm_dg_data);
! 1260: if (shm_dg_game[shm_idx].in_use &&
! 1261: !strcmp(shm_dg_game[shm_idx].ttyrec_fn, games[idx]->ttyrec_fn)) {
! 1262: shm_dg_game[shm_idx].nwatchers++;
! 1263: games[idx]->nwatchers++;
! 1264: }
! 1265: hup_shm_idx = shm_idx;
! 1266: hup_shm_ttyrec_fn = strdup(games[idx]->ttyrec_fn);
! 1267: shm_sem_post(shm_dg_data);
! 1268: }
! 1269: signals_release();
! 1270: #endif
! 1271: resizey = games[idx]->ws_row;
! 1272: resizex = games[idx]->ws_col;
! 1273: if (loggedin)
! 1274: setproctitle("%s [watching %s]", me->username, chosen_name);
! 1275: else
! 1276: setproctitle("<Anonymous> [watching %s]", chosen_name);
! 1277: ttyplay_main (ttyrecname, 1, resizex, resizey);
! 1278: if (loggedin)
! 1279: setproctitle("%s", me->username);
! 1280: else
! 1281: setproctitle("<Anonymous>");
! 1282: #ifdef USE_SHMEM
! 1283: signals_block();
! 1284: if (games[idx]->is_in_shm) {
! 1285: hup_shm_idx = -1;
! 1286: free(hup_shm_ttyrec_fn);
! 1287: shm_sem_wait(shm_dg_data);
! 1288: if (shm_dg_game[shm_idx].in_use &&
! 1289: !strcmp(shm_dg_game[shm_idx].ttyrec_fn, games[idx]->ttyrec_fn) &&
! 1290: (shm_dg_game[shm_idx].nwatchers > 0)) {
! 1291: shm_dg_game[shm_idx].nwatchers--;
! 1292: games[idx]->nwatchers--;
! 1293: }
! 1294: shm_sem_post(shm_dg_data);
! 1295: }
! 1296: signals_release();
! 1297: #endif
! 1298: initcurses ();
! 1299: redrawwin(stdscr);
! 1300: }
! 1301: }
! 1302:
! 1303: if (selected >= 0 && selected < len)
! 1304: selectedgame = strdup(games[selected]->name);
! 1305: games = populate_games (gameid, &len, NULL); /* FIXME: should be 'me' instead of 'NULL' */
! 1306: shm_update(shm_dg_data, games, len);
! 1307: games = sort_games (games, len, sortmode);
! 1308: if (selectedgame) {
! 1309: selected = -1;
! 1310: for (i = 0; i < len; i++)
! 1311: if (!strcmp(games[i]->name, selectedgame)) {
! 1312: selected = i;
! 1313: break;
! 1314: }
! 1315: free(selectedgame);
! 1316: selectedgame = NULL;
! 1317: }
! 1318: }
! 1319: leavewatchgame:
! 1320: free_populated_games(games, len);
! 1321: #ifdef USE_SHMEM
! 1322: shmdt(shm_dg_data);
! 1323: #endif
! 1324: }
! 1325:
! 1326: void
! 1327: inprogressdisplay (int gameid)
! 1328: {
! 1329: const char *selectorchars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPRSTUVWXYZ";
! 1330: int i, len = 20;
! 1331: static dg_sortmode sortmode = NUM_SORTMODES;
! 1332: struct dg_game **games = NULL;
! 1333: int shm_idx = -1;
! 1334:
! 1335: time_t ctime;
! 1336:
! 1337: struct dg_shm *shm_dg_data = NULL;
! 1338: struct dg_shm_game *shm_dg_game = NULL;
! 1339:
! 1340: struct dg_watchcols **watchcols = globalconfig_watch_columns();
! 1341: struct dg_watchcols **curr_watchcol;
! 1342:
! 1343: if (sortmode == NUM_SORTMODES)
! 1344: sortmode = globalconfig.sortmode;
! 1345:
! 1346: shm_init(&shm_dg_data, &shm_dg_game);
! 1347:
! 1348: games = populate_games (gameid, &len, NULL); /* FIXME: should be 'me' instead of 'NULL' */
! 1349: shm_update(shm_dg_data, games, len);
! 1350: games = sort_games (games, len, sortmode);
! 1351:
! 1352: signals_block();
! 1353: shm_sem_wait(shm_dg_data);
! 1354:
! 1355: (void) time(&ctime);
! 1356:
! 1357: for (i = 0; i < 100; i++) {
! 1358: if (i >= len)
! 1359: break;
! 1360:
! 1361: for (curr_watchcol = watchcols; *curr_watchcol; ++curr_watchcol) {
! 1362: struct dg_watchcols *col = *curr_watchcol;
! 1363: if ((dg_sortmode)col->dat == SORTMODE_NONE)
! 1364: continue;
! 1365: char tmpbuf[80];
! 1366: int hilite = 0;
! 1367: game_get_column_data(games[i],
! 1368: selectorchars[i],
! 1369: ctime, shm_dg_game,
! 1370: tmpbuf, sizeof tmpbuf, &hilite, (dg_sortmode)col->dat);
! 1371: fprintf(stdout, "%s#", tmpbuf); /* format in col->fmt */
! 1372: }
! 1373: fprintf(stdout, "\n");
! 1374: }
! 1375:
! 1376: shm_sem_post(shm_dg_data);
! 1377: signals_release();
! 1378:
! 1379: free_populated_games(games, len);
! 1380:
! 1381: #ifdef USE_SHMEM
! 1382: shmdt(shm_dg_data);
! 1383: #endif
! 1384: }
! 1385:
! 1386: /* ************************************************************* */
! 1387:
! 1388: /*
! 1389: * Check email address, returns 1 if valid, 0 otherwise.
! 1390: * Doesn't recognize addresses with parts in double-quotes.
! 1391: * Addresses with a colon in them are always rejected.
! 1392: */
! 1393: int
! 1394: check_email (char *s)
! 1395: {
! 1396: char *atomchars = "!#$%&'*+-/=?^_`{|}~" "0123456789"
! 1397: "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
! 1398: int f;
! 1399:
! 1400: if (*s == '@')
! 1401: return 0;
! 1402:
! 1403: while (*s != '\0' && *s != '@')
! 1404: {
! 1405: if (strchr(atomchars, *s) == NULL)
! 1406: return 0;
! 1407: s++;
! 1408: if (*s == '.')
! 1409: s++;
! 1410: }
! 1411:
! 1412: if (*s == '\0')
! 1413: return 0;
! 1414: s++;
! 1415:
! 1416: f = 0;
! 1417: while (*s != '\0')
! 1418: {
! 1419: if (strchr(atomchars, *s) == NULL)
! 1420: return 0;
! 1421: s++;
! 1422: if (*s == '.')
! 1423: s++, f = 1;
! 1424: }
! 1425:
! 1426: return f;
! 1427: }
! 1428:
! 1429: void
! 1430: change_email ()
! 1431: {
! 1432: char buf[81];
! 1433:
! 1434: clear();
! 1435:
! 1436: if (me->flags & DGLACCT_EMAIL_LOCK) {
! 1437: drawbanner(&banner);
! 1438: mvprintw(5, 1, "Sorry, you cannot change the email.--More--");
! 1439: dgl_getch();
! 1440: return;
! 1441: }
! 1442:
! 1443: for (;;)
! 1444: {
! 1445: drawbanner(&banner);
! 1446:
! 1447: mvprintw(3, 1, "Your current email is: %s", me->email);
! 1448: mvaddstr(4, 1, "Please enter a new one (max 80 chars; blank line aborts)");
! 1449: mvaddstr(6, 1, "=> ");
! 1450:
! 1451: if (mygetnstr (buf, 80, 1) != OK)
! 1452: return;
! 1453:
! 1454: if (*buf == '\0')
! 1455: return;
! 1456: else if (!strcmp(me->email, buf))
! 1457: {
! 1458: clear();
! 1459: mvaddstr (8, 1, "That's the same one as before. Try again?");
! 1460: move(1,1);
! 1461: }
! 1462: else if (check_email (buf))
! 1463: {
! 1464: mvprintw (8, 1, "Changing email address to '%s'. Confirm (y/n): ", buf);
! 1465: if (dgl_getch() == 'y')
! 1466: {
! 1467: free(me->email);
! 1468: me->email = strdup(buf);
! 1469: writefile(0);
! 1470: return;
! 1471: }
! 1472: else
! 1473: {
! 1474: mvaddstr(9, 1, "No changes made. Press any key to continue...");
! 1475: dgl_getch();
! 1476: return;
! 1477: }
! 1478: }
! 1479: else
! 1480: {
! 1481: clear();
! 1482: mvaddstr (8, 1, "That doesn't look like an email address to me.");
! 1483: move(1,1);
! 1484: }
! 1485: }
! 1486: }
! 1487:
! 1488: int
! 1489: changepw (int dowrite)
! 1490: {
! 1491: char buf[DGL_PASSWDLEN+1];
! 1492: int error = 2;
! 1493:
! 1494: /* A precondition is that struct `me' exists because we can be not-yet-logged-in. */
! 1495: if (!me) {
! 1496: debug_write("no 'me' in changepw");
! 1497: graceful_exit (122); /* Die. */
! 1498: }
! 1499:
! 1500: if (me->flags & DGLACCT_PASSWD_LOCK) {
! 1501: clear();
! 1502: drawbanner(&banner);
! 1503: mvprintw(5, 1, "Sorry, you cannot change the password.--More--");
! 1504: dgl_getch();
! 1505: return 0;
! 1506: }
! 1507:
! 1508: while (error)
! 1509: {
! 1510: char repeatbuf[DGL_PASSWDLEN+1];
! 1511: clear ();
! 1512:
! 1513: drawbanner (&banner);
! 1514:
! 1515: mvprintw (5, 1,
! 1516: "Please enter a%s password. Remember that this is sent over the net",
! 1517: loggedin ? " new" : "");
! 1518: mvaddstr (6, 1,
! 1519: "in plaintext, so make it something new and expect it to be relatively");
! 1520: mvaddstr (7, 1, "insecure.");
! 1521: mvprintw (8, 1,
! 1522: "%i character max. No ':' characters. Blank line to abort.", DGL_PASSWDLEN);
! 1523: mvaddstr (10, 1, "=> ");
! 1524:
! 1525: if (error == 1)
! 1526: {
! 1527: mvaddstr (15, 1, "Sorry, the passwords don't match. Try again.");
! 1528: move (10, 4);
! 1529: }
! 1530:
! 1531: refresh ();
! 1532:
! 1533: if (mygetnstr (buf, DGL_PASSWDLEN, 0) != OK)
! 1534: return 0;
! 1535:
! 1536: if (*buf == '\0')
! 1537: return 0;
! 1538:
! 1539: if (strchr (buf, ':') != NULL) {
! 1540: debug_write("cannot have ':' in passwd");
! 1541: graceful_exit (112);
! 1542: }
! 1543:
! 1544: mvaddstr (12, 1, "And again:");
! 1545: mvaddstr (13, 1, "=> ");
! 1546:
! 1547: if (mygetnstr (repeatbuf, DGL_PASSWDLEN, 0) != OK)
! 1548: return 0;
! 1549:
! 1550: if (!strcmp (buf, repeatbuf))
! 1551: error = 0;
! 1552: else
! 1553: error = 1;
! 1554: }
! 1555:
! 1556: free(me->password);
! 1557: me->password = strdup (crypt (buf, buf));
! 1558:
! 1559: if (dowrite)
! 1560: writefile (0);
! 1561:
! 1562: return 1;
! 1563: }
! 1564:
! 1565: /* ************************************************************* */
! 1566:
! 1567: void
! 1568: wall_email(char *from, char *msg)
! 1569: {
! 1570: int len, i;
! 1571: struct dg_game **games = NULL;
! 1572: char spool_fn[1024+1];
! 1573: FILE *user_spool = NULL;
! 1574: struct flock fl = { 0 };
! 1575:
! 1576: fl.l_type = F_WRLCK;
! 1577: fl.l_whence = SEEK_SET;
! 1578: fl.l_start = 0;
! 1579: fl.l_len = 0;
! 1580:
! 1581: if (!from || !msg) return;
! 1582:
! 1583: if (strlen(from) < 1) {
! 1584: fprintf(stderr, "Error: wall: 'from' username is too short!\n");
! 1585: debug_write("wall: 'from' username too short");
! 1586: graceful_exit(121);
! 1587: }
! 1588:
! 1589: if (strlen(msg) >= DGL_MAILMSGLEN) {
! 1590: fprintf(stderr, "Error: wall: message too long!\n");
! 1591: debug_write("wall: message too long");
! 1592: graceful_exit(120);
! 1593: }
! 1594:
! 1595: games = populate_games(-1, &len, me);
! 1596:
! 1597: if (len == 0) {
! 1598: fprintf(stderr, "Error: wall: no one's logged in!\n");
! 1599: debug_write("wall: no people playing");
! 1600: graceful_exit(118);
! 1601: }
! 1602:
! 1603: for (i = 0; i < len; i++) {
! 1604: int game = games[i]->gamenum;
! 1605: int fnamelen;
! 1606: if (strlen(myconfig[game]->spool) < 1) continue;
! 1607:
! 1608: snprintf (spool_fn, 1024, "%s/%s", myconfig[game]->spool, games[i]->name);
! 1609:
! 1610: if ((user_spool = fopen (spool_fn, "a")) == NULL) continue;
! 1611:
! 1612: while (fcntl(fileno(user_spool), F_SETLK, &fl) == -1) {
! 1613: if (errno != EAGAIN) continue;
! 1614: sleep (1);
! 1615: }
! 1616: fprintf(user_spool, "%s:%s\n", from, msg);
! 1617: fclose(user_spool);
! 1618: }
! 1619: free_populated_games(games, len);
! 1620: }
! 1621:
! 1622: void
! 1623: domailuser (char *username)
! 1624: {
! 1625: unsigned int len, i;
! 1626: char *spool_fn, message[DGL_MAILMSGLEN+1];
! 1627: FILE *user_spool = NULL;
! 1628: time_t now;
! 1629: int mail_empty = 1;
! 1630: int game;
! 1631: struct flock fl = { 0 };
! 1632:
! 1633: fl.l_type = F_WRLCK;
! 1634: fl.l_whence = SEEK_SET;
! 1635: fl.l_start = 0;
! 1636: fl.l_len = 0;
! 1637:
! 1638: assert (loggedin);
! 1639:
! 1640: game = 0; /*TODO: find_curr_player_game(username) */
! 1641:
! 1642: if (strlen(myconfig[game]->spool) < 1) return;
! 1643:
! 1644: len = strlen(myconfig[game]->spool) + strlen (username) + 1;
! 1645: spool_fn = malloc (len + 1);
! 1646: time (&now);
! 1647: snprintf (spool_fn, len + 1, "%s/%s", myconfig[game]->spool, username);
! 1648:
! 1649: /* print the enter your message line */
! 1650: clear ();
! 1651: drawbanner (&banner);
! 1652: mvprintw (5, 1,
! 1653: "Enter your message here. It is to be one line only and %i characters or less.",
! 1654: DGL_MAILMSGLEN);
! 1655: mvaddstr (7, 1, "=> ");
! 1656:
! 1657: if (mygetnstr (message, DGL_MAILMSGLEN, 1) != OK)
! 1658: return;
! 1659:
! 1660: for (i = 0; i < strlen (message); i++)
! 1661: {
! 1662: if (message[i] != ' ' && message[i] != '\n' && message[i] != '\t')
! 1663: mail_empty = 0;
! 1664: }
! 1665:
! 1666: if (mail_empty)
! 1667: {
! 1668: mvaddstr (9, 1, "This scroll appears to be blank.");
! 1669: mvaddstr (10, 1, "(Aborting your message.)");
! 1670: mvaddstr (12, 1, "--More--");
! 1671: dgl_getch ();
! 1672: return;
! 1673: }
! 1674:
! 1675: if ((user_spool = fopen (spool_fn, "a")) == NULL)
! 1676: {
! 1677: mvaddstr (9, 1,
! 1678: "You fall into the water! You sink like a rock.");
! 1679: mvprintw (10, 1,
! 1680: "(Couldn't open %s'%c spool file. Aborting.)",
! 1681: username, (username[strlen (username) - 1] != 's') ? 's' : 0);
! 1682: mvaddstr (12, 1, "--More--");
! 1683: dgl_getch ();
! 1684: return;
! 1685: }
! 1686:
! 1687: mvaddstr (9, 1, "Sending your scroll...");
! 1688: refresh ();
! 1689:
! 1690: /* Getting a lock on the mailspool... */
! 1691: while (fcntl (fileno (user_spool), F_SETLK, &fl) == -1)
! 1692: {
! 1693: if (errno != EAGAIN)
! 1694: {
! 1695: mvaddstr (10, 1,
! 1696: "(Received a weird error from fcntl. Aborting.)");
! 1697: mvaddstr (12, 1, "--More--");
! 1698: dgl_getch ();
! 1699: return;
! 1700: }
! 1701: sleep (1);
! 1702: }
! 1703:
! 1704: fprintf (user_spool, "%s:%s\n", me->username, message);
! 1705:
! 1706: /*
! 1707: * Don't unlock the file ourselves, this way it will be done automatically
! 1708: * after all data has been written. (Using file locking with stdio is icky.)
! 1709: */
! 1710:
! 1711: fclose (user_spool);
! 1712:
! 1713: mvaddstr (9, 1, "Scroll delivered! ");
! 1714: move(9, 19); /* Pedantry! */
! 1715: refresh ();
! 1716: sleep (2);
! 1717:
! 1718: return;
! 1719: }
! 1720:
! 1721:
! 1722: /* ************************************************************* */
! 1723:
! 1724: void
! 1725: freefile ()
! 1726: {
! 1727: #ifndef USE_SQLITE3
! 1728: int i;
! 1729:
! 1730: /* free existing mem, clear existing entries */
! 1731: for (i = 0; i < f_num; i++)
! 1732: {
! 1733: if (users[i] != me)
! 1734: {
! 1735: free (users[i]->password);
! 1736: free (users[i]->username);
! 1737: free (users[i]->email);
! 1738: free (users[i]->env);
! 1739: free (users[i]);
! 1740: }
! 1741: }
! 1742:
! 1743: if (users)
! 1744: free (users);
! 1745:
! 1746: users = NULL;
! 1747: f_num = 0;
! 1748: #endif
! 1749: }
! 1750:
! 1751: /* ************************************************************* */
! 1752:
! 1753: void
! 1754: initcurses ()
! 1755: {
! 1756: printf("\033[2J");
! 1757: if (newterm(NULL, stdout, stdin) == NULL) {
! 1758: if (!globalconfig.defterm || (newterm(globalconfig.defterm, stdout, stdin) == NULL)) {
! 1759: debug_write("cannot create newterm");
! 1760: graceful_exit(60);
! 1761: }
! 1762: mysetenv("TERM", globalconfig.defterm, 1);
! 1763: }
! 1764: cbreak ();
! 1765: noecho ();
! 1766: nonl ();
! 1767: intrflush (stdscr, FALSE);
! 1768: keypad (stdscr, TRUE);
! 1769: #ifdef USE_NCURSES_COLOR
! 1770: start_color();
! 1771: use_default_colors();
! 1772:
! 1773: init_pair(COLOR_BLACK, COLOR_WHITE, COLOR_BLACK);
! 1774: init_pair(COLOR_RED, COLOR_RED, COLOR_BLACK);
! 1775: init_pair(COLOR_GREEN, COLOR_GREEN, COLOR_BLACK);
! 1776: init_pair(COLOR_YELLOW, COLOR_YELLOW, COLOR_BLACK);
! 1777: init_pair(COLOR_BLUE, COLOR_BLUE, COLOR_BLACK);
! 1778: init_pair(COLOR_MAGENTA, COLOR_MAGENTA, COLOR_BLACK);
! 1779: init_pair(COLOR_CYAN, COLOR_CYAN, COLOR_BLACK);
! 1780: init_pair(COLOR_WHITE, COLOR_WHITE, COLOR_BLACK);
! 1781: init_pair(9, 0, COLOR_BLACK);
! 1782: init_pair(10, COLOR_BLACK, COLOR_BLACK);
! 1783: init_pair(11, -1, -1);
! 1784:
! 1785: if (globalconfig.utf8esc) (void) write(1, "\033%G", 3);
! 1786: #endif
! 1787: clear();
! 1788: refresh();
! 1789: }
! 1790:
! 1791: /* ************************************************************* */
! 1792:
! 1793: void
! 1794: autologin (char* user, char *pass)
! 1795: {
! 1796: struct dg_user *tmp;
! 1797: tmp = userexist(user, 0);
! 1798: if (tmp) {
! 1799: me = cpy_me(tmp);
! 1800: if ((passwordgood(pass) || initplayer == 1) && !(me->flags & DGLACCT_LOGIN_LOCK)) {
! 1801: loggedin = 1;
! 1802: setproctitle ("%s", me->username);
! 1803: dgl_exec_cmdqueue(globalconfig.cmdqueue[DGLTIME_LOGIN], 0, me);
! 1804: }
! 1805: }
! 1806: }
! 1807:
! 1808: void
! 1809: loginprompt (int from_ttyplay)
! 1810: {
! 1811: char user_buf[DGL_PLAYERNAMELEN+1], pw_buf[DGL_PASSWDLEN+2];
! 1812: int error = 2;
! 1813:
! 1814: loggedin = 0;
! 1815:
! 1816: while (error)
! 1817: {
! 1818: clear ();
! 1819:
! 1820: drawbanner (&banner);
! 1821:
! 1822: if (from_ttyplay == 1)
! 1823: mvaddstr (4, 1, "This operation requires you to be logged in.");
! 1824:
! 1825: mvaddstr (5, 1,
! 1826: "Please enter your username. (blank entry aborts)");
! 1827: mvaddstr (7, 1, "=> ");
! 1828:
! 1829: if (error == 1)
! 1830: {
! 1831: mvaddstr (9, 1, "There was a problem with your last entry.");
! 1832: move (7, 4);
! 1833: }
! 1834:
! 1835: refresh ();
! 1836:
! 1837: if (mygetnstr (user_buf, DGL_PLAYERNAMELEN, 1) != OK)
! 1838: return;
! 1839:
! 1840: if (*user_buf == '\0')
! 1841: return;
! 1842:
! 1843: error = 1;
! 1844:
! 1845: {
! 1846: struct dg_user *tmpme;
! 1847: if ((tmpme = userexist(user_buf, 0))) {
! 1848: me = cpy_me(tmpme);
! 1849: error = 0;
! 1850: }
! 1851: }
! 1852: }
! 1853:
! 1854: clear ();
! 1855:
! 1856: drawbanner (&banner);
! 1857:
! 1858: mvaddstr (5, 1, "Please enter your password.");
! 1859: mvaddstr (7, 1, "=> ");
! 1860:
! 1861: refresh ();
! 1862:
! 1863: if (mygetnstr (pw_buf, DGL_PASSWDLEN, 0) != OK)
! 1864: return;
! 1865:
! 1866: if (passwordgood (pw_buf))
! 1867: {
! 1868: if (me->flags & DGLACCT_LOGIN_LOCK) {
! 1869: clear ();
! 1870: mvprintw(5, 1, "Sorry, that account has been banned.--More--");
! 1871: dgl_getch();
! 1872: return;
! 1873: }
! 1874:
! 1875: loggedin = 1;
! 1876: if (from_ttyplay)
! 1877: setproctitle("%s [watching %s]", me->username, chosen_name);
! 1878: else
! 1879: setproctitle("%s", me->username);
! 1880: dgl_exec_cmdqueue(globalconfig.cmdqueue[DGLTIME_LOGIN], 0, me);
! 1881: }
! 1882: else
! 1883: {
! 1884: me = NULL;
! 1885: if (from_ttyplay == 1)
! 1886: {
! 1887: mvaddstr(9, 1, "Login failed. Returning to game.");
! 1888: refresh();
! 1889: sleep(2);
! 1890: }
! 1891: }
! 1892: }
! 1893:
! 1894: /* ************************************************************* */
! 1895:
! 1896: void
! 1897: newuser ()
! 1898: {
! 1899: char buf[1024], dirname[100];
! 1900: int error = 2;
! 1901: unsigned int i;
! 1902:
! 1903: loggedin = 0;
! 1904:
! 1905: #ifndef USE_SQLITE3
! 1906: if (f_num >= globalconfig.max)
! 1907: {
! 1908: clear ();
! 1909:
! 1910: drawbanner (&banner);
! 1911:
! 1912: mvaddstr (5, 1, "Sorry, too many users have registered now.");
! 1913: mvaddstr (6, 1, "You might email the server administrator.");
! 1914: mvaddstr (7, 1, "Press return to return to the menu. ");
! 1915: dgl_getch ();
! 1916:
! 1917: return;
! 1918: }
! 1919: #endif
! 1920:
! 1921: if (me)
! 1922: free (me);
! 1923:
! 1924: me = calloc (1, sizeof (struct dg_user));
! 1925:
! 1926: while (error)
! 1927: {
! 1928: clear ();
! 1929:
! 1930: sprintf(buf, "%i character max.", globalconfig.max_newnick_len);
! 1931:
! 1932: drawbanner (&banner);
! 1933:
! 1934: mvaddstr (5, 1, "Welcome new user. Please enter a username.");
! 1935: mvaddstr (6, 1,
! 1936: "Only characters and numbers are allowed, with no spaces.");
! 1937: mvaddstr (7, 1, buf);
! 1938: mvaddstr (9, 1, "=> ");
! 1939:
! 1940: if (error == 1)
! 1941: {
! 1942: mvaddstr (11, 1, "There was a problem with your last entry.");
! 1943: move (9, 4);
! 1944: }
! 1945:
! 1946: refresh ();
! 1947:
! 1948: if (mygetnstr (buf, globalconfig.max_newnick_len, 1) != OK)
! 1949: buf[0] = 0;
! 1950:
! 1951: if (*buf == '\0') {
! 1952: free(me);
! 1953: me = NULL;
! 1954: return;
! 1955: }
! 1956:
! 1957: if (!userexist(buf, 1)) {
! 1958: error = 0;
! 1959: } else
! 1960: error = 1;
! 1961:
! 1962: for (i = 0; i < strlen (buf); i++)
! 1963: {
! 1964: if (!isalnum((int)buf[i]))
! 1965: error = 1;
! 1966: }
! 1967:
! 1968: if (strlen (buf) < 2)
! 1969: error = 1;
! 1970:
! 1971: if (strlen (buf) == 0)
! 1972: {
! 1973: free(me);
! 1974: me = NULL;
! 1975: return;
! 1976: }
! 1977: }
! 1978:
! 1979: me->username = strdup (buf);
! 1980:
! 1981: /* password step */
! 1982:
! 1983: clear ();
! 1984:
! 1985: if (!changepw (0)) /* Calling changepw instead to prompt twice. */
! 1986: {
! 1987: free(me->username);
! 1988: free(me);
! 1989: me = NULL;
! 1990: return;
! 1991: }
! 1992:
! 1993: /* email step */
! 1994:
! 1995: error = 2;
! 1996: while (error != 0)
! 1997: {
! 1998: clear ();
! 1999:
! 2000: drawbanner (&banner);
! 2001:
! 2002: mvaddstr (5, 1, "Please enter your email address.");
! 2003: mvaddstr (6, 1, "This is sent _nowhere_ but will be used if you ask"
! 2004: " the sysadmin for lost");
! 2005: mvaddstr (7, 1, "password help. Please use a correct one. It only"
! 2006: " benefits you.");
! 2007: mvaddstr (8, 1, "80 character max. No ':' characters. Blank line"
! 2008: " aborts.");
! 2009: mvaddstr (10, 1, "=> ");
! 2010:
! 2011: if (error == 1)
! 2012: {
! 2013: mvaddstr (12, 1, "There was a problem with your last entry.");
! 2014: move (10, 4);
! 2015: }
! 2016:
! 2017: refresh ();
! 2018: if (mygetnstr (buf, 80, 1) != OK)
! 2019: buf[0] = 0;
! 2020:
! 2021: if (check_email (buf))
! 2022: error = 0;
! 2023: else
! 2024: error = 1;
! 2025:
! 2026: if (*buf == '\0')
! 2027: {
! 2028: free (me->username);
! 2029: free (me->password);
! 2030: free (me);
! 2031: me = NULL;
! 2032: return;
! 2033: }
! 2034: }
! 2035:
! 2036: me->email = strdup (buf);
! 2037: me->env = calloc (1, 1);
! 2038: me->flags = 0;
! 2039:
! 2040: loggedin = 1;
! 2041:
! 2042: setproctitle ("%s", me->username);
! 2043:
! 2044: dgl_exec_cmdqueue(globalconfig.cmdqueue[DGLTIME_REGISTER], 0, me);
! 2045:
! 2046: writefile (1);
! 2047: }
! 2048:
! 2049: /* ************************************************************* */
! 2050:
! 2051: int
! 2052: passwordgood (char *cpw)
! 2053: {
! 2054: char *crypted;
! 2055: assert (me != NULL);
! 2056:
! 2057: crypted = crypt (cpw, cpw);
! 2058: if (crypted == NULL)
! 2059: return 0;
! 2060: if (!strncmp (crypted, me->password, DGL_PASSWDLEN))
! 2061: return 1;
! 2062: if (!strncmp (cpw, me->password, DGL_PASSWDLEN))
! 2063: return 1;
! 2064:
! 2065: return 0;
! 2066: }
! 2067:
! 2068: /* ************************************************************* */
! 2069:
! 2070: int
! 2071: readfile (int nolock)
! 2072: {
! 2073: #ifndef USE_SQLITE3
! 2074: FILE *fp = NULL, *fpl = NULL;
! 2075: char buf[1200];
! 2076: struct flock fl = { 0 };
! 2077:
! 2078: fl.l_type = F_RDLCK;
! 2079: fl.l_whence = SEEK_SET;
! 2080: fl.l_start = 0;
! 2081: fl.l_len = 0;
! 2082:
! 2083: memset (buf, 0, 1024);
! 2084:
! 2085: /* read new stuff */
! 2086:
! 2087: if (!nolock)
! 2088: {
! 2089: fpl = fopen (globalconfig.lockfile, "r");
! 2090: if (!fpl) {
! 2091: debug_write("cannot fopen lockfile");
! 2092: graceful_exit (106);
! 2093: }
! 2094: if (fcntl (fileno (fpl), F_SETLKW, &fl) == -1) {
! 2095: debug_write("cannot fcntl lockfile");
! 2096: graceful_exit (95);
! 2097: }
! 2098: }
! 2099:
! 2100: fp = fopen (globalconfig.passwd, "r");
! 2101: if (!fp) {
! 2102: debug_write("cannot fopen passwd file");
! 2103: graceful_exit (106);
! 2104: }
! 2105:
! 2106: /* once per name in the file */
! 2107: while (fgets (buf, 1200, fp))
! 2108: {
! 2109: char *b = buf, *n = buf;
! 2110:
! 2111: users = realloc (users, sizeof (struct dg_user *) * (f_num + 1));
! 2112: users[f_num] = malloc (sizeof (struct dg_user));
! 2113: users[f_num]->username = (char *) calloc (DGL_PLAYERNAMELEN+2, sizeof (char));
! 2114: users[f_num]->email = (char *) calloc (82, sizeof (char));
! 2115: users[f_num]->password = (char *) calloc (DGL_PASSWDLEN+2, sizeof (char));
! 2116: users[f_num]->env = (char *) calloc (1026, sizeof (char));
! 2117:
! 2118: /* name field, must be valid */
! 2119: while (*b != ':')
! 2120: {
! 2121: if (!isalnum((int)*b))
! 2122: return 1;
! 2123: users[f_num]->username[(b - n)] = *b;
! 2124: b++;
! 2125: if ((b - n) >= DGL_PLAYERNAMELEN) {
! 2126: debug_write("name field too long");
! 2127: graceful_exit (100);
! 2128: }
! 2129: }
! 2130:
! 2131: /* advance to next field */
! 2132: n = b + 1;
! 2133: b = n;
! 2134:
! 2135: /* email field */
! 2136: while (*b != ':')
! 2137: {
! 2138: users[f_num]->email[(b - n)] = *b;
! 2139: b++;
! 2140: if ((b - n) > 80) {
! 2141: debug_write("email field too long");
! 2142: graceful_exit (101);
! 2143: }
! 2144: }
! 2145:
! 2146: /* advance to next field */
! 2147: n = b + 1;
! 2148: b = n;
! 2149:
! 2150: /* pw field */
! 2151: while (*b != ':')
! 2152: {
! 2153: users[f_num]->password[(b - n)] = *b;
! 2154: b++;
! 2155: if ((b - n) >= DGL_PASSWDLEN) {
! 2156: debug_write("passwd field too long");
! 2157: graceful_exit (102);
! 2158: }
! 2159: }
! 2160:
! 2161: /* advance to next field */
! 2162: n = b + 1;
! 2163: b = n;
! 2164:
! 2165: /* env field */
! 2166: while ((*b != '\n') && (*b != 0) && (*b != EOF))
! 2167: {
! 2168: users[f_num]->env[(b - n)] = *b;
! 2169: b++;
! 2170: if ((b - n) >= 1024) {
! 2171: debug_write("env field too long");
! 2172: graceful_exit (103);
! 2173: }
! 2174: }
! 2175:
! 2176: f_num++;
! 2177: /* prevent a buffer overrun here */
! 2178: if (f_num > globalconfig.max)
! 2179: {
! 2180: fprintf(stderr,"ERROR: number of users in database exceeds maximum. Exiting.\n");
! 2181: debug_write("too many users in database");
! 2182: graceful_exit (109);
! 2183: }
! 2184: }
! 2185:
! 2186: if (!nolock)
! 2187: fclose (fpl);
! 2188: fclose (fp);
! 2189: #endif
! 2190: return 0;
! 2191: }
! 2192:
! 2193: /* ************************************************************* */
! 2194:
! 2195: #ifndef USE_SQLITE3
! 2196: struct dg_user *userexist_tmp_me = NULL;
! 2197:
! 2198: struct dg_user *
! 2199: userexist (char *cname, int isnew)
! 2200: {
! 2201: int i;
! 2202:
! 2203: if (userexist_tmp_me) {
! 2204: free(userexist_tmp_me->username);
! 2205: free(userexist_tmp_me->email);
! 2206: free(userexist_tmp_me->env);
! 2207: free(userexist_tmp_me->password);
! 2208: free(userexist_tmp_me);
! 2209: userexist_tmp_me = NULL;
! 2210: }
! 2211:
! 2212: for (i = 0; i < f_num; i++)
! 2213: {
! 2214: if (!strncasecmp (cname, users[i]->username, (isnew ? globalconfig.max_newnick_len : DGL_PLAYERNAMELEN))) {
! 2215: userexist_tmp_me = cpy_me(users[i]);
! 2216: return userexist_tmp_me;
! 2217: }
! 2218: }
! 2219:
! 2220: return NULL;
! 2221: }
! 2222: #else
! 2223:
! 2224: struct dg_user *userexist_tmp_me = NULL;
! 2225:
! 2226: static int
! 2227: userexist_callback(void *NotUsed, int argc, char **argv, char **colname)
! 2228: {
! 2229: int i;
! 2230: NotUsed = NULL;
! 2231:
! 2232: userexist_tmp_me = malloc(sizeof(struct dg_user));
! 2233:
! 2234: for (i = 0; i < argc; i++) {
! 2235: if (!strcmp(colname[i], "username"))
! 2236: userexist_tmp_me->username = strdup(argv[i]);
! 2237: else if (!strcmp(colname[i], "email"))
! 2238: userexist_tmp_me->email = strdup(argv[i]);
! 2239: else if (!strcmp(colname[i], "env"))
! 2240: userexist_tmp_me->env = strdup(argv[i]);
! 2241: else if (!strcmp(colname[i], "password"))
! 2242: userexist_tmp_me->password = strdup(argv[i]);
! 2243: else if (!strcmp(colname[i], "flags"))
! 2244: userexist_tmp_me->flags = atoi(argv[i]);
! 2245: else if (!strcmp(colname[i], "id"))
! 2246: userexist_tmp_me->id = atoi(argv[i]);
! 2247: }
! 2248: return 0;
! 2249: }
! 2250:
! 2251: struct dg_user *
! 2252: userexist (char *cname, int isnew)
! 2253: {
! 2254: sqlite3 *db;
! 2255: char *errmsg = NULL;
! 2256: int ret, retry = 10;
! 2257:
! 2258: char *qbuf;
! 2259:
! 2260: char tmpbuf[DGL_PLAYERNAMELEN+2];
! 2261:
! 2262: memset(tmpbuf, 0, DGL_PLAYERNAMELEN+2);
! 2263: strncpy(tmpbuf, cname, (isnew ? globalconfig.max_newnick_len : DGL_PLAYERNAMELEN));
! 2264:
! 2265: /* Check that the nick doesn't interfere with already registered nicks */
! 2266: if (isnew && (strlen(cname) >= globalconfig.max_newnick_len))
! 2267: strcat(tmpbuf, "%");
! 2268:
! 2269: qbuf = sqlite3_mprintf("select * from dglusers where username = '%q' collate nocase limit 1", tmpbuf);
! 2270:
! 2271: ret = sqlite3_open(globalconfig.passwd, &db);
! 2272: if (ret) {
! 2273: sqlite3_close(db);
! 2274: debug_write("sqlite3_open failed");
! 2275: graceful_exit(96);
! 2276: }
! 2277:
! 2278: if (userexist_tmp_me) {
! 2279: free(userexist_tmp_me->username);
! 2280: free(userexist_tmp_me->email);
! 2281: free(userexist_tmp_me->env);
! 2282: free(userexist_tmp_me->password);
! 2283: free(userexist_tmp_me);
! 2284: userexist_tmp_me = NULL;
! 2285: }
! 2286:
! 2287: sqlite3_busy_timeout(db, 10000);
! 2288: ret = sqlite3_exec(db, qbuf, userexist_callback, 0, &errmsg);
! 2289:
! 2290: sqlite3_free(qbuf);
! 2291:
! 2292: if (ret != SQLITE_OK) {
! 2293: sqlite3_close(db);
! 2294: debug_write("sqlite3_exec failed");
! 2295: graceful_exit(108);
! 2296: }
! 2297: sqlite3_close(db);
! 2298:
! 2299: return userexist_tmp_me;
! 2300: }
! 2301: #endif
! 2302:
! 2303: /* ************************************************************* */
! 2304:
! 2305: void
! 2306: write_canned_rcfile (int game, char *target)
! 2307: {
! 2308: FILE *canned, *newfile;
! 2309: char buf[1024], *rfn;
! 2310: size_t bytes, len;
! 2311:
! 2312: len = strlen(myconfig[game]->rcfile) + 2;
! 2313: rfn = malloc(len);
! 2314: snprintf (rfn, len, "/%s", myconfig[game]->rcfile);
! 2315:
! 2316: if (!(newfile = fopen (target, "w")))
! 2317: {
! 2318: bail:
! 2319: mvaddstr (13, 1,
! 2320: "You don't know how to write that! You write \"%s was here\" and the scroll disappears.");
! 2321: mvaddstr (14, 1,
! 2322: "(Sorry, but I couldn't open one of the config files. This is a bug.)");
! 2323: return;
! 2324: }
! 2325:
! 2326: if (!(canned = fopen (rfn, "r")))
! 2327: goto bail;
! 2328:
! 2329: free(rfn);
! 2330:
! 2331: while ((bytes = fread (buf, 1, 1024, canned)) > 0)
! 2332: {
! 2333: if (fwrite (buf, 1, bytes, newfile) != bytes)
! 2334: {
! 2335: if (ferror (newfile))
! 2336: {
! 2337: mvaddstr (13, 1, "Your hand slips while engraving.");
! 2338: mvaddstr (14, 1,
! 2339: "(Encountered a problem writing the new file. This is a bug.)");
! 2340: fclose (canned);
! 2341: fclose (newfile);
! 2342: return;
! 2343: }
! 2344: }
! 2345: }
! 2346:
! 2347: fclose (canned);
! 2348: fclose (newfile);
! 2349: chmod (target, default_fmode);
! 2350: }
! 2351:
! 2352:
! 2353:
! 2354: /* ************************************************************* */
! 2355:
! 2356: #ifndef USE_SQLITE3
! 2357: void
! 2358: writefile (int requirenew)
! 2359: {
! 2360: FILE *fp, *fpl;
! 2361: int i = 0;
! 2362: int my_done = 0;
! 2363: struct flock fl = { 0 };
! 2364:
! 2365: fl.l_type = F_WRLCK;
! 2366: fl.l_whence = SEEK_SET;
! 2367: fl.l_start = 0;
! 2368: fl.l_len = 0;
! 2369:
! 2370: signals_block();
! 2371:
! 2372: fpl = fopen (globalconfig.lockfile, "r+");
! 2373: if (!fpl)
! 2374: {
! 2375: signals_release();
! 2376: debug_write("writefile locking failed");
! 2377: graceful_exit (115);
! 2378: }
! 2379: if (fcntl (fileno (fpl), F_SETLK, &fl))
! 2380: {
! 2381: signals_release();
! 2382: debug_write("writefile fcntl failed");
! 2383: graceful_exit (107);
! 2384: }
! 2385:
! 2386: fl.l_type = F_UNLCK;
! 2387:
! 2388: freefile ();
! 2389: readfile (1);
! 2390:
! 2391: fp = fopen (globalconfig.passwd, "w");
! 2392: if (!fp)
! 2393: {
! 2394: signals_release();
! 2395: debug_write("passwd file fopen failed");
! 2396: graceful_exit (99);
! 2397: }
! 2398:
! 2399: for (i = 0; i < f_num; i++)
! 2400: {
! 2401: if (loggedin && !strncmp (me->username, users[i]->username, DGL_PLAYERNAMELEN))
! 2402: {
! 2403: if (requirenew)
! 2404: {
! 2405: /* this is if someone managed to register at the same time
! 2406: * as someone else. just die. */
! 2407: fclose(fp);
! 2408: fclose(fpl);
! 2409: signals_release();
! 2410: debug_write("two users registering at the same time");
! 2411: graceful_exit (111);
! 2412: }
! 2413: fprintf (fp, "%s:%s:%s:%s\n", me->username, me->email, me->password,
! 2414: me->env);
! 2415: my_done = 1;
! 2416: }
! 2417: else
! 2418: {
! 2419: fprintf (fp, "%s:%s:%s:%s\n", users[i]->username, users[i]->email,
! 2420: users[i]->password, users[i]->env);
! 2421: }
! 2422: }
! 2423: if (loggedin && !my_done)
! 2424: { /* new entry */
! 2425: if (f_num < globalconfig.max)
! 2426: fprintf (fp, "%s:%s:%s:%s\n", me->username, me->email, me->password,
! 2427: me->env);
! 2428: else /* Oops, someone else registered the last available slot first */
! 2429: {
! 2430: fclose(fp);
! 2431: fclose(fpl);
! 2432: signals_release();
! 2433: debug_write("too many users in passwd db already");
! 2434: graceful_exit (116);
! 2435: }
! 2436: }
! 2437:
! 2438: fclose (fp);
! 2439: fclose (fpl);
! 2440:
! 2441: signals_release();
! 2442: }
! 2443: #else
! 2444: void
! 2445: writefile (int requirenew)
! 2446: {
! 2447: sqlite3 *db;
! 2448: char *errmsg = NULL;
! 2449: int ret, retry = 10;
! 2450:
! 2451: char *qbuf;
! 2452:
! 2453: if (requirenew) {
! 2454: qbuf = sqlite3_mprintf("insert into dglusers (username, email, env, password, flags) values ('%q', '%q', '%q', '%q', %li)", me->username, me->email, me->env, me->password, me->flags);
! 2455: } else {
! 2456: qbuf = sqlite3_mprintf("update dglusers set username='%q', email='%q', env='%q', password='%q', flags=%li where id=%i", me->username, me->email, me->env, me->password, me->flags, me->id);
! 2457: }
! 2458:
! 2459: ret = sqlite3_open(globalconfig.passwd, &db);
! 2460: if (ret) {
! 2461: sqlite3_close(db);
! 2462: debug_write("writefile sqlite3_open failed");
! 2463: graceful_exit(97);
! 2464: }
! 2465:
! 2466: sqlite3_busy_timeout(db, 10000);
! 2467: ret = sqlite3_exec(db, qbuf, NULL, NULL, &errmsg);
! 2468:
! 2469: sqlite3_free(qbuf);
! 2470:
! 2471: if (ret != SQLITE_OK) {
! 2472: sqlite3_close(db);
! 2473: debug_write("writefile sqlite3_exec failed");
! 2474: graceful_exit(98);
! 2475: }
! 2476: sqlite3_close(db);
! 2477: }
! 2478: #endif
! 2479:
! 2480: /* ************************************************************* */
! 2481:
! 2482: int
! 2483: purge_stale_locks (int game)
! 2484: {
! 2485: DIR *pdir;
! 2486: struct dirent *dent;
! 2487: char* dir;
! 2488: size_t len;
! 2489: short firsttime = 1;
! 2490:
! 2491: dir = strdup(dgl_format_str(game, me, myconfig[game]->inprogressdir, NULL));
! 2492:
! 2493: if (!(pdir = opendir (dir))) {
! 2494: debug_write("purge_stale_locks dir open failed");
! 2495: graceful_exit (200);
! 2496: }
! 2497:
! 2498: free(dir);
! 2499:
! 2500: while ((dent = readdir (pdir)) != NULL)
! 2501: {
! 2502: FILE *ipfile;
! 2503: char *colon, *fn;
! 2504: char buf[16];
! 2505: pid_t pid;
! 2506: size_t len;
! 2507: int seconds = 0;
! 2508:
! 2509: if (!strcmp (dent->d_name, ".") || !strcmp (dent->d_name, ".."))
! 2510: continue;
! 2511:
! 2512: colon = strchr (dent->d_name, ':');
! 2513: /* should never happen */
! 2514: if (!colon) {
! 2515: debug_write("purge_stale_locks !colon");
! 2516: graceful_exit (201);
! 2517: }
! 2518: if (colon - dent->d_name != strlen(me->username))
! 2519: continue;
! 2520: if (strncmp (dent->d_name, me->username, colon - dent->d_name))
! 2521: continue;
! 2522:
! 2523: len = strlen (dent->d_name) + strlen(dgl_format_str(game, me, myconfig[game]->inprogressdir, NULL)) + 1;
! 2524: fn = malloc (len);
! 2525:
! 2526: snprintf (fn, len, "%s%s", dgl_format_str(game, me, myconfig[game]->inprogressdir, NULL), dent->d_name);
! 2527:
! 2528: if (!(ipfile = fopen (fn, "r"))) {
! 2529: debug_write("purge_stale_locks fopen inprogressdir fail");
! 2530: graceful_exit (202);
! 2531: }
! 2532:
! 2533: if (fgets (buf, 16, ipfile) == NULL) {
! 2534: debug_write("purge_stale_locks fgets ipfile fail");
! 2535: graceful_exit (203);
! 2536: }
! 2537:
! 2538: fclose (ipfile);
! 2539:
! 2540: if (firsttime)
! 2541: {
! 2542: clear ();
! 2543: drawbanner (&banner);
! 2544:
! 2545: #define HUP_WAIT 10 /* seconds before HUPPING */
! 2546: mvprintw (3, 1,
! 2547: "There are some stale %s processes, will recover in %d seconds.",
! 2548: myconfig[game]->game_name, HUP_WAIT);
! 2549: mvaddstr (4, 1,
! 2550: "Press a key NOW if you don't want this to happen!");
! 2551:
! 2552: move (3, 51 + strlen(myconfig[game]->game_name)); /* pedantry */
! 2553: halfdelay(10);
! 2554:
! 2555: for (seconds = HUP_WAIT - 1; seconds >= 0; seconds--)
! 2556: {
! 2557: if (dgl_getch() != ERR)
! 2558: {
! 2559: nocbreak(); /* leave half-delay */
! 2560: cbreak();
! 2561: return 0;
! 2562: }
! 2563: mvprintw (3, 50 + strlen(myconfig[game]->game_name), "%d%s", seconds, (seconds > 9) ? "" : " ");
! 2564: }
! 2565:
! 2566: nocbreak();
! 2567: cbreak();
! 2568:
! 2569: firsttime = 0;
! 2570: }
! 2571:
! 2572: clear ();
! 2573: refresh ();
! 2574:
! 2575: pid = atoi (buf);
! 2576:
! 2577: kill (pid, SIGHUP);
! 2578:
! 2579: errno = 0;
! 2580:
! 2581: /* Wait for it to stop running */
! 2582: seconds = 0;
! 2583: while (kill (pid, 0) == 0)
! 2584: {
! 2585: seconds++;
! 2586: sleep (1);
! 2587: if (seconds == 10)
! 2588: {
! 2589: mvprintw (3, 1,
! 2590: "Couldn't terminate one of your stale %s processes gracefully.", myconfig[game]->game_name);
! 2591: mvaddstr (4, 1, "Force its termination? [yn] ");
! 2592: if (tolower (dgl_getch ()) == 'y')
! 2593: {
! 2594: kill (pid, SIGTERM);
! 2595: break;
! 2596: }
! 2597: else
! 2598: {
! 2599: endwin ();
! 2600: fprintf (stderr, "Sorry, no %s for you now, please "
! 2601: "contact the admin.\n", myconfig[game]->game_name);
! 2602: debug_write("could not terminate stale processes");
! 2603: graceful_exit (1);
! 2604: }
! 2605: }
! 2606: }
! 2607:
! 2608: /* Don't remove the lock file until the process is dead. */
! 2609: unlink (fn);
! 2610: free (fn);
! 2611: }
! 2612:
! 2613: closedir (pdir);
! 2614: return 1;
! 2615: }
! 2616:
! 2617:
! 2618: int
! 2619: runmenuloop(struct dg_menu *menu)
! 2620: {
! 2621: struct dg_banner ban;
! 2622: struct dg_menuoption *tmpopt;
! 2623: int userchoice = 0;
! 2624: int doclear = 1;
! 2625:
! 2626: if (!menu) return 1;
! 2627:
! 2628: ban.lines = NULL;
! 2629: ban.len = 0;
! 2630:
! 2631: loadbanner(menu->banner_fn, &ban);
! 2632: while (1) {
! 2633: term_resize_check();
! 2634: if (doclear) {
! 2635: doclear = 0;
! 2636: if (globalconfig.utf8esc) (void) write(1, "\033%G", 3);
! 2637: clear();
! 2638: }
! 2639: drawbanner(&ban);
! 2640: if (menu->cursor_x >= 0 && menu->cursor_y >= 0)
! 2641: mvprintw(menu->cursor_y, menu->cursor_x, "");
! 2642: refresh();
! 2643: userchoice = dgl_getch();
! 2644: if (userchoice == ERR) {
! 2645: freebanner(&ban);
! 2646: return 1;
! 2647: }
! 2648: tmpopt = menu->options;
! 2649: while (tmpopt) {
! 2650: if (strchr(tmpopt->keys, userchoice)) {
! 2651: dgl_exec_cmdqueue(tmpopt->cmdqueue, selected_game, me);
! 2652: doclear = 1;
! 2653: break;
! 2654: } else {
! 2655: tmpopt = tmpopt->next;
! 2656: }
! 2657: }
! 2658:
! 2659: if (return_from_submenu) {
! 2660: freebanner(&ban);
! 2661: return_from_submenu = 0;
! 2662: return 0;
! 2663: }
! 2664:
! 2665: if (check_retard(0)) {
! 2666: freebanner(&ban);
! 2667: debug_write("retard");
! 2668: graceful_exit(119);
! 2669: }
! 2670: }
! 2671: }
! 2672:
! 2673: int
! 2674: main (int argc, char** argv)
! 2675: {
! 2676: /* for chroot and program execution */
! 2677: char atrcfilename[81], *p, *auth = NULL;
! 2678: unsigned int len;
! 2679: int c, i;
! 2680: int userchoice;
! 2681: char *tmp;
! 2682: char *wall_email_str = NULL;
! 2683: #ifdef USE_RLIMIT
! 2684: struct rlimit lim;
! 2685: #endif
! 2686:
! 2687: #ifndef HAVE_SETPROCTITLE
! 2688: /* save argc, argv */
! 2689: char** saved_argv;
! 2690: int saved_argc;
! 2691:
! 2692: saved_argc = argc;
! 2693:
! 2694: saved_argv = malloc(sizeof(char**) * (argc + 1));
! 2695: for (i = 0; i < argc; i++)
! 2696: saved_argv[i] = strdup(argv[i]);
! 2697: saved_argv[i] = '\0';
! 2698:
! 2699: compat_init_setproctitle(argc, argv);
! 2700: argv = saved_argv;
! 2701: #endif
! 2702:
! 2703: p = getenv("DGLAUTH");
! 2704:
! 2705: /* Linux telnetd allows importing the USER envvar via telnet,
! 2706: * while FreeBSD does not. FreeBSD, on the other hand, does allow
! 2707: * the LOGNAME envvar. Check USER first, then LOGNAME.
! 2708: */
! 2709: if (p == NULL) {
! 2710: p = getenv("USER");
! 2711: }
! 2712:
! 2713: if (p == NULL) {
! 2714: p = getenv("LOGNAME");
! 2715: }
! 2716:
! 2717: if (p && *p != '\0')
! 2718: auth = strdup(p);
! 2719: /* else auth is still NULL */
! 2720:
! 2721: /* just to be sure */
! 2722: unsetenv("DGLAUTH"); unsetenv("USER"); unsetenv("LOGNAME");
! 2723:
! 2724: __progname = basename(strdup(argv[0]));
! 2725:
! 2726: while ((c = getopt(argc, argv, "csqh:pi:aeW:SD")) != -1)
! 2727: {
! 2728: /* Stop processing arguments at -c, so that user-provided
! 2729: * commands (via ssh for example) to the dgamelaunch login
! 2730: * shell are ignored.
! 2731: */
! 2732: if (c == 'c') break;
! 2733: switch (c)
! 2734: {
! 2735: case 's':
! 2736: showplayers = 1; break;
! 2737:
! 2738: case 'q':
! 2739: silent = 1; break;
! 2740:
! 2741: case 'i':
! 2742: if (optarg && *optarg != '\0') {
! 2743: if (p && *p != '\0')
! 2744: *p = '\0';
! 2745:
! 2746: p = strdup(optarg);
! 2747: initplayer = 1;
! 2748:
! 2749: if (auth && *auth != '\0')
! 2750: *auth = '\0';
! 2751: }
! 2752: break;
! 2753:
! 2754: case 'W':
! 2755: wall_email_str = strdup(optarg);
! 2756: break;
! 2757:
! 2758: case 'S': /* Free the shared memory block */
! 2759: #ifdef USE_SHMEM
! 2760: if (shm_free()) {
! 2761: if (!silent) fprintf(stderr, "nonexistent shmem block.\n");
! 2762: } else {
! 2763: if (!silent) fprintf(stderr, "shmem block freed.\n");
! 2764: }
! 2765: #else
! 2766: if (!silent) fprintf(stderr, "warning: dgamelaunch was compiled without shmem.\n");
! 2767: #endif
! 2768: graceful_exit(0);
! 2769: break;
! 2770:
! 2771: case 'D': /* dump the shared memory block data */
! 2772: #ifdef USE_SHMEM
! 2773: shm_dump();
! 2774: #else
! 2775: if (!silent) fprintf(stderr, "warning: dgamelaunch was compiled without shmem.\n");
! 2776: #endif
! 2777: graceful_exit(0);
! 2778: break;
! 2779:
! 2780: default:
! 2781: break; /*ignore */
! 2782: }
! 2783: }
! 2784:
! 2785: while (optind < argc)
! 2786: {
! 2787: size_t len = strlen(argv[optind]);
! 2788: memset(argv[optind++], 0, len);
! 2789: }
! 2790: setproctitle("<Anonymous>");
! 2791:
! 2792: srand(time(0));
! 2793:
! 2794: create_config();
! 2795:
! 2796: /* signal handlers */
! 2797: signal (SIGHUP, catch_sighup);
! 2798: signal (SIGINT, catch_sighup);
! 2799: signal (SIGQUIT, catch_sighup);
! 2800: signal (SIGTERM, catch_sighup);
! 2801:
! 2802: (void) tcgetattr (0, &tt);
! 2803:
! 2804: if (!globalconfig.flowctrl) {
! 2805: tt.c_iflag &= ~(IXON | IXOFF | IXANY); /* Disable XON/XOFF */
! 2806: (void) tcsetattr(0, TCSANOW, &tt);
! 2807: }
! 2808:
! 2809: if (-1 == ioctl (0, TIOCGWINSZ, (char *) &win) || win.ws_row < 4 ||
! 2810: win.ws_col < 4) /* Rudimentary validity check */
! 2811: {
! 2812: win.ws_row = 24;
! 2813: win.ws_col = 80;
! 2814: win.ws_xpixel = win.ws_col * 8;
! 2815: win.ws_ypixel = win.ws_row * 8;
! 2816: }
! 2817:
! 2818: /* get master tty just before chroot (lives in /dev) */
! 2819: ttyrec_getpty ();
! 2820:
! 2821: #ifdef USE_RLIMIT
! 2822: #ifdef USE_RLIMIT_CORE
! 2823: /* enable and set core dump size */
! 2824: if (!getrlimit(RLIMIT_CORE, &lim)) {
! 2825: lim.rlim_cur = USE_RLIMIT_CORE;
! 2826: setrlimit(RLIMIT_CORE, &lim);
! 2827: }
! 2828: #endif
! 2829: #ifdef USE_RLIMIT_AS
! 2830: /* set maximum memory usage */
! 2831: if (!getrlimit(RLIMIT_AS, &lim)) {
! 2832: lim.rlim_cur = USE_RLIMIT_AS;
! 2833: setrlimit(RLIMIT_AS, &lim);
! 2834: }
! 2835: #endif
! 2836: #endif
! 2837:
! 2838: if (geteuid () != globalconfig.shed_uid)
! 2839: {
! 2840: /* chroot */
! 2841: if (chroot (globalconfig.chroot))
! 2842: {
! 2843: perror ("cannot change root directory");
! 2844: graceful_exit (2);
! 2845: }
! 2846:
! 2847: if (chdir ("/"))
! 2848: {
! 2849: perror ("cannot chdir to root directory");
! 2850: graceful_exit (3);
! 2851: }
! 2852:
! 2853: /* shed privs. this is done immediately after chroot. */
! 2854: if (setgroups (1, &globalconfig.shed_gid) == -1)
! 2855: {
! 2856: perror ("setgroups");
! 2857: graceful_exit (4);
! 2858: }
! 2859:
! 2860: if (setgid (globalconfig.shed_gid) == -1)
! 2861: {
! 2862: perror ("setgid");
! 2863: graceful_exit (5);
! 2864: }
! 2865:
! 2866: if (setuid (globalconfig.shed_uid) == -1)
! 2867: {
! 2868: perror ("setuid");
! 2869: graceful_exit (6);
! 2870: }
! 2871: }
! 2872:
! 2873: if (globalconfig.locale) {
! 2874: setlocale(LC_CTYPE, globalconfig.locale);
! 2875: }
! 2876:
! 2877: if (showplayers) {
! 2878: inprogressdisplay(-1);
! 2879: graceful_exit (0);
! 2880: }
! 2881:
! 2882: if (wall_email_str) {
! 2883: char *emailfrom = wall_email_str;
! 2884: char *emailmsg = strchr(wall_email_str, ':');
! 2885: if (!emailmsg) {
! 2886: debug_write("wall: no mail msg");
! 2887: graceful_exit(117);
! 2888: }
! 2889: *emailmsg = '\0';
! 2890: emailmsg++;
! 2891: if (emailmsg)
! 2892: wall_email(emailfrom, emailmsg);
! 2893: graceful_exit(0);
! 2894: }
! 2895:
! 2896: banner.len = 0;
! 2897: banner.lines = NULL;
! 2898: loadbanner(globalconfig.banner, &banner);
! 2899:
! 2900: dgl_exec_cmdqueue(globalconfig.cmdqueue[DGLTIME_DGLSTART], 0, NULL);
! 2901:
! 2902: if (initplayer) {
! 2903: char *user, *pass;
! 2904:
! 2905: user = strdup(p);
! 2906: pass = strdup(p);
! 2907:
! 2908: autologin(user, pass);
! 2909:
! 2910: if (loggedin) {
! 2911: dgl_exec_cmdqueue(globalconfig.cmdqueue[DGLTIME_REGISTER], 0, me);
! 2912: fprintf(stdout, "Setup of %s succeeded.\n", me->username);
! 2913: graceful_exit(0);
! 2914: }
! 2915: else {
! 2916: fprintf(stdout, "Setup of %s failed.\n", p);
! 2917: graceful_exit(10);
! 2918: }
! 2919: }
! 2920:
! 2921: /* simple login routine, uses ncurses */
! 2922: if (readfile (0)) {
! 2923: debug_write("log in fail");
! 2924: graceful_exit (110);
! 2925: }
! 2926:
! 2927: if (auth)
! 2928: {
! 2929: char *user, *pass, *p;
! 2930:
! 2931: p = strchr(auth, ':');
! 2932:
! 2933: if (p)
! 2934: {
! 2935: pass = p + 1;
! 2936:
! 2937: if (*pass != '\0')
! 2938: {
! 2939: *p = '\0';
! 2940: user = auth;
! 2941: autologin(user, pass);
! 2942: }
! 2943: }
! 2944: }
! 2945:
! 2946: initcurses ();
! 2947:
! 2948: g_chain_winch = signal(SIGWINCH, sigwinch_func);
! 2949:
! 2950: term_resize_check();
! 2951:
! 2952: idle_alarm_set_enabled(1);
! 2953:
! 2954: while (1) {
! 2955: if (runmenuloop(dgl_find_menu(get_mainmenu_name())))
! 2956: break;
! 2957: }
! 2958:
! 2959: idle_alarm_set_enabled(0);
! 2960:
! 2961: /* NOW we can safely kill this */
! 2962: freefile ();
! 2963:
! 2964: if (me)
! 2965: free (me);
! 2966:
! 2967: freebanner(&banner);
! 2968: banner_var_free();
! 2969: graceful_exit (20);
! 2970:
! 2971: return 1;
! 2972: }
CVSweb
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dgamelaunch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [contributed] / dgamelaunch-openbsd