#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
+#include <string.h>
#include <fcntl.h>
#include <unistd.h>
+#include <signal.h>
#include <poll.h>
#include <errno.h>
#include <termios.h>
#include <pcre.h>
+/* RHEL 6 pcre did not define PCRE_PARTIAL_SOFT. However PCRE_PARTIAL
+ * is a synonym so use that.
+ */
+#ifndef PCRE_PARTIAL_SOFT
+#define PCRE_PARTIAL_SOFT PCRE_PARTIAL
+#endif
+
#include "miniexpect.h"
#define DEBUG 0
h->pid = 0;
h->timeout = 60000;
h->read_size = 1024;
+ h->pcre_error = 0;
h->buffer = NULL;
h->len = h->alloc = 0;
+ h->next_match = -1;
h->user1 = h->user2 = h->user3 = NULL;
return h;
free (h->buffer);
h->buffer = NULL;
h->alloc = h->len = 0;
+ h->next_match = -1;
}
int
return -1;
}
+ free (h);
+
return status;
}
mexp_h *
-mexp_spawnl (const char *file, const char *arg, ...)
+mexp_spawnlf (unsigned flags, const char *file, const char *arg, ...)
{
char **argv, **new_argv;
size_t i;
new_argv = realloc (argv, sizeof (char *) * (i+1));
if (new_argv == NULL) {
free (argv);
+ va_end (args);
return NULL;
}
argv = new_argv;
argv[i] = (char *) arg;
}
- h = mexp_spawnv (file, argv);
+ h = mexp_spawnvf (flags, file, argv);
free (argv);
+ va_end (args);
return h;
}
mexp_h *
-mexp_spawnv (const char *file, char **argv)
+mexp_spawnvf (unsigned flags, const char *file, char **argv)
{
- mexp_h *h;
+ mexp_h *h = NULL;
int fd = -1;
int err;
char slave[1024];
goto error;
if (pid == 0) { /* Child. */
- struct termios terminal_settings;
int slave_fd;
+ if (!(flags & MEXP_SPAWN_KEEP_SIGNALS)) {
+ struct sigaction sa;
+ int i;
+
+ /* Remove all signal handlers. See the justification here:
+ * https://www.redhat.com/archives/libvir-list/2008-August/msg00303.html
+ * We don't mask signal handlers yet, so this isn't completely
+ * race-free, but better than not doing it at all.
+ */
+ memset (&sa, 0, sizeof sa);
+ sa.sa_handler = SIG_DFL;
+ sa.sa_flags = 0;
+ sigemptyset (&sa.sa_mask);
+ for (i = 1; i < NSIG; ++i)
+ sigaction (i, &sa, NULL);
+ }
+
setsid ();
/* Open the slave side of the pty. We must do this in the child
if (slave_fd == -1)
goto error;
- /* Set raw mode. */
- tcgetattr (slave_fd, &terminal_settings);
- cfmakeraw (&terminal_settings);
- tcsetattr (slave_fd, TCSANOW, &terminal_settings);
+ if (!(flags & MEXP_SPAWN_COOKED_MODE)) {
+ struct termios termios;
+
+ /* Set raw mode. */
+ tcgetattr (slave_fd, &termios);
+ cfmakeraw (&termios);
+ tcsetattr (slave_fd, TCSANOW, &termios);
+ }
/* Set up stdin, stdout, stderr to point to the pty. */
dup2 (slave_fd, 0);
*/
close (fd);
+ if (!(flags & MEXP_SPAWN_KEEP_FDS)) {
+ int i, max_fd;
+
+ /* Close all other file descriptors. This ensures that we don't
+ * hold open (eg) pipes from the parent process.
+ */
+ max_fd = sysconf (_SC_OPEN_MAX);
+ if (max_fd == -1)
+ max_fd = 1024;
+ if (max_fd > 65536)
+ max_fd = 65536; /* bound the amount of work we do here */
+ for (i = 3; i < max_fd; ++i)
+ close (i);
+ }
+
/* Run the subprocess. */
execvp (file, argv);
perror (file);
close (fd);
if (pid > 0)
waitpid (pid, NULL, 0);
+ if (h != NULL)
+ mexp_close (h);
errno = err;
return NULL;
}
enum mexp_status
-mexp_expect (mexp_h *h, const pcre *code,
- const pcre_extra *extra,
- int options, int *ovector, int ovecsize,
- int *pcre_ret)
+mexp_expect (mexp_h *h, const mexp_regexp *regexps, int *ovector, int ovecsize)
{
time_t start_t, now_t;
int timeout;
time (&start_t);
- options |= PCRE_PARTIAL_SOFT;
-
- /* Clear the read buffer. */
- clear_buffer (h);
+ if (h->next_match == -1) {
+ /* Fully clear the buffer, then read. */
+ clear_buffer (h);
+ } else {
+ /* See the comment in the manual about h->next_match. We have
+ * some data remaining in the buffer, so begin by matching that.
+ */
+ memmove (&h->buffer[0], &h->buffer[h->next_match], h->len - h->next_match);
+ h->len -= h->next_match;
+ h->buffer[h->len] = '\0';
+ h->next_match = -1;
+ goto try_match;
+ }
for (;;) {
/* If we've got a timeout then work out how many seconds are left.
fprintf (stderr, "DEBUG: buffer content: %s\n", h->buffer);
#endif
- /* See if there is a full or partial match against the regular expression. */
- if (code) {
+ try_match:
+ /* See if there is a full or partial match against any regexp. */
+ if (regexps) {
+ size_t i;
+ int can_clear_buffer = 1;
+
assert (h->buffer != NULL);
- r = pcre_exec (code, extra, h->buffer, (int)h->len, 0,
- options, ovector, ovecsize);
- if (pcre_ret)
- *pcre_ret = r;
-
- if (r >= 0) {
- /* A full match. */
- return MEXP_MATCHED;
- }
- else if (r == PCRE_ERROR_NOMATCH) {
- /* No match at all, so we can dump the input buffer. */
- clear_buffer (h);
+ for (i = 0; regexps[i].r > 0; ++i) {
+ const int options = regexps[i].options | PCRE_PARTIAL_SOFT;
+
+ r = pcre_exec (regexps[i].re, regexps[i].extra,
+ h->buffer, (int)h->len, 0,
+ options,
+ ovector, ovecsize);
+ h->pcre_error = r;
+
+ if (r >= 0) {
+ /* A full match. */
+ if (ovector != NULL && ovecsize >= 1 && ovector[1] >= 0)
+ h->next_match = ovector[1];
+ else
+ h->next_match = -1;
+ return regexps[i].r;
+ }
+
+ else if (r == PCRE_ERROR_NOMATCH) {
+ /* No match at all. */
+ /* (nothing here) */
+ }
+
+ else if (r == PCRE_ERROR_PARTIAL) {
+ /* Partial match. Keep the buffer and keep reading. */
+ can_clear_buffer = 0;
+ }
+
+ else {
+ /* An actual PCRE error. */
+ return MEXP_PCRE_ERROR;
+ }
}
- else if (r == PCRE_ERROR_PARTIAL) {
- /* Partial match. Keep the buffer and keep reading. */
- /* (nothing here) */
- }
+ /* If none of the regular expressions matched (not partially)
+ * then we can clear the buffer. This is an optimization.
+ */
+ if (can_clear_buffer)
+ clear_buffer (h);
- else {
- /* An actual PCRE error. */
- return MEXP_PCRE_ERROR;
- }
- } /* if (code) */
+ } /* if (regexps) */
}
}
free (msg);
return len;
}
+
+int
+mexp_send_interrupt (mexp_h *h)
+{
+ return write (h->fd, "\003", 1);
+}