static void atbr (struct uart * uart)
{
clearcommand ();
insert ('A');
insert ('T');
insert ('B');
insert ('R');
decode (&uart->mode, sizeof (uart->mode));
insert (',');
uart->baudrate = HTOBE64 (uart->baudrate);
decode (&uart->baudrate, sizeof (uart->baudrate));
uart->baudrate = BE64TOH (uart->baudrate);
insert (',');
decode (&uart->databits, sizeof (uart->databits));
insert (',');
decode (&uart->parity, sizeof (uart->parity));
insert (',');
decode (&uart->stopbits, sizeof (uart->stopbits));
insert (',');
decode (&uart->flowctrl, sizeof (uart->flowctrl));
insert ('\r');
sendcommand (&uart->port, uart->flags);
readcommand (&uart->port, uart->flags);
mustbe ('O');
mustbe ('K');
mustbe ('\r');
return;
}
static void at_command (struct uart * uart)
{
clearcommand ();
while (*uart->string)
{
insert (*uart->string++);
}
insert ('\r');
sendcommand (&uart->port, uart->flags);
readcommand (&uart->port, uart->flags);
return;
}
static void at_wake (struct uart * uart)
{
clearcommand ();
insert ('+');
insert ('+');
insert ('+');
sendcommand (&uart->port, uart->flags);
readcommand (&uart->port, uart->flags);
mustbe ('O');
mustbe ('K');
mustbe ('\r');
return;
}
/*
* do the prompt/input/process loop
*
* If xflg is true, the function will not go interactive, but returns.
* If commandline != NULL, this command is processed first.
*
* Return: 0: on success
*/
int process_input(int xflag, char *commandline)
{
/* Dimensionate parsedline that no sprintf() can overflow the buffer
*/
char parsedline[MAX_INTERNAL_COMMAND_SIZE + sizeof(errorlevel) * 8]
, *readline;
/* Return the maximum pointer into parsedline to add 'numbytes' bytes */
#define parsedMax(numbytes) \
(parsedline + MAX_INTERNAL_COMMAND_SIZE - 1 - (numbytes))
char *evar;
char *tp;
char *ip;
char *cp;
char forvar;
int echothisline;
int tracethisline;
do
{
interactive_command = 0; /* not directly entered by user */
echothisline = tracethisline = 0;
if(commandline) {
ip = commandline;
readline = commandline = NULL;
} else {
if ((readline = malloc(MAX_INTERNAL_COMMAND_SIZE + 1)) == NULL)
{
error_out_of_memory();
return 1;
}
if (NULL == (ip = readbatchline(&echothisline, readline,
MAX_INTERNAL_COMMAND_SIZE)))
{ /* if no batch input then... */
if (xflag /* must not go interactive */
|| (fdattr(0) & 0x84) == 0x84 /* input is NUL device */
|| feof(stdin)) /* no further input */
{
free(readline);
break;
}
/* Go Interactive */
interactive_command = 1; /* directly entered by user */
readcommand(ip = readline, MAX_INTERNAL_COMMAND_SIZE);
tracemode = 0; /* reset trace mode */
}
}
/*
* The question mark '?' has a double meaning:
* C:\> ?
* ==> Display short help
*
* C:\> ? command arguments
* ==> enable tracemode for just this line
*/
if(*(ip = trim(ip)) == '?') {
ip = trim(ip + 1);
if(!*ip) { /* is short help command */
#ifdef INCLUDE_CMD_QUESTION
showcmds(ip);
#endif
free(readline);
continue;
}
/* this-line-tracemode */
echothisline = 0;
tracethisline = 1;
}
/* The FOR hack
If the line matches /^\s*for\s+\%[a-z]\s/, the FOR hack
becomes active, because FOR requires the sequence "%<ch>"
in its input.
When the percent (%) expansion is made later on, any
sequence "%<ch>" is retained.
*/
cp = ip;
if(matchtok(cp, "for") && *cp == '%' && isalpha(cp[1])
&& isspace(cp[2])) /* activate FOR hack */
forvar = toupper(cp[1]);
else forvar = 0;
cp = parsedline;
while (*ip)
{
/* Assume that at least one character is added, place the
test here to simplify the switch() statement */
if(cp >= parsedMax(1)) {
cp = NULL; /* error condition */
break;
}
if (*ip == '%')
{
switch (*++ip)
{
case '\0': /* FOR hack forvar == 0 if no FOR is active */
*cp++ = '%';
break;
case '%':
*cp++ = *ip++;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (NULL != (tp = find_arg(*ip - '0')))
{
if(cp >= parsedMax(strlen(tp))) {
cp = NULL;
goto intBufOver;
}
cp = stpcpy(cp, tp);
ip++;
}
else
*cp++ = '%';
/* Let the digit be copied in the cycle */
break;
case '?':
/* overflow check: parsedline has that many character
"on reserve" */
cp += sprintf(cp, "%u", errorlevel);
ip++;
break;
default:
if(forvar == toupper(*ip)) { /* FOR hack */
*cp++ = '%'; /* let the var be copied in next cycle */
break;
}
if ((tp = strchr(ip, '%')) != NULL)
{
*tp = '\0';
if ((evar = getEnv(ip)) != NULL) {
if(cp >= parsedMax(strlen(evar))) {
cp = NULL;
goto intBufOver;
}
cp = stpcpy(cp, evar);
}
ip = tp + 1;
}
break;
}
continue;
}
if (iscntrl(*ip))
*cp = ' ';
else
*cp++ = *ip++;
}
intBufOver:
free(readline);
if(!cp) { /* internal buffer overflow */
error_line_too_long();
continue;
}
*cp = '\0'; /* terminate copied string */
if (echothisline) /* Echo batch file line */
{
printprompt();
puts(parsedline);
}
if (*parsedline)
{
if(tracethisline)
++tracemode;
parsecommandline(parsedline);
if(tracethisline)
--tracemode;
if (echothisline || echo)
putchar('\n');
}
}
while (!canexit || !exitflag);
return 0;
}
/*
* do the prompt/input/process loop
*
* If xflg is true, the function will not go interactive, but returns.
* If commandline != NULL, this command is processed first.
*
* Return: 0: on success
*/
int process_input(int xflag, char *commandline)
{
/* Dimensionate parsedline that no sprintf() can overflow the buffer
*/
char parsedline[MAX_INTERNAL_COMMAND_SIZE + sizeof(errorlevel) * 8]
, *readline;
#if 0
/* Return the maximum pointer into parsedline to add 'numbytes' bytes */
#define parsedMax(numbytes) \
(parsedline + MAX_INTERNAL_COMMAND_SIZE - 1 - (numbytes))
char *evar;
char *tp;
char *cp;
#endif
char *ip;
#if 0
char forvar;
#endif
int echothisline;
int tracethisline;
do
{
#ifdef FEATURE_LONG_FILENAMES
if( toupper( *getEnv( "LFN" ) ) == 'N' )
__supportlfns = 0;
else __supportlfns = 1;
#endif
interactive_command = 0; /* not directly entered by user */
echothisline = tracethisline = 0;
if(commandline) {
ip = commandline;
readline = commandline = 0;
} else {
if ((readline = malloc(MAX_INTERNAL_COMMAND_SIZE + 1)) == 0)
{
error_out_of_memory();
return 1;
}
if (0 == (ip = readbatchline(&echothisline, readline,
MAX_INTERNAL_COMMAND_SIZE)))
{ /* if no batch input then... */
if (xflag /* must not go interactive */
|| (fdattr(0) & 0x84) == 0x84 /* input is NUL device */
|| feof(stdin)) /* no further input */
{
free(readline);
break;
}
/* Go Interactive */
interactive_command = 1; /* directly entered by user */
/* Ensure the prompt starts at column #0 */
if(echo && (mywherex()>1))
outc('\n');
readcommand(ip = readline, MAX_INTERNAL_COMMAND_SIZE);
tracemode = 0; /* reset trace mode */
}
}
/* Make sure there is no left-over from last run */
currCmdHelpScreen = 0;
/*
* The question mark '?' has a double meaning:
* C:\> ?
* ==> Display short help
*
* C:\> ? command arguments
* ==> enable tracemode for just this line
*/
if(*(ip = ltrimcl(ip)) == '?') {
ip = ltrimcl(ip + 1);
if(!*ip) { /* is short help command */
#ifdef INCLUDE_CMD_QUESTION
showcmds(ip);
#endif
free(readline);
continue;
}
/* this-line-tracemode */
echothisline = 0;
tracethisline = 1;
}
#if 0
/* The FOR hack
If the line matches /^\s*for\s+\%[a-z]\s/, the FOR hack
becomes active, because FOR requires the sequence "%<ch>"
in its input.
When the percent (%) expansion is made later on, any
sequence "%<ch>" is retained.
*/
cp = ip;
if(matchtok(cp, "for") && *cp == '%' && isalpha(cp[1])
&& isargdelim(cp[2])) /* activate FOR hack */
forvar = toupper(cp[1]);
else forvar = 0;
#else
if(cmd_for_hackery(ip)) {
free(readline);
continue;
}
#endif
{ int rc = expandEnvVars(ip, parsedline);
free(readline);
if(!rc) {
error_line_too_long();
continue;
}
}
if (echothisline) /* Echo batch file line */
{
printprompt();
puts(parsedline);
}
if (*parsedline)
{
if(swapOnExec != ERROR)
swapOnExec = defaultToSwap;
if(tracethisline)
++tracemode;
parsecommandline(parsedline, TRUE);
if(tracethisline)
--tracemode;
}
}
while (!canexit || !exitflag);
return 0;
}
/* do the actual work */
static int assemble (const char *str, unsigned char *_obuf) {
int ifcount = 0, noifcount = 0;
const char *ptr;
char *bufptr;
int r, s; /* registers */
obuflen = 0;
obuf = _obuf;
/* continue assembling until the last input file is done */
//for (file = 0; file < infilecount; ++file)
do {
int cmd, cont = 1;
// XXX: must free
z80buffer = strdup (str);
if (!cont)
break; /* break to next source file */
// if (havelist)
// fprintf (listfile, "%04x", addr);
for (bufptr = z80buffer; (bufptr = strchr (bufptr, '\n'));)
*bufptr = ' ';
for (bufptr = z80buffer; (bufptr = strchr (bufptr, '\r'));)
*bufptr = ' ';
ptr = z80buffer;
//lastlabel = NULL;
baseaddr = addr;
++stack[sp].line;
ptr = delspc (ptr);
if (!*ptr)
continue;
if (!noifcount && !define_macro)
readlabel (&ptr, 1);
else
readlabel (&ptr, 0);
ptr = delspc (ptr);
if (!*ptr)
continue;
comma = 0;
indexed = 0;
indexjmp = 0;
writebyte = 0;
readbyte = 0;
readword = 0;
cmd = readcommand (&ptr) - 1;
int i, have_quote;
switch (cmd) {
case Z80_ADC:
if (!(r = rd_a_hl (&ptr)))
break;
if (r == HL) {
if (!(r = rd_rr_ (&ptr)))
break;
wrtb (0xED);
wrtb (0x4A + 0x10 * --r);
break;
}
if (!(r = rd_r (&ptr)))
break;
wrtb (0x88 + --r);
break;
case Z80_ADD:
if (!(r = rd_r_add (&ptr)))
break;
if (r == addHL) {
if (!(r = rd_rrxx (&ptr)))
break;
wrtb (0x09 + 0x10 * --r); /* ADD HL/IX/IY, qq */
break;
}
if (has_argument (&ptr)) {
if (r != A) {
eprintf ("parse error before: %s\n", ptr);
break;
}
if (!(r = rd_r (&ptr)))
break;
wrtb (0x80 + --r); /* ADD A,r */
break;
}
wrtb (0x80 + --r); /* ADD r */
break;
case Z80_AND:
if (!(r = rd_r (&ptr)))
break;
wrtb (0xA0 + --r);
break;
case Z80_BIT:
if (!rd_0_7 (&ptr))
break;
rd_comma (&ptr);
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x40 + (r - 1));
break;
case Z80_CALL:
if ((r = rd_cc (&ptr))) {
wrtb (0xC4 + 8 * --r);
rd_comma (&ptr);
} else wrtb (0xCD);
break;
case Z80_CCF:
wrtb (0x3F);
break;
case Z80_CP:
if (!(r = rd_r (&ptr)))
break;
wrtb (0xB8 + --r);
break;
case Z80_CPD:
wrtb (0xED);
wrtb (0xA9);
break;
case Z80_CPDR:
wrtb (0xED);
wrtb (0xB9);
break;
case Z80_CPI:
wrtb (0xED);
wrtb (0xA1);
break;
case Z80_CPIR:
wrtb (0xED);
wrtb (0xB1);
break;
case Z80_CPL:
wrtb (0x2F);
break;
case Z80_DAA:
wrtb (0x27);
break;
case Z80_DEC:
if (!(r = rd_r_rr (&ptr)))
break;
if (r < 0) {
wrtb (0x05 - 8 * ++r);
break;
}
wrtb (0x0B + 0x10 * --r);
break;
case Z80_DI:
wrtb (0xF3);
break;
case Z80_DJNZ:
wrtb (0x10);
//rd_wrt_jr (&ptr, '\0');
break;
case Z80_EI:
wrtb (0xFB);
break;
case Z80_EX:
if (!(r = rd_ex1 (&ptr)))
break;
switch (r) {
case DE:
if (!rd_hl (&ptr))
break;
wrtb (0xEB);
break;
case AF:
if (!rd_af_ (&ptr))
break;
wrtb (0x08);
break;
default:
if (!rd_hlx (&ptr))
break;
wrtb (0xE3);
}
break;
case Z80_EXX:
wrtb (0xD9);
break;
case Z80_HALT:
wrtb (0x76);
break;
case Z80_IM:
if (!(r = rd_0_2 (&ptr)))
break;
wrtb (0xED);
wrtb (0x46 + 8 * --r);
break;
case Z80_IN:
if (!(r = rd_in (&ptr)))
break;
if (r == A) {
if (!(r = rd_nnc (&ptr)))
break;
if (r == C) {
wrtb (0xED);
wrtb (0x40 + 8 * (A - 1));
break;
}
wrtb (0xDB);
break;
}
if (!rd_c (&ptr))
break;
wrtb (0xED);
wrtb (0x40 + 8 * --r);
break;
case Z80_INC:
if (!(r = rd_r_rr (&ptr)))
break;
if (r < 0) {
wrtb (0x04 - 8 * ++r);
break;
}
wrtb (0x03 + 0x10 * --r);
break;
case Z80_IND:
wrtb (0xED);
wrtb (0xAA);
break;
case Z80_INDR:
wrtb (0xED);
wrtb (0xBA);
break;
case Z80_INI:
wrtb (0xED);
wrtb (0xA2);
break;
case Z80_INIR:
wrtb (0xED);
wrtb (0xB2);
break;
case Z80_JP:
r = rd_jp (&ptr);
if (r < 0) {
wrtb (0xE9);
break;
}
if (r) {
wrtb (0xC2 + 8 * --r);
rd_comma (&ptr);
} else wrtb (0xC3);
break;
case Z80_JR:
r = rd_jr (&ptr);
if (r)
rd_comma (&ptr);
wrtb (0x18 + 8 * r);
break;
case Z80_LD:
if (!(r = rd_ld (&ptr)))
break;
switch (r) {
case ld_BC:
case ld_DE:
if (!rd_a (&ptr))
break;
wrtb (0x02 + 0x10 * (r == ld_DE));
break;
case ld_HL:
r = rd_ld_hl (&ptr);
wrtb (0x70 + --r);
break;
case ld_NN:
if (!(r = rd_ld_nn (&ptr)))
break;
if (r == ld_nnA || r == ld_nnHL) {
wrtb (0x22 + 0x10 * (r == ld_nnA));
break;
}
wrtb (0xED);
wrtb (0x43 + 0x10 * --r);
break;
case ldA:
if (!(r = rd_lda (&ptr)))
break;
if (r == A_NN) {
wrtb (0x3A);
break;
}
if (r == A_I || r == A_R) {
wrtb (0xED);
wrtb (0x57 + 8 * (r == A_R));
break;
}
if (r < 0) {
wrtb (0x0A - 0x10 * ++r);
break;
}
wrtb (0x78 + --r);
break;
case ldB:
case ldC:
case ldD:
case ldE:
case ldH:
case ldL:
if (!(s = rd_ldbcdehla (&ptr)))
break;
wrtb (0x40 + 0x08 * (r - 7) + (s - 1));
break;
case ldBC:
case ldDE:
s = rd_nn_nn (&ptr);
if (s == _NN) {
wrtb (0xED);
wrtb (0x4B + 0x10 * (r == ldDE));
break;
}
wrtb (0x01 + (r == ldDE) * 0x10);
break;
case ldHL:
r = rd_nn_nn (&ptr);
wrtb (0x21 + (r == _NN) * 9);
break;
case ldI:
case ldR:
if (!rd_a (&ptr))
break;
wrtb (0xED);
wrtb (0x47 + 0x08 * (r == ldR));
break;
case ldSP:
r = rd_sp (&ptr);
if (r == SPHL) {
wrtb (0xF9);
break;
}
if (r == SPNN) {
wrtb (0x31);
break;
}
wrtb (0xED);
wrtb (0x7B);
break;
}
break;
case Z80_LDD:
wrtb (0xED);
wrtb (0xA8);
break;
case Z80_LDDR:
wrtb (0xED);
wrtb (0xB8);
break;
case Z80_LDI:
wrtb (0xED);
wrtb (0xA0);
break;
case Z80_LDIR:
wrtb (0xED);
wrtb (0xB0);
break;
case Z80_NEG:
wrtb (0xED);
wrtb (0x44);
break;
case Z80_NOP:
wrtb (0x00);
break;
case Z80_OR:
if (!(r = rd_r (&ptr)))
break;
wrtb (0xB0 + --r);
break;
case Z80_OTDR:
wrtb (0xED);
wrtb (0xBB);
break;
case Z80_OTIR:
wrtb (0xED);
wrtb (0xB3);
break;
case Z80_OUT:
if (!(r = rd_nnc (&ptr)))
break;
if (r == C) {
if (!(r = rd_out (&ptr)))
break;
wrtb (0xED);
wrtb (0x41 + 8 * --r);
break;
}
if (!rd_a (&ptr))
break;
wrtb (0xD3);
break;
case Z80_OUTD:
wrtb (0xED);
wrtb (0xAB);
break;
case Z80_OUTI:
wrtb (0xED);
wrtb (0xA3);
break;
case Z80_POP:
if (!(r = rd_stack (&ptr)))
break;
wrtb (0xC1 + 0x10 * --r);
break;
case Z80_PUSH:
if (!(r = rd_stack (&ptr)))
break;
wrtb (0xC5 + 0x10 * --r);
break;
case Z80_RES:
if (!rd_0_7 (&ptr))
break;
rd_comma (&ptr);
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x80 + --r);
break;
case Z80_RET:
if (!(r = rd_cc (&ptr))) {
wrtb (0xC9);
break;
}
wrtb (0xC0 + 8 * --r);
break;
case Z80_RETI:
wrtb (0xED);
wrtb (0x4D);
break;
case Z80_RETN:
wrtb (0xED);
wrtb (0x45);
break;
case Z80_RL:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x10 + --r);
break;
case Z80_RLA:
wrtb (0x17);
break;
case Z80_RLC:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x00 + --r);
break;
case Z80_RLCA:
wrtb (0x07);
break;
case Z80_RLD:
wrtb (0xED);
wrtb (0x6F);
break;
case Z80_RR:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x18 + --r);
break;
case Z80_RRA:
wrtb (0x1F);
break;
case Z80_RRC:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x08 + --r);
break;
case Z80_RRCA:
wrtb (0x0F);
break;
case Z80_RRD:
wrtb (0xED);
wrtb (0x67);
break;
case Z80_RST:
ptr = "";
break;
case Z80_SBC:
if (!(r = rd_a_hl (&ptr)))
break;
if (r == HL) {
if (!(r = rd_rr_ (&ptr)))
break;
wrtb (0xED);
wrtb (0x42 + 0x10 * --r);
break;
}
if (!(r = rd_r (&ptr)))
break;
wrtb (0x98 + --r);
break;
case Z80_SCF:
wrtb (0x37);
break;
case Z80_SET:
if (!rd_0_7 (&ptr))
break;
rd_comma (&ptr);
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0xC0 + --r);
break;
case Z80_SLA:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x20 + --r);
break;
case Z80_SLI:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x30 + --r);
break;
case Z80_SRA:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x28 + --r);
break;
case Z80_SRL:
if (!(r = rd_r_ (&ptr)))
break;
wrtb (0xCB);
wrtb (0x38 + --r);
break;
case Z80_SUB:
if (!(r = rd_r (&ptr)))
break;
if (has_argument (&ptr)) {/* SUB A,r ? */
if (r != A) {
eprintf ("parse error before: %s\n", ptr);
break;
}
if (!(r = rd_r (&ptr)))
break;
}
wrtb (0x90 + --r);
break;
case Z80_XOR:
if (!(r = rd_r (&ptr)))
break;
wrtb (0xA8 + --r);
break;
case Z80_DEFB:
case Z80_DB:
case Z80_DEFM:
case Z80_DM:
ptr = delspc (ptr);
while (1) {
have_quote = (*ptr == '"' || *ptr == '\'');
if (have_quote) {
/* Read string. */
int quote = *ptr;
++ptr;
while (*ptr != quote)
{
write_one_byte (rd_character (&ptr, NULL, 1), 0);
if (*ptr == 0)
{
eprintf ("end of line in quoted string\n");
break;
}
}
++ptr;
} else {
/* Read expression. */
skipword (&ptr, ',');
}
ptr = delspc (ptr);
if (*ptr == ',') {
++ptr;
continue;
}
if (*ptr != 0)
eprintf ("junk in byte definition: %s\n", ptr);
break;
}
break;
case Z80_DEFW:
case Z80_DW:
if (!(r = rd_word (&ptr, ','))) {
eprintf ("No data for word definition\n");
break;
}
while (1) {
ptr = delspc (ptr);
if (*ptr != ',')
break;
++ptr;
if (!(r = rd_word (&ptr, ',')))
eprintf ("Missing expression in defw\n");
}
break;
case Z80_DEFS:
case Z80_DS:
r = rd_expr (&ptr, ',', NULL, sp, 1);
if (r < 0) {
eprintf ("ds should have its first argument >=0"
" (not -0x%x)\n", -r);
break;
}
ptr = delspc (ptr);
if (*ptr) {
rd_comma (&ptr);
readbyte = 0;
rd_byte (&ptr, '\0');
writebyte = 0;
break;
}
for (i = 0; i < r; i++) {
write_one_byte (0, 0);
}
break;
case Z80_END:
break;
case Z80_ORG:
addr = rd_expr (&ptr, '\0', NULL, sp, 1) & 0xffff;
break;
case Z80_IF:
if (rd_expr (&ptr, '\0', NULL, sp, 1))
ifcount++;
else
noifcount++;
break;
case Z80_ELSE:
if (ifcount == 0)
{
eprintf ("else without if\n");
break;
}
noifcount = 1;
ifcount--;
break;
case Z80_ENDIF:
if (noifcount == 0 && ifcount == 0) {
eprintf ("endif without if\n");
break;
}
if (noifcount)
noifcount--;
else
ifcount--;
break;
case Z80_ENDM:
if (stack[sp].file)
eprintf ("endm outside macro definition\n");
break;
case Z80_SEEK:
eprintf ("seek error\n");
break;
default:
//eprintf ("command or comment expected (was %s)\n", ptr);
return 0;
}
} while (0);
//free (infile);
return obuflen;
}
void Database::readTreeGsp ( FILE *input, Tid tid , Tid orig_tid) {
InputNodeLabel inputnodelabel;
DatabaseTreePtr tree = new DatabaseTree ( tid , orig_tid , tid );
trees.push_back ( tree );
trees_map[orig_tid] = tree;
char command;
int dummy;
int nodessize = 0, edgessize = 0;
command = readcommand ( input );
static vector<DatabaseTreeNode> nodes;
static vector<vector<DatabaseTreeEdge> > edges;
nodes.resize ( 0 );
while ( command == 'v' ) {
dummy = readint ( input );
inputnodelabel = readint ( input );
if ( dummy != nodessize ) {
cerr << "Error reading input file - node number does not correspond to its position." << endl;
exit ( 1 );
}
nodessize++;
map_insert_pair ( nodelabelmap ) p = nodelabelmap.insert ( make_pair ( inputnodelabel, nodelabels.size () ) );
if ( p.second ) {
vector_push_back ( DatabaseNodeLabel, nodelabels, nodelabel );
nodelabel.inputlabel = inputnodelabel;
nodelabel.occurrences.parent = NULL;
nodelabel.occurrences.number = 1;
nodelabel.lasttid = tid;
}
else {
DatabaseNodeLabel &nodelabel = nodelabels[p.first->second];
if ( nodelabel.lasttid != tid )
nodelabel.frequency++;
nodelabel.lasttid = tid;
}
vector_push_back ( DatabaseTreeNode, nodes, node );
node.nodelabel = p.first->second;
node.incycle = false;
command = readcommand ( input );
}
tree->nodes.reserve ( nodessize );
if ( (int) edges.size () < nodessize )
edges.resize ( nodessize );
for ( int i = 0; i < nodessize; i++ ) {
edges[i].resize ( 0 );
tree->nodes.push_back ( nodes[i] );
}
InputEdgeLabel inputedgelabel;
InputNodeId nodeid1, nodeid2;
while ( !feof ( input ) && command == 'e' ) {
nodeid1 = readint ( input );
nodeid2 = readint ( input );
inputedgelabel = readint ( input );
NodeLabel node2label = tree->nodes[nodeid2].nodelabel;
NodeLabel node1label = tree->nodes[nodeid1].nodelabel;
CombinedInputLabel combinedinputlabel;
if ( node1label > node2label ) {
NodeLabel temp = node1label;
node1label = node2label;
node2label = temp;
}
combinedinputlabel = combineInputLabels ( inputedgelabel, node1label, node2label );
map_insert_pair ( edgelabelmap ) p = edgelabelmap.insert ( make_pair ( combinedinputlabel, edgelabels.size () ) );
if ( p.second ) {
vector_push_back ( DatabaseEdgeLabel, edgelabels, edgelabel );
edgelabel.fromnodelabel = node1label;
edgelabel.tonodelabel = node2label;
edgelabel.inputedgelabel = inputedgelabel;
edgelabel.lasttid = tid;
}
else {
DatabaseEdgeLabel &edgelabel = edgelabels[p.first->second];
if ( edgelabel.lasttid != tid )
edgelabel.frequency++;
edgelabel.lasttid = tid;
}
vector_push_back ( DatabaseTreeEdge, edges[nodeid1], edge );
edge.edgelabel = p.first->second;
edge.tonode = nodeid2;
vector_push_back ( DatabaseTreeEdge, edges[nodeid2], edge2 );
edge2.edgelabel = p.first->second;
edge2.tonode = nodeid1;
edgessize++;
command = readcommand ( input );
if (command == 't') fseek (input, -1, SEEK_CUR);
}
tree->edges = new DatabaseTreeEdge[edgessize * 2];
int pos = 0;
for ( int i = 0; i < nodessize; i++ ) {
int s = edges[i].size ();
tree->nodes[i].edges._size = s;
tree->nodes[i].edges.array = tree->edges + pos;
for ( int j = 0; j < s; j++, pos++ ) {
tree->edges[pos] = edges[i][j];
}
}
static vector<int> nodestack;
static vector<bool> visited1, visited2;
nodestack.resize ( 0 );
visited1.resize ( 0 );
visited1.resize ( nodessize, false );
visited2.resize ( 0 );
visited2.resize ( nodessize, false );
for ( int i = 0; i < nodessize; i++ ) {
if ( !visited1[i] ) {
nodestack.push_back ( i );
visited1[i] = visited2[i] = true;
determineCycledNodes ( tree, nodestack, visited1, visited2 );
visited2[i] = false;
nodestack.pop_back ();
}
}
}
int main(int argc, char **argv)
{
int listenfd, connfd, port;
socklen_t clientlen;
struct sockaddr_in clientaddr;
struct hostent *hp;
char *haddrp;
if (argc != 2) {
fprintf(stderr, "usage: %s <port>\n", argv[0]);
exit(0);
}
port = atoi(argv[1]);
// read in the first line from the client
readconfig();
readcommand();
//size_t n;
char buf[128];
char user[40];
char pass[40];
rio_t rio;
listenfd = Open_listenfd(port);
clientlen = sizeof(clientaddr);
connfd = Accept(listenfd, (SA *)&clientaddr, &clientlen);
Rio_readinitb(&rio, connfd);
//read username and password from client. Each individual line.
Rio_readlineb(&rio, user, 40); //line:netp:echo:eof
Rio_readlineb(&rio, pass, 40);
int login = 0;
int ctr = 0;
strtok(pass, "\n");
strtok(user, "\n");
while(ctr < 128)
{
if(strcmp(userpass[0][ctr], user) == 0 && (strcmp(userpass[1][ctr], pass)) == 0)
{
login++;
}
ctr++;
}
if (login == 0)
{
printf("User %s Failed logging in\n", user);
Rio_writen(connfd, "Login Failed\n", 14);
Close(connfd);
exit(0);
}
else
{
// Determine the domain name and IP address of the client
hp = Gethostbyaddr((const char *)&clientaddr.sin_addr.s_addr,
sizeof(clientaddr.sin_addr.s_addr), AF_INET);
haddrp = inet_ntoa(clientaddr.sin_addr);
printf("server connected to %s (%s)\n", hp->h_name, haddrp);
printf("User %s logging in from %s at TCP Port %d\n", user, haddrp, port);
printf("User %s successfully logged in.\n", user);
Rio_writen(connfd, "Login Successful\n", 17);//Warning if this isn't 17 it will affect every Rio_writen after this
ctr = 0;
while(ctr == 0)
{
//reads your command from the client
Rio_readlineb(&rio, buf, 128);
strtok(buf, "\n");
printf("User %s sent the commandline %s to be executed\n", user, buf);
if(strcmp(buf, "quit") == 0)
{
printf("Logged out\n");
Rio_writen(connfd, "quit\n", 5);// Same warning as above
ctr++;
}
else
{
char *file;
char *command;
char *thirdinput;
char *str = buf; //buf = /bin/cat echo.c
command = strtok(str, " "); //command = /bin/cat
file = strtok(NULL, " "); //file = echo.c
thirdinput = strtok(NULL, " ");
int usecommand = 0;
int ctr2 = 0;
while(ctr2 < 128)
{
if(strcmp(execcom[ctr2], command) == 0)
{
usecommand++;
}
ctr2++;
}
if(usecommand == 0)
{
Rio_writen(connfd, "nocomm\n", 7);// Same warning as above
printf("Cannot execute '%s' on this server.\n", buf);
}
else
{
printf("Forking/Execing the command '%s' on behalf of %s\n", buf, user);
char buffer[MAXLINE];
int pipefd[2];
pipe(pipefd);
pid_t pid = fork();
if (!pid)
{
close(pipefd[0]);
dup2(pipefd[1], 1);
dup2(pipefd[1], 2);
close(pipefd[1]);
char *env[] = {0};
char *arg[] = {command, file, thirdinput, NULL};
//call your executable in your current directory
execve(command, arg, env);
}
else if (pid == -1)
{
perror("fork");
}
else
{
//parent
close(pipefd[1]);
while (read(pipefd[0], buffer, sizeof(buffer)) != 0)
{
}
}
int status;
wait(&status);
//sends out the string results of exec.
Rio_writen(connfd, buffer, strlen(buffer));
//we use this as a counter to tell the client that we have sent everything over.
Rio_writen(connfd, "exec\n", 5);// Same warning as above
int ctr2 = 0;
while(ctr2 < MAXLINE)
{
buffer[ctr2] = 0;
ctr2++;
}
}
}
}
}
Close(connfd);
exit(0);
}
