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); }