Annotation of embedaddon/mpd/src/chat.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * chat.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 "chat.h"
! 12: #include "util.h"
! 13: #include <regex.h>
! 14:
! 15: /*
! 16: * DEFINITIONS
! 17: */
! 18:
! 19: /* Bounds */
! 20:
! 21: #define CHAT_MAX_ARGS 10
! 22: #define CHAT_MAX_VARNAME 100
! 23:
! 24: /* Keywords */
! 25:
! 26: #define IF "if"
! 27: #define SET "set"
! 28: #define MATCH "match"
! 29: #define REGEX "regex"
! 30: #define TIMER "timer"
! 31: #define CANCEL "cancel"
! 32: #define PRINT "print"
! 33: #define CALL "call"
! 34: #define LOG "log"
! 35: #define RETURN "return"
! 36: #define GOTO "goto"
! 37: #define SUCCESS "success"
! 38: #define FAILURE "failure"
! 39: #define WAIT "wait"
! 40: #define NOTHING "nop"
! 41: #define CHAT_KEYWORD_ALL "all"
! 42:
! 43: /* Special timer used when no label given */
! 44:
! 45: #define DEFAULT_LABEL ""
! 46: #define DEFAULT_SET ""
! 47:
! 48: /* States */
! 49:
! 50: enum
! 51: {
! 52: CHAT_IDLE = 0,
! 53: CHAT_RUNNING,
! 54: CHAT_WAIT
! 55: };
! 56:
! 57: /* Commands */
! 58:
! 59: enum
! 60: {
! 61: CMD_IF,
! 62: CMD_SET,
! 63: CMD_MATCH,
! 64: CMD_REGEX,
! 65: CMD_TIMER,
! 66: CMD_CANCEL,
! 67: CMD_PRINT,
! 68: CMD_CALL,
! 69: CMD_LOG,
! 70: CMD_RETURN,
! 71: CMD_GOTO,
! 72: CMD_SUCCESS,
! 73: CMD_FAILURE,
! 74: CMD_WAIT,
! 75: CMD_NOTHING
! 76: };
! 77:
! 78: /* Structures */
! 79:
! 80: struct chatcmd
! 81: {
! 82: const char *name;
! 83: short id;
! 84: short min;
! 85: short max;
! 86: };
! 87:
! 88: struct chatvar
! 89: {
! 90: char *name;
! 91: char *value;
! 92: struct chatvar *next;
! 93: };
! 94: typedef struct chatvar *ChatVar;
! 95:
! 96: struct chatmatch
! 97: {
! 98: char *set;
! 99: char *label;
! 100: u_char exact:1; /* true if this is an exact match */
! 101: union {
! 102: struct cm_exact {
! 103: char *pat; /* exact string to match */
! 104: u_short *fail; /* failure function */
! 105: u_int matched; /* number of chars matched so far */
! 106: } exact;
! 107: regex_t regex; /* regular expression to match */
! 108: } u;
! 109: int frameDepth; /* number of frames to pop */
! 110: struct chatmatch *next;
! 111: };
! 112: typedef struct chatmatch *ChatMatch;
! 113:
! 114: struct chattimer
! 115: {
! 116: char *set;
! 117: char *label;
! 118: EventRef event;
! 119: int frameDepth; /* number of frames to pop */
! 120: struct chatinfo *c;
! 121: struct chattimer *next;
! 122: };
! 123: typedef struct chattimer *ChatTimer;
! 124:
! 125: struct chatframe
! 126: {
! 127: fpos_t posn;
! 128: int lineNum;
! 129: struct chatframe *up;
! 130: };
! 131: typedef struct chatframe *ChatFrame;
! 132:
! 133: struct chatinfo
! 134: {
! 135: void *arg; /* opaque client context */
! 136: FILE *fp; /* chat script file */
! 137: int lineNum; /* current script line number */
! 138: int state; /* run/wait/idle state */
! 139: int fd; /* device to talk to */
! 140: EventRef rdEvent; /* readable event */
! 141: EventRef wrEvent; /* writable event */
! 142: char *out; /* output queue */
! 143: int outLen; /* output queue length */
! 144: struct chattimer *timers; /* pending timers */
! 145: struct chatmatch *matches; /* pending matches */
! 146: struct chatframe *stack; /* call/return stack */
! 147: struct chatvar *globals; /* global variables */
! 148: struct chatvar *temps; /* temporary variables */
! 149: char *lastLog; /* last message logged */
! 150: char *scriptName; /* name of script we're running */
! 151: char lineBuf[CHAT_MAX_LINE]; /* line buffer */
! 152: char readBuf[CHAT_READBUF_SIZE]; /* read buffer */
! 153: int readBufLen;
! 154: chatbaudfunc_t setBaudrate;
! 155: chatresultfunc_t result;
! 156: };
! 157:
! 158: /*
! 159: * INTERNAL VARIABLES
! 160: */
! 161:
! 162: static const struct chatcmd gCmds[] =
! 163: {
! 164: { IF, CMD_IF, 4, 0 },
! 165: { SET, CMD_SET, 3, 3 },
! 166: { MATCH, CMD_MATCH, 2, 4 },
! 167: { REGEX, CMD_REGEX, 2, 4 },
! 168: { TIMER, CMD_TIMER, 2, 4 },
! 169: { CANCEL, CMD_CANCEL, 2, 0 },
! 170: { PRINT, CMD_PRINT, 2, 2 },
! 171: { CALL, CMD_CALL, 2, 2 },
! 172: { LOG, CMD_LOG, 2, 2 },
! 173: { RETURN, CMD_RETURN, 1, 1 },
! 174: { GOTO, CMD_GOTO, 2, 2 },
! 175: { SUCCESS, CMD_SUCCESS, 1, 1 },
! 176: { FAILURE, CMD_FAILURE, 1, 1 },
! 177: { WAIT, CMD_WAIT, 1, 2 },
! 178: { NOTHING, CMD_NOTHING, 1, 1 },
! 179: };
! 180:
! 181: #define CHAT_NUM_COMMANDS (sizeof(gCmds) / sizeof(*gCmds))
! 182:
! 183: /*
! 184: * INTERNAL FUNCTIONS
! 185: */
! 186:
! 187: static void ChatAddTimer(ChatInfo c, const char *set,
! 188: u_int secs, const char *label);
! 189: static void ChatAddMatch(ChatInfo c, int exact,
! 190: const char *set, char *pat, const char *label);
! 191: static void ChatCancel(ChatInfo c, const char *set);
! 192: static int ChatGoto(ChatInfo c, const char *label);
! 193: static void ChatCall(ChatInfo c, const char *label);
! 194: static void ChatLog(ChatInfo c, int code, const char *string);
! 195: static void ChatPrint(ChatInfo c, const char *string);
! 196: static void ChatReturn(ChatInfo c, int seek);
! 197: static void ChatRun(ChatInfo c);
! 198: static void ChatStop(ChatInfo c);
! 199: static void ChatSuccess(ChatInfo c);
! 200: static void ChatFailure(ChatInfo c);
! 201: static void ChatIf(ChatInfo c, int ac, char *av[]);
! 202:
! 203: static void ChatRead(int type, void *cookie);
! 204: static void ChatWrite(int type, void *cookie);
! 205: static void ChatTimeout(int type, void *cookie);
! 206: static int ChatGetCmd(ChatInfo c, const char *token, int n_args);
! 207: static void ChatDoCmd(ChatInfo c, int ac, char *av[]);
! 208: static void ChatDumpReadBuf(ChatInfo c);
! 209:
! 210: static int ChatVarSet(ChatInfo c, const char *name,
! 211: const char *val, int exp, int pre);
! 212: static ChatVar ChatVarGet(ChatInfo c, const char *name);
! 213: static ChatVar ChatVarFind(ChatVar *head, char *name);
! 214: static int ChatVarExtract(const char *string,
! 215: char *buf, int max, int strict);
! 216:
! 217: static void ChatFreeMatch(ChatInfo c, ChatMatch match);
! 218: static void ChatFreeTimer(ChatInfo c, ChatTimer timer);
! 219: static int ChatMatchChar(struct cm_exact *ex, char ch);
! 220: static int ChatMatchRegex(ChatInfo c, regex_t *reg, const char *input);
! 221: static void ChatSetMatchVars(ChatInfo c, int exact, const char *input, ...);
! 222: static void ChatComputeFailure(ChatInfo c, struct cm_exact *ex);
! 223:
! 224: static int ChatDecodeTime(ChatInfo c, char *string, u_int *secsp);
! 225: static int ChatSetBaudrate(ChatInfo c, const char *new);
! 226: static char *ChatExpandString(ChatInfo c, const char *string);
! 227:
! 228: static char *ChatReadLine(ChatInfo c);
! 229: static int ChatParseLine(ChatInfo c, char *line, char *av[], int max);
! 230: static int ChatSeekToLabel(ChatInfo c, const char *label);
! 231: static void ChatDumpBuf(ChatInfo c, const char *buf,
! 232: int len, const char *fmt, ...);
! 233:
! 234: /*
! 235: * ChatInit()
! 236: */
! 237:
! 238: ChatInfo
! 239: ChatInit(void *arg, chatbaudfunc_t setBaudrate)
! 240: {
! 241: ChatInfo c;
! 242:
! 243: c = (ChatInfo) Malloc(MB_CHAT, sizeof(*c));
! 244: c->arg = arg;
! 245: c->setBaudrate = setBaudrate;
! 246: return(c);
! 247: }
! 248:
! 249: /*
! 250: * ChatActive()
! 251: */
! 252:
! 253: int
! 254: ChatActive(ChatInfo c)
! 255: {
! 256: return(c->state != CHAT_IDLE);
! 257: }
! 258:
! 259: /*
! 260: * ChatPresetVar()
! 261: */
! 262:
! 263: void
! 264: ChatPresetVar(ChatInfo c, const char *name, const char *value)
! 265: {
! 266: Link const l = (Link) c->arg;
! 267:
! 268: if (ChatVarSet(c, name, value, 1, 1) < 0)
! 269: {
! 270: Log(LG_ERR, ("[%s] CHAT: chat: invalid variable \"%s\"", l->name, name));
! 271: return;
! 272: }
! 273: }
! 274:
! 275: /*
! 276: * ChatGetVar()
! 277: *
! 278: * Caller must free the returned value
! 279: */
! 280:
! 281: char *
! 282: ChatGetVar(ChatInfo c, const char *var)
! 283: {
! 284: ChatVar const cv = ChatVarGet(c, var);
! 285:
! 286: return cv ? Mstrdup(MB_CHAT, cv->value) : NULL;
! 287: }
! 288:
! 289: /*
! 290: * ChatStart()
! 291: *
! 292: * Start executing chat script at label, or at beginning of file
! 293: * if no label specified. The "fd" must be set to non-blocking I/O.
! 294: */
! 295:
! 296: void
! 297: ChatStart(ChatInfo c, int fd, FILE *scriptfp,
! 298: const char *label, chatresultfunc_t result)
! 299: {
! 300: ChatVar baud;
! 301: const char *labelName;
! 302: Link const l = (Link) c->arg;
! 303:
! 304: /* Sanity */
! 305:
! 306: assert(c->fp == NULL);
! 307: assert(c->state == CHAT_IDLE);
! 308:
! 309: if (label)
! 310: Log(LG_CHAT2, ("[%s] CHAT: running script at label \"%s\"", l->name, label));
! 311: else
! 312: Log(LG_CHAT2, ("[%s] CHAT: running script from beginning", l->name));
! 313:
! 314: c->result = result;
! 315: c->fd = fd;
! 316: c->fp = scriptfp;
! 317: c->lineNum = 0;
! 318:
! 319: /* Save script name */
! 320:
! 321: assert(!c->scriptName);
! 322: labelName = label ? label : "<default>";
! 323: c->scriptName = Mstrdup(MB_CHAT, labelName);
! 324:
! 325: /* Jump to label, if any */
! 326:
! 327: if (label && ChatGoto(c, label) < 0)
! 328: return;
! 329:
! 330: /* Make sure serial port baudrate and $Baudrate variable agree */
! 331:
! 332: if ((baud = ChatVarGet(c, CHAT_VAR_BAUDRATE)))
! 333: ChatSetBaudrate(c, baud->value);
! 334:
! 335: /* Start running script */
! 336:
! 337: ChatRun(c);
! 338: }
! 339:
! 340: /*
! 341: * ChatAbort()
! 342: */
! 343:
! 344: void
! 345: ChatAbort(ChatInfo c)
! 346: {
! 347: Link const l = (Link) c->arg;
! 348:
! 349: if (c->state != CHAT_IDLE)
! 350: Log(LG_CHAT2, ("[%s] CHAT: script halted", l->name));
! 351: ChatStop(c);
! 352: }
! 353:
! 354: /*
! 355: * ChatRead()
! 356: */
! 357:
! 358: static void
! 359: ChatRead(int type, void *cookie)
! 360: {
! 361: ChatInfo const c = (ChatInfo) cookie;
! 362: ChatMatch match;
! 363: int nread, lineBufLen;
! 364: char ch;
! 365: Link const l = (Link) c->arg;
! 366:
! 367: /* Sanity */
! 368:
! 369: assert(c->state == CHAT_WAIT);
! 370:
! 371: /* Process one byte at a time */
! 372:
! 373: for (lineBufLen = strlen(c->lineBuf); 1; )
! 374: {
! 375:
! 376: /* Input next character */
! 377:
! 378: if ((nread = read(c->fd, &ch, 1)) < 0)
! 379: {
! 380: if (errno == EAGAIN)
! 381: break;
! 382: Perror("[%s] CHAT: read", l->name);
! 383: goto die;
! 384: }
! 385: else if (nread == 0)
! 386: {
! 387: Log(LG_CHAT, ("[%s] CHAT: detected EOF from device", l->name));
! 388: die:
! 389: ChatFailure(c);
! 390: return;
! 391: }
! 392:
! 393: /* Add to "bytes read" buffer for later debugging display */
! 394:
! 395: if (c->readBufLen == sizeof(c->readBuf) || ch == '\n')
! 396: ChatDumpReadBuf(c);
! 397: c->readBuf[c->readBufLen++] = ch;
! 398:
! 399: /* Add to current line buffer */
! 400:
! 401: if (lineBufLen < sizeof(c->lineBuf) - 1) {
! 402: c->lineBuf[lineBufLen++] = ch;
! 403: } else {
! 404: Log(LG_CHAT, ("[%s] CHAT: warning: line buffer overflow", l->name));
! 405: }
! 406:
! 407: /* Try to match a match pattern */
! 408:
! 409: for (match = c->matches; match; match = match->next) {
! 410: if (match->exact) {
! 411: if (ChatMatchChar(&match->u.exact, ch)) {
! 412: ChatSetMatchVars(c, 1, match->u.exact.pat);
! 413: break;
! 414: }
! 415: } else {
! 416: const int nmatch = match->u.regex.re_nsub + 1;
! 417: regmatch_t *pmatch;
! 418: int r, flags = (REG_STARTEND | REG_NOTEOL);
! 419:
! 420: /* Check for end of line */
! 421:
! 422: pmatch = Malloc(MB_CHAT, nmatch * sizeof(*pmatch));
! 423: pmatch[0].rm_so = 0;
! 424: pmatch[0].rm_eo = lineBufLen;
! 425: if (pmatch[0].rm_eo > 0 && c->lineBuf[pmatch[0].rm_eo - 1] == '\n') {
! 426: pmatch[0].rm_eo--;
! 427: flags &= ~REG_NOTEOL; /* this is a complete line */
! 428: if (pmatch[0].rm_eo > 0 && c->lineBuf[pmatch[0].rm_eo - 1] == '\r')
! 429: pmatch[0].rm_eo--; /* elide the CR byte too */
! 430: }
! 431:
! 432: /* Do comparison */
! 433:
! 434: switch ((r = regexec(&match->u.regex,
! 435: c->lineBuf, nmatch, pmatch, flags))) {
! 436: default:
! 437: Log(LG_ERR, ("[%s] CHAT: regexec() returned %d?", l->name, r));
! 438: /* fall through */
! 439: case REG_NOMATCH:
! 440: Freee(pmatch);
! 441: continue;
! 442: case 0:
! 443: ChatSetMatchVars(c, 0, c->lineBuf, nmatch, pmatch);
! 444: Freee(pmatch);
! 445: break;
! 446: }
! 447: break;
! 448: }
! 449: }
! 450:
! 451: /* Reset line buffer after a newline */
! 452: if (ch == '\n') {
! 453: memset(&c->lineBuf, 0, sizeof(c->lineBuf));
! 454: lineBufLen = 0;
! 455: }
! 456:
! 457: /* Log match, pop the stack, and jump to target label */
! 458: if (match) {
! 459: char label[CHAT_MAX_LABEL];
! 460: int numPop;
! 461:
! 462: ChatDumpReadBuf(c);
! 463: Log(LG_CHAT2, ("[%s] CHAT: matched set \"%s\", goto label \"%s\"",
! 464: l->name, match->set, match->label));
! 465: numPop = match->frameDepth;
! 466: strlcpy(label, match->label, sizeof(label));
! 467: ChatCancel(c, match->set);
! 468: while (numPop-- > 0)
! 469: ChatReturn(c, 0);
! 470: if (ChatGoto(c, label) >= 0)
! 471: ChatRun(c);
! 472: return;
! 473: }
! 474: }
! 475:
! 476: /* Reregister input event */
! 477:
! 478: EventRegister(&c->rdEvent, EVENT_READ, c->fd, 0, ChatRead, c);
! 479: }
! 480:
! 481: /*
! 482: * ChatTimeout()
! 483: *
! 484: * Handle one of our timers timing out
! 485: */
! 486:
! 487: static void
! 488: ChatTimeout(int type, void *cookie)
! 489: {
! 490: ChatTimer const timer = (ChatTimer) cookie;
! 491: ChatInfo const c = timer->c;
! 492: ChatTimer *tp;
! 493: char label[CHAT_MAX_LABEL];
! 494: int numPop;
! 495: Link const l = (Link) c->arg;
! 496:
! 497: /* Sanity */
! 498:
! 499: assert(c->state == CHAT_WAIT);
! 500:
! 501: /* Locate timer in list */
! 502:
! 503: for (tp = &c->timers; *tp != timer; tp = &(*tp)->next);
! 504: assert(*tp);
! 505: Log(LG_CHAT2, ("[%s] CHAT: timer in set \"%s\" expired", l->name, timer->set));
! 506:
! 507: /* Cancel set */
! 508:
! 509: strlcpy(label, timer->label, sizeof(label));
! 510: numPop = timer->frameDepth;
! 511: ChatCancel(c, timer->set);
! 512:
! 513: /* Pop the stack as needed */
! 514:
! 515: while (numPop-- > 0)
! 516: ChatReturn(c, 0);
! 517:
! 518: /* Jump to target label */
! 519:
! 520: if (ChatGoto(c, label) >= 0)
! 521: ChatRun(c);
! 522: }
! 523:
! 524: /*
! 525: * ChatRun()
! 526: *
! 527: * Run chat script
! 528: */
! 529:
! 530: static void
! 531: ChatRun(ChatInfo c)
! 532: {
! 533: char *line;
! 534: Link const l = (Link) c->arg;
! 535:
! 536: /* Sanity */
! 537:
! 538: assert(c->state != CHAT_RUNNING);
! 539:
! 540: /* Cancel default set before running */
! 541:
! 542: ChatCancel(c, DEFAULT_SET);
! 543:
! 544: /* Execute commands while running */
! 545:
! 546: for (c->state = CHAT_RUNNING;
! 547: c->state == CHAT_RUNNING && (line = ChatReadLine(c)) != NULL; )
! 548: {
! 549: int ac;
! 550: char *av[CHAT_MAX_ARGS];
! 551:
! 552: /* Skip labels */
! 553:
! 554: if (!isspace(*line))
! 555: {
! 556: Freee(line);
! 557: continue;
! 558: }
! 559:
! 560: /* Parse out line */
! 561:
! 562: ac = ChatParseLine(c, line, av, CHAT_MAX_ARGS);
! 563: Freee(line);
! 564:
! 565: /* Do command */
! 566:
! 567: ChatDoCmd(c, ac, av);
! 568: while (ac > 0)
! 569: Freee(av[--ac]);
! 570: }
! 571:
! 572: /* What state are we in? */
! 573:
! 574: switch (c->state)
! 575: {
! 576: case CHAT_RUNNING:
! 577: Log(LG_ERR, ("[%s] CHAT: EOF while reading script", l->name));
! 578: ChatFailure(c);
! 579: break;
! 580: case CHAT_WAIT:
! 581: if (!EventIsRegistered(&c->rdEvent))
! 582: EventRegister(&c->rdEvent, EVENT_READ, c->fd, 0, ChatRead, c);
! 583: break;
! 584: case CHAT_IDLE:
! 585: break;
! 586: }
! 587:
! 588: /* Sanity */
! 589:
! 590: assert(c->state != CHAT_RUNNING);
! 591: }
! 592:
! 593: /*
! 594: * ChatDoCmd()
! 595: */
! 596:
! 597: static void
! 598: ChatDoCmd(ChatInfo c, int ac, char *av[])
! 599: {
! 600: char buf[200];
! 601: u_int secs;
! 602: int j, k;
! 603: Link const l = (Link) c->arg;
! 604:
! 605: /* Show command */
! 606:
! 607: for (buf[0] = k = 0; k < ac; k++) {
! 608: for (j = 0; av[k][j] && isgraph(av[k][j]); j++);
! 609: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
! 610: !*av[k] || av[k][j] ? " \"%s\"" : " %s", av[k]);
! 611: }
! 612: Log(LG_CHAT2, ("[%s] CHAT: line %d:%s", l->name, c->lineNum, buf));
! 613:
! 614: /* Execute command */
! 615:
! 616: if (ac == 0)
! 617: return;
! 618: switch (ChatGetCmd(c, av[0], ac))
! 619: {
! 620: case CMD_IF:
! 621: ChatIf(c, ac, av);
! 622: break;
! 623:
! 624: case CMD_SET:
! 625: if (ChatVarSet(c, av[1], av[2], 1, 0) < 0)
! 626: {
! 627: Log(LG_ERR, ("[%s] CHAT: line %d: %s: invalid variable \"%s\"",
! 628: l->name, c->lineNum, SET, av[1]));
! 629: ChatFailure(c);
! 630: }
! 631: break;
! 632:
! 633: case CMD_MATCH:
! 634: switch (ac)
! 635: {
! 636: case 4:
! 637: ChatAddMatch(c, 1, av[1], av[2], av[3]);
! 638: break;
! 639: case 3:
! 640: ChatAddMatch(c, 1, DEFAULT_SET, av[1], av[2]);
! 641: break;
! 642: case 2:
! 643: ChatAddMatch(c, 1, DEFAULT_SET, av[1], DEFAULT_LABEL);
! 644: break;
! 645: default:
! 646: assert(0);
! 647: }
! 648: break;
! 649:
! 650: case CMD_REGEX:
! 651: switch (ac)
! 652: {
! 653: case 4:
! 654: ChatAddMatch(c, 0, av[1], av[2], av[3]);
! 655: break;
! 656: case 3:
! 657: ChatAddMatch(c, 0, DEFAULT_SET, av[1], av[2]);
! 658: break;
! 659: case 2:
! 660: ChatAddMatch(c, 0, DEFAULT_SET, av[1], DEFAULT_LABEL);
! 661: break;
! 662: default:
! 663: assert(0);
! 664: }
! 665: break;
! 666:
! 667: case CMD_TIMER:
! 668: switch (ac)
! 669: {
! 670: case 4:
! 671: if (!ChatDecodeTime(c, av[2], &secs))
! 672: ChatFailure(c);
! 673: else if (secs != 0)
! 674: ChatAddTimer(c, av[1], secs, av[3]);
! 675: break;
! 676: case 3:
! 677: if (!ChatDecodeTime(c, av[1], &secs))
! 678: ChatFailure(c);
! 679: else if (secs != 0)
! 680: ChatAddTimer(c, DEFAULT_SET, secs, av[2]);
! 681: break;
! 682: case 2:
! 683: if (!ChatDecodeTime(c, av[1], &secs))
! 684: ChatFailure(c);
! 685: else if (secs != 0)
! 686: ChatAddTimer(c, DEFAULT_SET, secs, DEFAULT_LABEL);
! 687: break;
! 688: default:
! 689: assert(0);
! 690: }
! 691: break;
! 692:
! 693: case CMD_WAIT:
! 694: if (ac == 2)
! 695: {
! 696: if (!ChatDecodeTime(c, av[1], &secs))
! 697: ChatFailure(c);
! 698: else if (secs > 0)
! 699: {
! 700: ChatAddTimer(c, DEFAULT_SET, secs, DEFAULT_LABEL);
! 701: c->state = CHAT_WAIT;
! 702: }
! 703: else
! 704: ChatCancel(c, DEFAULT_SET); /* Simulate immediate expiration */
! 705: }
! 706: else
! 707: {
! 708: if (!c->matches && !c->timers)
! 709: {
! 710: Log(LG_ERR, ("[%s] CHAT: line %d: %s with no events pending",
! 711: l->name, c->lineNum, WAIT));
! 712: ChatFailure(c);
! 713: }
! 714: else
! 715: c->state = CHAT_WAIT;
! 716: }
! 717: break;
! 718:
! 719: case CMD_CANCEL:
! 720: for (k = 1; k < ac; k++)
! 721: ChatCancel(c, av[k]);
! 722: break;
! 723:
! 724: case CMD_PRINT:
! 725: ChatPrint(c, av[1]);
! 726: break;
! 727:
! 728: case CMD_CALL:
! 729: ChatCall(c, av[1]);
! 730: break;
! 731:
! 732: case CMD_NOTHING:
! 733: break;
! 734:
! 735: case CMD_LOG:
! 736: ChatLog(c, 0, av[1]);
! 737: break;
! 738:
! 739: case CMD_RETURN:
! 740: ChatReturn(c, 1);
! 741: break;
! 742:
! 743: case CMD_GOTO:
! 744: ChatGoto(c, av[1]);
! 745: break;
! 746:
! 747: case CMD_SUCCESS:
! 748: ChatSuccess(c);
! 749: break;
! 750:
! 751: case -1:
! 752: case CMD_FAILURE:
! 753: ChatFailure(c);
! 754: break;
! 755:
! 756: default:
! 757: assert(0);
! 758: }
! 759: }
! 760:
! 761: /*
! 762: * ChatIf()
! 763: */
! 764:
! 765: static void
! 766: ChatIf(ChatInfo c, int ac, char *av[])
! 767: {
! 768: char *const arg1 = ChatExpandString(c, av[1]);
! 769: char *const arg2 = ChatExpandString(c, av[3]);
! 770: int proceed = 0, invert = 0;
! 771: Link const l = (Link) c->arg;
! 772:
! 773: /* Check operator */
! 774:
! 775: if (!strcmp(av[2], "==") || !strcmp(av[2], "!=")) {
! 776: proceed = !strcmp(arg1, arg2);
! 777: invert = (*av[2] == '!');
! 778: } else if (!strncmp(av[2], MATCH, strlen(MATCH))
! 779: || !strncmp(av[2], "!" MATCH, strlen("!" MATCH))) {
! 780: regex_t regex;
! 781: char errbuf[100];
! 782: int errcode;
! 783:
! 784: if ((errcode = regcomp(®ex, arg2, REG_EXTENDED)) != 0) {
! 785: regerror(errcode, ®ex, errbuf, sizeof(errbuf));
! 786: Log(LG_ERR, ("[%s] CHAT: line %d: invalid regular expression \"%s\": %s",
! 787: l->name, c->lineNum, arg2, errbuf));
! 788: } else {
! 789: proceed = ChatMatchRegex(c, ®ex, arg1);
! 790: regfree(®ex);
! 791: invert = (*av[2] == '!');
! 792: }
! 793: } else {
! 794: Log(LG_ERR, ("[%s] CHAT: line %d: invalid operator \"%s\"",
! 795: l->name, c->lineNum, av[2]));
! 796: }
! 797: Freee(arg1);
! 798: Freee(arg2);
! 799:
! 800: /* Do command */
! 801:
! 802: if (proceed ^ invert)
! 803: ChatDoCmd(c, ac - 4, av + 4);
! 804: }
! 805:
! 806: /*
! 807: * ChatSuccess()
! 808: */
! 809:
! 810: static void
! 811: ChatSuccess(ChatInfo c)
! 812: {
! 813: ChatStop(c);
! 814: (*c->result)(c->arg, 1, NULL);
! 815: }
! 816:
! 817: /*
! 818: * ChatFailure()
! 819: */
! 820:
! 821: static void
! 822: ChatFailure(ChatInfo c)
! 823: {
! 824: char *reason;
! 825:
! 826: reason = c->lastLog;
! 827: c->lastLog = NULL;
! 828: ChatStop(c);
! 829: (*c->result)(c->arg, 0, reason);
! 830: Freee(reason);
! 831: }
! 832:
! 833: /*
! 834: * ChatStop()
! 835: */
! 836:
! 837: static void
! 838: ChatStop(ChatInfo c)
! 839: {
! 840: ChatVar var, next;
! 841:
! 842: /* Free temporary variables */
! 843:
! 844: for (var = c->temps; var; var = next)
! 845: {
! 846: next = var->next;
! 847: Freee(var->name);
! 848: Freee(var->value);
! 849: Freee(var);
! 850: }
! 851: c->temps = NULL;
! 852:
! 853: /* Close script file */
! 854:
! 855: if (c->fp)
! 856: {
! 857: fclose(c->fp);
! 858: c->fp = NULL;
! 859: }
! 860:
! 861: /* Forget active script name */
! 862:
! 863: Freee(c->scriptName);
! 864: c->scriptName = NULL;
! 865:
! 866: /* Cancel all sets */
! 867:
! 868: ChatCancel(c, CHAT_KEYWORD_ALL);
! 869:
! 870: /* Cancel all input and output */
! 871:
! 872: EventUnRegister(&c->rdEvent);
! 873: EventUnRegister(&c->wrEvent);
! 874: if (c->out != NULL) {
! 875: Freee(c->out);
! 876: c->out = NULL;
! 877: c->outLen = 0;
! 878: }
! 879:
! 880: /* Pop the stack */
! 881:
! 882: while (c->stack)
! 883: ChatReturn(c, 0);
! 884:
! 885: /* Empty read buffer and last log message buffer */
! 886:
! 887: c->readBufLen = 0;
! 888: if (c->lastLog)
! 889: {
! 890: Freee(c->lastLog);
! 891: c->lastLog = NULL;
! 892: }
! 893:
! 894: /* Done */
! 895:
! 896: c->state = CHAT_IDLE;
! 897: }
! 898:
! 899: /*
! 900: * ChatAddMatch()
! 901: */
! 902:
! 903: static void
! 904: ChatAddMatch(ChatInfo c, int exact, const char *set,
! 905: char *pat, const char *label)
! 906: {
! 907: ChatMatch match, *mp;
! 908: Link const l = (Link) c->arg;
! 909:
! 910: /* Expand pattern */
! 911: pat = ChatExpandString(c, pat);
! 912:
! 913: /* Create new match */
! 914: match = (ChatMatch) Malloc(MB_CHAT, sizeof(*match));
! 915: match->exact = !!exact;
! 916: if (exact) {
! 917: match->u.exact.pat = pat;
! 918: match->u.exact.matched = 0;
! 919: ChatComputeFailure(c, &match->u.exact);
! 920: } else {
! 921: int errcode;
! 922: char errbuf[100];
! 923:
! 924: /* Convert pattern into compiled regular expression */
! 925: errcode = regcomp(&match->u.regex, pat, REG_EXTENDED);
! 926: Freee(pat);
! 927:
! 928: /* Check for error */
! 929: if (errcode != 0) {
! 930: regerror(errcode, &match->u.regex, errbuf, sizeof(errbuf));
! 931: Log(LG_ERR, ("[%s] CHAT: line %d: invalid regular expression \"%s\": %s",
! 932: l->name, c->lineNum, pat, errbuf));
! 933: ChatFailure(c);
! 934: Freee(match);
! 935: return;
! 936: }
! 937: }
! 938: match->set = ChatExpandString(c, set);
! 939: match->label = ChatExpandString(c, label);
! 940:
! 941: /* Add at the tail of the list, so if there's a tie, first match defined wins */
! 942:
! 943: for (mp = &c->matches; *mp; mp = &(*mp)->next);
! 944: *mp = match;
! 945: match->next = NULL;
! 946: }
! 947:
! 948: /*
! 949: * ChatAddTimer()
! 950: */
! 951:
! 952: static void
! 953: ChatAddTimer(ChatInfo c, const char *set, u_int secs, const char *label)
! 954: {
! 955: ChatTimer timer;
! 956:
! 957: /* Add new timer */
! 958:
! 959: timer = (ChatTimer) Malloc(MB_CHAT, sizeof(*timer));
! 960: timer->c = c;
! 961: timer->set = ChatExpandString(c, set);
! 962: timer->label = ChatExpandString(c, label);
! 963: timer->next = c->timers;
! 964: c->timers = timer;
! 965:
! 966: /* Start it */
! 967:
! 968: EventRegister(&timer->event, EVENT_TIMEOUT,
! 969: secs * 1000, 0, ChatTimeout, timer);
! 970: }
! 971:
! 972: /*
! 973: * ChatCancel()
! 974: */
! 975:
! 976: static void
! 977: ChatCancel(ChatInfo c, const char *set0)
! 978: {
! 979: int all;
! 980: char *set;
! 981: ChatMatch match, *mp;
! 982: ChatTimer timer, *tp;
! 983:
! 984: /* Expand set name; check for special "all" keyword */
! 985:
! 986: set = ChatExpandString(c, set0);
! 987: all = !strcasecmp(set, CHAT_KEYWORD_ALL);
! 988:
! 989: /* Nuke matches */
! 990:
! 991: for (mp = &c->matches; (match = *mp) != NULL; ) {
! 992: if (all || !strcmp(match->set, set)) {
! 993: *mp = match->next;
! 994: ChatFreeMatch(c, match);
! 995: } else
! 996: mp = &match->next;
! 997: }
! 998:
! 999: /* Nuke timers */
! 1000:
! 1001: for (tp = &c->timers; (timer = *tp) != NULL; ) {
! 1002: if (all || !strcmp(timer->set, set)) {
! 1003: *tp = timer->next;
! 1004: ChatFreeTimer(c, timer);
! 1005: } else
! 1006: tp = &timer->next;
! 1007: }
! 1008:
! 1009: /* Done */
! 1010:
! 1011: Freee(set);
! 1012: }
! 1013:
! 1014: /*
! 1015: * ChatGoto()
! 1016: */
! 1017:
! 1018: static int
! 1019: ChatGoto(ChatInfo c, const char *label0)
! 1020: {
! 1021: const int lineNum = c->lineNum;
! 1022: char *label;
! 1023: int rtn;
! 1024: Link const l = (Link) c->arg;
! 1025:
! 1026: /* Expand label */
! 1027:
! 1028: label = ChatExpandString(c, label0);
! 1029:
! 1030: /* Default label means "here" */
! 1031:
! 1032: if (!strcmp(label, DEFAULT_LABEL))
! 1033: {
! 1034: Freee(label);
! 1035: return(0);
! 1036: }
! 1037:
! 1038: /* Search script file */
! 1039:
! 1040: if ((rtn = ChatSeekToLabel(c, label)) < 0)
! 1041: {
! 1042: Log(LG_ERR, ("[%s] CHAT: line %d: label \"%s\" not found",
! 1043: l->name, lineNum, label));
! 1044: ChatFailure(c);
! 1045: }
! 1046: Freee(label);
! 1047: return(rtn);
! 1048: }
! 1049:
! 1050: /*
! 1051: * ChatCall()
! 1052: */
! 1053:
! 1054: static void
! 1055: ChatCall(ChatInfo c, const char *label0)
! 1056: {
! 1057: ChatFrame frame;
! 1058: ChatMatch match;
! 1059: ChatTimer timer;
! 1060: char *label;
! 1061: Link const l = (Link) c->arg;
! 1062:
! 1063: /* Expand label */
! 1064:
! 1065: label = ChatExpandString(c, label0);
! 1066:
! 1067: /* Adjust stack */
! 1068:
! 1069: frame = (ChatFrame) Malloc(MB_CHAT, sizeof(*frame));
! 1070: fgetpos(c->fp, &frame->posn);
! 1071: frame->lineNum = c->lineNum;
! 1072: frame->up = c->stack;
! 1073: c->stack = frame;
! 1074:
! 1075: /* Find label */
! 1076:
! 1077: if (ChatSeekToLabel(c, label) < 0)
! 1078: {
! 1079: Log(LG_ERR, ("[%s] CHAT: line %d: %s: label \"%s\" not found",
! 1080: l->name, frame->lineNum, CALL, label));
! 1081: ChatFailure(c);
! 1082: }
! 1083: Freee(label);
! 1084:
! 1085: /* Increment call depth for timer and match events */
! 1086:
! 1087: for (match = c->matches; match; match = match->next)
! 1088: match->frameDepth++;
! 1089: for (timer = c->timers; timer; timer = timer->next)
! 1090: timer->frameDepth++;
! 1091: }
! 1092:
! 1093: /*
! 1094: * ChatReturn()
! 1095: */
! 1096:
! 1097: static void
! 1098: ChatReturn(ChatInfo c, int seek)
! 1099: {
! 1100: ChatFrame frame;
! 1101: ChatMatch *mp, match;
! 1102: ChatTimer *tp, timer;
! 1103: Link const l = (Link) c->arg;
! 1104:
! 1105: if (c->stack == NULL)
! 1106: {
! 1107: Log(LG_ERR, ("[%s] CHAT: line %d: %s without corresponding %s",
! 1108: l->name, c->lineNum, RETURN, CALL));
! 1109: ChatFailure(c);
! 1110: return;
! 1111: }
! 1112:
! 1113: /* Pop frame */
! 1114:
! 1115: frame = c->stack;
! 1116: if (seek) {
! 1117: fsetpos(c->fp, &frame->posn);
! 1118: c->lineNum = frame->lineNum;
! 1119: }
! 1120: c->stack = frame->up;
! 1121: Freee(frame);
! 1122:
! 1123: /* Decrement call depth for timer and match events */
! 1124:
! 1125: for (mp = &c->matches; (match = *mp) != NULL; ) {
! 1126: if (--match->frameDepth < 0) {
! 1127: *mp = match->next;
! 1128: ChatFreeMatch(c, match);
! 1129: } else
! 1130: mp = &match->next;
! 1131: }
! 1132: for (tp = &c->timers; (timer = *tp) != NULL; ) {
! 1133: if (--timer->frameDepth < 0) {
! 1134: *tp = timer->next;
! 1135: ChatFreeTimer(c, timer);
! 1136: } else
! 1137: tp = &timer->next;
! 1138: }
! 1139: }
! 1140:
! 1141: /*
! 1142: * ChatLog()
! 1143: */
! 1144:
! 1145: static void
! 1146: ChatLog(ChatInfo c, int code, const char *string)
! 1147: {
! 1148: char *exp_string;
! 1149: Link const l = (Link) c->arg;
! 1150:
! 1151: exp_string = ChatExpandString(c, string);
! 1152: Log(LG_CHAT, ("[%s] CHAT: %s", l->name, exp_string));
! 1153: if (c->lastLog)
! 1154: Freee(c->lastLog);
! 1155: c->lastLog = exp_string;
! 1156: }
! 1157:
! 1158: /*
! 1159: * ChatPrint()
! 1160: */
! 1161:
! 1162: static void
! 1163: ChatPrint(ChatInfo c, const char *string)
! 1164: {
! 1165: char *exp_string, *buf;
! 1166: int exp_len;
! 1167:
! 1168: /* Add variable-expanded string to output queue */
! 1169:
! 1170: exp_len = strlen(exp_string = ChatExpandString(c, string));
! 1171: buf = Malloc(MB_CHAT, c->outLen + exp_len);
! 1172: if (c->out != NULL) {
! 1173: memcpy(buf, c->out, c->outLen);
! 1174: Freee(c->out);
! 1175: } else
! 1176: assert(c->outLen == 0);
! 1177: memcpy(buf + c->outLen, exp_string, exp_len);
! 1178: c->out = buf;
! 1179: c->outLen += exp_len;
! 1180:
! 1181: /* Debugging dump */
! 1182:
! 1183: ChatDumpBuf(c, exp_string, exp_len, "sending");
! 1184: Freee(exp_string);
! 1185:
! 1186: /* Simulate a writable event to get things going */
! 1187:
! 1188: ChatWrite(EVENT_WRITE, c);
! 1189: }
! 1190:
! 1191: /*
! 1192: * ChatWrite()
! 1193: */
! 1194:
! 1195: static void
! 1196: ChatWrite(int type, void *cookie)
! 1197: {
! 1198: ChatInfo const c = (ChatInfo) cookie;
! 1199: int nw;
! 1200: Link const l = (Link) c->arg;
! 1201:
! 1202: /* Write as much as we can */
! 1203:
! 1204: assert(c->out != NULL && c->outLen > 0);
! 1205: if ((nw = write(c->fd, c->out, c->outLen)) < 0) {
! 1206: if (errno == EAGAIN)
! 1207: return;
! 1208: Perror("[%s] CHAT: write", l->name);
! 1209: ChatFailure(c);
! 1210: return;
! 1211: }
! 1212:
! 1213: /* Update output queue */
! 1214:
! 1215: c->outLen -= nw;
! 1216: if (c->outLen <= 0) {
! 1217: Freee(c->out);
! 1218: c->out = NULL;
! 1219: c->outLen = 0;
! 1220: } else {
! 1221: memmove(c->out, c->out + nw, c->outLen);
! 1222: EventRegister(&c->wrEvent, EVENT_WRITE, c->fd, 0, ChatWrite, c);
! 1223: }
! 1224: }
! 1225:
! 1226: /*
! 1227: * ChatSetBaudrate()
! 1228: */
! 1229:
! 1230: static int
! 1231: ChatSetBaudrate(ChatInfo c, const char *new)
! 1232: {
! 1233: char *endptr;
! 1234: int rate = strtoul(new, &endptr, 0);
! 1235: Link const l = (Link) c->arg;
! 1236:
! 1237: if (!*new || *endptr || (*c->setBaudrate)(c->arg, rate) < 0)
! 1238: {
! 1239: Log(LG_CHAT, ("[%s] CHAT: line %d: invalid baudrate \"%s\"",
! 1240: l->name, c->lineNum, new));
! 1241: ChatFailure(c);
! 1242: return(-1);
! 1243: }
! 1244: return(0);
! 1245: }
! 1246:
! 1247: /*
! 1248: * ChatVarSet()
! 1249: */
! 1250:
! 1251: static int
! 1252: ChatVarSet(ChatInfo c, const char *rname,
! 1253: const char *value, int expand, int pre)
! 1254: {
! 1255: ChatVar var, *head;
! 1256: char *new, name[CHAT_MAX_VARNAME];
! 1257:
! 1258: /* Check & extract variable name */
! 1259:
! 1260: assert(rname && value);
! 1261: if (!*rname || ChatVarExtract(rname + 1, name, sizeof(name), 1) < 0)
! 1262: return(-1);
! 1263: head = isupper(*name) ? &c->globals : &c->temps;
! 1264:
! 1265: /* Create new value */
! 1266:
! 1267: if (expand)
! 1268: new = ChatExpandString(c, value);
! 1269: else
! 1270: {
! 1271: new = Mstrdup(MB_CHAT, value);
! 1272: }
! 1273:
! 1274: /* Check for special variable names */
! 1275:
! 1276: if (!strcmp(rname, CHAT_VAR_BAUDRATE))
! 1277: {
! 1278: if (!pre && ChatSetBaudrate(c, new) < 0)
! 1279: {
! 1280: Freee(new);
! 1281: return(0);
! 1282: }
! 1283: }
! 1284:
! 1285: /* Find variable if it exists, otherwise create and add to list */
! 1286:
! 1287: if ((var = ChatVarFind(head, name)))
! 1288: {
! 1289: char *ovalue;
! 1290:
! 1291: /* Replace value; free it after expanding (might be used in expansion) */
! 1292:
! 1293: ovalue = var->value;
! 1294: var->value = new;
! 1295: Freee(ovalue);
! 1296: }
! 1297: else
! 1298: {
! 1299:
! 1300: /* Create new struct and add to list */
! 1301:
! 1302: var = Malloc(MB_CHAT, sizeof(*var));
! 1303: var->name = Mstrdup(MB_CHAT, name);
! 1304: var->value = new;
! 1305: var->next = *head;
! 1306: *head = var;
! 1307: }
! 1308: return(0);
! 1309: }
! 1310:
! 1311: /*
! 1312: * ChatVarGet()
! 1313: */
! 1314:
! 1315: static ChatVar
! 1316: ChatVarGet(ChatInfo c, const char *rname)
! 1317: {
! 1318: char name[CHAT_MAX_VARNAME];
! 1319:
! 1320: /* Check & extract variable name */
! 1321:
! 1322: if (!*rname || ChatVarExtract(rname + 1, name, sizeof(name), 1) < 0)
! 1323: return(NULL);
! 1324: return(ChatVarFind(isupper(*name) ? &c->globals : &c->temps, name));
! 1325: }
! 1326:
! 1327: /*
! 1328: * ChatVarFind()
! 1329: */
! 1330:
! 1331: static ChatVar
! 1332: ChatVarFind(ChatVar *head, char *name)
! 1333: {
! 1334: ChatVar var, *vp;
! 1335:
! 1336: assert(head && name);
! 1337: for (vp = head;
! 1338: (var = *vp) && strcmp(var->name, name);
! 1339: vp = &var->next);
! 1340: if (var)
! 1341: {
! 1342: *vp = var->next; /* caching */
! 1343: var->next = *head;
! 1344: *head = var;
! 1345: }
! 1346: return(var);
! 1347: }
! 1348:
! 1349: /*
! 1350: * ChatVarExtract()
! 1351: */
! 1352:
! 1353: static int
! 1354: ChatVarExtract(const char *string, char *buf, int max, int strict)
! 1355: {
! 1356: int k, len, brace;
! 1357:
! 1358: /* Get variable name, optionally surrounded by braces */
! 1359:
! 1360: k = brace = (*string == '{');
! 1361: if (!isalpha(string[k]))
! 1362: return(-1);
! 1363: for (len = 0, k = brace;
! 1364: (isalnum(string[k]) || string[k] == '_') && len < max - 1;
! 1365: k++)
! 1366: buf[len++] = string[k];
! 1367: buf[len] = 0;
! 1368: if (len == 0 || (brace && string[k] != '}') || (strict && string[k + brace]))
! 1369: return(-1);
! 1370: return(len + brace * 2);
! 1371: }
! 1372:
! 1373: /*
! 1374: * ChatFreeMatch()
! 1375: */
! 1376:
! 1377: static void
! 1378: ChatFreeMatch(ChatInfo c, ChatMatch match)
! 1379: {
! 1380: Freee(match->set);
! 1381: Freee(match->label);
! 1382: if (match->exact) {
! 1383: Freee(match->u.exact.pat);
! 1384: Freee(match->u.exact.fail);
! 1385: } else {
! 1386: regfree(&match->u.regex);
! 1387: }
! 1388: Freee(match);
! 1389: }
! 1390:
! 1391: /*
! 1392: * ChatFreeTimer()
! 1393: */
! 1394:
! 1395: static void
! 1396: ChatFreeTimer(ChatInfo c, ChatTimer timer)
! 1397: {
! 1398: EventUnRegister(&timer->event);
! 1399: Freee(timer->set);
! 1400: Freee(timer->label);
! 1401: Freee(timer);
! 1402: }
! 1403:
! 1404: /*
! 1405: * ChatDumpReadBuf()
! 1406: *
! 1407: * Display accumulated input bytes for debugging purposes. Reset buffer.
! 1408: */
! 1409:
! 1410: static void
! 1411: ChatDumpReadBuf(ChatInfo c)
! 1412: {
! 1413: if (c->readBufLen)
! 1414: {
! 1415: ChatDumpBuf(c, c->readBuf, c->readBufLen, "read");
! 1416: c->readBufLen = 0;
! 1417: }
! 1418: }
! 1419:
! 1420: /*
! 1421: * ChatGetCmd()
! 1422: */
! 1423:
! 1424: static int
! 1425: ChatGetCmd(ChatInfo c, const char *token, int n_args)
! 1426: {
! 1427: int k;
! 1428: Link const l = (Link) c->arg;
! 1429:
! 1430: for (k = 0; k < CHAT_NUM_COMMANDS; k++)
! 1431: if (!strcasecmp(gCmds[k].name, token))
! 1432: {
! 1433: if ((gCmds[k].min && n_args < gCmds[k].min)
! 1434: || (gCmds[k].max && n_args > gCmds[k].max))
! 1435: {
! 1436: Log(LG_ERR, ("[%s] CHAT: line %d: %s: bad argument count",
! 1437: l->name, c->lineNum, token));
! 1438: return(-1);
! 1439: }
! 1440: else
! 1441: return(gCmds[k].id);
! 1442: }
! 1443: Log(LG_ERR, ("[%s] CHAT: line %d: unknown command \"%s\"",
! 1444: l->name, c->lineNum, token));
! 1445: return(-1);
! 1446: }
! 1447:
! 1448: /*
! 1449: * ChatExpandString()
! 1450: *
! 1451: * Expand variables in string. Return result in malloc'd buffer.
! 1452: */
! 1453:
! 1454: static char *
! 1455: ChatExpandString(ChatInfo c, const char *string)
! 1456: {
! 1457: ChatVar var;
! 1458: int k, j, new_len, nlen, doit = 0;
! 1459: char *new = NULL, nbuf[CHAT_MAX_VARNAME];
! 1460:
! 1461: /* Compute expanded length and then rescan and expand */
! 1462:
! 1463: new_len = 0;
! 1464: rescan:
! 1465: for (j = k = 0; string[k]; k++)
! 1466: switch (string[k])
! 1467: {
! 1468: case CHAT_VAR_PREFIX:
! 1469: *nbuf = string[k];
! 1470: if (string[k + 1] == CHAT_VAR_PREFIX) /* $$ -> $ */
! 1471: {
! 1472: k++;
! 1473: goto normal;
! 1474: }
! 1475: if ((nlen = ChatVarExtract(string + k + 1,
! 1476: nbuf + 1, sizeof(nbuf) - 1, 0)) < 0)
! 1477: goto normal;
! 1478: k += nlen;
! 1479: if ((var = ChatVarGet(c, nbuf)))
! 1480: {
! 1481: if (doit)
! 1482: {
! 1483: memcpy(new + j, var->value, strlen(var->value));
! 1484: j += strlen(var->value);
! 1485: }
! 1486: else
! 1487: new_len += strlen(var->value);
! 1488: }
! 1489: break;
! 1490: default: normal:
! 1491: if (doit)
! 1492: new[j++] = string[k];
! 1493: else
! 1494: new_len++;
! 1495: break;
! 1496: }
! 1497:
! 1498: /* Allocate and rescan */
! 1499:
! 1500: if (!doit)
! 1501: {
! 1502: new = Malloc(MB_CHAT, new_len + 1);
! 1503: doit = 1;
! 1504: goto rescan;
! 1505: }
! 1506:
! 1507: /* Done */
! 1508:
! 1509: new[j] = 0;
! 1510: assert(j == new_len);
! 1511: return(new);
! 1512: }
! 1513:
! 1514: /*
! 1515: * ChatSetMatchVars()
! 1516: *
! 1517: * Set the various special match string variables after a successful
! 1518: * match (of either type, exact or regular expression).
! 1519: */
! 1520:
! 1521: static void
! 1522: ChatSetMatchVars(ChatInfo c, int exact, const char *input, ...)
! 1523: {
! 1524: const int preflen = strlen(CHAT_VAR_MATCHED);
! 1525: ChatVar var, *vp;
! 1526: va_list args;
! 1527:
! 1528: /* Unset old match variables */
! 1529: for (vp = &c->temps; (var = *vp) != NULL; ) {
! 1530: char *eptr;
! 1531:
! 1532: if (strncmp(var->name, CHAT_VAR_MATCHED, preflen)) {
! 1533: vp = &var->next;
! 1534: continue;
! 1535: }
! 1536: (void) strtoul(var->name + preflen, &eptr, 10);
! 1537: if (*eptr) {
! 1538: vp = &var->next;
! 1539: continue;
! 1540: }
! 1541: *vp = var->next;
! 1542: Freee(var->name);
! 1543: Freee(var->value);
! 1544: Freee(var);
! 1545: }
! 1546:
! 1547: /* Set new match variables */
! 1548: va_start(args, input);
! 1549: if (exact) {
! 1550: ChatVarSet(c, CHAT_VAR_MATCHED, input, 0, 0);
! 1551: } else {
! 1552: const int nmatch = va_arg(args, int);
! 1553: regmatch_t *const pmatch = va_arg(args, regmatch_t *);
! 1554: char *const value = Malloc(MB_CHAT, strlen(input) + 1);
! 1555: int k;
! 1556:
! 1557: for (k = 0; k < nmatch; k++) {
! 1558: const int len = pmatch[k].rm_eo - pmatch[k].rm_so;
! 1559: char name[sizeof(CHAT_VAR_MATCHED) + 16];
! 1560:
! 1561: memcpy(value, input + pmatch[k].rm_so, len);
! 1562: value[len] = 0;
! 1563: snprintf(name, sizeof(name), "%s%d", CHAT_VAR_MATCHED, k);
! 1564: if (k == 0)
! 1565: ChatVarSet(c, CHAT_VAR_MATCHED, value, 0, 0);
! 1566: ChatVarSet(c, name, value, 0, 0);
! 1567: }
! 1568: Freee(value);
! 1569: }
! 1570: va_end(args);
! 1571: }
! 1572:
! 1573: /*
! 1574: * ChatMatchChar()
! 1575: *
! 1576: * Update "ex" given that "ch" is the next character.
! 1577: * Returns 1 if target has become fully matched.
! 1578: */
! 1579:
! 1580: static int
! 1581: ChatMatchChar(struct cm_exact *ex, char ch)
! 1582: {
! 1583: const int len = strlen(ex->pat);
! 1584:
! 1585: /* Account for zero length pattern string -- match on next input char */
! 1586: if (len == 0)
! 1587: return 1;
! 1588:
! 1589: /* Update longest-matched-prefix-length based on next char */
! 1590: assert(ex->matched < len);
! 1591: while (1) {
! 1592: if (ch == ex->pat[ex->matched])
! 1593: return ++ex->matched == len;
! 1594: if (ex->matched == 0)
! 1595: return 0;
! 1596: ex->matched = ex->fail[ex->matched];
! 1597: }
! 1598: }
! 1599:
! 1600: /*
! 1601: * ChatMatchRegex()
! 1602: *
! 1603: * See if a line matches a regular expression. If so, return 1
! 1604: * and set the corresponding match variables.
! 1605: */
! 1606:
! 1607: static int
! 1608: ChatMatchRegex(ChatInfo c, regex_t *reg, const char *input)
! 1609: {
! 1610: const int nmatch = reg->re_nsub + 1;
! 1611: regmatch_t *pmatch = Malloc(MB_CHAT, nmatch * sizeof(*pmatch));
! 1612: int rtn, match;
! 1613: Link const l = (Link) c->arg;
! 1614:
! 1615: switch ((rtn = regexec(reg, input, nmatch, pmatch, 0))) {
! 1616: default:
! 1617: Log(LG_ERR, ("[%s] CHAT: regexec() returned %d?", l->name, rtn));
! 1618: /* fall through */
! 1619: case REG_NOMATCH:
! 1620: match = 0;
! 1621: break;
! 1622: case 0:
! 1623: ChatSetMatchVars(c, 0, input, nmatch, pmatch);
! 1624: match = 1;
! 1625: break;
! 1626: }
! 1627: Freee(pmatch);
! 1628: return match;
! 1629: }
! 1630:
! 1631: /*
! 1632: * ChatComputeFailure()
! 1633: *
! 1634: * Compute the failure function for the exact match pattern string.
! 1635: * That is, for each character position i=0..n-1, compute fail(i) =
! 1636: * 0 if i==0, else fail(i) = the greatest j < i such that characters
! 1637: * 0..j match characters (i - j)..(i - 1).
! 1638: *
! 1639: * There are linear time ways to compute this, but we're lazy.
! 1640: */
! 1641:
! 1642: static void
! 1643: ChatComputeFailure(ChatInfo c, struct cm_exact *ex)
! 1644: {
! 1645: const int len = strlen(ex->pat);
! 1646: int i, j, k;
! 1647:
! 1648: ex->fail = (u_short *) Malloc(MB_CHAT, len * sizeof(*ex->fail));
! 1649: for (i = 1; i < len; i++) {
! 1650: for (j = i - 1; j > 0; j--) {
! 1651: for (k = 0; k < j && ex->pat[k] == ex->pat[i - j + k]; k++);
! 1652: if (k == j) {
! 1653: ex->fail[i] = j;
! 1654: break;
! 1655: }
! 1656: }
! 1657: }
! 1658: }
! 1659:
! 1660: /*
! 1661: * ChatDecodeTime()
! 1662: */
! 1663:
! 1664: static int
! 1665: ChatDecodeTime(ChatInfo c, char *string, u_int *secsp)
! 1666: {
! 1667: u_long secs;
! 1668: char *secstr, *mark;
! 1669: Link const l = (Link) c->arg;
! 1670:
! 1671: secstr = ChatExpandString(c, string);
! 1672: secs = strtoul(secstr, &mark, 0);
! 1673: Freee(secstr);
! 1674: if (mark == secstr) {
! 1675: Log(LG_ERR, ("[%s] CHAT: line %d: illegal value \"%s\"",
! 1676: l->name, c->lineNum, string));
! 1677: return(0);
! 1678: }
! 1679: *secsp = (u_int) secs;
! 1680: return(1);
! 1681: }
! 1682:
! 1683: /*
! 1684: * ChatReadLine()
! 1685: */
! 1686:
! 1687: static char *
! 1688: ChatReadLine(ChatInfo c)
! 1689: {
! 1690: return ReadFullLine(c->fp, &c->lineNum, NULL, 0);
! 1691: }
! 1692:
! 1693: /*
! 1694: * ChatParseLine()
! 1695: */
! 1696:
! 1697: static int
! 1698: ChatParseLine(ChatInfo c, char *line, char *av[], int max)
! 1699: {
! 1700: return ParseLine(line, av, max, 1);
! 1701: }
! 1702:
! 1703: /*
! 1704: * ChatSeekToLabel()
! 1705: */
! 1706:
! 1707: static int
! 1708: ChatSeekToLabel(ChatInfo c, const char *label)
! 1709: {
! 1710: return SeekToLabel(c->fp, label, &c->lineNum, NULL);
! 1711: }
! 1712:
! 1713: /*
! 1714: * ChatDumpBuf()
! 1715: */
! 1716:
! 1717: #define DUMP_BYTES_PER_LINE 16
! 1718:
! 1719: static void
! 1720: ChatDumpBuf(ChatInfo c, const char *buf, int len, const char *fmt, ...)
! 1721: {
! 1722: va_list args;
! 1723: char cbuf[128];
! 1724: int k, pos;
! 1725: Link const l = (Link) c->arg;
! 1726:
! 1727: /* Do label */
! 1728: va_start(args, fmt);
! 1729: vsnprintf(cbuf, sizeof(cbuf), fmt, args);
! 1730: va_end(args);
! 1731: Log(LG_CHAT2, ("[%s] CHAT: %s", l->name, cbuf));
! 1732:
! 1733: /* Do bytes */
! 1734: for (pos = 0; pos < len; pos += DUMP_BYTES_PER_LINE) {
! 1735: *cbuf = '\0';
! 1736: for (k = 0; k < DUMP_BYTES_PER_LINE; k++) {
! 1737: if (pos + k < len) {
! 1738: snprintf(cbuf + strlen(cbuf), sizeof(cbuf) - strlen(cbuf),
! 1739: " %02x", buf[pos + k]);
! 1740: } else {
! 1741: snprintf(cbuf + strlen(cbuf), sizeof(cbuf) - strlen(cbuf),
! 1742: " ");
! 1743: }
! 1744: }
! 1745: snprintf(cbuf + strlen(cbuf), sizeof(cbuf) - strlen(cbuf), " ");
! 1746: for (k = 0; k < DUMP_BYTES_PER_LINE; k++) {
! 1747: if (pos + k < len) {
! 1748: snprintf(cbuf + strlen(cbuf), sizeof(cbuf) - strlen(cbuf),
! 1749: "%c", isprint(buf[pos + k]) ? buf[pos + k] : '.');
! 1750: } else {
! 1751: snprintf(cbuf + strlen(cbuf), sizeof(cbuf) - strlen(cbuf),
! 1752: " ");
! 1753: }
! 1754: }
! 1755: Log(LG_CHAT2, ("[%s] CHAT: %s", l->name, cbuf));
! 1756: }
! 1757: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to chat.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