void cli_destroy(void)
{
unsigned int i;
if (!cli_event)
return;
if (cli_rl) {
cli_rl = false;
rl_replace_line("", 0);
rl_crlf();
rl_on_new_line();
rl_redisplay();
rl_message("");
rl_callback_handler_remove();
}
sd_event_source_unref(cli_stdin);
cli_stdin = NULL;
for (i = 0; cli_sigs[i]; ++i) {
sd_event_source_unref(cli_sigs[i]);
cli_sigs[i] = NULL;
}
cli_cmds = NULL;
sd_bus_detach_event(cli_bus);
cli_bus = NULL;
sd_event_unref(cli_event);
cli_event = NULL;
}
void
input_stop_list(void)
{
/* Reprint the currently edited line after listing */
rl_on_new_line();
rl_redisplay();
}
/* server option completion function */
static char *
rl_complete_set(char *text, int state)
{
static struct ph_option *phopt;
static int textlen;
int debug;
if (!state)
{
phopt = NULL;
textlen = strlen(text);
if (!ph_is_optionlist_cached(ph))
{
get_option("debug", &debug);
if (debug)
{
putchar('\n');
rl_on_new_line();
}
if (ph_retrieve_options(ph) == -1)
{
perror("ph_retrieve_options()");
return NULL;
}
if (debug)
rl_redisplay();
}
}
while (ph_option_iterate(ph, &phopt) == 1)
if (strncasecmp(phopt->po_option, text, textlen) == 0)
return strdup(phopt->po_option);
return NULL;
}
void readline_constructor_impl::impl::redisplay(
boost::system::error_code const& ec
)
{
if (ec) {
return;
}
std::cout << std::endl;
rl_on_new_line();
rl_redisplay();
}
int tty_vmsg( const char *fmt, va_list ap )
{
int r;
putchar(13);
putp( tcap.clreol );
r = vprintf( fmt, ap );
rl_on_new_line();
if(! RL_ISSTATE(RL_STATE_DONE) )
rl_redisplay();
return r;
}
int my_bind_cr(int count, int key) {
struct slre_cap caps[4];
if (my_eoq == 1 || slre_match("(\\\\G|;)\\s*$", rl_line_buffer, strlen(rl_line_buffer), caps, 4, SLRE_IGNORE_CASE) > 0){
rl_done = 1;
return 1;
} else if( slre_match("^(\\\\q|exit)$", rl_line_buffer, strlen(rl_line_buffer), caps, 4, 0) > 0) {
rl_done = 1;exit_flag=1;
return 1;
}
if (strcmp( rl_line_buffer , "") == 0 || slre_match("^\\s+$", rl_line_buffer, strlen(rl_line_buffer), caps, 4, 0) > 0) {
printf("\n");
rl_on_new_line();
}else{
rl_insert_text(" \n");
}
return 1;
}
static int cli_signal_fn(sd_event_source *source,
const struct signalfd_siginfo *ssi,
void *data)
{
if (ssi->ssi_signo == SIGCHLD) {
cli_debug("caught SIGCHLD for %d", (int)ssi->ssi_pid);
} else if (ssi->ssi_signo == SIGINT) {
rl_replace_line("", 0);
rl_crlf();
rl_on_new_line();
rl_redisplay();
} else {
cli_notice("caught signal %d, exiting..",
(int)ssi->ssi_signo);
sd_event_exit(cli_event, 0);
}
return 0;
}
static gboolean signal_handler(GIOChannel *channel, GIOCondition condition,
gpointer user_data)
{
static unsigned int __terminated = 0;
struct signalfd_siginfo si;
ssize_t result;
int fd;
if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
g_main_loop_quit(event_loop);
return FALSE;
}
fd = g_io_channel_unix_get_fd(channel);
result = read(fd, &si, sizeof(si));
if (result != sizeof(si))
return FALSE;
switch (si.ssi_signo) {
case SIGINT:
rl_replace_line("", 0);
rl_crlf();
rl_on_new_line();
rl_redisplay();
break;
case SIGTERM:
if (__terminated == 0) {
rl_replace_line("", 0);
rl_crlf();
g_main_loop_quit(event_loop);
}
__terminated = 1;
break;
}
return TRUE;
}
int
adapt_tty_winsize(int from_fd, int to_fd)
{
int ret;
struct winsize old_winsize = winsize;
ret = ioctl(from_fd, TIOCGWINSZ, &winsize);
DPRINTF1(DEBUG_SIGNALS, "ioctl (..., TIOCGWINSZ) = %d", ret);
if (winsize.ws_col != old_winsize.ws_col || winsize.ws_row != old_winsize.ws_row) {
DPRINTF4(DEBUG_SIGNALS, "ws.col: %d -> %d, ws.row: %d -> %d", old_winsize.ws_col, winsize.ws_col, old_winsize.ws_row, winsize.ws_row);
if (always_readline &&!dont_wrap_command_waits()) /* if --always_readline option is set, the client will probably spew a */
deferred_adapt_commands_window_size = TRUE; /* volley of control chars at us when its terminal is resized. Hence we don't do it now */
else {
ret = ioctl(to_fd, TIOCSWINSZ, &winsize);
DPRINTF1(DEBUG_SIGNALS, "ioctl (..., TIOCSWINSZ) = %d", ret);
}
DPRINTF2(DEBUG_READLINE, "rl_prompt: %s, line_buffer: %s", mangle_string_for_debug_log(rl_prompt, 100), rl_line_buffer);
rl_set_screen_size(winsize.ws_row, winsize.ws_col); /* this is safe: we know that right now rlwrap is not calling
the readline library because we keep SIGWINCH blocked all the time */
if (!within_line_edit && !skip_rlwrap()) {
wipe_textarea(&old_winsize);
received_WINCH = TRUE; /* we can't start line edit in signal handler, so we only set a flag */
} else if (within_line_edit) { /* try to keep displayed line tidy */
wipe_textarea(&old_winsize);
rl_on_new_line();
rl_redisplay();
}
return (!always_readline || dont_wrap_command_waits()); /* pass the signal on (except when always_readline is set and command is not waiting) */
} else { /* window size has not changed */
return FALSE;
}
}
int cli_init(sd_bus *bus, const struct cli_cmd *cmds)
{
static const int sigs[] = {
SIGINT, SIGTERM, SIGQUIT, SIGHUP, SIGPIPE, SIGCHLD, 0
};
unsigned int i;
sigset_t mask;
int r;
if (cli_event)
return cli_EINVAL();
r = sd_event_default(&cli_event);
if (r < 0) {
cli_vERR(r);
goto error;
}
cli_cmds = cmds;
cli_bus = bus;
r = sd_bus_attach_event(cli_bus, cli_event, 0);
if (r < 0) {
cli_vERR(r);
goto error;
}
for (i = 0; sigs[i]; ++i) {
sigemptyset(&mask);
sigaddset(&mask, sigs[i]);
sigprocmask(SIG_BLOCK, &mask, NULL);
r = sd_event_add_signal(cli_event,
&cli_sigs[i],
sigs[i],
cli_signal_fn,
NULL);
if (r < 0) {
cli_vERR(r);
goto error;
}
}
r = sd_event_add_io(cli_event,
&cli_stdin,
fileno(stdin),
EPOLLHUP | EPOLLERR | EPOLLIN,
cli_stdin_fn,
NULL);
if (r < 0) {
cli_vERR(r);
goto error;
}
cli_rl = true;
rl_erase_empty_line = 1;
rl_callback_handler_install(NULL, cli_handler_fn);
rl_set_prompt(CLI_PROMPT);
printf("\r");
rl_on_new_line();
rl_redisplay();
return 0;
error:
cli_destroy();
return r;
}
int main(int argc,char *argv[])
{
int c;
int port=-1;
int len=0;
char *ptr;
char bfr[8192];
while((c=getopt(argc,argv,"p:"))!=-1)switch(c)
{
case 'p':
port=atoi(optarg);
break;
}
if(port<1||port>65535)
{
fprintf(stderr,"Illegal port\n");
return 1;
}
p[0].fd=0;
p[0].events=POLLIN;
if((p[1].fd=mklisten(port))==-1)return 1;
p[1].events=POLLIN;
p[2].fd=-1;
p[2].events=POLLIN;
rl_bind_key ('\t',rl_insert);
rl_callback_handler_install("> ",docmd);
while(running)
{
p[2].revents=0;
if(poll(p,p[2].fd==-1?2:3,-1)<=0)continue;
if(p[0].revents&POLLHUP)break;
if(p[0].revents&POLLIN)rl_callback_read_char();
if(p[1].revents&POLLIN)
if((c=accept(p[1].fd,NULL,NULL))!=-1)
{
if(p[2].fd!=-1)close(p[2].fd);
p[2].revents=0;
p[2].fd=c;
len=0;
c=1;
ioctl(p[2].fd,FIONBIO,&c);
#if defined(TCP_KEEPCNT) && defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL)
c=2;
setsockopt(p[2].fd,IPPROTO_TCP,TCP_KEEPCNT,
&c,sizeof(c));
c=90;
setsockopt(p[2].fd,IPPROTO_TCP,TCP_KEEPIDLE,
&c,sizeof(c));
c=90;
setsockopt(p[2].fd,IPPROTO_TCP,TCP_KEEPINTVL,
&c,sizeof(c));
c=1;
setsockopt(p[2].fd,SOL_SOCKET,SO_KEEPALIVE,
&c,sizeof(c));
#endif
}
if(p[2].revents&POLLHUP)
{
close(p[2].fd);
p[2].fd=-1;
}
else if(p[2].revents&POLLIN)
{
if((c=read(p[2].fd,bfr+len,sizeof(bfr)-len))<=0)
{
close(p[2].fd);
p[2].fd=-1;
}
else
{
len+=c;
for(ptr=bfr,c=0;c<len;c++)if(bfr[c]=='$')
{
bfr[c]=0;
printf("\n%s$",ptr);
ptr=bfr+c+1;
}
if(ptr!=bfr)
{
printf("\n");
rl_on_new_line();
rl_redisplay();
if(ptr<bfr+len)
{
len=bfr+len-ptr;
memmove(bfr,ptr,len);
}
else len=0;
}
if(len==sizeof(bfr))
{
close(p[2].fd);
p[2].fd=-1;
}
}
}
}
close(p[1].fd);
if(p[2].fd!=-1)
{
close(p[2].fd);
p[2].fd=-1;
}
rl_set_prompt("");
rl_replace_line("",0);
rl_redisplay();
rl_callback_handler_remove();
return 0;
}
void restart(void)
{
rl_on_new_line();
}
int
main(int argc, char *argv[])
{
int echo = 0;
#ifdef notyet
int print_statistics = 0;
#endif
int fipsflagger = 0;
int perfstats = 0;
int no_prompt = 0;
int use_encryption = 0;
int chained_transactions = 0;
const char *cmdend = "go";
int headers = 0;
char *columnwidth = NULL;
const char *colseparator = " ";
const char *lineseparator = "\n";
int timeout = 0;
char *username = NULL;
char *password = NULL;
char *server = NULL;
DBCHAR *char_set = NULL;
const char *editor;
char *hostname = NULL;
char *sqlch;
char *interfaces_filename = NULL;
char *input_filename = NULL;
char *output_filename = NULL;
int logintime = -1;
char *language = NULL;
int size = 0;
char *sybenv;
DBPROCESS *dbproc;
LOGINREC *login;
char **ibuf = NULL;
int ibuflines = 0;
int printedlines;
int i;
char *line;
int dbrc;
char foobuf[512];
char *firstword;
char *cp;
int c;
int errflg = 0;
char *prbuf;
int prbuflen;
FILE *fp;
FILE *tmpfp;
FILE *tmpfp2;
char *tfn;
char tmpfn[256];
int num_cols;
int selcol;
int col;
int collen;
DBINT colid;
const char *opname;
char adbuf[512];
DBINT convlen;
int printedcompute = 0;
char adash;
const char *database_name = NULL;
int default_exit = EXIT_SUCCESS;
setlocale(LC_ALL, "");
#ifdef __VMS
/* Convert VMS-style arguments to Unix-style */
parse_vms_args(&argc, &argv);
#endif
editor = getenv("EDITOR");
if (!editor) {
editor = getenv("VISUAL");
}
if (!editor) {
editor = "vi";
}
opterr = 0;
optarg = NULL;
while (!errflg && (c = getopt(argc, argv, "eFgpnvXYa:c:D:E:h:H:i:I:J:l:m:o:P:s:S:t:U:w:y:z:A:"))
!= -1) {
switch (c) {
case 'e':
echo = 1;
break;
case 'F':
fipsflagger = 1;
break;
case 'g':
errflg++;
break;
case 'p':
errflg++;
perfstats = 1;
break;
case 'n':
no_prompt = 1;
break;
case 'v':
puts("fisql, a free isql replacement by Nicholas S. Castellano");
exit(EXIT_SUCCESS);
break;
case 'X':
/* XXX: We get a different error message than isql gives; neither seems
* to work
*/
use_encryption = 1;
break;
case 'Y':
chained_transactions = 1;
break;
case 'c':
cmdend = optarg;
break;
case 'E':
editor = optarg;
break;
case 'h':
headers = atoi(optarg);
break;
case 'H':
hostname = optarg;
break;
case 'i':
input_filename = optarg;
break;
case 'I':
interfaces_filename = optarg;
break;
case 'J':
errflg++;
break;
case 'l':
logintime = atoi(optarg);
break;
case 'm':
global_errorlevel = atoi(optarg);
break;
case 'o':
output_filename = optarg;
break;
case 'P':
password = optarg;
break;
case 's':
colseparator = optarg;
break;
case 'S':
server = optarg;
break;
case 't':
timeout = atoi(optarg);
break;
case 'U':
username = optarg;
break;
case 'w':
columnwidth = optarg;
break;
case 'y':
/* XXX: this doesn't seem to be what isql does with -y...it doesn't
* seem to do anything actually
*/
sybenv = (char *) xmalloc((strlen(optarg) + 8) * sizeof(char));
strcpy(sybenv, "SYBASE=");
strcat(sybenv, optarg);
putenv(sybenv);
break;
case 'z':
language = optarg;
break;
case 'A':
size = atoi(optarg);
break;
case 'D':
database_name = optarg;
break;
default:
errflg++;
break;
}
}
if (errflg) {
fprintf(stderr, "usage: fisql [-e] [-F] [-g] [-p] [-n] [-v] [-X] [-Y]\n");
fprintf(stderr, "\t[-c cmdend] [-D database_name] [-E editor]\n");
fprintf(stderr, "\t[-h headers] [-H hostname] [-i inputfile]\n");
fprintf(stderr, "\t[-I interfaces_file] [-J client character set]\n");
fprintf(stderr, "\t[-l login_timeout] [-m errorlevel]\n");
fprintf(stderr, "\t[-o outputfile]\n");
fprintf(stderr, "\t[-P password] [-s colseparator] [-S server]\n");
fprintf(stderr, "\t[-t timeout] [-U username] [-w columnwidth]\n");
fprintf(stderr, "\t[-y sybase_dir] [-z language]\n");
exit(EXIT_FAILURE);
}
if (!(isatty(fileno(stdin)))) {
no_prompt = 1;
rl_outstream = fopen("/dev/null", "rw");
}
rl_readline_name = "fisql";
rl_bind_key('\t', rl_insert);
if (password == NULL) {
password = (char *) xmalloc(READPASSPHRASE_MAXLEN);
readpassphrase("Password: "******"r", stdin) == NULL) {
/* XXX: sybase isql generates this error while parsing the options,
* but doesn't redirect the input until after the Password: prompt
*/
/* lack of newline for bug-compatibility with isql */
fprintf(stderr, "Unable to open input file '%s'.", optarg);
exit(EXIT_FAILURE);
}
}
if (output_filename) {
if (freopen(output_filename, "w", stdout) == NULL) {
/* XXX: sybase isql generates this error while parsing the options,
* but doesn't redirect the output until after the Password: prompt
*/
/* lack of newline for bug-compatibility with isql */
fprintf(stderr, "Unable to open output file '%s'.", output_filename);
exit(EXIT_FAILURE);
}
}
if (isatty(fileno(stdin))) {
rl_outstream = stdout;
}
dbinit();
#if 0
#ifdef DBVERSION_100
dbsetversion(DBVERSION_100);
#endif
#endif
if ((login = dblogin()) == NULL) {
reset_term();
exit(EXIT_FAILURE);
}
dbmsghandle(msg_handler);
dberrhandle(err_handler);
DBSETLAPP(login, "fisql");
if (username) {
DBSETLUSER(login, username);
}
DBSETLPWD(login, password);
memset(password, 0, strlen(password));
if (char_set) {
DBSETLCHARSET(login, char_set);
}
if (use_encryption) {
DBSETLENCRYPT(login, TRUE);
}
if (hostname) {
DBSETLHOST(login, hostname);
}
if (language) {
DBSETLNATLANG(login, language);
}
if (size) {
DBSETLPACKET(login, (short) size);
}
if (interfaces_filename) {
dbsetifile(interfaces_filename);
}
dbsettime(timeout);
if (logintime >= 0) {
dbsetlogintime(logintime);
}
if ((dbproc = dbopen(login, server)) == NULL) {
fprintf(stderr, "fisql: dbopen() failed.\n");
reset_term();
exit(EXIT_FAILURE);
}
dbsetopt(dbproc, DBPRLINESEP, lineseparator, strlen(lineseparator));
if (colseparator) {
dbsetopt(dbproc, DBPRCOLSEP, colseparator, strlen(colseparator));
}
if (columnwidth) {
dbsetopt(dbproc, DBPRLINELEN, columnwidth, 0);
}
if (chained_transactions) {
dbsetopt(dbproc, DBCHAINXACTS, NULL, 0);
}
if (fipsflagger) {
dbsetopt(dbproc, DBFIPSFLAG, NULL, 0);
}
if (perfstats) {
dbsetopt(dbproc, DBSTAT, "time", 0);
}
if (database_name) {
dbuse(dbproc, database_name);
}
while (1) {
if (sigsetjmp(restart, 1)) {
if (ibuf) {
for (i = 0; i < ibuflines; i++) {
free(ibuf[i]);
}
ibuflines = 0;
free(ibuf);
ibuf = NULL;
}
fputc('\n', stdout);
rl_on_new_line();
rl_reset_line_state();
}
dbcancel(dbproc);
signal(SIGINT, inactive_interrupt_handler);
ibuf = (char **) xmalloc(sizeof(char *));
ibuflines = 0;
while (1) {
if (no_prompt) {
foobuf[0] = '\0';
} else {
sprintf(foobuf, "%d>> ", ibuflines + 1);
}
line = readline(foobuf);
if (line == NULL) {
line = "exit";
}
for (cp = line; *cp && isspace((unsigned char) *cp); cp++)
continue;
if (*cp) {
add_history(line);
}
if (!(strncasecmp(line, "!!", 2))) {
int rv;
cp = line + 2;
switch (rv = system(cp)) {
case 0:
continue;
case -1:
fprintf(stderr,
"Failed to execute `%s'\n", cp);
continue;
default:
fprintf(stderr, "Command `%s' exited "
"with code %d\n", cp, rv);
continue;
}
}
/* XXX: isql off-by-one line count error for :r not duplicated */
if (!(strncasecmp(line, ":r", 2))) {
for (cp = line + 2; *cp && (isspace((unsigned char) *cp)); cp++)
continue;
tfn = cp;
for (; *cp && !(isspace((unsigned char) *cp)); cp++)
continue;
*cp = '\0';
if ((fp = fopen(tfn, "r")) == NULL) {
fprintf(stderr, "Operating system error: Failed to open %s.\n", tfn);
continue;
}
tmpfp = rl_instream;
tmpfp2 = rl_outstream;
rl_instream = fp;
rl_outstream = fopen("/dev/null", "w");
while ((line = readline("")) != NULL) {
ibuf[ibuflines++] = line;
ibuf = (char **) xrealloc(ibuf, (ibuflines + 1) * sizeof(char *));
}
rl_instream = tmpfp;
fclose(rl_outstream);
rl_outstream = tmpfp2;
fclose(fp);
fputc('\r', stdout);
fflush(stdout);
continue;
}
firstword = (char *) xmalloc((strlen(line) + 1) * sizeof(char));
strcpy(firstword, line);
for (cp = firstword; *cp; cp++) {
if (isspace((unsigned char) *cp)) {
*cp = '\0';
break;
}
}
if ((!(strcasecmp(firstword, "exit")))
|| (!(strcasecmp(firstword, "quit")))) {
reset_term();
dbexit();
exit(default_exit);
}
if (!(strcasecmp(firstword, "reset"))) {
for (i = 0; i < ibuflines; i++) {
free(ibuf[i]);
}
ibuflines = 0;
continue;
}
if (!(strcasecmp(firstword, cmdend))) {
if (ibuflines == 0) {
continue;
}
free(firstword);
break;
}
if ((!(strcasecmp(firstword, "vi")))
|| (!(strcasecmp(firstword, editor)))) {
int tmpfd;
strcpy(tmpfn, "/tmp/fisqlXXXXXX");
tmpfd = mkstemp(tmpfn);
if ((fp = fdopen(tmpfd, "w")) == NULL) {
perror("fisql");
reset_term();
dbexit();
exit(2);
}
if (ibuflines) {
for (i = 0; i < ibuflines; i++) {
fputs(ibuf[i], fp);
fputc('\n', fp);
free(ibuf[i]);
}
} else {
for (i = 0; ((sqlch = dbgetchar(dbproc, i)) != NULL); i++) {
fputc(*sqlch, fp);
}
}
fclose(fp);
if (!(strcmp(firstword, "vi"))) {
edit("vi", tmpfn);
} else {
edit(editor, tmpfn);
}
ibuflines = 0;
fp = fopen(tmpfn, "r");
tmpfp = rl_instream;
rl_instream = fp;
strcpy(foobuf, "1>> ");
while ((line = readline(foobuf)) != NULL) {
ibuf[ibuflines++] = line;
sprintf(foobuf, "%d>> ", ibuflines + 1);
ibuf = (char **) xrealloc(ibuf, (ibuflines + 1) * sizeof(char *));
}
rl_instream = tmpfp;
fclose(fp);
fputc('\r', stdout);
fflush(stdout);
unlink(tmpfn);
continue;
}
free(firstword);
ibuf[ibuflines++] = line;
ibuf = (char **) xrealloc(ibuf, (ibuflines + 1) * sizeof(char *));
}
dbfreebuf(dbproc);
for (i = 0; i < ibuflines; i++) {
if (echo) {
puts(ibuf[i]);
}
dbcmd(dbproc, ibuf[i]);
dbcmd(dbproc, "\n");
free(ibuf[i]);
}
free(ibuf);
ibuf = NULL;
signal(SIGINT, active_interrupt_handler);
dbsetinterrupt(dbproc, (void *) active_interrupt_pending, (void *) active_interrupt_servhandler);
if (dbsqlexec(dbproc) == SUCCEED) {
maybe_handle_active_interrupt();
while ((dbrc = dbresults(dbproc)) != NO_MORE_RESULTS) {
printedlines = 0;
#define USE_DBPRROW 0
#if USE_DBPRROW
dbprhead(dbproc);
dbprrow(dbproc);
#else
if ((dbrc == SUCCEED) && (DBROWS(dbproc) == SUCCEED)) {
prbuflen = dbspr1rowlen(dbproc);
prbuf = (char *) xmalloc(prbuflen * sizeof(char));
dbsprhead(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
dbsprline(dbproc, prbuf, prbuflen, '-');
fputs(prbuf, stdout);
fputc('\n', stdout);
maybe_handle_active_interrupt();
while ((dbrc = dbnextrow(dbproc)) != NO_MORE_ROWS) {
if (dbrc == FAIL) {
break;
}
if (dbrc != REG_ROW) {
num_cols = dbnumalts(dbproc, dbrc);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
opname = dbprtype(dbaltop(dbproc, dbrc, col));
printf("%s", opname);
collen = get_printable_column_size(dbproc, colid);
collen -= strlen(opname);
while (collen-- > 0) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
collen = get_printable_column_size(dbproc, colid);
adash = '-';
for (i = 0; i < collen; i++) {
putchar(adash);
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
for (selcol = col = 1; col <= num_cols; col++) {
colid = dbaltcolid(dbproc, dbrc, col);
while (selcol < colid) {
collen = get_printable_column_size(dbproc, selcol);
for (i = 0; i < collen; i++) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
convlen = dbconvert(dbproc,
dbalttype(dbproc, dbrc, col),
dbadata(dbproc, dbrc, col),
dbadlen(dbproc, dbrc, col),
SYBCHAR, (BYTE *) adbuf, sizeof(adbuf));
printf("%.*s", (int) convlen, adbuf);
collen = get_printable_column_size(dbproc, colid);
collen -= convlen;
while (collen-- > 0) {
putchar(' ');
}
selcol++;
printf("%s", colseparator);
}
printf("%s", lineseparator);
printedcompute = 1;
continue;
}
if (printedcompute || (headers && (printedlines >= headers)
&& ((printedlines % headers) == 0))) {
fputc('\n', stdout);
dbsprhead(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
dbsprline(dbproc, prbuf, prbuflen, '-');
fputs(prbuf, stdout);
fputc('\n', stdout);
printedcompute = 0;
}
printedlines++;
dbspr1row(dbproc, prbuf, prbuflen);
fputs(prbuf, stdout);
fputc('\n', stdout);
maybe_handle_active_interrupt();
}
fputc('\n', stdout);
free(prbuf);
maybe_handle_active_interrupt();
}
#endif
if (dbrc != FAIL) {
if ((DBCOUNT(dbproc) >= 0) || dbhasretstat(dbproc)) {
if (DBCOUNT(dbproc) >= 0) {
fprintf(stdout, "(%d rows affected", (int) DBCOUNT(dbproc));
if (dbhasretstat(dbproc)) {
dbrc = dbretstatus(dbproc);
fprintf(stdout, ", return status = %d", dbrc);
}
fprintf(stdout, ")\n");
} else {
if (dbhasretstat(dbproc)) {
dbrc = dbretstatus(dbproc);
fprintf(stdout, "(return status = %d)\n", dbrc);
}
}
}
}
}
} else {
/* Something failed, so change the default
* exit status to reflect that.
*/
default_exit = EXIT_FAILURE;
}
}
reset_term();
dbexit();
exit(EXIT_FAILURE);
return (0);
}
/* field completion function */
static char *
rl_complete_field(char *text, int state)
{
static struct ph_fieldinfo *phfield;
static int namecounter;
static int textlen;
int debug;
if (!state)
{
phfield = NULL;
textlen = strlen(text);
if (!ph_is_fieldinfo_cached(ph))
{
get_option("debug", &debug);
if (debug)
{
putchar('\n');
rl_on_new_line();
}
if (ph_retrieve_fieldinfo(ph) == -1)
{
perror("ph_retrieve_fieldinfo()");
return NULL;
}
if (debug)
rl_redisplay();
#ifdef DEBUG
printf("==> rl_complete_field(\"%s\")\n", text);
#endif
}
}
else
namecounter++;
while (1)
{
if (phfield != NULL)
for (;
phfield->pf_fnames[namecounter] != NULL;
namecounter++)
{
#ifdef DEBUG
printf("rl_complete_field(): "
"phfield->pf_fnames[%d] = \"%s\"\n",
namecounter,
phfield->pf_fnames[namecounter]);
#endif
if (strncasecmp(phfield->pf_fnames[namecounter],
text, textlen) == 0)
return strdup(phfield->pf_fnames[namecounter]);
}
if (ph_fieldinfo_iterate(ph, &phfield) != 1)
break;
namecounter = 0;
}
return NULL;
}
static int
handle_hotkey2(int UNUSED(count), int hotkey, int ignore_history)
{
char *prefix, *postfix, *history, *histpos_as_string, *executing_keyseq;
char *new_prefix, *new_postfix, *new_history, *new_histpos_as_string, *message;
char *filter_food, *filtered, **fragments, *new_rl_line_buffer;
int length, new_histpos;
unsigned long int hash;
static const unsigned int MAX_HISTPOS_DIGITS = 6; /* one million history items should suffice */
#ifdef HAVE_RL_EXECUTING_KEYSEQ /* i.e. if readline version is >= 6.3 */
executing_keyseq = mysavestring(rl_executing_keyseq);
#else
executing_keyseq = mysavestring("?");
*executing_keyseq = hotkey; /* The filter will only get the *last* byte of the key sequence that triggered rl_handle_hotkey */
#endif
DPRINTF3(DEBUG_READLINE, "hotkey press (ignore_history == %d): %x (%s)", ignore_history, hotkey, mangle_string_for_debug_log(executing_keyseq, MANGLE_LENGTH));
if (hotkey == '\t') /* this would go horribly wrong with all the splitting on '\t' going on.... @@@ or pass key as a string e.g. "009" */
myerror(FATAL | NOERRNO, "Sorry, you cannot use TAB as an hotkey in rlwrap");
prefix = mysavestring(rl_line_buffer);
prefix[rl_point] = '\0'; /* chop off just before cursor */
postfix = mysavestring(rl_line_buffer + rl_point);
if (ignore_history) {
histpos_as_string = mysavestring("0");
history = mysavestring("");
} else {
histpos_as_string = as_string(where_history());
assert(strlen(histpos_as_string) <= MAX_HISTPOS_DIGITS);
history = entire_history_as_one_string();
hash = hash_multiple(2, history, histpos_as_string);
}
/* filter_food = key + tab + prefix + tab + postfix + tab + history + tab + histpos + '\0' */
length = strlen(rl_line_buffer) + strlen(history) + MAX_HISTPOS_DIGITS + 5;
filter_food = mymalloc(length);
sprintf(filter_food, "%s\t%s\t%s\t%s\t%s", executing_keyseq, prefix, postfix, history, histpos_as_string); /* this is the format that the filter expects */
/* let the filter filter ...! */
filtered= pass_through_filter(TAG_HOTKEY, filter_food);
/* OK, we now have to read back everything. There should be exactly 5 TAB-separated components*/
fragments = split_on_single_char(filtered, '\t', 5);
message = fragments[0];
new_prefix = fragments[1];
new_postfix = fragments[2];
new_history = fragments[3];
new_histpos_as_string = fragments[4];
if (!ignore_history && hash_multiple(2, new_history, new_histpos_as_string) != hash) { /* history has been rewritten */
char **linep, **history_lines = split_on_single_char(new_history, '\n', 0);
DPRINTF3(DEBUG_READLINE, "hash=%lx, new_history is %d bytes long, histpos <%s>", hash, (int) strlen(new_history), new_histpos_as_string);
clear_history();
for (linep = history_lines; *linep; linep++)
add_history(*linep);
new_histpos = my_atoi(new_histpos_as_string);
history_set_pos(new_histpos);
free_splitlist(history_lines);
}
new_rl_line_buffer = add2strings(new_prefix, new_postfix);
if ( (length = strlen(new_rl_line_buffer)) > 0 && new_rl_line_buffer[length - 1] == '\n') {
new_rl_line_buffer[length - 1] = '\0';
rl_done = TRUE;
return_key = (char) '\n';
assert(strchr(new_rl_line_buffer, '\n') == NULL);
}
rl_delete_text(0, strlen(rl_line_buffer));
rl_point = 0;
rl_insert_text(new_rl_line_buffer);
rl_point = strlen(new_rl_line_buffer);
if (*message && *message != hotkey) { /* if message has been set (i.e. != hotkey) , and isn't empty: */
message = append_and_free_old(mysavestring(message), " "); /* put space (for readability) between the message and the input line .. */
message_in_echo_area(message); /* .. then write it to echo area */
}
clear_line();
rl_on_new_line();
rl_redisplay();
free_splitlist(fragments); /* this will free all the fragments (and the list itself) in one go */
free_multiple(prefix, postfix, filter_food, executing_keyseq, filtered, new_rl_line_buffer, history, histpos_as_string, FMEND);
return 0;
}
void edit_redraw(void)
{
rl_on_new_line();
rl_redisplay();
}
int main(int argc, char** argv)
{
extern char *optarg;
char command[200];
char* res;
int ret=0;
int sysret=0;
int i=0;
if (sem_init(&Write_sem, 0, 0) == -1)
handle_error("Writesem_init");
if (sem_init(&Read_sem, 0, 0) == -1)
handle_error("Readsem_init");
/* Defaults */
strcpy(LibraryPath,"/usr/lib/libcanfestival_can_peak_linux.so");
strcpy(BoardBusName,"0");
strcpy(BoardBaudRate,"1M");
/* Init stack timer */
TimerInit();
if (argc > 1){
printf("ok\n");
/* Strip command-line*/
for(i=1 ; i<argc ; i++)
{
if(ProcessCommand(argv[i]) == INIT_ERR) goto init_fail;
}
}
NodeInit(0,1);
RegisterSetODentryCallBack(CANOpenShellOD_Data, 0x2003, 0, &OnStatus3Update);
help_menu();
CurrentNode = 3;
sleep(1);
//setState(CANOpenShellOD_Data, Operational); // Put the master in operational mode
stopSYNC(CANOpenShellOD_Data);
/* Enter in a loop to read stdin command until "quit" is called */
while(ret != QUIT)
{
// wait on stdin for string command
rl_on_new_line ();
res = rl_gets();
//sysret = system(CLEARSCREEN);
if(res[0]=='.'){
ret = ProcessCommand(res+1);
}
else if(res[0]==','){
ret = ProcessFocusedCommand(res+1);
}
else if (res[0]=='\n'){
}
else {
EnterMutex();
SDO_write(CANOpenShellOD_Data,CurrentNode,0x1023,0x01,strlen(res),visible_string, res, 0);
EnterMutex();
SDO_read(CANOpenShellOD_Data,CurrentNode,0x1023,0x03,visible_string,0);
printf("%s\n",SDO_read_data);
}
fflush(stdout);
usleep(500000);
}
printf("Finishing.\n");
// Stop timer thread
StopTimerLoop(&Exit);
/* Close CAN board */
canClose(CANOpenShellOD_Data);
init_fail:
TimerCleanup();
return 0;
}
