Annotation of embedaddon/mpd/src/console.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * console.c
! 4: *
! 5: * Written by Archie Cobbs <archie@freebsd.org>
! 6: * Copyright (c) 1995-1999 Whistle Communications, Inc. All rights reserved.
! 7: * See ``COPYRIGHT.whistle''
! 8: */
! 9:
! 10: #include "ppp.h"
! 11: #include "console.h"
! 12: #include "util.h"
! 13: #include <termios.h>
! 14:
! 15: /*
! 16: * DEFINITIONS
! 17: */
! 18:
! 19: #ifndef CTRL
! 20: #define CTRL(c) (c - '@')
! 21: #endif
! 22:
! 23: #define EchoOff() cs->write(cs, "\xFF\xFB\x01\xFF\xFD\x01");
! 24: #define EchoOn() cs->write(cs, "\xFF\xFC\x01\xFF\xFE\x01");
! 25:
! 26:
! 27: enum {
! 28: STATE_USERNAME = 0,
! 29: STATE_PASSWORD,
! 30: STATE_AUTHENTIC
! 31: };
! 32:
! 33: /* Set menu options */
! 34: enum {
! 35: SET_OPEN,
! 36: SET_CLOSE,
! 37: SET_SELF,
! 38: SET_DISABLE,
! 39: SET_ENABLE
! 40: };
! 41:
! 42:
! 43: /*
! 44: * INTERNAL FUNCTIONS
! 45: */
! 46:
! 47: static void ConsoleConnect(int type, void *cookie);
! 48: static void ConsoleSessionClose(ConsoleSession cs);
! 49: static void ConsoleSessionReadEvent(int type, void *cookie);
! 50: static void ConsoleSessionWrite(ConsoleSession cs, const char *fmt, ...);
! 51: static void ConsoleSessionWriteV(ConsoleSession cs, const char *fmt, va_list vl);
! 52: static void ConsoleSessionShowPrompt(ConsoleSession cs);
! 53:
! 54: static void StdConsoleSessionClose(ConsoleSession cs);
! 55: static void StdConsoleSessionWrite(ConsoleSession cs, const char *fmt, ...);
! 56: static void StdConsoleSessionWriteV(ConsoleSession cs, const char *fmt, va_list vl);
! 57:
! 58: static int ConsoleUserHashEqual(struct ghash *g, const void *item1,
! 59: const void *item2);
! 60: static u_int32_t ConsoleUserHash(struct ghash *g, const void *item);
! 61: static int ConsoleSetCommand(Context ctx, int ac, char *av[], void *arg);
! 62:
! 63:
! 64: /*
! 65: * GLOBAL VARIABLES
! 66: */
! 67:
! 68: const struct cmdtab ConsoleSetCmds[] = {
! 69: { "open", "Open the console" ,
! 70: ConsoleSetCommand, NULL, 2, (void *) SET_OPEN },
! 71: { "close", "Close the console" ,
! 72: ConsoleSetCommand, NULL, 2, (void *) SET_CLOSE },
! 73: { "self {ip} [{port}]", "Set console ip and port" ,
! 74: ConsoleSetCommand, NULL, 2, (void *) SET_SELF },
! 75: { "enable [opt ...]", "Enable this console option" ,
! 76: ConsoleSetCommand, NULL, 0, (void *) SET_ENABLE },
! 77: { "disable [opt ...]", "Disable this console option" ,
! 78: ConsoleSetCommand, NULL, 0, (void *) SET_DISABLE },
! 79: { NULL },
! 80: };
! 81:
! 82: struct ghash *gUsers; /* allowed users */
! 83: pthread_rwlock_t gUsersLock;
! 84:
! 85: /*
! 86: * INTERNAL VARIABLES
! 87: */
! 88:
! 89: static const struct confinfo gConfList[] = {
! 90: { 0, CONSOLE_LOGGING, "logging" },
! 91: { 0, 0, NULL },
! 92: };
! 93:
! 94: struct termios gOrigTermiosAttrs;
! 95: int gOrigFlags;
! 96:
! 97: /*
! 98: * ConsoleInit()
! 99: */
! 100:
! 101: int
! 102: ConsoleInit(Console c)
! 103: {
! 104: int ret;
! 105:
! 106: /* setup console-defaults */
! 107: memset(&gConsole, 0, sizeof(gConsole));
! 108: ParseAddr(DEFAULT_CONSOLE_IP, &c->addr, ALLOW_IPV4|ALLOW_IPV6);
! 109: c->port = DEFAULT_CONSOLE_PORT;
! 110:
! 111: SLIST_INIT(&c->sessions);
! 112:
! 113: if ((ret = pthread_rwlock_init (&c->lock, NULL)) != 0) {
! 114: Log(LG_ERR, ("Could not create rwlock %d", ret));
! 115: return (-1);
! 116: }
! 117:
! 118: gUsers = ghash_create(c, 0, 0, MB_CONS, ConsoleUserHash, ConsoleUserHashEqual, NULL, NULL);
! 119: if ((ret = pthread_rwlock_init (&gUsersLock, NULL)) != 0) {
! 120: Log(LG_ERR, ("Could not create rwlock %d", ret));
! 121: return (-1);
! 122: }
! 123:
! 124: return (0);
! 125: }
! 126:
! 127: /*
! 128: * ConsoleOpen()
! 129: */
! 130:
! 131: int
! 132: ConsoleOpen(Console c)
! 133: {
! 134: char addrstr[INET6_ADDRSTRLEN];
! 135:
! 136: if (c->fd) {
! 137: Log(LG_ERR, ("CONSOLE: Console already running"));
! 138: return -1;
! 139: }
! 140:
! 141: u_addrtoa(&c->addr, addrstr, sizeof(addrstr));
! 142: if ((c->fd = TcpGetListenPort(&c->addr, c->port, FALSE)) < 0) {
! 143: Log(LG_ERR, ("CONSOLE: Can't listen for connections on %s %d",
! 144: addrstr, c->port));
! 145: return -1;
! 146: }
! 147:
! 148: if (EventRegister(&c->event, EVENT_READ, c->fd,
! 149: EVENT_RECURRING, ConsoleConnect, c) < 0)
! 150: return -1;
! 151:
! 152: Log(LG_CONSOLE, ("CONSOLE: listening on %s %d",
! 153: addrstr, c->port));
! 154: return 0;
! 155: }
! 156:
! 157: /*
! 158: * ConsoleClose()
! 159: */
! 160:
! 161: int
! 162: ConsoleClose(Console c)
! 163: {
! 164: if (!c->fd)
! 165: return 0;
! 166: EventUnRegister(&c->event);
! 167: close(c->fd);
! 168: c->fd = 0;
! 169: return 0;
! 170: }
! 171:
! 172: /*
! 173: * ConsoleStat()
! 174: */
! 175:
! 176: int
! 177: ConsoleStat(Context ctx, int ac, char *av[], void *arg)
! 178: {
! 179: Console c = &gConsole;
! 180: ConsoleSession s;
! 181: ConsoleSession cs = ctx->cs;
! 182: char addrstr[INET6_ADDRSTRLEN];
! 183:
! 184: Printf("Configuration:\r\n");
! 185: Printf("\tState : %s\r\n", c->fd ? "OPENED" : "CLOSED");
! 186: Printf("\tIP-Address : %s\r\n", u_addrtoa(&c->addr,addrstr,sizeof(addrstr)));
! 187: Printf("\tPort : %d\r\n", c->port);
! 188:
! 189: RWLOCK_RDLOCK(c->lock);
! 190: Printf("Active sessions:\r\n");
! 191: SLIST_FOREACH(s, &c->sessions, next) {
! 192: Printf("\tUsername: %s\tFrom: %s\r\n",
! 193: s->user.username, u_addrtoa(&s->peer_addr,addrstr,sizeof(addrstr)));
! 194: }
! 195: RWLOCK_UNLOCK(c->lock);
! 196:
! 197: if (cs) {
! 198: Printf("This session options:\r\n");
! 199: OptStat(ctx, &cs->options, gConfList);
! 200: }
! 201: return 0;
! 202: }
! 203:
! 204: /*
! 205: * ConsoleConnect()
! 206: */
! 207:
! 208: static void
! 209: ConsoleConnect(int type, void *cookie)
! 210: {
! 211: Console c = cookie;
! 212: ConsoleSession cs;
! 213: const char *options =
! 214: "\xFF\xFB\x03" /* WILL Suppress Go-Ahead */
! 215: "\xFF\xFD\x03" /* DO Suppress Go-Ahead */
! 216: "\xFF\xFB\x01" /* WILL echo */
! 217: "\xFF\xFD\x01"; /* DO echo */
! 218: char addrstr[INET6_ADDRSTRLEN];
! 219: struct sockaddr_storage ss;
! 220:
! 221: Log(LG_CONSOLE, ("CONSOLE: Connect"));
! 222: cs = Malloc(MB_CONS, sizeof(*cs));
! 223: if ((cs->fd = TcpAcceptConnection(c->fd, &ss, FALSE)) < 0)
! 224: goto cleanup;
! 225: sockaddrtou_addr(&ss, &cs->peer_addr, &cs->peer_port);
! 226:
! 227: if (EventRegister(&cs->readEvent, EVENT_READ, cs->fd,
! 228: EVENT_RECURRING, ConsoleSessionReadEvent, cs) < 0)
! 229: goto fail;
! 230:
! 231: cs->console = c;
! 232: cs->close = ConsoleSessionClose;
! 233: cs->write = ConsoleSessionWrite;
! 234: cs->writev = ConsoleSessionWriteV;
! 235: cs->prompt = ConsoleSessionShowPrompt;
! 236: cs->state = STATE_USERNAME;
! 237: cs->context.cs = cs;
! 238: RWLOCK_WRLOCK(c->lock);
! 239: SLIST_INSERT_HEAD(&c->sessions, cs, next);
! 240: RWLOCK_UNLOCK(c->lock);
! 241: Log(LG_CONSOLE, ("CONSOLE: Allocated new console session %p from %s",
! 242: cs, u_addrtoa(&cs->peer_addr,addrstr,sizeof(addrstr))));
! 243: cs->write(cs, "Multi-link PPP daemon for FreeBSD\r\n\r\n");
! 244: cs->write(cs, options);
! 245: cs->prompt(cs);
! 246: return;
! 247:
! 248: fail:
! 249: close(cs->fd);
! 250:
! 251: cleanup:
! 252: Freee(cs);
! 253: return;
! 254:
! 255: }
! 256:
! 257: /*
! 258: * StdConsoleConnect()
! 259: */
! 260:
! 261: Context
! 262: StdConsoleConnect(Console c)
! 263: {
! 264: ConsoleSession cs;
! 265: struct termios settings;
! 266:
! 267: cs = Malloc(MB_CONS, sizeof(*cs));
! 268:
! 269: /* Init stdin */
! 270: cs->fd = 0;
! 271:
! 272: /* Save original STDxxx flags */
! 273: gOrigFlags = fcntl(0, F_GETFL, 0);
! 274:
! 275: tcgetattr(cs->fd, &settings);
! 276: gOrigTermiosAttrs = settings;
! 277: settings.c_lflag &= (~ICANON);
! 278: settings.c_lflag &= (~ECHO); // don't echo the character
! 279: settings.c_cc[VTIME] = 0; // timeout (tenths of a second)
! 280: settings.c_cc[VMIN] = 0; // minimum number of characters
! 281: tcsetattr(cs->fd, TCSANOW, &settings);
! 282:
! 283: if (fcntl(cs->fd, F_SETFL, O_NONBLOCK) < 0) {
! 284: Perror("%s: fcntl", __FUNCTION__);
! 285: Freee(cs);
! 286: return(NULL);
! 287: }
! 288:
! 289: /* Init stdout */
! 290: if (fcntl(1, F_SETFL, O_NONBLOCK) < 0) {
! 291: Perror("%s: fcntl", __FUNCTION__);
! 292: Freee(cs);
! 293: return(NULL);
! 294: }
! 295:
! 296: Enable(&cs->options, CONSOLE_LOGGING);
! 297: cs->console = c;
! 298: cs->close = StdConsoleSessionClose;
! 299: cs->write = StdConsoleSessionWrite;
! 300: cs->writev = StdConsoleSessionWriteV;
! 301: cs->prompt = ConsoleSessionShowPrompt;
! 302: cs->state = STATE_AUTHENTIC;
! 303: cs->context.cs = cs;
! 304: strcpy(cs->user.username, "root");
! 305: cs->context.priv = 2;
! 306: RWLOCK_WRLOCK(c->lock);
! 307: SLIST_INSERT_HEAD(&c->sessions, cs, next);
! 308: RWLOCK_UNLOCK(c->lock);
! 309:
! 310: EventRegister(&cs->readEvent, EVENT_READ, cs->fd,
! 311: EVENT_RECURRING, ConsoleSessionReadEvent, cs);
! 312:
! 313: return (&cs->context);
! 314: }
! 315:
! 316:
! 317: /*
! 318: * ConsoleSessionClose()
! 319: * This function is potentially thread unsafe.
! 320: * To avois this locks should be used.
! 321: * The only unlocked place is ->readEvent,
! 322: * but it is actually the only place where ->close called.
! 323: */
! 324:
! 325: static void
! 326: ConsoleSessionClose(ConsoleSession cs)
! 327: {
! 328: cs->write(cs, "Console closed.\r\n");
! 329: RWLOCK_WRLOCK(cs->console->lock);
! 330: SLIST_REMOVE(&cs->console->sessions, cs, console_session, next);
! 331: RWLOCK_UNLOCK(cs->console->lock);
! 332: EventUnRegister(&cs->readEvent);
! 333: close(cs->fd);
! 334: Freee(cs);
! 335: return;
! 336: }
! 337:
! 338: /*
! 339: * StdConsoleSessionClose()
! 340: */
! 341:
! 342: static void
! 343: StdConsoleSessionClose(ConsoleSession cs)
! 344: {
! 345: cs->write(cs, "Console closed.\r\n");
! 346: EventUnRegister(&cs->readEvent);
! 347: /* Restore original attrs */
! 348: tcsetattr(cs->fd, TCSANOW, &gOrigTermiosAttrs);
! 349: /* Restore original STDxxx flags. */
! 350: if (gOrigFlags>=0)
! 351: fcntl(cs->fd, F_SETFL, gOrigFlags);
! 352: cs->close = NULL;
! 353: return;
! 354: }
! 355:
! 356: /*
! 357: * ConsoleSessionReadEvent()
! 358: */
! 359:
! 360: static void
! 361: ConsoleSessionReadEvent(int type, void *cookie)
! 362: {
! 363: ConsoleSession cs = cookie;
! 364: CmdTab cmd, tab;
! 365: int n, ac, ac2, i;
! 366: u_char c;
! 367: char compl[MAX_CONSOLE_LINE], line[MAX_CONSOLE_LINE];
! 368: char *av[MAX_CONSOLE_ARGS], *av2[MAX_CONSOLE_ARGS];
! 369: char *av_copy[MAX_CONSOLE_ARGS];
! 370: char addrstr[INET6_ADDRSTRLEN];
! 371:
! 372: while(1) {
! 373: if ((n = read(cs->fd, &c, 1)) <= 0) {
! 374: if (n < 0) {
! 375: if (errno == EAGAIN)
! 376: goto out;
! 377: Perror("CONSOLE: Error while reading");
! 378: } else {
! 379: if (cs->fd == 0)
! 380: goto out;
! 381: Log(LG_ERR, ("CONSOLE: Connection closed by peer"));
! 382: }
! 383: goto abort;
! 384: }
! 385:
! 386: if (cs->context.lnk && cs->context.lnk->dead) {
! 387: UNREF(cs->context.lnk);
! 388: cs->context.lnk = NULL;
! 389: }
! 390: if (cs->context.bund && cs->context.bund->dead) {
! 391: UNREF(cs->context.bund);
! 392: cs->context.bund = NULL;
! 393: }
! 394: if (cs->context.rep && cs->context.rep->dead) {
! 395: UNREF(cs->context.rep);
! 396: cs->context.rep = NULL;
! 397: }
! 398:
! 399: /* deal with escapes, map cursors */
! 400: if (cs->escaped) {
! 401: if (cs->escaped == '[') {
! 402: switch(c) {
! 403: case 'A': /* up */
! 404: c = CTRL('P');
! 405: break;
! 406: case 'B': /* down */
! 407: c = CTRL('N');
! 408: break;
! 409: case 'C': /* right */
! 410: c = CTRL('F');
! 411: break;
! 412: case 'D': /* left */
! 413: c = CTRL('B');
! 414: break;
! 415: default:
! 416: c = 0;
! 417: }
! 418: cs->escaped = FALSE;
! 419: } else {
! 420: cs->escaped = c == '[' ? c : 0;
! 421: continue;
! 422: }
! 423: }
! 424:
! 425: switch(c) {
! 426: case 0:
! 427: break;
! 428: case 27: /* escape */
! 429: cs->escaped = TRUE;
! 430: break;
! 431: case 255: /* telnet option follows */
! 432: cs->telnet = TRUE;
! 433: break;
! 434: case 253: /* telnet option-code DO */
! 435: break;
! 436: case 9: /* TAB */
! 437: if (cs->state != STATE_AUTHENTIC)
! 438: break;
! 439: strcpy(line, cs->cmd);
! 440: ac = ParseLine(line, av, sizeof(av) / sizeof(*av), 1);
! 441: memset(compl, 0, sizeof(compl));
! 442: tab = gCommands;
! 443: for (i = 0; i < ac; i++) {
! 444:
! 445: if (FindCommand(&cs->context, tab, av[i], &cmd)) {
! 446: cs->write(cs, "\a");
! 447: goto notfound;
! 448: }
! 449: strcpy(line, cmd->name);
! 450: ac2 = ParseLine(line, av2, sizeof(av2) / sizeof(*av2), 1);
! 451: snprintf(&compl[strlen(compl)], sizeof(compl) - strlen(compl), "%s ", av2[0]);
! 452: FreeArgs(ac2, av2);
! 453: if (cmd->func != CMD_SUBMENU &&
! 454: (i != 0 || strcmp(compl, "help ") !=0)) {
! 455: i++;
! 456: if (i < ac) {
! 457: cs->write(cs, "\a");
! 458: for (; i < ac; i++) {
! 459: strcat(compl, av[i]);
! 460: if ((i+1) < ac)
! 461: strcat(compl, " ");
! 462: }
! 463: }
! 464: break;
! 465: } else if (cmd->func == CMD_SUBMENU) {
! 466: tab = cmd->arg;
! 467: }
! 468: }
! 469: for (i = 0; i < cs->cmd_len; i++)
! 470: cs->write(cs, "\b \b");
! 471: strcpy(cs->cmd, compl);
! 472: cs->cmd_len = strlen(cs->cmd);
! 473: cs->write(cs, cs->cmd);
! 474: notfound:
! 475: FreeArgs(ac, av);
! 476: break;
! 477: case CTRL('C'):
! 478: if (cs->telnet)
! 479: break;
! 480: cs->write(cs, "\r\n");
! 481: memset(cs->cmd, 0, MAX_CONSOLE_LINE);
! 482: cs->cmd_len = 0;
! 483: cs->prompt(cs);
! 484: cs->telnet = FALSE;
! 485: break;
! 486: case CTRL('P'): /* page up */
! 487: if ((cs->currhist < MAX_CONSOLE_HIST) &&
! 488: (cs->history[cs->currhist][0])) {
! 489: for (i = 0; i < cs->cmd_len; i++)
! 490: cs->write(cs, "\b \b");
! 491: memcpy(cs->cmd, cs->history[cs->currhist], MAX_CONSOLE_LINE);
! 492: cs->currhist++;
! 493: cs->cmd_len = strlen(cs->cmd);
! 494: cs->write(cs, cs->cmd);
! 495: }
! 496: break;
! 497: case CTRL('N'): /* page down */
! 498: if (cs->currhist > 1) {
! 499: for (i = 0; i < cs->cmd_len; i++)
! 500: cs->write(cs, "\b \b");
! 501: cs->currhist--;
! 502: memcpy(cs->cmd, cs->history[cs->currhist-1], MAX_CONSOLE_LINE);
! 503: cs->cmd_len = strlen(cs->cmd);
! 504: cs->write(cs, cs->cmd);
! 505: } else {
! 506: if (cs->cmd_len>0) {
! 507: if (strncmp(cs->cmd, cs->history[0], MAX_CONSOLE_LINE) != 0) {
! 508: for (i = MAX_CONSOLE_HIST - 1; i > 0; i--)
! 509: memcpy(cs->history[i], cs->history[i - 1], MAX_CONSOLE_LINE);
! 510: memcpy(cs->history[0], cs->cmd, MAX_CONSOLE_LINE);
! 511: cs->write(cs, "\r\n");
! 512: cs->prompt(cs);
! 513: } else {
! 514: for (i = 0; i < cs->cmd_len; i++)
! 515: cs->write(cs, "\b \b");
! 516: }
! 517: }
! 518: cs->currhist = 0;
! 519: memset(cs->cmd, 0, MAX_CONSOLE_LINE);
! 520: cs->cmd_len = 0;
! 521: }
! 522: break;
! 523: case CTRL('F'):
! 524: case CTRL('B'):
! 525: break;
! 526: case CTRL('H'):
! 527: case 127: /* BS */
! 528: if (cs->cmd_len > 0) {
! 529: cs->cmd_len -= 1;
! 530: cs->cmd[cs->cmd_len] = 0;
! 531: if (cs->state != STATE_PASSWORD)
! 532: cs->write(cs, "\b \b");
! 533: }
! 534: break;
! 535: case '\r':
! 536: case '\n':
! 537: case '?':
! 538: {
! 539: if (c == '?')
! 540: cs->write(cs, "?");
! 541: cs->write(cs, "\r\n");
! 542:
! 543: cs->telnet = FALSE;
! 544: if (cs->state == STATE_USERNAME) {
! 545: strlcpy(cs->user.username, cs->cmd, sizeof(cs->user.username));
! 546: memset(cs->cmd, 0, MAX_CONSOLE_LINE);
! 547: cs->cmd_len = 0;
! 548: cs->state = STATE_PASSWORD;
! 549: cs->prompt(cs);
! 550: break;
! 551: } else if (cs->state == STATE_PASSWORD) {
! 552: ConsoleUser u;
! 553:
! 554: RWLOCK_RDLOCK(gUsersLock);
! 555: u = ghash_get(gUsers, &cs->user);
! 556: RWLOCK_UNLOCK(gUsersLock);
! 557:
! 558: if (!u)
! 559: goto failed;
! 560:
! 561: if (strcmp(u->password, cs->cmd))
! 562: goto failed;
! 563:
! 564: cs->state = STATE_AUTHENTIC;
! 565: cs->user.priv = u->priv;
! 566: cs->context.priv = u->priv;
! 567: cs->write(cs, "\r\nWelcome!\r\nMpd pid %lu, version %s\r\n",
! 568: (u_long) gPid, gVersion);
! 569: goto success;
! 570:
! 571: failed:
! 572: cs->write(cs, "Login failed\r\n");
! 573: Log(LG_CONSOLE, ("CONSOLE: Failed login attempt from %s",
! 574: u_addrtoa(&cs->peer_addr,addrstr,sizeof(addrstr))));
! 575: cs->user.username[0] = 0;
! 576: cs->state = STATE_USERNAME;
! 577: success:
! 578: memset(cs->cmd, 0, MAX_CONSOLE_LINE);
! 579: cs->cmd_len = 0;
! 580: cs->prompt(cs);
! 581: break;
! 582: }
! 583:
! 584: memcpy(line, cs->cmd, sizeof(line));
! 585: ac = ParseLine(line, av, sizeof(av) / sizeof(*av), 1);
! 586: memcpy(av_copy, av, sizeof(av));
! 587: if (c != '?') {
! 588: Log2(LG_CONSOLE, ("[%s] CONSOLE: %s: %s",
! 589: cs->context.lnk ? cs->context.lnk->name :
! 590: (cs->context.bund? cs->context.bund->name : ""),
! 591: cs->user.username, cs->cmd));
! 592: DoCommand(&cs->context, ac, av, NULL, 0);
! 593: } else {
! 594: HelpCommand(&cs->context, ac, av, NULL);
! 595: }
! 596: FreeArgs(ac, av_copy);
! 597: if (cs->exit)
! 598: goto abort;
! 599: cs->prompt(cs);
! 600: if (c != '?') {
! 601: if (cs->cmd_len > 0 &&
! 602: strncmp(cs->cmd, cs->history[0], MAX_CONSOLE_LINE) != 0) {
! 603: for (i = MAX_CONSOLE_HIST - 1; i > 0; i--)
! 604: memcpy(cs->history[i], cs->history[i - 1], MAX_CONSOLE_LINE);
! 605: memcpy(cs->history[0], cs->cmd, MAX_CONSOLE_LINE);
! 606: }
! 607: cs->currhist = 0;
! 608: memset(cs->cmd, 0, MAX_CONSOLE_LINE);
! 609: cs->cmd_len = 0;
! 610: } else {
! 611: cs->write(cs, cs->cmd);
! 612: }
! 613: break;
! 614: }
! 615: /* "normal" char entered */
! 616: default:
! 617: if (cs->telnet) {
! 618: if (c < 251)
! 619: cs->telnet = FALSE;
! 620: break;
! 621: }
! 622:
! 623: if ((cs->cmd_len + 2) >= MAX_CONSOLE_LINE) {
! 624: cs->write(cs, "\a");
! 625: break;
! 626: }
! 627:
! 628: if (c < 32)
! 629: break;
! 630:
! 631: if (cs->state != STATE_PASSWORD)
! 632: cs->write(cs, "%c", c);
! 633:
! 634: cs->cmd[cs->cmd_len++] = c;
! 635: }
! 636: }
! 637:
! 638: abort:
! 639: if (cs->close) {
! 640: RESETREF(cs->context.lnk, NULL);
! 641: RESETREF(cs->context.bund, NULL);
! 642: RESETREF(cs->context.rep, NULL);
! 643: cs->close(cs);
! 644: }
! 645: out:
! 646: return;
! 647: }
! 648:
! 649: /*
! 650: * ConsoleSessionWrite()
! 651: */
! 652:
! 653: static void
! 654: ConsoleSessionWrite(ConsoleSession cs, const char *fmt, ...)
! 655: {
! 656: va_list vl;
! 657:
! 658: va_start(vl, fmt);
! 659: ConsoleSessionWriteV(cs, fmt, vl);
! 660: va_end(vl);
! 661: }
! 662:
! 663: /*
! 664: * ConsoleSessionWriteV()
! 665: */
! 666:
! 667: static void
! 668: ConsoleSessionWriteV(ConsoleSession cs, const char *fmt, va_list vl)
! 669: {
! 670: char *buf;
! 671: size_t len;
! 672:
! 673: len = vasprintf(&buf, fmt, vl);
! 674: write(cs->fd, buf, len);
! 675: free(buf);
! 676: }
! 677:
! 678: /*
! 679: * StdConsoleSessionWrite()
! 680: */
! 681:
! 682: static void
! 683: StdConsoleSessionWrite(ConsoleSession cs, const char *fmt, ...)
! 684: {
! 685: va_list vl;
! 686:
! 687: va_start(vl, fmt);
! 688: StdConsoleSessionWriteV(cs, fmt, vl);
! 689: va_end(vl);
! 690: }
! 691:
! 692: /*
! 693: * StdConsoleSessionWriteV()
! 694: */
! 695:
! 696: static void
! 697: StdConsoleSessionWriteV(ConsoleSession cs, const char *fmt, va_list vl)
! 698: {
! 699: vprintf(fmt, vl);
! 700: fflush(stdout);
! 701: }
! 702:
! 703: /*
! 704: * ConsoleShowPrompt()
! 705: */
! 706:
! 707: static void
! 708: ConsoleSessionShowPrompt(ConsoleSession cs)
! 709: {
! 710: switch(cs->state) {
! 711: case STATE_USERNAME:
! 712: cs->write(cs, "Username: ");
! 713: break;
! 714: case STATE_PASSWORD:
! 715: cs->write(cs, "Password: ");
! 716: break;
! 717: case STATE_AUTHENTIC:
! 718: if (cs->context.lnk)
! 719: cs->write(cs, "[%s] ", cs->context.lnk->name);
! 720: else if (cs->context.bund)
! 721: cs->write(cs, "[%s] ", cs->context.bund->name);
! 722: else if (cs->context.rep)
! 723: cs->write(cs, "[%s] ", cs->context.rep->name);
! 724: else
! 725: cs->write(cs, "[] ");
! 726: break;
! 727: }
! 728: }
! 729:
! 730:
! 731: /*
! 732: * ConsoleUserHash
! 733: *
! 734: * Fowler/Noll/Vo- hash
! 735: * see http://www.isthe.com/chongo/tech/comp/fnv/index.html
! 736: *
! 737: * By:
! 738: * chongo <Landon Curt Noll> /\oo/\
! 739: * http://www.isthe.com/chongo/
! 740: */
! 741:
! 742: static u_int32_t
! 743: ConsoleUserHash(struct ghash *g, const void *item)
! 744: {
! 745: ConsoleUser u = (ConsoleUser) item;
! 746: u_char *s = (u_char *) u->username;
! 747: u_int32_t hash = 0x811c9dc5;
! 748:
! 749: while (*s) {
! 750: hash += (hash<<1) + (hash<<4) + (hash<<7) + (hash<<8) + (hash<<24);
! 751: /* xor the bottom with the current octet */
! 752: hash ^= (u_int32_t)*s++;
! 753: }
! 754:
! 755: return hash;
! 756: }
! 757:
! 758: /*
! 759: * ConsoleUserHashEqual
! 760: */
! 761:
! 762: static int
! 763: ConsoleUserHashEqual(struct ghash *g, const void *item1, const void *item2)
! 764: {
! 765: ConsoleUser u1 = (ConsoleUser) item1;
! 766: ConsoleUser u2 = (ConsoleUser) item2;
! 767:
! 768: if (u1 && u2)
! 769: return (strcmp(u1->username, u2->username) == 0);
! 770: else
! 771: return 0;
! 772: }
! 773:
! 774: /*
! 775: * ConsoleSetCommand()
! 776: */
! 777:
! 778: static int
! 779: ConsoleSetCommand(Context ctx, int ac, char *av[], void *arg)
! 780: {
! 781: Console c = &gConsole;
! 782: ConsoleSession cs = ctx->cs;
! 783: int port;
! 784:
! 785: switch ((intptr_t)arg) {
! 786:
! 787: case SET_OPEN:
! 788: ConsoleOpen(c);
! 789: break;
! 790:
! 791: case SET_CLOSE:
! 792: ConsoleClose(c);
! 793: break;
! 794:
! 795: case SET_ENABLE:
! 796: if (cs)
! 797: EnableCommand(ac, av, &cs->options, gConfList);
! 798: break;
! 799:
! 800: case SET_DISABLE:
! 801: if (cs)
! 802: DisableCommand(ac, av, &cs->options, gConfList);
! 803: break;
! 804:
! 805: case SET_SELF:
! 806: if (ac < 1 || ac > 2)
! 807: return(-1);
! 808:
! 809: if (!ParseAddr(av[0], &c->addr, ALLOW_IPV4|ALLOW_IPV6))
! 810: Error("CONSOLE: Bogus IP address given %s", av[0]);
! 811:
! 812: if (ac == 2) {
! 813: port = strtol(av[1], NULL, 10);
! 814: if (port < 1 || port > 65535)
! 815: Error("CONSOLE: Bogus port given %s", av[1]);
! 816: c->port=port;
! 817: }
! 818: break;
! 819:
! 820: default:
! 821: return(-1);
! 822:
! 823: }
! 824:
! 825: return 0;
! 826: }
! 827:
! 828: /*
! 829: * ConsoleShutdown()
! 830: */
! 831:
! 832: void
! 833: ConsoleShutdown(Console c)
! 834: {
! 835: ConsoleSession s, tmp;
! 836:
! 837: SLIST_FOREACH_SAFE(s, &c->sessions, next, tmp) {
! 838: if (s->close != NULL)
! 839: s->close(s);
! 840: }
! 841: }
! 842:
! 843: /*
! 844: * UserCommand()
! 845: */
! 846:
! 847: int
! 848: UserCommand(Context ctx, int ac, char *av[], void *arg)
! 849: {
! 850: ConsoleUser u;
! 851:
! 852: if (ac < 2 || ac > 3)
! 853: return(-1);
! 854:
! 855: u = Malloc(MB_CONS, sizeof(*u));
! 856: strlcpy(u->username, av[0], sizeof(u->username));
! 857: strlcpy(u->password, av[1], sizeof(u->password));
! 858: if (ac == 3) {
! 859: if (!strcmp(av[2],"admin"))
! 860: u->priv = 2;
! 861: else if (!strcmp(av[2],"operator"))
! 862: u->priv = 1;
! 863: else if (!strcmp(av[2],"user"))
! 864: u->priv = 0;
! 865: else {
! 866: Freee(u);
! 867: return (-1);
! 868: }
! 869: }
! 870: RWLOCK_WRLOCK(gUsersLock);
! 871: ghash_put(gUsers, u);
! 872: RWLOCK_UNLOCK(gUsersLock);
! 873:
! 874: return (0);
! 875: }
! 876:
! 877: /*
! 878: * UserStat()
! 879: */
! 880:
! 881: int
! 882: UserStat(Context ctx, int ac, char *av[], void *arg)
! 883: {
! 884: struct ghash_walk walk;
! 885: ConsoleUser u;
! 886:
! 887: Printf("Configured users:\r\n");
! 888: RWLOCK_RDLOCK(gUsersLock);
! 889: ghash_walk_init(gUsers, &walk);
! 890: while ((u = ghash_walk_next(gUsers, &walk)) != NULL) {
! 891: Printf("\tUsername: %-15s Priv:%s\r\n", u->username,
! 892: ((u->priv == 2)?"admin":((u->priv == 1)?"operator":"user")));
! 893: }
! 894: RWLOCK_UNLOCK(gUsersLock);
! 895:
! 896: return 0;
! 897: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to console.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src