diff options
Diffstat (limited to 'src/chat.c')
-rw-r--r-- | src/chat.c | 797 |
1 files changed, 797 insertions, 0 deletions
diff --git a/src/chat.c b/src/chat.c new file mode 100644 index 0000000..bd635d5 --- /dev/null +++ b/src/chat.c @@ -0,0 +1,797 @@ +/*- + * Copyright (c) 1998 Brian Somers <brian@Awfulhak.org> + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS + * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) + * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT + * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY + * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + * + * $FreeBSD: src/usr.sbin/ppp/chat.c,v 1.80.26.1 2010/12/21 17:10:29 kensmith Exp $ + */ + +#include <sys/param.h> +#include <netinet/in.h> +#include <netinet/in_systm.h> +#include <netinet/ip.h> +#include <sys/socket.h> +#include <sys/un.h> + +#include <errno.h> +#include <fcntl.h> +#include <paths.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/wait.h> +#include <termios.h> +#include <unistd.h> + +#include "layer.h" +#include "mbuf.h" +#include "log.h" +#include "defs.h" +#include "timer.h" +#include "lqr.h" +#include "hdlc.h" +#include "throughput.h" +#include "fsm.h" +#include "lcp.h" +#include "ccp.h" +#include "link.h" +#include "async.h" +#include "descriptor.h" +#include "physical.h" +#include "chat.h" +#include "mp.h" +#include "auth.h" +#include "chap.h" +#include "slcompress.h" +#include "iplist.h" +#include "ncpaddr.h" +#include "ipcp.h" +#include "filter.h" +#include "cbcp.h" +#include "command.h" +#include "datalink.h" +#ifndef NORADIUS +#include "radius.h" +#endif +#include "ipv6cp.h" +#include "ncp.h" +#include "bundle.h" +#include "id.h" + +#define BUFLEFT(c) (sizeof (c)->buf - ((c)->bufend - (c)->buf)) + +static void ExecStr(struct physical *, char *, char *, int); +static char *ExpandString(struct chat *, const char *, char *, int, int); + +static void +chat_PauseTimer(void *v) +{ + struct chat *c = (struct chat *)v; + timer_Stop(&c->pause); + c->pause.load = 0; +} + +static void +chat_Pause(struct chat *c, u_long load) +{ + timer_Stop(&c->pause); + c->pause.load += load; + c->pause.func = chat_PauseTimer; + c->pause.name = "chat pause"; + c->pause.arg = c; + timer_Start(&c->pause); +} + +static void +chat_TimeoutTimer(void *v) +{ + struct chat *c = (struct chat *)v; + timer_Stop(&c->timeout); + c->TimedOut = 1; +} + +static void +chat_SetTimeout(struct chat *c) +{ + timer_Stop(&c->timeout); + if (c->TimeoutSec > 0) { + c->timeout.load = SECTICKS * c->TimeoutSec; + c->timeout.func = chat_TimeoutTimer; + c->timeout.name = "chat timeout"; + c->timeout.arg = c; + timer_Start(&c->timeout); + } +} + +static char * +chat_NextChar(char *ptr, char ch) +{ + for (; *ptr; ptr++) + if (*ptr == ch) + return ptr; + else if (*ptr == '\\') + if (*++ptr == '\0') + return NULL; + + return NULL; +} + +static int +chat_UpdateSet(struct fdescriptor *d, fd_set *r, fd_set *w, fd_set *e, int *n) +{ + struct chat *c = descriptor2chat(d); + int special, gotabort, gottimeout, needcr; + int TimedOut = c->TimedOut; + static char arg_term; /* An empty string */ + + if (c->pause.state == TIMER_RUNNING) + return 0; + + if (TimedOut) { + log_Printf(LogCHAT, "Expect timeout\n"); + if (c->nargptr == NULL) + c->state = CHAT_FAILED; + else { + /* c->state = CHAT_EXPECT; */ + c->argptr = &arg_term; + } + c->TimedOut = 0; + } + + if (c->state != CHAT_EXPECT && c->state != CHAT_SEND) + return 0; + + gottimeout = gotabort = 0; + + if (c->arg < c->argc && (c->arg < 0 || *c->argptr == '\0')) { + /* Go get the next string */ + if (c->arg < 0 || c->state == CHAT_SEND) + c->state = CHAT_EXPECT; + else + c->state = CHAT_SEND; + + special = 1; + while (special && (c->nargptr || c->arg < c->argc - 1)) { + if (c->arg < 0 || (!TimedOut && c->state == CHAT_SEND)) + c->nargptr = NULL; + + if (c->nargptr != NULL) { + /* We're doing expect-send-expect.... */ + c->argptr = c->nargptr; + /* Put the '-' back in case we ever want to rerun our script */ + c->nargptr[-1] = '-'; + c->nargptr = chat_NextChar(c->nargptr, '-'); + if (c->nargptr != NULL) + *c->nargptr++ = '\0'; + } else { + int minus; + + if ((c->argptr = c->argv[++c->arg]) == NULL) { + /* End of script - all ok */ + c->state = CHAT_DONE; + return 0; + } + + if (c->state == CHAT_EXPECT) { + /* Look for expect-send-expect sequence */ + c->nargptr = c->argptr; + minus = 0; + while ((c->nargptr = chat_NextChar(c->nargptr, '-'))) { + c->nargptr++; + minus++; + } + + if (minus % 2) + log_Printf(LogWARN, "chat_UpdateSet: \"%s\": Uneven number of" + " '-' chars, all ignored\n", c->argptr); + else if (minus) { + c->nargptr = chat_NextChar(c->argptr, '-'); + *c->nargptr++ = '\0'; + } + } + } + + /* + * c->argptr now temporarily points into c->script (via c->argv) + * If it's an expect-send-expect sequence, we've just got the correct + * portion of that sequence. + */ + + needcr = c->state == CHAT_SEND && + (*c->argptr != '!' || c->argptr[1] == '!'); + + /* We leave room for a potential HDLC header in the target string */ + ExpandString(c, c->argptr, c->exp + 2, sizeof c->exp - 2, needcr); + + /* + * Now read our string. If it's not a special string, we unset + * ``special'' to break out of the loop. + */ + if (gotabort) { + if (c->abort.num < MAXABORTS) { + int len, i; + + len = strlen(c->exp+2); + for (i = 0; i < c->abort.num; i++) + if (len > c->abort.string[i].len) { + int last; + + for (last = c->abort.num; last > i; last--) { + c->abort.string[last].data = c->abort.string[last-1].data; + c->abort.string[last].len = c->abort.string[last-1].len; + } + break; + } + c->abort.string[i].len = len; + if ((c->abort.string[i].data = (char *)malloc(len+1)) != NULL) { + memcpy(c->abort.string[i].data, c->exp+2, len+1); + c->abort.num++; + } + } else + log_Printf(LogERROR, "chat_UpdateSet: too many abort strings\n"); + gotabort = 0; + } else if (gottimeout) { + c->TimeoutSec = atoi(c->exp + 2); + if (c->TimeoutSec <= 0) + c->TimeoutSec = 30; + gottimeout = 0; + } else if (c->nargptr == NULL && !strcmp(c->exp+2, "ABORT")) + gotabort = 1; + else if (c->nargptr == NULL && !strcmp(c->exp+2, "TIMEOUT")) + gottimeout = 1; + else { + if (c->exp[2] == '!' && c->exp[3] != '!') + ExecStr(c->physical, c->exp + 3, c->exp + 3, sizeof c->exp - 3); + + if (c->exp[2] == '\0') { + /* Empty string, reparse (this may be better as a `goto start') */ + c->argptr = &arg_term; + return chat_UpdateSet(d, r, w, e, n); + } + + special = 0; + } + } + + if (special) { + if (gottimeout) + log_Printf(LogWARN, "chat_UpdateSet: TIMEOUT: Argument expected\n"); + else if (gotabort) + log_Printf(LogWARN, "chat_UpdateSet: ABORT: Argument expected\n"); + + /* End of script - all ok */ + c->state = CHAT_DONE; + return 0; + } + + /* set c->argptr to point in the right place */ + c->argptr = c->exp + (c->exp[2] == '!' ? 3 : 2); + c->arglen = strlen(c->argptr); + + if (c->state == CHAT_EXPECT) { + /* We must check to see if the string's already been found ! */ + char *begin, *end; + + end = c->bufend - c->arglen + 1; + if (end < c->bufstart) + end = c->bufstart; + for (begin = c->bufstart; begin < end; begin++) + if (!strncmp(begin, c->argptr, c->arglen)) { + c->bufstart = begin + c->arglen; + c->argptr += c->arglen; + c->arglen = 0; + /* Continue - we've already read our expect string */ + return chat_UpdateSet(d, r, w, e, n); + } + + log_Printf(LogCHAT, "Expect(%d): %s\n", c->TimeoutSec, c->argptr); + chat_SetTimeout(c); + } + } + + /* + * We now have c->argptr pointing at what we want to expect/send and + * c->state saying what we want to do... we now know what to put in + * the fd_set :-) + */ + + if (c->state == CHAT_EXPECT) + return physical_doUpdateSet(&c->physical->desc, r, NULL, e, n, 1); + else + return physical_doUpdateSet(&c->physical->desc, NULL, w, e, n, 1); +} + +static int +chat_IsSet(struct fdescriptor *d, const fd_set *fdset) +{ + struct chat *c = descriptor2chat(d); + return c->argptr && physical_IsSet(&c->physical->desc, fdset); +} + +static void +chat_UpdateLog(struct chat *c, int in) +{ + if (log_IsKept(LogCHAT) || log_IsKept(LogCONNECT)) { + /* + * If a linefeed appears in the last `in' characters of `c's input + * buffer, output from there, all the way back to the last linefeed. + * This is called for every read of `in' bytes. + */ + char *ptr, *end, *stop, ch; + int level; + + level = log_IsKept(LogCHAT) ? LogCHAT : LogCONNECT; + if (in == -1) + end = ptr = c->bufend; + else { + ptr = c->bufend - in; + for (end = c->bufend - 1; end >= ptr; end--) + if (*end == '\n') + break; + } + + if (end >= ptr) { + for (ptr = c->bufend - (in == -1 ? 1 : in + 1); ptr >= c->bufstart; ptr--) + if (*ptr == '\n') + break; + ptr++; + stop = NULL; + while (stop < end) { + if ((stop = memchr(ptr, '\n', end - ptr)) == NULL) + stop = end; + ch = *stop; + *stop = '\0'; + if (level == LogCHAT || strstr(ptr, "CONNECT")) + log_Printf(level, "Received: %s\n", ptr); + *stop = ch; + ptr = stop + 1; + } + } + } +} + +static void +chat_Read(struct fdescriptor *d, struct bundle *bundle __unused, + const fd_set *fdset __unused) +{ + struct chat *c = descriptor2chat(d); + + if (c->state == CHAT_EXPECT) { + ssize_t in; + char *abegin, *ebegin, *begin, *aend, *eend, *end; + int n; + + /* + * XXX - should this read only 1 byte to guarantee that we don't + * swallow any ppp talk from the peer ? + */ + in = BUFLEFT(c); + if (in > (ssize_t)sizeof c->buf / 2) + in = sizeof c->buf / 2; + + in = physical_Read(c->physical, c->bufend, in); + if (in <= 0) + return; + + /* `begin' and `end' delimit where we're going to strncmp() from */ + ebegin = c->bufend - c->arglen + 1; + eend = ebegin + in; + if (ebegin < c->bufstart) + ebegin = c->bufstart; + + if (c->abort.num) { + abegin = c->bufend - c->abort.string[0].len + 1; + aend = c->bufend - c->abort.string[c->abort.num-1].len + in + 1; + if (abegin < c->bufstart) + abegin = c->bufstart; + } else { + abegin = ebegin; + aend = eend; + } + begin = abegin < ebegin ? abegin : ebegin; + end = aend < eend ? eend : aend; + + c->bufend += in; + + chat_UpdateLog(c, in); + + if (c->bufend > c->buf + sizeof c->buf / 2) { + /* Shuffle our receive buffer back a bit */ + int chop; + + for (chop = begin - c->buf; chop; chop--) + if (c->buf[chop] == '\n') + /* found some already-logged garbage to remove :-) */ + break; + + if (!chop) + chop = begin - c->buf; + + if (chop) { + char *from, *to; + + to = c->buf; + from = to + chop; + while (from < c->bufend) + *to++ = *from++; + c->bufstart -= chop; + c->bufend -= chop; + begin -= chop; + end -= chop; + abegin -= chop; + aend -= chop; + ebegin -= chop; + eend -= chop; + } + } + + for (; begin < end; begin++) + if (begin >= ebegin && begin < eend && + !strncmp(begin, c->argptr, c->arglen)) { + /* Got it ! */ + timer_Stop(&c->timeout); + if (memchr(begin + c->arglen - 1, '\n', + c->bufend - begin - c->arglen + 1) == NULL) { + /* force it into the log */ + end = c->bufend; + c->bufend = begin + c->arglen; + chat_UpdateLog(c, -1); + c->bufend = end; + } + c->bufstart = begin + c->arglen; + c->argptr += c->arglen; + c->arglen = 0; + break; + } else if (begin >= abegin && begin < aend) { + for (n = c->abort.num - 1; n >= 0; n--) { + if (begin + c->abort.string[n].len > c->bufend) + break; + if (!strncmp(begin, c->abort.string[n].data, + c->abort.string[n].len)) { + if (memchr(begin + c->abort.string[n].len - 1, '\n', + c->bufend - begin - c->abort.string[n].len + 1) == NULL) { + /* force it into the log */ + end = c->bufend; + c->bufend = begin + c->abort.string[n].len; + chat_UpdateLog(c, -1); + c->bufend = end; + } + c->bufstart = begin + c->abort.string[n].len; + c->state = CHAT_FAILED; + return; + } + } + } + } +} + +static int +chat_Write(struct fdescriptor *d, struct bundle *bundle __unused, + const fd_set *fdset __unused) +{ + struct chat *c = descriptor2chat(d); + int result = 0; + + if (c->state == CHAT_SEND) { + int wrote; + + if (strstr(c->argv[c->arg], "\\P")) /* Don't log the password */ + log_Printf(LogCHAT, "Send: %s\n", c->argv[c->arg]); + else { + int sz; + + sz = c->arglen - 1; + while (sz >= 0 && c->argptr[sz] == '\n') + sz--; + log_Printf(LogCHAT, "Send: %.*s\n", sz + 1, c->argptr); + } + + if (physical_IsSync(c->physical)) { + /* + * XXX: Fix me + * This data should be stuffed down through the link layers + */ + /* There's always room for the HDLC header */ + c->argptr -= 2; + c->arglen += 2; + memcpy(c->argptr, "\377\003", 2); /* Prepend HDLC header */ + } + + wrote = physical_Write(c->physical, c->argptr, c->arglen); + result = wrote > 0 ? 1 : 0; + if (wrote == -1) { + if (errno != EINTR) { + log_Printf(LogWARN, "chat_Write: %s\n", strerror(errno)); + result = -1; + } + if (physical_IsSync(c->physical)) { + c->argptr += 2; + c->arglen -= 2; + } + } else if (wrote < 2 && physical_IsSync(c->physical)) { + /* Oops - didn't even write our HDLC header ! */ + c->argptr += 2; + c->arglen -= 2; + } else { + c->argptr += wrote; + c->arglen -= wrote; + } + } + + return result; +} + +void +chat_Init(struct chat *c, struct physical *p) +{ + c->desc.type = CHAT_DESCRIPTOR; + c->desc.UpdateSet = chat_UpdateSet; + c->desc.IsSet = chat_IsSet; + c->desc.Read = chat_Read; + c->desc.Write = chat_Write; + c->physical = p; + *c->script = '\0'; + c->argc = 0; + c->arg = -1; + c->argptr = NULL; + c->nargptr = NULL; + c->bufstart = c->bufend = c->buf; + + memset(&c->pause, '\0', sizeof c->pause); + memset(&c->timeout, '\0', sizeof c->timeout); +} + +int +chat_Setup(struct chat *c, const char *data, const char *phone) +{ + c->state = CHAT_EXPECT; + + if (data == NULL) { + *c->script = '\0'; + c->argc = 0; + } else { + strncpy(c->script, data, sizeof c->script - 1); + c->script[sizeof c->script - 1] = '\0'; + c->argc = MakeArgs(c->script, c->argv, VECSIZE(c->argv), PARSE_NOHASH); + } + + c->arg = -1; + c->argptr = NULL; + c->nargptr = NULL; + + c->TimeoutSec = 30; + c->TimedOut = 0; + c->phone = phone; + c->abort.num = 0; + + timer_Stop(&c->pause); + timer_Stop(&c->timeout); + + return c->argc >= 0; +} + +void +chat_Finish(struct chat *c) +{ + timer_Stop(&c->pause); + timer_Stop(&c->timeout); + while (c->abort.num) + free(c->abort.string[--c->abort.num].data); + c->abort.num = 0; +} + +void +chat_Destroy(struct chat *c) +{ + chat_Finish(c); +} + +/* + * \c don't add a cr + * \d Sleep a little (delay 2 seconds + * \n Line feed character + * \P Auth Key password + * \p pause 0.25 sec + * \r Carrige return character + * \s Space character + * \T Telephone number(s) (defined via `set phone') + * \t Tab character + * \U Auth User + */ +static char * +ExpandString(struct chat *c, const char *str, char *result, int reslen, int cr) +{ + int len; + + result[--reslen] = '\0'; + while (*str && reslen > 0) { + switch (*str) { + case '\\': + str++; + switch (*str) { + case 'c': + cr = 0; + break; + case 'd': /* Delay 2 seconds */ + chat_Pause(c, 2 * SECTICKS); + break; + case 'p': + chat_Pause(c, SECTICKS / 4); + break; /* Delay 0.25 seconds */ + case 'n': + *result++ = '\n'; + reslen--; + break; + case 'r': + *result++ = '\r'; + reslen--; + break; + case 's': + *result++ = ' '; + reslen--; + break; + case 't': + *result++ = '\t'; + reslen--; + break; + case 'P': + strncpy(result, c->physical->dl->bundle->cfg.auth.key, reslen); + len = strlen(result); + reslen -= len; + result += len; + break; + case 'T': + if (c->phone) { + strncpy(result, c->phone, reslen); + len = strlen(result); + reslen -= len; + result += len; + } + break; + case 'U': + strncpy(result, c->physical->dl->bundle->cfg.auth.name, reslen); + len = strlen(result); + reslen -= len; + result += len; + break; + default: + reslen--; + *result++ = *str; + break; + } + if (*str) + str++; + break; + case '^': + str++; + if (*str) { + *result++ = *str++ & 0x1f; + reslen--; + } + break; + default: + *result++ = *str++; + reslen--; + break; + } + } + if (--reslen > 0) { + if (cr) + *result++ = '\r'; + } + if (--reslen > 0) + *result++ = '\0'; + return (result); +} + +static void +ExecStr(struct physical *physical, char *command, char *out, int olen) +{ + pid_t pid; + int fids[2]; + char *argv[MAXARGS], *vector[MAXARGS], *startout, *endout; + int stat, nb, argc, i; + + log_Printf(LogCHAT, "Exec: %s\n", command); + if ((argc = MakeArgs(command, vector, VECSIZE(vector), + PARSE_REDUCE|PARSE_NOHASH)) <= 0) { + if (argc < 0) + log_Printf(LogWARN, "Syntax error in exec command\n"); + *out = '\0'; + return; + } + + if (pipe(fids) < 0) { + log_Printf(LogCHAT, "Unable to create pipe in ExecStr: %s\n", + strerror(errno)); + *out = '\0'; + return; + } + if ((pid = fork()) == 0) { + command_Expand(argv, argc, (char const *const *)vector, + physical->dl->bundle, 0, getpid()); + close(fids[0]); + timer_TermService(); + if (fids[1] == STDIN_FILENO) + fids[1] = dup(fids[1]); + dup2(physical->fd, STDIN_FILENO); + dup2(fids[1], STDERR_FILENO); + dup2(STDIN_FILENO, STDOUT_FILENO); + close(3); + if (open(_PATH_TTY, O_RDWR) != 3) + open(_PATH_DEVNULL, O_RDWR); /* Leave it closed if it fails... */ + for (i = getdtablesize(); i > 3; i--) + fcntl(i, F_SETFD, 1); +#ifndef NOSUID + setuid(ID0realuid()); +#endif + execvp(argv[0], argv); + fprintf(stderr, "execvp: %s: %s\n", argv[0], strerror(errno)); + _exit(127); + } else { + char *name = strdup(vector[0]); + + close(fids[1]); + endout = out + olen - 1; + startout = out; + while (out < endout) { + nb = read(fids[0], out, 1); + if (nb <= 0) + break; + out++; + } + *out = '\0'; + close(fids[0]); + close(fids[1]); + waitpid(pid, &stat, WNOHANG); + if (WIFSIGNALED(stat)) { + log_Printf(LogWARN, "%s: signal %d\n", name, WTERMSIG(stat)); + free(name); + *out = '\0'; + return; + } else if (WIFEXITED(stat)) { + switch (WEXITSTATUS(stat)) { + case 0: + free(name); + break; + case 127: + log_Printf(LogWARN, "%s: %s\n", name, startout); + free(name); + *out = '\0'; + return; + break; + default: + log_Printf(LogWARN, "%s: exit %d\n", name, WEXITSTATUS(stat)); + free(name); + *out = '\0'; + return; + break; + } + } else { + log_Printf(LogWARN, "%s: Unexpected exit result\n", name); + free(name); + *out = '\0'; + return; + } + } +} |