Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/usr.sbin/sushi/scanform.c

1360 lines
31 KiB
C
Raw Blame History

/* $NetBSD: scanform.c,v 1.8 2001/01/24 07:46:23 garbled Exp $ */
/*
* Copyright (c) 2000 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Copyright (c) 2000 Tim Rightnour <garbled@netbsd.org>
*
* 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.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/cdefs.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <ctype.h>
#include <dirent.h>
#include <err.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <curses.h>
#include <form.h>
#include <cdk/cdk.h>
#include "sushi.h"
#include "functions.h"
#include "scanform.h"
#include "formtree.h"
#include "handlers.h"
#include "run.h"
#include "blabel.h"
extern func_record func_map[];
extern CDKSCREEN *cdkscreen;
extern struct winsize ws;
extern nl_catd catalog;
extern char *lang_id;
extern char *keylabel[10];
extern chtype keybinding[10];
static void scan_formindex(struct cqForm *cqf, char *row);
static void
form_status(FORM *form)
{
char buf[20];
wstandout(stdscr);
mvwaddstr(stdscr, ws.ws_row-3, 0, catgets(catalog, 4, 9,
"PGUP/PGDN to change page, UP/DOWN switch field, ENTER=Do."));
wstandend(stdscr);
sprintf(buf, "%s (%d/%d)", catgets(catalog, 4, 8, "Form Page:"),
form_page(form)+1, form->max_page);
mvwaddstr(stdscr, ws.ws_row-3, 60, buf);
wrefresh(stdscr);
}
static int
scan_form(struct cqForm *cqf, char *path)
{
FILE *filep;
int lcnt;
char *p, *t;
size_t len;
if((filep = fopen(path, "r"))) {
for (lcnt = 1; (p = fgetln(filep, &len)) != NULL; ++lcnt) {
if (len == 1) /* Skip empty lines. */
continue;
if (p[len - 1] == '#') /* Skip remarked lines. */
continue;
if (p[len - 1] != '\n') {/* Skip corrupted lines. */
warnx("%s: line %d corrupted", path, lcnt);
continue;
}
p[len - 1] = '\0'; /* Terminate the line. */
/* Skip leading spaces. */
for (; *p != '\0' && isspace((unsigned char)*p); ++p);
/* Skip empty/comment lines. */
if (*p == '\0' || *p == '#')
continue;
/* Find first token. */
for (t = p; *t && !isspace((unsigned char)*t); ++t);
if (*t == '\0') /* Need more than one token.*/
continue;
*t = '\0';
scan_formindex(cqf, p);
}
fclose(filep);
} else
return(1);
return(0);
}
static void
form_appenditem(struct cqForm *cqf, char *desc, int type, char *data, int req)
{
FTREE_ENTRY *fte;
if ((fte = malloc(sizeof(FTREE_ENTRY))) == NULL ||
((fte->desc = strdup(desc)) == NULL) ||
((fte->type = type) == NULL) ||
((fte->data = strdup(data)) == NULL) ||
((fte->list = malloc(sizeof(char *)*2)) == NULL))
bailout("malloc: %s", strerror(errno));
fte->required = req;
fte->elen = 0;
CIRCLEQ_INIT(&fte->cqSubFormHead);
CIRCLEQ_INSERT_TAIL(cqf, fte, cqFormEntries);
}
static void
scan_formindex(struct cqForm *cqf, char *row)
{
char *t = row;
char *x;
char desc[80];
int type;
char data[80];
int req = 0;
while (*++t && !isspace((unsigned char)*t));
x = (char *)strsep(&row, ":");
if (strcmp(x, "entry") == 0)
type = DATAT_ENTRY;
else if (strcmp(x, "req-entry") == 0) {
type = DATAT_ENTRY;
req = 1;
} else if (strcmp(x, "escript") == 0)
type = DATAT_ESCRIPT;
else if (strcmp(x, "req-escript") == 0) {
type = DATAT_ESCRIPT;
req = 1;
} else if (strcmp(x, "nescript") == 0)
type = DATAT_NESCRIPT;
else if (strcmp(x, "list") == 0)
type = DATAT_LIST;
else if (strcmp(x, "multilist") == 0)
type = DATAT_MLIST;
else if (strcmp(x, "req-list") == 0) {
type = DATAT_LIST;
req = 1;
} else if (strcmp(x, "blank") == 0)
type = DATAT_BLANK;
else if (strcmp(x, "func") == 0)
type = DATAT_FUNC;
else if (strcmp(x, "multifunc") == 0)
type = DATAT_MFUNC;
else if (strcmp(x, "req-func") == 0) {
type = DATAT_FUNC;
req = 1;
} else if (strcmp(x, "script") == 0)
type = DATAT_SCRIPT;
else if (strcmp(x, "multiscript") == 0)
type = DATAT_MSCRIPT;
else if (strcmp(x, "req-script") == 0) {
type = DATAT_SCRIPT;
req = 1;
} else if (strcmp(x, "noedit") == 0)
type = DATAT_NOEDIT;
else if (strcmp(x, "invis") == 0)
type = DATAT_INVIS;
else if (strcmp(x, "integer") == 0)
type = DATAT_INTEGER;
else if (strcmp(x, "req-integer") == 0) {
type = DATAT_INTEGER;
req = 1;
} else
bailout("%s: %s",
catgets(catalog, 1, 11, "invalid data type"), x);
snprintf(data, (size_t)(t-row+1), "%s", row);
while (*++t && isspace((unsigned char)*t));
if (strlen(t) > 50)
bailout(catgets(catalog, 1, 12, "description too long"));
snprintf(desc, sizeof(desc), "%s", t);
if (strcmp(desc, "BLANK") == 0)
sprintf(desc, " ");
form_appenditem(cqf, desc, type, data, req);
}
int
form_entries(struct cqForm *cqf)
{
FTREE_ENTRY *fte;
int entries = 0;
for (fte = CIRCLEQ_FIRST(cqf); fte != (void *)cqf;
fte = CIRCLEQ_NEXT(fte, cqFormEntries))
++entries;
return(entries);
}
FTREE_ENTRY *
form_getentry(struct cqForm *cqf, int entry)
{
FTREE_ENTRY *fte;
int entries = 0;
for (fte = CIRCLEQ_FIRST(cqf); (fte != (void *)cqf);
fte = CIRCLEQ_NEXT(fte, cqFormEntries)) {
if(entry == entries)
return(fte);
++entries;
}
return(NULL);
}
void
form_printtree(struct cqForm *cqf)
{
FTREE_ENTRY *ftp;
for (ftp = CIRCLEQ_FIRST(cqf); ftp != (void *)cqf;
ftp = CIRCLEQ_NEXT(ftp, cqFormEntries))
printf("%s\t- %d:%s\n", ftp->desc, ftp->type, ftp->data);
}
/* This is the keymap for the forms */
static int
get_request(WINDOW *w) /* virtual key mapping */
{
static int mode = REQ_INS_MODE;
int c = wgetch(w); /* read a character */
int i;
/* printf("GOT A THINGIE: 0x%x %d\n", c, c); */
/* convert to an FKEY for case */
if (c != 0)
for (i=0; i < 10; i++)
if (c == keybinding[i])
c = KEY_F(i+1);
switch (c) {
case KEY_F(1):
return SHOWHELP;
case KEY_F(2):
return REFRESH;
case KEY_F(3):
return BAIL;
case KEY_F(4):
return GENLIST;
case KEY_F(5):
return RESET;
case KEY_F(6):
return COMMAND;
case KEY_F(7):
return EDIT;
case KEY_F(8):
return DUMPSCREEN;
case KEY_F(9):
return SHELL;
case KEY_F(10):
return FASTBAIL;
case 0x1b: /* ESC */
return BAIL;
case 0x0d:
return QUIT;
case KEY_ENTER:
return QUIT;
case 0xa: /* LF */
return QUIT;
case KEY_NPAGE: /* ^F */
return REQ_NEXT_PAGE;
case KEY_PPAGE: /* ^B */
return REQ_PREV_PAGE;
case KEY_DOWN:
return REQ_NEXT_FIELD;
case KEY_UP:
return REQ_PREV_FIELD;
case 0x06: /* ^F */
return REQ_NEXT_PAGE;
case 0x02: /* ^B */
return REQ_PREV_PAGE;
case 0x0e: /* ^N */
return REQ_NEXT_FIELD;
case 0x10: /* ^P */
return REQ_PREV_FIELD;
case KEY_HOME:
return REQ_FIRST_FIELD;
case KEY_LL:
return REQ_LAST_FIELD;
case 0x0c: /* ^L */
return REQ_LEFT_FIELD;
case 0x12: /* ^R */
return REQ_RIGHT_FIELD;
case 0x15: /* ^U */
return REQ_UP_FIELD;
case 0x04: /* ^D */
return REQ_DOWN_FIELD;
case 0x17: /* ^W */
return REQ_NEXT_WORD;
case 0x14: /* ^T */
return REQ_PREV_WORD;
case 0x01: /* ^A */
return REQ_BEG_FIELD;
case 0x05: /* ^E */
return REQ_END_FIELD;
case KEY_LEFT:
return REQ_LEFT_CHAR;
case KEY_RIGHT:
return REQ_RIGHT_CHAR;
case 0x0f: /* ^O */
return REQ_INS_LINE;
case 0x16: /* ^V */
return REQ_DEL_CHAR;
case 0x08: /* ^H */
return REQ_DEL_PREV;
case 0x19: /* ^Y */
return REQ_DEL_LINE;
case 0x07: /* ^G */
return REQ_DEL_WORD;
case 0x03: /* ^C */
return REQ_CLR_EOL;
case 0x0b: /* ^K */
return REQ_CLR_EOF;
case 0x18: /* ^X */
return REQ_CLR_FIELD;
case 0x9: /* tab*/
return REQ_NEXT_CHOICE;
case 0x1a: /* ^Z 0x1a*/
return REQ_PREV_CHOICE;
case KEY_IC: /* INS */
if (mode == REQ_INS_MODE)
return mode =
REQ_OVL_MODE;
else
return mode =
REQ_INS_MODE;
}
return c;
}
static int
my_driver(FORM * form, int c, char *path)
{
WINDOW *subwindow;
CDKSCROLL *plist;
CDKSELECTION *slist;
CDKENTRY *entry;
FIELD *curfield;
char **list;
int i, j, y, n, dcols, drows, dmax;
char *tmp, *p;
char *choices[] = {" ", "+"};
char buf[1024];
switch (c) {
case EDIT:
curfield = current_field(form);
if (field_opts(curfield) & O_STATIC) {
field_info(curfield, &drows, &dcols, &j, &j, &j, &j);
dmax = 0;
} else
dynamic_field_info(curfield, &drows, &dcols, &dmax);
if (dmax == 0)
dmax = dcols;
entry = newCDKEntry(cdkscreen, BOTTOM, CENTER,
catgets(catalog, 4, 6, "Enter the field data "
"below, and hit enter to return to the form."),
catgets(catalog, 4, 7, "Data Entry: "),
A_REVERSE, field_pad(curfield), vMIXED, ws.ws_col-20,
0, dmax, TRUE, FALSE);
if (field_buffer(curfield, 0) == NULL)
setCDKEntry(entry, "", 0, dmax, TRUE);
else
setCDKEntry(entry, field_buffer(curfield, 0), 0,
dmax, TRUE);
injectCDKEntry(entry, CDK_BEGOFLINE);
tmp = activateCDKEntry(entry, NULL);
if (entry->exitType == vESCAPE_HIT) {
destroyCDKEntry(entry);
return(FALSE);
}
set_field_buffer(curfield, 0, tmp);
destroyCDKEntry(entry);
return(FALSE);
/* NOTREACHED */
break;
case COMMAND:
/* for now, ignore this.. it's messy */
return(FALSE);
/* NOTREACHED */
break;
case RESET:
return(2); /* hrmmm... */
/* NOTREACHED */
break;
case REFRESH:
touchwin(stdscr);
wrefresh(stdscr);
return(FALSE);
/* NOTREACHED */
break;
case SHELL:
endwin();
system("/bin/sh");
wrefresh(stdscr);
return(FALSE);
/* NOTREACHED */
break;
case DUMPSCREEN:
do_scrdump(NULL, NULL, NULL, NULL);
return(FALSE);
/* NOTREACHED */
break;
case SHOWHELP:
if (simple_lang_handler(path, HELPFILE, handle_help) == -2)
nohelp();
subwindow = form_win(form);
touchwin(subwindow);
wrefresh(subwindow);
return(FALSE);
/* NOTREACHED */
break;
case GENLIST:
/* pull the grand popup list */
curfield = current_field(form);
list = (char **) field_userptr(curfield);
if (list == NULL)
break;
for (i=0, y=0; list[i] != NULL; i++)
if ((strlen(list[i]) + 1) > y)
y = strlen(list[i]) + 1;
if (field_buffer(curfield, 1) == NULL ||
field_buffer(curfield, 0) == NULL)
return(FALSE);
tmp = strdup(field_buffer(curfield, 1));
stripWhiteSpace(vBOTH, tmp);
if (*tmp == 'm') {
slist = newCDKSelection(cdkscreen, RIGHT, CENTER,
RIGHT, 10, y+2,
catgets(catalog, 4, 1, "Select choices"),
list, i, choices, 2, A_REVERSE ,TRUE, FALSE);
tmp = strdup(field_buffer(curfield, 0));
stripWhiteSpace(vBOTH, tmp);
if (*tmp != '\0')
for (p = tmp; p != NULL; p = strsep(&tmp, ","))
for (y = 0; y < i; y++)
if (strcmp(p, list[y]) == 0)
slist->selections[y] = 1;
activateCDKSelection(slist, NULL);
for (y = 0; y < i; y++)
if (slist->selections[y] == 1) {
memset(&buf, '\0', sizeof(buf));
break;
}
for (y = 0, n = 0; y < i; y++)
if (slist->selections[y] == 1) {
n++;
if (n != 1)
sprintf(buf, "%s,", buf);
sprintf(buf, "%s%s", buf, list[y]);
}
tmp = buf;
set_field_buffer(curfield, 0, tmp);
destroyCDKSelection(slist);
} else if (*tmp == 's') {
plist = newCDKScroll(cdkscreen, RIGHT, CENTER, RIGHT,
10, y+2, catgets(catalog, 4, 1, "Select choice"),
list, i, FALSE, A_REVERSE ,TRUE, FALSE);
i = activateCDKScroll(plist, NULL);
if (i != -1)
set_field_buffer(curfield, 0, list[i]);
destroyCDKScroll(plist);
}
return(FALSE);
/* NOTREACHED */
break;
case QUIT:
/* do something useful */
if (form_driver(form, REQ_VALIDATION) == E_OK) {
if (process_form(form, path) == 0)
return TRUE;
else
return(2); /* special meaning */
}
/* NOTREACHED */
break;
case BAIL:
return(TRUE);
/* NOTREACHED */
break;
case FASTBAIL:
endwin();
exit(EXIT_SUCCESS);
break;
}
beep();
return FALSE;
}
static FIELD *
LABEL(FIELD_RECORD *x)
{
char *tmp;
FIELD *f = new_field(1, (int)(strlen(x->v)+2), x->frow, x->fcol, 0, 0);
if (f) {
tmp = malloc(sizeof(char *) * (strlen(x->v)+2));
*tmp = '\0';
if (x->required == 1)
tmp = strcat(tmp, "* ");
else
tmp = strcat(tmp, " ");
tmp = strcat(tmp, x->v);
set_field_buffer(f, 0, tmp);
field_opts_off(f, O_ACTIVE);
if (x->newpage == 1)
set_new_page(f, TRUE);
}
return f;
}
static FIELD *
STRING(FIELD_RECORD *x)
{ /* create a STRING field */
FIELD *f = new_field(x->rows, x->cols, x->frow, x->fcol, 0, 0);
if (f) {
set_field_back(f, A_UNDERLINE);
if (x->newpage == 1)
set_new_page(f, TRUE);
if (x->required == 1)
field_opts_off(f, O_NULLOK);
if (x->bigfield) {
field_opts_off(f, O_STATIC);
set_max_field(f, x->rcols);
}
set_field_buffer(f, 0, x->v);
}
return f;
}
static FIELD *
MULTI(FIELD_RECORD *x)
{ /* create a MULTI field */
FIELD *f = new_field(x->rows, x->cols, x->frow, x->fcol, 0, 1);
if (f) {
set_field_back(f, A_REVERSE);
if (x->newpage == 1)
set_new_page(f, TRUE);
field_opts_off(f, O_STATIC);
field_opts_off(f, O_EDIT);
set_field_userptr(f, x->list);
set_field_buffer(f, 1, "multi");
}
return f;
}
static FIELD *
INTEGER(FIELD_RECORD *x)
{ /* create an INTEGER field */
FIELD *f = new_field(x->rows, x->cols, x->frow, x->fcol, 0, 0);
int pre, min, max;
char *p, *q;
p = strdup(x->v);
q = strsep(&p, ",");
pre = atoi(q);
q = strsep(&p, ",");
min = atoi(q);
max = atoi(p);
if (f) {
set_field_back(f, A_UNDERLINE);
set_field_type(f, TYPE_INTEGER, pre, min, max);
if (x->newpage == 1)
set_new_page(f, TRUE);
if (x->required == 1)
field_opts_off(f, O_NULLOK);
if (x->bigfield)
field_opts_off(f, O_STATIC);
}
return f;
}
static FIELD *
INVIS(FIELD_RECORD *x)
{ /* create an INVIS field */
FIELD *f = new_field(x->rows, x->cols, x->frow, x->fcol, 0, 0);
if (f) {
set_field_buffer(f, 0, x->v);
set_field_opts(f, field_opts(f) & ~(O_ACTIVE|O_VISIBLE));
if (x->newpage == 1)
set_new_page(f, TRUE);
}
return f;
}
static FIELD *
NOEDIT(FIELD_RECORD *x)
{ /* create a NOEDIT field */
FIELD *f = new_field(x->rows, x->cols, x->frow, x->fcol, 0, 0);
if (f) {
set_field_buffer(f, 0, x->v);
set_field_opts(f, field_opts(f) & ~(O_EDIT|O_ACTIVE));
if (x->newpage == 1)
set_new_page(f, TRUE);
if (x->bigfield)
field_opts_off(f, O_STATIC);
}
return f;
}
static FIELD *
ENUM(FIELD_RECORD *x)
{ /* create a ENUM field */
FIELD *f = new_field(x->rows, x->cols, x->frow, x->fcol, 0, 1);
if (f) {
set_field_back(f, A_REVERSE);
set_field_buffer(f, 0, x->list[0]);
set_field_type(f, TYPE_ENUM, x->list, FALSE, FALSE);
set_field_userptr(f, x->list);
if (x->newpage == 1)
set_new_page(f, TRUE);
if (x->required == 1)
field_opts_off(f, O_NULLOK);
field_opts_off(f, O_EDIT);
set_field_buffer(f, 1, "single");
if (x->bigfield)
field_opts_off(f, O_STATIC);
}
return f;
}
static FIELD *fields[MAX_FIELD + 1];
FIELD_RECORD *F;
static int
process_preform(FORM *form, char *path)
{
char file[PATH_MAX];
struct stat sb;
char *p;
int lcnt, i;
FIELD **f;
char **args;
if (lang_id == NULL) {
sprintf(file, "%s/%s", path, FORMFILE);
} else {
sprintf(file, "%s/%s.%s", path, FORMFILE, lang_id);
if (stat(file, &sb) != 0)
sprintf(file, "%s/%s", path, FORMFILE);
}
args = malloc(sizeof(char *) * 2);
if (args == NULL)
bailout("malloc: %s", strerror(errno));
lcnt = field_count(form);
args = realloc(args, sizeof(char *) * (lcnt+1));
f = malloc(sizeof(FIELD *) * lcnt);
if (f == NULL || args == NULL)
bailout("malloc: %s", strerror(errno));
f = form_fields(form);
for (lcnt=0, i=0; f[lcnt] != NULL; lcnt++)
if (F[lcnt].type != (PF_field)LABEL) {
if (field_buffer(f[lcnt], 0) == NULL)
args[i] = "";
else
args[i] = strdup(field_buffer(f[lcnt], 0));
if (args[i] != NULL) {
p = &args[i][strlen(args[i]) - 1];
p--;
while(isspace(*p))
*p-- = '\0';
}
i++;
}
args[i] = NULL;
i = handle_form(path, file, args);
free(args);
return(i);
}
int
process_form(FORM *form, char *path)
{
FILE *fp;
char file[PATH_MAX], file2[PATH_MAX];
struct stat sb;
char *exec, *t, *p;
size_t len;
int lcnt, i;
FIELD **f;
char **args;
/* handle the preform somewhere else */
if (strcmp("pre", form_userptr(form)) == 0)
return(process_preform(form, path));
if (lang_id == NULL) {
sprintf(file, "%s/%s", path, EXECFILE);
sprintf(file2, "%s/%s", path, SCRIPTFILE);
} else {
sprintf(file, "%s/%s.%s", path, EXECFILE, lang_id);
sprintf(file2, "%s/%s.%s", path, SCRIPTFILE, lang_id);
if (stat(file, &sb) != 0)
sprintf(file, "%s/%s", path, EXECFILE);
if (stat(file2, &sb) != 0)
sprintf(file2, "%s/%s", path, SCRIPTFILE);
}
args = malloc(sizeof(char *) * 2);
if (args == NULL)
bailout("malloc: %s", strerror(errno));
if ((fp = fopen(file, "r"))) {
for (lcnt = 1; (exec = fgetln(fp, &len)) != NULL; ++lcnt) {
if (len == 1) /* skip blank */
continue;
if (exec[len - 1] == '#') /* Skip comments */
continue;
if (exec[len - 1] != '\n') { /* corruped? */
warnx("%s: line %d corrupted", path, lcnt);
continue;
}
exec[len - 1] = '\0'; /* NUL terminate */
for (; *exec != '\0' && isspace((unsigned char)*exec);
++exec);
if (*exec == '\0' || *exec == '#')
continue;
p = strsep(&exec, " ");
for (i = 0; p != NULL; p = strsep(&exec, " "), i++) {
args = realloc(args, sizeof(char *) * (i+2));
if (args == NULL)
bailout("realloc: %s", strerror(errno));
args[i] = strdup(p);
}
t = NULL;
}
fclose(fp);
} else if (stat(file2, &sb) == 0) {
t = strdup(file2);
i = 1;
} else
bailout(catgets(catalog, 1, 13, "no files"));
lcnt = field_count(form);
args = realloc(args, sizeof(char *) * (lcnt+1+i));
f = malloc(sizeof(FIELD *) * lcnt);
if (f == NULL || args == NULL)
bailout("malloc: %s", strerror(errno));
f = form_fields(form);
for (lcnt=0; f[lcnt] != NULL; lcnt++)
if (F[lcnt].type != (PF_field)LABEL) {
if (field_buffer(f[lcnt], 0) == NULL)
args[i] = "";
else
args[i] = strdup(field_buffer(f[lcnt], 0));
if (args[i] != NULL) {
p = &args[i][strlen(args[i]) - 1];
p--;
while(isspace(*p))
*p-- = '\0';
}
i++;
}
if (t != NULL)
args[0] = t;
args[i] = NULL;
i = run_prog(1, args);
free(args);
return(i);
}
static FIELD **
make_fields(void)
{ /* create the fields */
FIELD **f = fields;
int i;
for (i = 0; i < MAX_FIELD && F[i].type; ++i, ++f)
*f = (F[i].type)(&F[i]);
*f = (FIELD *) 0;
return fields;
}
struct cqForm cqFormHead, *cqFormHeadp;
static int
tstring(int max, char *string)
{
char hold[10];
char *str;
int cur;
if (max == 0)
return(0);
for (cur=0; cur <= max; cur++) {
sprintf(hold, "@@@%d@@@", cur);
str = strdup(hold);
if (strcmp(str, string) == 0)
return(cur);
}
return(0);
}
static int
strlen_data(FTREE_ENTRY *ftp)
{
int i, j;
char *p, *q;
i = 0;
switch(ftp->type) {
case DATAT_BLANK:
return(1);
/* NOTREACHED */
break;
case DATAT_ENTRY:
case DATAT_ESCRIPT:
return(ftp->elen);
/* NOTREACHED */
break;
case DATAT_LIST:
case DATAT_FUNC:
case DATAT_SCRIPT:
case DATAT_MLIST:
case DATAT_MFUNC:
case DATAT_MSCRIPT:
for (i = 0, j = 0; ftp->list[i] != NULL; i++)
if (strlen(ftp->list[i]) > j)
j = strlen(ftp->list[i]);
return(j);
/* NOTREACHED */
break;
case DATAT_INVIS:
case DATAT_NOEDIT:
case DATAT_NESCRIPT:
return(strlen(ftp->data));
/* NOTREACHED */
break;
case DATAT_INTEGER:
p = strdup(ftp->data);
q = strsep(&p, ",");
return(atoi(q));
/* NOTREACHED */
break;
default:
bailout(catgets(catalog, 1, 14, "invalid field type"));
break;
}
return(1); /* eep! */
}
static void
gen_list(FTREE_ENTRY *ftp, int max, char **args)
{
int i=0;
int cur;
char *p, *q;
ftp->list = malloc(sizeof(char*));
if (ftp->list == NULL)
bailout("malloc: %s", strerror(errno));
for (p = ftp->data; p != NULL;) {
q = (char *)strsep(&p, ",");
if (q != NULL) {
cur = tstring(max, q);
if (cur)
ftp->list[i++] = strdup(args[cur-1]);
else
ftp->list[i++] = strdup(q);
}
ftp->list = realloc(ftp->list, (i+1)*sizeof(char*));
if (ftp->list == NULL)
bailout("realloc: %s", strerror(errno));
}
ftp->list[i] = NULL;
}
static void
gen_func(FTREE_ENTRY *ftp)
{
int i;
char *p, *q;
p = strsep(&ftp->data, ",");
q = strsep(&ftp->data, ",");
for (i=0; func_map[i].funcname != NULL; i++)
if (strcmp(func_map[i].funcname, p) == 0)
break;
if (func_map[i].function == NULL)
bailout("%s: %s",
catgets(catalog, 1, 5, "function not found"), p);
ftp->list = func_map[i].function(q);
}
static void
gen_script(FTREE_ENTRY *ftp, char *dir, int max, char **args)
{
char *p, *q, *comm, *test;
FILE *file;
char buf[PATH_MAX+30];
size_t len;
int i, cur;
q = strdup(ftp->data);
comm = malloc(sizeof(char) * strlen(q));
if (comm == NULL)
bailout("malloc: %s", strerror(errno));
comm = strsep(&q, ",");
if (q != NULL)
for (p=strdup(q); p != NULL && q != NULL; p = strsep(&q, ",")) {
comm = strcat(comm, " ");
for (test=p; *test != '\0'; test++)
if (*test == ',') {
*test = '\0';
break;
}
cur = tstring(max, p);
if (cur) {
comm = realloc(comm, sizeof(char) *
(strlen(comm) + strlen(args[cur-1]) + 1));
if (comm == NULL)
bailout("malloc: %s", strerror(errno));
comm = strcat(comm, args[cur-1]);
} else {
comm = realloc(comm, sizeof(char) *
(strlen(comm) + strlen(p) + 1));
if (comm == NULL)
bailout("malloc: %s", strerror(errno));
comm = strcat(comm, p);
}
}
sprintf(buf, "%s/%s", dir, comm);
file = popen(buf, "r");
if (file == NULL)
bailout("popen: %s", strerror(errno));
ftp->list = malloc(sizeof(char *)*2);
if (ftp->list == NULL)
bailout("malloc: %s", strerror(errno));
for (i=0; (p = fgetln(file, &len)) != NULL; i++ ) {
ftp->list[i] = strdup(p);
ftp->list[i][len -1] = '\0';
ftp->list = realloc(ftp->list, sizeof(char *) * (i+2));
if (ftp->list == NULL)
bailout("realloc: %s", strerror(errno));
}
ftp->list[i] = NULL;
pclose(file);
}
static char *
gen_escript(FTREE_ENTRY *ftp, char *dir, int max, char **args)
{
char *p, *q, *test, *comm;
FILE *file;
char buf[PATH_MAX+30];
size_t len;
int cur;
q = strdup(ftp->data);
comm = malloc(sizeof(char) * strlen(q));
if (comm == NULL)
bailout("malloc: %s", strerror(errno));
comm = strsep(&q, ",");
if (q != NULL)
for (p=strdup(q); p != NULL && q != NULL; p = strsep(&q, ",")) {
comm = strcat(comm, " ");
for (test=p; *test != '\0'; test++)
if (*test == ',') {
*test = '\0';
break;
}
cur = tstring(max, p);
if (cur) {
comm = realloc(comm, sizeof(char) *
(strlen(comm) + strlen(args[cur-1]) + 1));
if (comm == NULL)
bailout("malloc: %s", strerror(errno));
comm = strcat(comm, args[cur-1]);
} else {
comm = realloc(comm, sizeof(char) *
(strlen(comm) + strlen(p) + 1));
if (comm == NULL)
bailout("malloc: %s", strerror(errno));
comm = strcat(comm, p);
}
}
sprintf(buf, "%s/%s", dir, comm);
file = popen(buf, "r");
if (file == NULL)
bailout("popen: %s", strerror(errno));
p = fgetln(file, &len);
if (p != NULL) {
q = strdup(p);
q[len -1] = '\0';
} else
bailout("fgetln: %s", strerror(errno));
pclose(file);
return(q);
}
static void
form_generate(struct cqForm *cqf, char *basedir, char **args)
{
int i=0;
int lrow=0;
int max, cur;
char *p;
FTREE_ENTRY *ftp;
for (max=0, cur=0; args[max] != NULL; max++);
for (ftp = CIRCLEQ_FIRST(cqf); ftp != (void *)cqf;
ftp = CIRCLEQ_NEXT(ftp, cqFormEntries)) {
F[i].type = LABEL;
F[i].rows = 0;
F[i].cols = 0;
if (lrow >= ws.ws_row-6) {
F[i].newpage = 1;
lrow = 0;
} else
F[i].newpage = 0;
F[i].frow = lrow;
F[i].fcol = 0;
F[i].v = strdup(ftp->desc);
F[i].required = ftp->required;
i++;
if (ftp->type != DATAT_BLANK) {
F[i].required = ftp->required;
switch(ftp->type) {
case DATAT_ENTRY:
F[i].type = STRING;
p = strsep(&ftp->data, ",");
if (ftp->data == NULL)
ftp->data = strdup("");
ftp->elen = atoi(p);
cur = tstring(max, ftp->data);
if (cur)
F[i].v = strdup(args[cur-1]);
else
F[i].v = strdup(ftp->data);
break;
case DATAT_LIST:
F[i].type = ENUM;
F[i].v = strdup(ftp->data);
gen_list(ftp, max, args);
F[i].list = ftp->list;
break;
case DATAT_FUNC:
F[i].type = ENUM;
F[i].v = strdup(ftp->data);
gen_func(ftp);
F[i].list = ftp->list;
break;
case DATAT_SCRIPT:
F[i].type = ENUM;
F[i].v = strdup(ftp->data);
gen_script(ftp, basedir, max, args);
F[i].list = ftp->list;
break;
case DATAT_MLIST:
F[i].type = MULTI;
F[i].v = strdup(ftp->data);
gen_list(ftp, max, args);
F[i].list = ftp->list;
break;
case DATAT_MFUNC:
F[i].type = MULTI;
F[i].v = strdup(ftp->data);
gen_func(ftp);
F[i].list = ftp->list;
break;
case DATAT_MSCRIPT:
F[i].type = MULTI;
F[i].v = strdup(ftp->data);
gen_script(ftp, basedir, max, args);
F[i].list = ftp->list;
break;
case DATAT_NOEDIT:
F[i].type = NOEDIT;
cur = tstring(max, ftp->data);
if (cur)
F[i].v = strdup(args[cur-1]);
else
F[i].v = strdup(ftp->data);
break;
case DATAT_INVIS:
F[i].type = INVIS;
cur = tstring(max, ftp->data);
if (cur)
F[i].v = strdup(args[cur-1]);
else
F[i].v = strdup(ftp->data);
break;
case DATAT_INTEGER:
F[i].type = INTEGER;
cur = tstring(max, ftp->data);
if (cur)
F[i].v = strdup(args[cur-1]);
else
F[i].v = strdup(ftp->data);
break;
case DATAT_ESCRIPT:
F[i].type = STRING;
p = strsep(&ftp->data, ",");
ftp->elen = atoi(p);
F[i].v = gen_escript(ftp, basedir, max, args);
break;
case DATAT_NESCRIPT:
F[i].type = NOEDIT;
F[i].v = gen_escript(ftp, basedir, max, args);
break;
}
F[i].rows = 1;
F[i].rcols = F[i].cols = strlen_data(ftp);
if (F[i].cols > 21) {
F[i].bigfield = 1;
F[i].cols = 21;
} else
F[i].bigfield = 0;
F[i].newpage = 0;
F[i].fcol = 55;
F[i].frow = lrow;
i++;
}
lrow++;
}
/* generate the final entry */
F[i].type = (PF_field)NULL;
F[i].rows = 0;
F[i].cols = 0;
F[i].frow = 0;
F[i].fcol = 0;
F[i].v = (char *)NULL;
F[i].list = (char **)NULL;
F[i].newpage = 0;
}
int
handle_form(char *basedir, char *path, char **args)
{
WINDOW *formwin, *boxwin;
CDKLABEL *label;
char *msg[1];
FORM *menuform;
FIELD **f;
int done = FALSE;
int c;
CIRCLEQ_INIT(&cqFormHead);
cqFormHeadp = &cqFormHead;
if (scan_form(cqFormHeadp, path))
return(1);
F = malloc(sizeof(FIELD_RECORD) *
(form_entries(&cqFormHead) * 2 + 1));
if (F == NULL)
bailout("malloc: %s", strerror(errno));
fflush(NULL);
/* generate a label to let the user know we are thinking */
msg[0] = catgets(catalog, 4, 2, "Generating form data, please wait");
label = newCDKLabel(cdkscreen, CENTER, CENTER, msg, 1, TRUE, FALSE);
activateCDKLabel(label, NULL);
if (args == NULL)
form_generate(&cqFormHead, basedir, (char **)NULL);
else
form_generate(&cqFormHead, basedir, args);
if (!(menuform = new_form(make_fields())))
bailout(catgets(catalog, 1, 15, "error return from new_form"));
set_form_userptr(menuform, "post");
destroyCDKLabel(label);
wclear(stdscr);
formwin = subwin(stdscr, ws.ws_row-5, ws.ws_col-2, 1, 1);
boxwin = subwin(stdscr, ws.ws_row-3, ws.ws_col, 0, 0);
bottom_help(2);
box(boxwin, 0, 0);
keypad(formwin, TRUE);
set_form_sub(menuform, formwin);
post_form(menuform);
wrefresh(stdscr);
wrefresh(boxwin);
form_status(menuform);
while (!done) {
switch (form_driver(menuform, c = get_request(formwin))) {
case E_OK:
if (c == REQ_NEXT_PAGE || c == REQ_PREV_PAGE ||
c == REQ_FIRST_PAGE || c == REQ_LAST_PAGE)
form_status(menuform);
break;
case E_UNKNOWN_COMMAND:
done = my_driver(menuform, c, basedir);
break;
default:
break;
}
}
f = form_fields(menuform);
unpost_form(menuform);
free_form(menuform);
while (*f)
free_field(*f++);
delwin(formwin);
delwin(boxwin);
wclear(stdscr);
wrefresh(stdscr);
free(F);
if (done == 2)
return(1);
return(0);
}
int
handle_preform(char *basedir, char *path)
{
WINDOW *formwin, *boxwin;
CDKLABEL *label;
char *msg[1];
FORM *menuform;
FIELD **f;
int done = FALSE;
int c;
char *args[2];
CIRCLEQ_INIT(&cqFormHead);
cqFormHeadp = &cqFormHead;
if (scan_form(cqFormHeadp, path))
return(1);
F = malloc(sizeof(FIELD_RECORD) *
(form_entries(&cqFormHead) * 2 + 1));
if (F == NULL)
bailout("malloc: %s", strerror(errno));
fflush(NULL);
/* generate a label to let the user know we are thinking */
msg[0] = catgets(catalog, 4, 2, "Generating form data, please wait");
label = newCDKLabel(cdkscreen, CENTER, CENTER, msg, 1, TRUE, FALSE);
activateCDKLabel(label, NULL);
args[0] = NULL;
form_generate(&cqFormHead, basedir, args);
if (!(menuform = new_form(make_fields())))
bailout(catgets(catalog, 1, 15, "error return from new_form"));
set_form_userptr(menuform, "pre");
destroyCDKLabel(label);
wclear(stdscr);
formwin = subwin(stdscr, ws.ws_row-5, ws.ws_col-2, 1, 1);
boxwin = subwin(stdscr, ws.ws_row-3, ws.ws_col, 0, 0);
bottom_help(2);
box(boxwin, 0, 0);
keypad(formwin, TRUE);
set_form_sub(menuform, formwin);
post_form(menuform);
wrefresh(stdscr);
form_status(menuform);
while (!done) {
switch (form_driver(menuform, c = get_request(formwin))) {
case E_OK:
if (c == REQ_NEXT_PAGE || c == REQ_PREV_PAGE ||
c == REQ_FIRST_PAGE || c == REQ_LAST_PAGE)
form_status(menuform);
break;
case E_UNKNOWN_COMMAND:
done = my_driver(menuform, c, basedir);
break;
default:
break;
}
}
f = form_fields(menuform);
unpost_form(menuform);
free_form(menuform);
while (*f)
free_field(*f++);
delwin(formwin);
delwin(boxwin);
wclear(stdscr);
wrefresh(stdscr);
free(F);
if (done == 2)
return(1);
return(0);
}
Reference in New Issue View Git Blame Copy Permalink