void endedit() { editing = 0; if (elc) { el_end(elc); elc = NULL; } if (eli) { el_end(eli); eli = NULL; } }
static int acc_el_initialize(void) { HistEvent ev; if (el != NULL) el_end(el); if (el_hist != NULL) history_end(el_hist); el = el_init("accedian", stdin, stdout, stderr); el_set(el, EL_PROMPT, cli_prompt); el_set(el, EL_EDITMODE, 1); el_set(el, EL_EDITOR, "emacs"); el_hist = history_init(); if (!el || !el_hist) return -1; /* setup history with 100 entries */ history(el_hist, &ev, H_SETSIZE, 100); el_set(el, EL_HIST, history, el_hist); el_set(el, EL_ADDFN, "ed-complete", "Complete argument", cli_complete); /* Bind <tab> to command completion */ el_set(el, EL_BIND, "^I", "ed-complete", NULL); #if 0 // Ticket #8152 - This corrupts show_rc passwords containing question marks /* Bind ? to command completion */ el_set(el, EL_BIND, "?", "ed-complete", NULL); #endif /* Bind ^D to redisplay */ el_set(el, EL_BIND, "^D", "ed-redisplay", NULL); return 0; }
void noit_console_closure_free(void *vncct) { noit_console_closure_t ncct = (noit_console_closure_t) vncct; noit_log_stream_t lf; noitL(noit_debug, "ncct free(%p)\n", (void *)ncct); if(ncct->el) el_end(ncct->el); if(ncct->hist) { history_end(ncct->hist); noitL(noit_debug, "ncct free->hist(%p)\n", (void *)ncct->hist); free(ncct->hist); } if(ncct->pty_master >= 0) close(ncct->pty_master); if(ncct->pty_slave >= 0) close(ncct->pty_slave); if(ncct->outbuf) free(ncct->outbuf); if(ncct->telnet) noit_console_telnet_free(ncct->telnet); noit_hash_destroy(&ncct->userdata, NULL, noit_console_userdata_free); while(ncct->state_stack) { noit_console_state_stack_t *tmp; tmp = ncct->state_stack; ncct->state_stack = tmp->last; if(tmp->name) free(tmp->name); free(tmp); } lf = noit_log_stream_find(ncct->feed_path); noit_log_stream_remove(ncct->feed_path); if(lf) { noit_log_stream_free(lf); } free(ncct); }
void bye(void) { cliLogCommand("End Session"); //Set flag for thread to terminate terminate_cli_check_session_thread = ACD_TRUE; //Reset EditLine (useful if el_gets() did not complete normally) if (el != NULL) el_end(el); //Free dynamically-allocated data cli_command_cleanup(CLEAR_STATIC_DATA); cli_free_command_cleanup_arr(); //Kill session if (session_id) cli_delete_session(); //Free IPC handles cmd_free(&cli_backend_handle); cmd_free(&cli_check_session_thread_ipc_handle); #ifdef ACCEDIAN_CONFIG_DISCOVERY_ENABLED if (acd_cap_discovery()) { discovery_module_cleanup(); } #endif }
static void _cleanup_editlineobject(EditLineObject *self) { /* mop up libedit */ if (self->el) el_end(self->el); if (self->tok) tok_end(self->tok); if (self->hist) history_end(self->hist); /* tidy up the allocated bits */ if (self->name) PyMem_RawFree(self->name); if (self->prompt) PyMem_RawFree(self->prompt); if (self->rprompt) PyMem_RawFree(self->rprompt); if (self->buffer) PyMem_RawFree(self->buffer); /* manage file-handles? */ if (self->fin) fclose(self->fin); if (self->fout) fclose(self->fout); if (self->ferr) fclose(self->ferr); /* release my ownership of the I/O refs */ Py_DECREF(self->pyin); Py_DECREF(self->pyout); Py_DECREF(self->pyerr); }
void AXA_NORETURN stop(int status) { if (el_e != NULL) { if (el_history) history(el_history, &el_event, H_SAVE, history_savefile); history_end(el_history); el_end(el_e); } close_in_files(); fflush(stderr); fflush(stdout); disconnect(false); if (nmsg_input != NULL) nmsg_input_close(&nmsg_input); if (nmsg_pres != NULL) nmsg_output_close(&nmsg_pres); /* this closes stdout */ out_close(false); axa_unload_fields(); axa_unload_client_config(); axa_io_cleanup(); exit(status); }
/* * ntp_readline_init - setup, set or reset prompt string */ int ntp_readline_init( const char * prompt ) { int success; success = 1; if (prompt) { if (lineedit_prompt) free(lineedit_prompt); lineedit_prompt = estrdup(prompt); } #ifdef LE_EDITLINE if (NULL == ntp_el) { # if 4 == EL_INIT_ARGS ntp_el = el_init(progname, stdin, stdout, stderr); # else ntp_el = el_init(progname, stdin, stdout); # endif if (ntp_el) { el_set(ntp_el, EL_PROMPT, ntp_prompt_callback); el_set(ntp_el, EL_EDITOR, "emacs"); ntp_hist = history_init(); if (NULL == ntp_hist) { mfprintf(stderr, "history_init(): %m\n"); fflush(stderr); el_end(ntp_el); ntp_el = NULL; success = 0; } else { ZERO(hev); #ifdef H_SETSIZE history(ntp_hist, &hev, H_SETSIZE, 128); #endif el_set(ntp_el, EL_HIST, history, ntp_hist); /* use any .editrc */ el_source(ntp_el, NULL); } } else success = 0; } #endif /* LE_EDITLINE */ ntp_readline_initted = success; return success; }
void IoEditLine_free(IoEditLine *self) { if (IoObject_dataPointer(self)) { el_end(DATA(self)->editline); history_end(DATA(self)->history); } }
/* * ntp_readline_init - setup, set or reset prompt string */ int ntp_readline_init( const char * prompt ) { int success; success = 1; if (prompt) { if (lineedit_prompt) free(lineedit_prompt); lineedit_prompt = estrdup(prompt); } #ifdef LE_EDITLINE if (NULL == ntp_el) { ntp_el = el_init(progname, stdin, stdout, stderr); if (ntp_el) { el_set(ntp_el, EL_PROMPT, ntp_prompt_callback); el_set(ntp_el, EL_EDITOR, "emacs"); ntp_hist = history_init(); if (NULL == ntp_hist) { fprintf(stderr, "history_init(): %s\n", strerror(errno)); fflush(stderr); el_end(ntp_el); ntp_el = NULL; success = 0; } else { memset(&hev, 0, sizeof hev); history(ntp_hist, &hev, H_SETSIZE, 128); el_set(ntp_el, EL_HIST, history, ntp_hist); /* use any .editrc */ el_source(ntp_el, NULL); } } else success = 0; } #endif /* LE_EDITLINE */ ntp_readline_initted = success; return success; }
void cmdend(void *arg) { struct clitenv *env = arg; el_end(env->el); history_end(env->hist); free(env); }
void x_readline_end(void) { if (el) { el_end(el); el = NULL; } if (hist) { history_end(hist); hist = NULL; } }
static void _cliDebuggerDeinit(struct Debugger* debugger) { struct CLIDebugger* cliDebugger = (struct CLIDebugger*) debugger; history_end(cliDebugger->histate); el_end(cliDebugger->elstate); if (cliDebugger->system) { cliDebugger->system->deinit(cliDebugger->system); free(cliDebugger->system); cliDebugger->system = 0; } }
CommandPrompt::~CommandPrompt() { #ifdef ZORBA_HAVE_LIBEDIT_H history_end(theHistory); el_end(theEditLine); #endif std::map<std::string, UntypedCommand*>::iterator lIter; for (lIter = theCommands.begin(); lIter != theCommands.end(); ++lIter) { delete lIter->second; } }
repl::repl(FILE * in, FILE * out, CommandHandler handler) noexcept { auto t = new std::thread([=]() { init_editline(in, out); const char * line; int length; io::log::info("init done"); while((line = el_gets(el, &length))) { io::log::info("got line: {}", line); // io::log::info("el->el_flags | NO_TTY {}", el->el_flags&0x02); if(length > 1) { history(hist, &ev, H_ENTER, line); } } history_end(hist); el_end(el); fclose(in); fclose(out); }); }
/* * ntp_readline_uninit - release resources */ void ntp_readline_uninit( void ) { #ifdef LE_EDITLINE if (ntp_el) { el_end(ntp_el); ntp_el = NULL; history_end(ntp_hist); ntp_hist = NULL; } #endif /* LE_EDITLINE */ if (lineedit_prompt) { free(lineedit_prompt); lineedit_prompt = NULL; } ntp_readline_initted = 0; }
void CliContext::Cleanup() { Terminating(); while (Event* event = fPendingEvents.RemoveHead()) delete event; if (fEditLine != NULL) { el_end(fEditLine); fEditLine = NULL; } if (fHistory != NULL) { history_end(fHistory); fHistory = NULL; } if (fTeam != NULL) { fTeam->RemoveListener(this); fTeam = NULL; } if (fNodeManager != NULL) { fNodeManager->ReleaseReference(); fNodeManager = NULL; } if (fCurrentBlock != NULL) { fCurrentBlock->ReleaseReference(); fCurrentBlock = NULL; } if (fExpressionInfo != NULL) { fExpressionInfo->ReleaseReference(); fExpressionInfo = NULL; } }
int main(int argc, char *argv[]) { int num; const char *buf; Tokenizer *tok; #if 0 int lastevent = 0; #endif int ncontinuation; History *hist; HistEvent ev; (void) signal(SIGINT, sig); (void) signal(SIGQUIT, sig); (void) signal(SIGHUP, sig); (void) signal(SIGTERM, sig); hist = history_init(); /* Init the builtin history */ /* Remember 100 events */ history(hist, &ev, H_SETSIZE, 100); tok = tok_init(NULL); /* Initialize the tokenizer */ /* Initialize editline */ el = el_init(*argv, stdin, stdout, stderr); el_set(el, EL_EDITOR, "vi"); /* Default editor is vi */ el_set(el, EL_SIGNAL, 1); /* Handle signals gracefully */ el_set(el, EL_PROMPT, prompt); /* Set the prompt function */ /* Tell editline to use this history interface */ el_set(el, EL_HIST, history, hist); /* Add a user-defined function */ el_set(el, EL_ADDFN, "ed-complete", "Complete argument", complete); /* Bind tab to it */ el_set(el, EL_BIND, "^I", "ed-complete", NULL); /* * Bind j, k in vi command mode to previous and next line, instead * of previous and next history. */ el_set(el, EL_BIND, "-a", "k", "ed-prev-line", NULL); el_set(el, EL_BIND, "-a", "j", "ed-next-line", NULL); /* * Source the user's defaults file. */ el_source(el, NULL); while ((buf = el_gets(el, &num)) != NULL && num != 0) { int ac; const char **av; #ifdef DEBUG (void) fprintf(stderr, "got %d %s", num, buf); #endif if (!continuation && num == 1) continue; ncontinuation = tok_line(tok, buf, &ac, &av) > 0; #if 0 if (continuation) { /* * Append to the right event in case the user * moved around in history. */ if (history(hist, &ev, H_SET, lastevent) == -1) err(1, "%d: %s\n", lastevent, ev.str); history(hist, &ev, H_ADD , buf); } else { history(hist, &ev, H_ENTER, buf); lastevent = ev.num; } #else /* Simpler */ history(hist, &ev, continuation ? H_APPEND : H_ENTER, buf); #endif continuation = ncontinuation; ncontinuation = 0; if (strcmp(av[0], "history") == 0) { int rv; switch (ac) { case 1: for (rv = history(hist, &ev, H_LAST); rv != -1; rv = history(hist, &ev, H_PREV)) (void) fprintf(stdout, "%4d %s", ev.num, ev.str); break; case 2: if (strcmp(av[1], "clear") == 0) history(hist, &ev, H_CLEAR); else goto badhist; break; case 3: if (strcmp(av[1], "load") == 0) history(hist, &ev, H_LOAD, av[2]); else if (strcmp(av[1], "save") == 0) history(hist, &ev, H_SAVE, av[2]); break; badhist: default: (void) fprintf(stderr, "Bad history arguments\n"); break; } } else if (el_parse(el, ac, av) == -1) { switch (fork()) { case 0: execvp(av[0], (char *const *)av); perror(av[0]); _exit(1); /*NOTREACHED*/ break; case -1: perror("fork"); break; default: if (wait(&num) == -1) perror("wait"); (void) fprintf(stderr, "Exit %x\n", num); break; } } tok_reset(tok); } el_end(el); tok_end(tok); history_end(hist); return (0); }
/* * Set history and editing status. Called whenever the status may * have changed (figures out what to do). */ void histedit() { #define editing (Eflag || Vflag) if (iflag) { if (!hist) { /* * turn history on */ INTOFF; hist = history_init(); INTON; if (hist != NULL) sethistsize(histsizeval()); else out2str("sh: can't initialize history\n"); } if (editing && !el && isatty(0)) { /* && isatty(2) ??? */ /* * turn editing on */ INTOFF; if (el_in == NULL) el_in = fdopen(0, "r"); if (el_out == NULL) el_out = fdopen(2, "w"); if (el_in == NULL || el_out == NULL) goto bad; el = el_init(arg0, el_in, el_out); if (el != NULL) { if (hist) el_set(el, EL_HIST, history, hist); el_set(el, EL_PROMPT, getprompt); } else { bad: out2str("sh: can't initialize editing\n"); } INTON; } else if (!editing && el) { INTOFF; el_end(el); el = NULL; INTON; } if (el) { if (Vflag) el_set(el, EL_EDITOR, "vi"); else if (Eflag) el_set(el, EL_EDITOR, "emacs"); } } else { INTOFF; if (el) { /* no editing if not interactive */ el_end(el); el = NULL; } if (hist) { history_end(hist); hist = NULL; } INTON; } }
void interact( const char *const argv_0) { EditLine *const el = el_init(argv_0, stdin, stdout, stderr); el_set(el, EL_PROMPT, &prompt); el_set(el, EL_EDITOR, "emacs"); History *const hist = history_init(); if (!hist) { fprintf(stderr, "Could not initalize history\n"); exit(EXIT_FAILURE); } HistEvent ev; history(hist, &ev, H_SETSIZE, 100); el_set(el, EL_HIST, history, hist); const pid_t child_pid = _gen_child(); verbose_printf("child process is %d\n", child_pid); if (options.verbose) help(); char buf[PAGE_SIZE]; size_t buf_sz = 0; int end = 0; struct proc_info_t info = {}; ARCH_INIT_PROC_INFO(info); ptrace_launch(child_pid); ptrace_cont(child_pid, &info); ptrace_reap(child_pid, &info); display(&info); for (;;) { int count; const char *const line = el_gets(el, &count); if (count == -1) { perror("el_gets"); exit(EXIT_FAILURE); } // count is 0 == ^d if (!count || strcasestr(line, ".quit") || strcasestr(line, ".exit")) break; // We have input, add it to the our history history(hist, &ev, H_ENTER, line); // If we start with a ., we have a command if (line[0] == '.') { if (strcasestr(line, "help")) { help(); continue; } if (strcasestr(line, "info")) { display(&info); continue; } if (strcasestr(line, "showmap")) { char cmd[PATH_MAX] = { 0 }; snprintf(cmd, sizeof(cmd), "cat /proc/%d/maps", child_pid); if (system(cmd)) fprintf(stderr, "sh: %s failed\n", cmd); continue; } if (strcasestr(line, "read")) { ui_read(child_pid, line); continue; } if (strcasestr(line, "write")) { continue; } if (strcasestr(line, "begin")) { in_block = 1; continue; } // Note the lack of continue. Need to fall through... if (strcasestr(line, "end")) { in_block = 0; end = 1; } } if (buf_sz + count > sizeof(buf)) { printf("Buffer full (max: 0x%lx), please use '.end'\n", sizeof(buf)); continue; } // Since we fell through, we want to avoid adding adding .end to our buffer if (!end) { memcpy(buf + buf_sz, line, count); buf_sz += count; } if (!in_block) { verbose_printf("Trying to assemble(%zu):\n%s", buf_sz, buf); uint8_t bytecode[PAGE_SIZE]; const size_t bytecode_sz = assemble(bytecode, sizeof(bytecode), buf, buf_sz); memset(buf, 0, sizeof(buf)); buf_sz = 0; end = 0; verbose_printf("Got asm(%zu):\n", bytecode_sz); verbose_dump(bytecode, bytecode_sz, -1); if (!bytecode_sz) { fprintf(stderr, "'%s' assembled to 0 length bytecode\n", buf); continue; } ptrace_write(child_pid, (void *)options.start, bytecode, bytecode_sz); ptrace_reset(child_pid, options.start); ptrace_cont(child_pid, &info); ptrace_reap(child_pid, &info); display(&info); } } ptrace_detatch(child_pid, &info); printf("\n"); history_end(hist); el_end(el); }
EditLineReader::~EditLineReader() { el_end(_editLine); history_end(_history); }
/* * Connect to ppp using either a local domain socket or a tcp socket. * * If we're given arguments, process them and quit, otherwise create two * threads to handle interactive mode. */ int main(int argc, char **argv) { struct sockaddr_un ifsun; int n, arg, fd, len, verbose, save_errno, hide1, hide1off, hide2; unsigned TimeoutVal; char *DoneWord = "x", *next, *start; struct sigaction act, oact; void *thread_ret; pthread_t mon; char Command[LINELEN]; char Buffer[LINELEN]; verbose = 0; TimeoutVal = 2; hide1 = hide1off = hide2 = 0; for (arg = 1; arg < argc; arg++) if (*argv[arg] == '-') { for (start = argv[arg] + 1; *start; start++) switch (*start) { case 't': TimeoutVal = (unsigned)atoi (start[1] ? start + 1 : argv[++arg]); start = DoneWord; break; case 'v': verbose = REC_VERBOSE; break; case 'p': if (start[1]) { hide1 = arg; hide1off = start - argv[arg]; passwd = start + 1; } else { hide1 = arg; hide1off = start - argv[arg]; passwd = argv[++arg]; hide2 = arg; } start = DoneWord; break; default: usage(); } } else break; if (argc < arg + 1) usage(); if (hide1) { char title[1024]; int pos, harg; for (harg = pos = 0; harg < argc; harg++) if (harg == 0 || harg != hide2) { if (harg == 0 || harg != hide1) n = snprintf(title + pos, sizeof title - pos, "%s%s", harg ? " " : "", argv[harg]); else if (hide1off > 1) n = snprintf(title + pos, sizeof title - pos, " %.*s", hide1off, argv[harg]); else n = 0; if (n < 0 || n >= sizeof title - pos) break; pos += n; } #ifdef __FreeBSD__ setproctitle("-%s", title); #else setproctitle("%s", title); #endif } if (*argv[arg] == '/') { memset(&ifsun, '\0', sizeof ifsun); ifsun.sun_len = strlen(argv[arg]); if (ifsun.sun_len > sizeof ifsun.sun_path - 1) { warnx("%s: path too long", argv[arg]); return 1; } ifsun.sun_family = AF_LOCAL; strcpy(ifsun.sun_path, argv[arg]); if (fd = socket(AF_LOCAL, SOCK_STREAM, 0), fd < 0) { warnx("cannot create local domain socket"); return 2; } if (connect(fd, (struct sockaddr *)&ifsun, sizeof(ifsun)) < 0) { if (errno) warn("cannot connect to socket %s", argv[arg]); else warnx("cannot connect to socket %s", argv[arg]); close(fd); return 3; } } else { char *addr, *p, *port; const char *caddr; struct addrinfo hints, *res, *pai; int gai; char local[] = "localhost"; addr = argv[arg]; if (addr[strspn(addr, "0123456789")] == '\0') { /* port on local machine */ port = addr; addr = local; } else if (*addr == '[') { /* [addr]:port */ if ((p = strchr(addr, ']')) == NULL) { warnx("%s: mismatched '['", addr); return 1; } addr++; *p++ = '\0'; if (*p != ':') { warnx("%s: missing port", addr); return 1; } port = ++p; } else { /* addr:port */ p = addr + strcspn(addr, ":"); if (*p != ':') { warnx("%s: missing port", addr); return 1; } *p++ = '\0'; port = p; } memset(&hints, 0, sizeof(hints)); hints.ai_socktype = SOCK_STREAM; gai = getaddrinfo(addr, port, &hints, &res); if (gai != 0) { warnx("%s: %s", addr, gai_strerror(gai)); return 1; } for (pai = res; pai != NULL; pai = pai->ai_next) { if (fd = socket(pai->ai_family, pai->ai_socktype, pai->ai_protocol), fd < 0) { warnx("cannot create socket"); continue; } TimedOut = 0; if (TimeoutVal) { act.sa_handler = Timeout; sigemptyset(&act.sa_mask); act.sa_flags = 0; sigaction(SIGALRM, &act, &oact); alarm(TimeoutVal); } if (connect(fd, pai->ai_addr, pai->ai_addrlen) == 0) break; if (TimeoutVal) { save_errno = errno; alarm(0); sigaction(SIGALRM, &oact, 0); errno = save_errno; } caddr = sockaddr_ntop(pai->ai_addr); if (caddr == NULL) caddr = argv[arg]; if (TimedOut) warnx("timeout: cannot connect to %s", caddr); else { if (errno) warn("cannot connect to %s", caddr); else warnx("cannot connect to %s", caddr); } close(fd); } freeaddrinfo(res); if (pai == NULL) return 1; if (TimeoutVal) { alarm(0); sigaction(SIGALRM, &oact, 0); } } len = 0; Command[sizeof(Command)-1] = '\0'; for (arg++; arg < argc; arg++) { if (len && len < sizeof(Command)-1) strcpy(Command+len++, " "); strncpy(Command+len, argv[arg], sizeof(Command)-len-1); len += strlen(Command+len); } switch (Receive(fd, verbose | REC_PASSWD)) { case 1: fprintf(stderr, "Password incorrect\n"); break; case 0: passwd = NULL; if (len == 0) { struct thread_data td; const char *env; int size; #ifndef __OpenBSD__ HistEvent hev = { 0, "" }; #endif td.hist = history_init(); if ((env = getenv("EL_SIZE"))) { size = atoi(env); if (size < 0) size = 20; } else size = 20; #ifdef __OpenBSD__ history(td.hist, H_EVENT, size); td.edit = el_init("pppctl", stdin, stdout); #else history(td.hist, &hev, H_SETSIZE, size); td.edit = el_init("pppctl", stdin, stdout, stderr); #endif el_source(td.edit, NULL); el_set(td.edit, EL_PROMPT, GetPrompt); if ((env = getenv("EL_EDITOR"))) { if (!strcmp(env, "vi")) el_set(td.edit, EL_EDITOR, "vi"); else if (!strcmp(env, "emacs")) el_set(td.edit, EL_EDITOR, "emacs"); } el_set(td.edit, EL_SIGNAL, 1); el_set(td.edit, EL_HIST, history, (const char *)td.hist); td.ppp = fd; td.trm = NULL; /* * We create two threads. The Terminal thread does all the * work while the Monitor thread simply tells the Terminal * thread when ``fd'' becomes readable. The telling is done * by sending a SIGUSR1 to the Terminal thread. The * sem_select semaphore is used to prevent the monitor * thread from firing excessive signals at the Terminal * thread (it's abused for exit handling too - see below). * * The Terminal thread never uses td.trm ! */ sem_init(&sem_select, 0, 0); pthread_create(&td.trm, NULL, Terminal, &td); pthread_create(&mon, NULL, Monitor, &td); /* Wait for the terminal thread to finish */ pthread_join(td.trm, &thread_ret); fprintf(stderr, "Connection closed\n"); /* Get rid of the monitor thread by abusing sem_select */ timetogo = 1; close(fd); fd = -1; sem_post(&sem_select); pthread_join(mon, &thread_ret); /* Restore our terminal and release resources */ el_end(td.edit); history_end(td.hist); sem_destroy(&sem_select); } else { start = Command; do { next = strchr(start, ';'); while (*start == ' ' || *start == '\t') start++; if (next) *next = '\0'; strcpy(Buffer, start); Buffer[sizeof(Buffer)-2] = '\0'; strcat(Buffer, "\n"); if (verbose) write(STDOUT_FILENO, Buffer, strlen(Buffer)); write(fd, Buffer, strlen(Buffer)); if (Receive(fd, verbose | REC_SHOW) != 0) { fprintf(stderr, "Connection closed\n"); break; } if (next) start = ++next; } while (next && *next); if (verbose) write(STDOUT_FILENO, "quit\n", 5); write(fd, "quit\n", 5); while (Receive(fd, verbose | REC_SHOW) == 0) ; if (verbose) puts(""); } break; default: warnx("ppp is not responding"); break; } if (fd != -1) close(fd); return 0; }
void deinitialize_libedit(void) { el_end(el); history_end(hist); }
static int cmdloop(void) { char *line = NULL; const char *elline; int cmd_argc, rval = 0, known; #define scratch known char **cmd_argv; struct cmdtable *cmdp; History *hist; EditLine *elptr; HistEvent hev; curinode = ginode(ROOTINO); curinum = ROOTINO; printactive(); hist = history_init(); history(hist, &hev, H_SETSIZE, 100); /* 100 elt history buffer */ elptr = el_init(__progname, stdin, stdout, stderr); el_set(elptr, EL_EDITOR, "emacs"); el_set(elptr, EL_PROMPT, prompt); el_set(elptr, EL_HIST, history, hist); el_source(elptr, NULL); while ((elline = el_gets(elptr, &scratch)) != NULL && scratch != 0) { if (debug) printf("command `%s'\n", line); history(hist, &hev, H_ENTER, elline); line = strdup(elline); if (line == NULL) errx(1, "out of memory"); cmd_argv = crack(line, &cmd_argc); if (cmd_argc) { /* * el_parse returns -1 to signal that it's not been handled * internally. */ if (el_parse(elptr, cmd_argc, (const char **)cmd_argv) != -1) continue; known = 0; for (cmdp = cmds; cmdp->cmd; cmdp++) { if (!strcmp(cmdp->cmd, cmd_argv[0])) { if (cmd_argc >= cmdp->minargc && cmd_argc <= cmdp->maxargc) rval = (*cmdp->handler)(cmd_argc, cmd_argv); else rval = argcount(cmdp, cmd_argc, cmd_argv); known = 1; break; } } if (!known) { warnx("unknown command `%s'", cmd_argv[0]); rval = 1; } } else rval = 0; free(line); if (rval < 0) return rval; if (rval) warnx("rval was %d", rval); } el_end(elptr); history_end(hist); return rval; }
/* * Set history and editing status. Called whenever the status may * have changed (figures out what to do). */ void histedit(void) { #define editing (Eflag || Vflag) if (iflag) { if (!hist) { /* * turn history on */ INTOFF; hist = history_init(); INTON; if (hist != NULL) sethistsize(histsizeval()); else out2fmt_flush("sh: can't initialize history\n"); } if (editing && !el && isatty(0)) { /* && isatty(2) ??? */ /* * turn editing on */ char *term; INTOFF; if (el_in == NULL) el_in = fdopen(0, "r"); if (el_err == NULL) el_err = fdopen(1, "w"); if (el_out == NULL) el_out = fdopen(2, "w"); if (el_in == NULL || el_err == NULL || el_out == NULL) goto bad; term = lookupvar("TERM"); if (term) { if (setenv("TERM", term, 1) == -1) error("setenv: cannot set TERM=1"); } else unsetenv("TERM"); el = el_init(arg0, el_in, el_out, el_err); if (el != NULL) { if (hist) el_set(el, EL_HIST, history, hist); el_set(el, EL_PROMPT, getprompt); el_set(el, EL_ADDFN, "rl-complete", "ReadLine compatible completion function", _el_fn_complete); } else { bad: out2fmt_flush("sh: can't initialize editing\n"); } INTON; } else if (!editing && el) { INTOFF; el_end(el); el = NULL; INTON; } if (el) { if (Vflag) el_set(el, EL_EDITOR, "vi"); else if (Eflag) el_set(el, EL_EDITOR, "emacs"); el_set(el, EL_BIND, "^I", tabcomplete ? "rl-complete" : "ed-insert", NULL); el_source(el, NULL); } } else { INTOFF; if (el) { /* no editing if not interactive */ el_end(el); el = NULL; } if (hist) { history_end(hist); hist = NULL; } INTON; } }
int main(int argc, char *argv[]) { EditLine *el = NULL; int numc, ncontinuation; const wchar_t *line; TokenizerW *tok; HistoryW *hist; HistEventW ev; #ifdef DEBUG int i; #endif setlocale(LC_ALL, ""); (void)signal(SIGINT, sig); (void)signal(SIGQUIT, sig); (void)signal(SIGHUP, sig); (void)signal(SIGTERM, sig); hist = history_winit(); /* Init built-in history */ history_w(hist, &ev, H_SETSIZE, 100); /* Remember 100 events */ history_w(hist, &ev, H_LOAD, hfile); tok = tok_winit(NULL); /* Init the tokenizer */ el = el_init(argv[0], stdin, stdout, stderr); el_wset(el, EL_EDITOR, L"vi"); /* Default editor is vi */ el_wset(el, EL_SIGNAL, 1); /* Handle signals gracefully */ el_wset(el, EL_PROMPT_ESC, prompt, '\1'); /* Set the prompt function */ el_wset(el, EL_HIST, history_w, hist); /* FIXME - history_w? */ /* Add a user-defined function */ el_wset(el, EL_ADDFN, L"ed-complete", L"Complete argument", complete); /* Bind <tab> to it */ el_wset(el, EL_BIND, L"^I", L"ed-complete", NULL); /* * Bind j, k in vi command mode to previous and next line, instead * of previous and next history. */ el_wset(el, EL_BIND, L"-a", L"k", L"ed-prev-line", NULL); el_wset(el, EL_BIND, L"-a", L"j", L"ed-next-line", NULL); /* Source the user's defaults file. */ el_source(el, NULL); while((line = el_wgets(el, &numc)) != NULL && numc != 0) { int ac, cc, co, rc; const wchar_t **av; const LineInfoW *li; li = el_wline(el); #ifdef DEBUG (void)fwprintf(stderr, L"==> got %d %ls", numc, line); (void)fwprintf(stderr, L" > li `%.*ls_%.*ls'\n", (li->cursor - li->buffer), li->buffer, (li->lastchar - 1 - li->cursor), (li->cursor >= li->lastchar) ? L"" : li->cursor); #endif if (gotsig) { (void)fprintf(stderr, "Got signal %d.\n", gotsig); gotsig = 0; el_reset(el); } if(!continuation && numc == 1) continue; /* Only got a linefeed */ ac = cc = co = 0; ncontinuation = tok_wline(tok, li, &ac, &av, &cc, &co); if (ncontinuation < 0) { (void) fprintf(stderr, "Internal error\n"); continuation = 0; continue; } #ifdef DEBUG (void)fprintf(stderr, " > nc %d ac %d cc %d co %d\n", ncontinuation, ac, cc, co); #endif history_w(hist, &ev, continuation ? H_APPEND : H_ENTER, line); continuation = ncontinuation; ncontinuation = 0; if(continuation) continue; #ifdef DEBUG for (i = 0; i < ac; ++i) { (void)fwprintf(stderr, L" > arg# %2d ", i); if (i != cc) (void)fwprintf(stderr, L"`%ls'\n", av[i]); else (void)fwprintf(stderr, L"`%.*ls_%ls'\n", co, av[i], av[i] + co); } #endif if (wcscmp (av[0], L"history") == 0) { switch(ac) { case 1: for(rc = history_w(hist, &ev, H_LAST); rc != -1; rc = history_w(hist, &ev, H_PREV)) (void)fwprintf(stdout, L"%4d %ls", ev.num, ev.str); break; case 2: if (wcscmp(av[1], L"clear") == 0) history_w(hist, &ev, H_CLEAR); else goto badhist; break; case 3: if (wcscmp(av[1], L"load") == 0) history_w(hist, &ev, H_LOAD, my_wcstombs(av[2])); else if (wcscmp(av[1], L"save") == 0) history_w(hist, &ev, H_SAVE, my_wcstombs(av[2])); else goto badhist; break; badhist: default: (void)fprintf(stderr, "Bad history arguments\n"); break; } } else if (el_wparse(el, ac, av) == -1) { switch (fork()) { case 0: { Tokenizer *ntok = tok_init(NULL); int nargc; const char **nav; tok_str(ntok, my_wcstombs(line), &nargc, &nav); execvp(nav[0],(char **)nav); perror(nav[0]); _exit(1); /* NOTREACHED */ break; } case -1: perror("fork"); break; default: if (wait(&rc) == -1) perror("wait"); (void)fprintf(stderr, "Exit %x\n", rc); break; } } tok_wreset(tok); } el_end(el); tok_wend(tok); history_w(hist, &ev, H_SAVE, hfile); history_wend(hist); fprintf(stdout, "\n"); return 0; }
/* * Set history and editing status. Called whenever the status may * have changed (figures out what to do). */ void histedit(void) { FILE *el_err; #define editing (Eflag || Vflag) if (iflag == 1) { if (!hist) { /* * turn history on */ INTOFF; hist = history_init(); INTON; if (hist != NULL) sethistsize(histsizeval()); else out2str("sh: can't initialize history\n"); } if (editing && !el && isatty(0)) { /* && isatty(2) ??? */ /* * turn editing on */ char *term, *shname; INTOFF; if (el_in == NULL) el_in = fdopen(0, "r"); if (el_out == NULL) el_out = fdopen(2, "w"); if (el_in == NULL || el_out == NULL) goto bad; el_err = el_out; #if DEBUG if (tracefile) el_err = tracefile; #endif term = lookupvar("TERM"); if (term) setenv("TERM", term, 1); else unsetenv("TERM"); shname = arg0; if (shname[0] == '-') shname++; el = el_init(shname, el_in, el_out, el_err); if (el != NULL) { if (hist) el_set(el, EL_HIST, history, hist); el_set(el, EL_PROMPT, getprompt); el_set(el, EL_SIGNAL, 1); el_set(el, EL_ALIAS_TEXT, alias_text, NULL); el_set(el, EL_ADDFN, "rl-complete", "ReadLine compatible completion function", _el_fn_complete); } else { bad: out2str("sh: can't initialize editing\n"); } INTON; } else if (!editing && el) { INTOFF; el_end(el); el = NULL; INTON; } if (el) { el_source(el, NULL); if (Vflag) el_set(el, EL_EDITOR, "vi"); else if (Eflag) el_set(el, EL_EDITOR, "emacs"); el_set(el, EL_BIND, "^I", tabcomplete ? "rl-complete" : "ed-insert", NULL); } } else { INTOFF; if (el) { /* no editing if not interactive */ el_end(el); el = NULL; } if (hist) { history_end(hist); hist = NULL; } INTON; } }
int cmdloop(void) { char *line; const char *elline; int cmd_argc, rval = 0, known; #define scratch known char **cmd_argv; struct cmdtable *cmdp; History *hist; EditLine *elptr; HistEvent he; curinode = check_ginode(ROOTINO); curinum = ROOTINO; printactive(0); hist = history_init(); history(hist, &he, H_SETSIZE, 100); /* 100 elt history buffer */ elptr = el_init("fsdb", stdin, stdout, stderr); el_set(elptr, EL_EDITOR, "emacs"); el_set(elptr, EL_PROMPT, prompt); el_set(elptr, EL_HIST, history, hist); el_source(elptr, NULL); while ((elline = el_gets(elptr, &scratch)) != NULL && scratch != 0) { if (check_debug) printf("command `%s'\n", elline); history(hist, &he, H_ENTER, elline); line = strdup(elline); cmd_argv = crack(line, &cmd_argc); /* * el_parse returns -1 to signal that it's not been handled * internally. */ if (el_parse(elptr, cmd_argc, (const char **)cmd_argv) != -1) continue; if (cmd_argc) { known = 0; for (cmdp = cmds; cmdp->cmd; cmdp++) { if (!strcmp(cmdp->cmd, cmd_argv[0])) { if ((cmdp->flags & FL_WR) == FL_WR && nflag) warnx("`%s' requires write access", cmd_argv[0]), rval = 1; else if (cmd_argc >= cmdp->minargc && cmd_argc <= cmdp->maxargc) rval = (*cmdp->handler)(cmd_argc, cmd_argv); else if (cmd_argc >= cmdp->minargc && (cmdp->flags & FL_ST) == FL_ST) { strcpy(line, elline); cmd_argv = recrack(line, &cmd_argc, cmdp->maxargc); rval = (*cmdp->handler)(cmd_argc, cmd_argv); } else rval = argcount(cmdp, cmd_argc, cmd_argv); known = 1; break; } } if (!known) warnx("unknown command `%s'", cmd_argv[0]), rval = 1; } else rval = 0; free(line); if (rval < 0) /* user typed "quit" */ return 0; if (rval) warnx("rval was %d", rval); } el_end(elptr); history_end(hist); return rval; }
int main (int argc, char* argv[]) { #ifdef OSV_CLI putenv("TERM=vt100-qemu"); cli_console_size_dirty(); #else struct winsize sz; ioctl(0, TIOCGWINSZ, &sz); if (sz.ws_col > 0 && sz.ws_row > 0) { con_width = sz.ws_col; con_height = sz.ws_row; signal(SIGWINCH, cli_sigwinch_handler); } #endif /* Context */ env_osv_api = getenv("OSV_API"); /* Process command line options */ int opt = 0; static struct option long_options[] = { {"api", optional_argument, 0, 'a'} }; int long_index = 0; while ((opt = getopt_long(argc, argv, "a:", long_options, &long_index)) != -1) { switch (opt) { case 'a': env_osv_api = optarg; break; } } /* Lua state */ L = cli_luaL_newstate(); if (optind < argc) { /* If we have more arguments, the user is running a single command */ if (L != NULL) { lua_getglobal(L, "cli_command_single"); lua_createtable(L, argc, 0); for (int i=1; i<argc; i++) { lua_pushinteger(L, i); lua_pushstring(L, argv[i]); lua_settable(L, -3); } lua_pushinteger(L, optind - 1); int error = lua_pcall(L, 2, 0, 0); if (error) { fprintf(stderr, "%s\n", lua_tostring(L, -1)); lua_pop(L, 1); } } } else { /* Start a shell */ /* This holds all the state for our line editor */ EditLine *el; /* This holds the info for our history */ History *cli_history; /* Temp variables */ int keepreading = 1; HistEvent ev; /* editline */ int el_count = 0; char *el_line; /* Initialize the EditLine state to use our prompt function and emacs style editing. */ el = el_init(argv[0], stdin, stdout, stderr); el_set(el, EL_PROMPT, &cli_prompt); el_set(el, EL_SIGNAL, 1); el_set(el, EL_EDITOR, "emacs"); /* Initialize the history */ cli_history = history_init(); if (cli_history == 0) { fprintf(stderr, "history could not be initialized\n"); } /* Set the size of the history */ history(cli_history, &ev, H_SETSIZE, 800); /* This sets up the call back functions for history functionality */ el_set(el, EL_HIST, history, cli_history); while (keepreading) { /* el_count is the number of characters read. line is a const char* of our command line with the tailing \n */ el_line = (char *) el_gets(el, &el_count); /* If lua failed to load previously, retry */ if (L == NULL) { cli_luaL_renewstate(&L); } /* with zero input (^D), reset the lua state */ if (L != NULL && el_count == 0) { cli_luaL_renewstate(&L); } else if (L != NULL && el_count > 0) { /* Remove tailing \n */ el_line[strlen(el_line)-1] = '\0'; /* Add commands to history. Don't add empty lines */ if (strlen(el_line) > 0) { history(cli_history, &ev, H_ENTER, el_line); } /* Typing reset is a special case which, like ^D, will reset the lua state */ if (strcmp(el_line, "reset") == 0) { cli_luaL_renewstate(&L); } else { /* Pass the line, as is, to cli() */ lua_getglobal(L, "cli_command"); lua_pushstring(L, el_line); int error = lua_pcall(L, 1, 0, 0); if (error) { fprintf(stderr, "%s\n", lua_tostring(L, -1)); lua_pop(L, 1); } } } } history_end(cli_history); el_end(el); } if (L != NULL) { lua_close(L); } return 0; }
int main(int argc, char *argv[]) { EditLine *el = NULL; int num; const char *buf; Tokenizer *tok; #if 0 int lastevent = 0; #endif int ncontinuation; History *hist; HistEvent ev; (void) setlocale(LC_CTYPE, ""); (void) signal(SIGINT, sig); (void) signal(SIGQUIT, sig); (void) signal(SIGHUP, sig); (void) signal(SIGTERM, sig); hist = history_init(); /* Init the builtin history */ /* Remember 100 events */ history(hist, &ev, H_SETSIZE, 100); tok = tok_init(NULL); /* Initialize the tokenizer */ /* Initialize editline */ el = el_init(*argv, stdin, stdout, stderr); el_set(el, EL_EDITOR, "vi"); /* Default editor is vi */ el_set(el, EL_SIGNAL, 1); /* Handle signals gracefully */ el_set(el, EL_PROMPT_ESC, prompt, '\1');/* Set the prompt function */ /* Tell editline to use this history interface */ el_set(el, EL_HIST, history, hist); /* Add a user-defined function */ el_set(el, EL_ADDFN, "ed-complete", "Complete argument", complete); /* Bind tab to it */ el_set(el, EL_BIND, "^I", "ed-complete", NULL); /* * Bind j, k in vi command mode to previous and next line, instead * of previous and next history. */ el_set(el, EL_BIND, "-a", "k", "ed-prev-line", NULL); el_set(el, EL_BIND, "-a", "j", "ed-next-line", NULL); /* * Source the user's defaults file. */ el_source(el, NULL); while ((buf = el_gets(el, &num)) != NULL && num != 0) { int ac, cc, co; #ifdef DEBUG int i; #endif const char **av; const LineInfo *li; li = el_line(el); #ifdef DEBUG (void) fprintf(stderr, "==> got %d %s", num, buf); (void) fprintf(stderr, " > li `%.*s_%.*s'\n", (li->cursor - li->buffer), li->buffer, (li->lastchar - 1 - li->cursor), (li->cursor >= li->lastchar) ? "" : li->cursor); #endif if (gotsig) { (void) fprintf(stderr, "Got signal %d.\n", (int)gotsig); gotsig = 0; el_reset(el); } if (!continuation && num == 1) continue; ac = cc = co = 0; ncontinuation = tok_line(tok, li, &ac, &av, &cc, &co); if (ncontinuation < 0) { (void) fprintf(stderr, "Internal error\n"); continuation = 0; continue; } #ifdef DEBUG (void) fprintf(stderr, " > nc %d ac %d cc %d co %d\n", ncontinuation, ac, cc, co); #endif #if 0 if (continuation) { /* * Append to the right event in case the user * moved around in history. */ if (history(hist, &ev, H_SET, lastevent) == -1) err(1, "%d: %s", lastevent, ev.str); history(hist, &ev, H_ADD , buf); } else { history(hist, &ev, H_ENTER, buf); lastevent = ev.num; } #else /* Simpler */ history(hist, &ev, continuation ? H_APPEND : H_ENTER, buf); #endif continuation = ncontinuation; ncontinuation = 0; if (continuation) continue; #ifdef DEBUG for (i = 0; i < ac; i++) { (void) fprintf(stderr, " > arg# %2d ", i); if (i != cc) (void) fprintf(stderr, "`%s'\n", av[i]); else (void) fprintf(stderr, "`%.*s_%s'\n", co, av[i], av[i] + co); } #endif if (strcmp(av[0], "history") == 0) { int rv; switch (ac) { case 1: for (rv = history(hist, &ev, H_LAST); rv != -1; rv = history(hist, &ev, H_PREV)) (void) fprintf(stdout, "%4d %s", ev.num, ev.str); break; case 2: if (strcmp(av[1], "clear") == 0) history(hist, &ev, H_CLEAR); else goto badhist; break; case 3: if (strcmp(av[1], "load") == 0) history(hist, &ev, H_LOAD, av[2]); else if (strcmp(av[1], "save") == 0) history(hist, &ev, H_SAVE, av[2]); break; badhist: default: (void) fprintf(stderr, "Bad history arguments\n"); break; } } else if (el_parse(el, ac, av) == -1) { switch (fork()) { case 0: execvp(av[0], __DECONST(char **, av)); perror(av[0]); _exit(1); /*NOTREACHED*/ break; case -1: perror("fork"); break; default: if (wait(&num) == -1) perror("wait"); (void) fprintf(stderr, "Exit %x\n", num); break; } } tok_reset(tok); } el_end(el); tok_end(tok); history_end(hist); return (0); }
int main(int argc, char **argv) { const char *fields_file = ""; const char *config_file = ""; #if LIBEDIT_IS_UNICODE wchar_t wc; #endif char cmd_buf[500]; const char *cmd; int cmd_len; bool version = false; const char *cfile = NULL; size_t n; nmsg_res res; char *p; int i; axa_set_me(argv[0]); AXA_ASSERT(axa_parse_log_opt(NULL, "trace,off,stderr")); AXA_ASSERT(axa_parse_log_opt(NULL, "error,off,stderr")); axa_syslog_init(); axa_set_core(); axa_client_init(&client); if (strcmp(axa_prog_name, "radtool") == 0) mode = RAD; if (isatty(STDIN_FILENO)) el_e = el_init(axa_prog_name, stdin, stdout, stderr); if (el_e != NULL) { int flag; if (0 > el_get(el_e, EL_EDITMODE, &flag) || !flag) { el_end(el_e); el_e = NULL; } } if (el_e != NULL) { /* prefer emacs mode but let the user choose in .editrc */ el_set(el_e, EL_EDITOR, "emacs"); /* bind emacs search to ^R */ el_set(el_e, EL_BIND, "\022", "em-inc-search-prev", NULL); el_source(el_e, NULL); el_history = history_init(); history(el_history, &el_event, H_SETSIZE, 800); history_get_savefile(); history(el_history, &el_event, H_LOAD, history_savefile); el_set(el_e, EL_HIST, history, el_history); el_set(el_e, EL_PROMPT, el_prompt); el_set(el_e, EL_SIGNAL, 1); el_set(el_e, EL_GETCFN, getcfn); } while ((i = getopt(argc, argv, "hVdNF:E:S:c:n:")) != -1) { switch (i) { case 'n': config_file = optarg; break; case 'V': version = true; break; case 'h': usage(); break; case 'd': ++axa_debug; break; case 'N': no_prompt = true; break; case 'F': fields_file = optarg; break; case 'E': if (axa_tls_cipher_list(&emsg, optarg) == NULL) error_msg("%s", emsg.c); break; case 'S': if (!axa_tls_certs_dir(&emsg, optarg)) error_msg("%s", emsg.c); break; case 'c': if (cfile != NULL) error_msg("only one -c allowed;" " ignoring all but the last"); cfile = optarg; break; default: usage(); } } argc -= optind; argv += optind; if (version) { version_cmd(AXA_TAG_NONE, "", NULL); if (argc == 0) stop(EX_OK); } signal(SIGPIPE, SIG_IGN); if (el_e != NULL) { signal(SIGINT, sigint); signal(SIGTERM, sigterm); signal(SIGHUP, sigterm); } AXA_DEBUG_TO_NMSG(axa_debug); res = nmsg_init(); if (res != nmsg_res_success) { error_msg("nmsg_init(): %s", nmsg_res_lookup(res)); exit(EX_SOFTWARE); } nmsg_input = nmsg_input_open_null(); AXA_ASSERT(nmsg_input != NULL); nmsg_pres = nmsg_output_open_pres(STDOUT_FILENO); axa_load_fields(fields_file); if (!axa_load_client_config(&emsg, config_file)) { axa_error_msg("can't load config file: %s", emsg.c); exit(EXIT_FAILURE); } /* Answer commands from the control file. */ if (cfile != NULL) { axa_asprintf(&p, "source %s", cfile); if (el_e != NULL) history(el_history, &el_event, H_ENTER, p); if (!do_cmds(p)) error_msg(" initial \"-c %s\" failed", cfile); free(p); } /* Answer commands from the command line. */ while (argc != 0) { if (el_e != NULL) history(el_history, &el_event, H_ENTER, *argv); if (!do_cmds(*argv)) { error_msg(" initial command \"%s\" failed", *argv); break; } ++argv; --argc; } for (;;) { cmd_input.tv_sec = 0; fflush(stderr); fflush(stdout); if (in_file_cur > 0) { /* Get a command from a "sourced" file. */ if (interrupted) { close_in_files(); continue; } cmd = axa_fgetln(in_files[in_file_cur].f, in_files[in_file_cur].name, &in_files[in_file_cur].lineno, &in_files[in_file_cur].buf, &in_files[in_file_cur].buf_size); if (cmd == NULL) { close_in_file_cur(); continue; } if (axa_debug != 0) { printf("< %s\n", cmd); fflush(stdout); } } else if (el_e != NULL) { /* Get a command from the terminal via editline(3). */ cmd = el_gets(el_e, &cmd_len); prompt_len = 0; if (!interrupted) { if (cmd == NULL) { fputc('\n', stdout); if (cmd_len == -1) error_msg("el_gets(): %s", strerror(errno)); stop(EX_OK); } /* Save nontrivial command lines. */ if (*(cmd+strspn(cmd, AXA_WHITESPACE)) != '\0') history(el_history, &el_event, H_ENTER, cmd); } } else if (!interrupted) { /* Get a command from stdin. */ n = 0; for (;;) { #if LIBEDIT_IS_UNICODE getcfn(NULL, &wc); cmd_buf[n] = wctob(wc); #else getcfn(NULL, &cmd_buf[n]); #endif if (cmd_buf[n++] == '\n' || n >= sizeof(cmd_buf)-1) break; } cmd_buf[n] = '\0'; cmd = cmd_buf; } if (interrupted) { interrupted = false; if (el_e != NULL) { el_set(el_e, EL_UNBUFFERED, 0); el_reset(el_e); if (prompt_cleared.tv_sec != 0) { packet_counting = true; packet_count = 0; packet_count_total = 0; } } close_in_files(); fputs(" (int)\n", stdout); continue; } if (!do_cmds(cmd)) { fputs(" ?\n", stderr); fflush(stdout); close_in_files(); } } }