int main(int argc, char **argv) { int sock, nserver0; int errfd; pthread_t th; pthread_create(&th, NULL, response_to_search, NULL); parseArgv(argc, argv); if (Daemonize) { if (fork()) { exit(0); } else { close(2); errfd = open(LogFileName, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR); if (errfd < 0) { perror("open:"); } close(0); close(1); } } initEnv(); sock = create_daemon_socket(RC_DAEMON_IP_PORT, NBACKLOG); if (sock == -1) { WARN(0, "create_daemon_socket() failed\n"); exit(1); } nserver0 = Nserver; while (1) { if (Nserver < RC_NSERVERMAX) { spawn_server(sock); if (nserver0 != Nserver) { if (Nserver < RC_NSERVERMAX) { WARN(0, "%d servers active (%d max possible).\n", Nserver, RC_NSERVERMAX); } else { WARN(0, "%d servers active. reached the limit.\n", Nserver); } } } sleep(1); nserver0 = Nserver; } WARN(0, "%s: cannot be reached.\n", __FILE__); pthread_join(th, NULL); exit(1); }
///------------------------------------------------------------- bool CCommandLineParser::parseCommandLine( int argc, const char *const argv[ ] ) ///------------------------------------------------------------- { bool isOkay = false; if ( true == verifyArgc( argc ) && true == parseArgv( argv ) ) { isOkay = true; } return isOkay; }
int main( int argc, char *argv[] ) { myDistro->Init( argc, argv ); config(); dprintf_config_tool_on_error(0); dprintf_OnExitDumpOnErrorBuffer(stderr); parseArgv( argc, argv ); DCStartd startd( target, pool ); if( ! startd.locate() ) { fprintf( stderr, "ERROR: %s\n", startd.error() ); exit( 1 ); } bool rval = false; if( cmd == DRAIN_JOBS ) { std::string request_id; rval = startd.drainJobs( how_fast, resume_on_completion, draining_check_expr, request_id ); if( rval ) { printf("Sent request to drain %s\n",startd.name()); if (dash_verbose && ! request_id.empty()) { printf("\tRequest id: %s\n", request_id.c_str()); } } } else if( cmd == CANCEL_DRAIN_JOBS ) { rval = startd.cancelDrainJobs( cancel_request_id ); if( rval ) { printf("Sent request to cancel draining on %s\n",startd.name()); } } if( ! rval ) { fprintf( stderr, "Attempt to send %s to startd %s failed\n%s\n", getCommandString(cmd), startd.addr(), startd.error() ); return 1; } dprintf_SetExitCode(0); return 0; }
int main(int argc, char **argv) { int sock, nserver0; int errfd; parseArgv(argc, argv); if (Daemonize) { if (fork()) { exit(0); } else { close(2); errfd = open(LogFileName, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR); if (errfd < 0) { perror("open:"); } close(0); close(1); } } initEnv(); sock = create_daemon_socket(RC_DAEMON_IP_PORT, NSERVERMAX); if (sock == -1) { WARN(0, "create_daemon_socket() failed\n"); exit(1); } nserver0 = Nserver; while (1) { if (Nserver < NSERVERMAX) { spawn_server(sock); } else { if (nserver0 != Nserver) { WARN(0, "already max possible clients (=%d) active.\n", Nserver); } sleep(1); } nserver0 = Nserver; } WARN(0, "%s: cannot be reached.\n", __FILE__); exit(1); }
int main( int argc, char *argv[] ) { #ifndef WIN32 // Ignore SIGPIPE so if we cannot connect to a daemon we do not // blowup with a sig 13. install_sig_handler(SIGPIPE, SIG_IGN ); #endif myDistro->Init( argc, argv ); config(); cmd = getCommandFromArgv( argc, argv ); parseArgv( argc, argv ); DCStartd startd( target, pool ? pool->addr() : NULL ); if( needs_id ) { assert( claim_id ); startd.setClaimId( claim_id ); } if( ! startd.locate() ) { fprintf( stderr, "ERROR: %s\n", startd.error() ); exit( 1 ); } bool rval = FALSE; int irval; ClassAd reply; ClassAd ad; switch( cmd ) { case CA_REQUEST_CLAIM: fillRequestAd( &ad ); rval = startd.requestClaim( CLAIM_COD, &ad, &reply, timeout ); break; case CA_ACTIVATE_CLAIM: fillActivateAd( &ad ); irval = startd.activateClaim( &ad, &reply, timeout ); rval = (irval == OK); break; case CA_SUSPEND_CLAIM: rval = startd.suspendClaim( &reply, timeout ); break; case CA_RESUME_CLAIM: rval = startd.resumeClaim( &reply, timeout ); break; case CA_DEACTIVATE_CLAIM: rval = startd.deactivateClaim( vacate_type, &reply, timeout ); break; case CA_RELEASE_CLAIM: rval = startd.releaseClaim( vacate_type, &reply, timeout ); break; case CA_RENEW_LEASE_FOR_CLAIM: rval = startd.renewLeaseForClaim( &reply, timeout ); break; case DELEGATE_GSI_CRED_STARTD: irval = startd.delegateX509Proxy( proxy_file, 0, NULL ); rval = (irval == OK); break; } if( ! rval ) { fprintf( stderr, "Attempt to send %s to startd %s failed\n%s\n", getCommandString(cmd), startd.addr(), startd.error() ); return 1; } printOutput( &reply, &startd ); return 0; }
int main ( int argc, char *argv[] ) { // Loop variables int i=0, j=0, k=0, l=0; // The number of faces and their size depend of the database of faces int n=0,m=0; // size of faces int N = 0; // number of faces char **originFacesPath = NULL; Image *originFaces = NULL; Image *eigenFaces = NULL; Image faceAverage; // ACP elements : // we use array of doubles double** R = NULL; // Matrice d'image (une ligne = un visage) double** transposedR = NULL; // Matrice d'image transposée double* uR = NULL; // Vecteur moyen double** XXT = NULL; // Eigen elements double* eigenValues = NULL; // the same for XXT and XTX double** eigenVectorsV = NULL; // eigen vectors of XXT double** eigenVectorsU = NULL; // eigen vectors of XTX // Face projetction on the new space int q; // dimension of the new space double** tabCoefficients = NULL; double** eigenProjections = NULL; Image *faceProjections = NULL; // Output pictures char output[OUTPUT_SIZE]; if(argc <= 1){ fprintf(stderr, "Usage : %s image1 image2 ...\n",argv[0]); exit (EXIT_FAILURE); } N = argc - 1; originFacesPath = parseArgv(argv,N); printf("Faces importation... "); // Importation des N visages sources (matrix nxm) originFaces = importFaces(originFacesPath,N); free(originFacesPath); free(originFacesPath[0]); originFacesPath = NULL; n = originFaces[0].nbLignes; m = originFaces[0].nbColonnes; // Conversion des visages en vecteurs lignes dans R // (première colonne de la matrice puis seconde etc. = m colonnes qui se suivent de n pixels) // R = {I1,I2, ... IN}T avec N le nombre de visages (cela donne une matrice de N * (n*m)) // Un visage dans R correspond à une ligne R = facesConversion(originFaces,N); for(i=0 ; i<N ; i++){ originFaces[i].t2D = imageDesallocation(originFaces[i].t2D); } free(originFaces); printf("Success!\n"); // If it is a center ACP we have to find the average face uR uR = averageFace(R,N,(n*m)); // then, for a center ACP, we transform R in a center matrix : R <- R - uR centerFacesMatrix(R,uR,N,(n*m)); matrixExport(uR,n,m,"averageFace.pgm"); // dim(XXT) = N*N != dim(XTX) = (n*m) * (n*m) [BEAUCOUP] // Donc on fait l'ACP sur XXT puis on récupère les composantes principales (CP) de XTX grâce aux formules : // va = CP de l'axe a de XXT et ua = CP de l'axe A de XTX // ua = va * XT * 1/sqrt(lambdaA) avec lambdaA la valeur propre de l'axe A (eigenValues of XXT are equal to the eigenValues of XTX) // a. XXT transposedR = transposeMatrix(R,N,(n*m)); XXT = multiplyMatrix(R,N,(n*m),transposedR,(n*m),N); // R = matrixDesallocation(R); // b. Valeurs propres et vecteurs propres if((eigenValues = malloc(N*sizeof(double)))==NULL){ perror("Memory allocation error\n"); exit(EXIT_FAILURE); } eigenVectorsV = memoryAllocation(N,N); printf("ACP... "); acp(XXT,N,eigenValues,eigenVectorsV); XXT = matrixDesallocation(XXT); // c. Now we have to recovery the principal components of XTX eigenVectorsU = memoryAllocation(n*m,n*m); // /!\ we must consider the number of eigen values != 0 // There are as many eigen values !=0 in XXT as in XTX // but the size of these matrix is different // so the loop stop before n*m and even N because here N < n*m for(j=0 ; j<N ; j++){ // we multiply the transposedR matrix by the XXT eigen vector of the jth column. for(i=0 ; i<n*m ; i++){ double sum = 0; for(k=0 ; k<N ; k++){ sum += transposedR[i][k]*eigenVectorsV[k][j]; } eigenVectorsU[i][j]=sum/sqrt(eigenValues[j]); } } free(eigenValues); transposedR = matrixDesallocation(transposedR); eigenVectorsV = matrixDesallocation(eigenVectorsV); if ((eigenFaces = malloc(N*sizeof(Image))) == NULL){ perror("Memory allocation error\n"); exit(EXIT_FAILURE); } for(i=0 ; i< N ; i++){ eigenFaces[i].nbLignes = n; eigenFaces[i].nbColonnes = m; eigenFaces[i].t2D = imageAllocation(n,m); } //inverseFacesConversion(eigenFaces,eigenVectorsU,N,n,m); for(k=0 ; k<N ; k++){ for(i=0 ; i<n ; i++){ for(j=0 ; j<m ; j++){ // /!\ Why a and b ?! without values are too low double a = 110; double b = 7000; if(k==0) printf("%g\t",eigenVectorsU[j*n+i][k]); eigenFaces[k].t2D[i][j] = (Pixel) (abs((int) (a+eigenVectorsU[j*n+i][k]*b))); } if(k==0) printf("\n"); } } // eigenVectorsU = matrixDesallocation(eigenVectorsU); /* for(k=0 ; k<N ; k++){ sprintf(output,"eigen_faces/eigen_face%d.pgm",k); matrixExport(eigenVectorsU[][k],n,m,output); }*/ printf("Success!\n"); printf("# Writing eigen faces ...\n"); for(i = 0 ; i < N ; i++){ sprintf(output,"img/eigen_faces/eigen_face%d.pgm",i); ecrireImage (eigenFaces[i], output); } // desallocation memoire for(i=0 ; i<N ; i++){ eigenFaces[i].t2D = imageDesallocation(eigenFaces[i].t2D); } printf("# Face projection ...\n"); // face projection q = N - 1; // each line contains the coefficients of the face in the new q-dimension-space tabCoefficients = memoryAllocation(N,q); eigenProjections = memoryAllocation(N,n*m); for(i=0 ; i<N ; i++){ projection(R[i], eigenVectorsU, uR, n, m, q, tabCoefficients[i], eigenProjections[i]); } // We search the origin face which is the closest of the face to project search_face("img/toProject.pgm", eigenVectorsU, uR, n, m, q, N, tabCoefficients); tabCoefficients = matrixDesallocation(tabCoefficients); eigenVectorsU = matrixDesallocation(eigenVectorsU); R = matrixDesallocation(R); free(uR); uR = NULL; // Now we have to create faceProjection with the eigenProjections /* if((faceProjections=malloc(N*sizeof(Image)))==NULL){ perror("Memory allocation error !"); exit(EXIT_FAILURE); } for(i=0 ; i< N ; i++){ faceProjections[i].nbLignes = n; faceProjections[i].nbColonnes = m; faceProjections[i].t2D = imageAllocation(n,m); } for(k=0 ; k<N ; k++){ for(i=0 ; i<n ; i++){ for(j=0 ; j<m ; j++){ faceProjections[k].t2D[i][j] = (Pixel) eigenProjections[k][j*n+i]; } } }*/ for(i=0 ; i<N ; i++){ sprintf(output,"projections/projection%d.pgm",i); matrixExport(eigenProjections[i],n,m,output); } eigenProjections = matrixDesallocation(eigenProjections); /*printf("# Writing projection faces ...\n"); for(i = 0 ; i < N ; i++){ sprintf(output,"img/projections/projection%d.pgm",i); ecrireImage (faceProjections[i], output); } // Memory desallocation for(i=0 ; i<N ; i++){ faceProjections[i].t2D = imageDesallocation(faceProjections[i].t2D); }*/ return EXIT_SUCCESS; }
/* Yet !!! main funtion in here */ int main (int argc, char *argv[]) { if (RaiseItsPriority ()) { printf ("Raise it's priority failed.\n"); } memset (&zfs, 0, sizeof (ZFS)); PZFS pzfs = &zfs; /* Parse command line */ if (parseArgv (pzfs, argc, argv) != 0) exit (-1); getFileSupport(CONFIG_SUPPORT_FILE, pzfs); //add by Joe ZError(DBG_MISC, "pzfs->audioConfig = %d\n", pzfs->audioConfig); ZError(DBG_MISC, "pzfs->photoConfig = %d\n", pzfs->photoConfig); ZError(DBG_MISC, "pzfs->videoConfig = %d\n", pzfs->videoConfig); /* Check, if /data/ImportsummaryDB exists */ if (fileExists (IMPORT_SUMMARY_DB) == 0) { ZError (DBG_MISC, "Will create database->%s", IMPORT_SUMMARY_DB); if (createImportSummaryDB () != 0) { ZError (DBG_MISC, "Create database failed."); exit (-1); } } /* initialize zfs */ if (initZFS (pzfs) != 0) exit (-1); /* Sync persist data */ if (getSummary (pzfs) != 0) { ZError (DBG_MISC, "Get persist data failed"); exit (-1); } /* Check to see if the DIR_IMPORT and DIR_IMPORTED exists NOTE: The zfs will make sure DIR_IMPORTED (/data/AudioLibrary1exists, if it doesn't exists, create it */ if (fixImportFolder () != 0) exit (-1); if (fixImportedFolder () != 0) exit (-1); if (fixExtractedFolder () != 0) exit (-1); if (fixTmpFolder () != 0) exit (-1); /* NOTE:Don't give SIGINT signal, just uncommit it when we want debug it */ //signal(SIGINT, catchKill); /* ctr+c */ signal (SIGKILL, catchKill); signal (SIGTERM, catchKill); /* add_inotify_watch to DIR_IMPORT */ if (addWatchDir (pzfs, DIR_IMPORT) != 0) { ZError (DBG_MISC, "Add watch to %s failed", DIR_IMPORT); exit (-1); } /* Send ide event to zqdevice for our policy */ zfsSendIdleEvent (); /* TCP & UDP */ ZUtilStartThread (&pzfs->tcpThr, "ZFS_TCP", pzfs, requestThread); ZUtilStartThread (&pzfs->udpThr, "ZFS_UDP", pzfs, eventThread); /* Watch thread */ ZUtilStartThread (&pzfs->watchThr, "ZFS_WATCH", pzfs, watchThread); //scan import folder on start scanImportFolder(pzfs, REMOVE_UNSUPPORTED_FILE); /* Task thread */ sleep (2); /* TBD */ ZUtilStartThread (&pzfs->taskThr, "ZFS_TASK", pzfs, taskThead); /* NOTE: May we can move one thread in here, May be it can cut down spend */ while (1) { #ifdef Z_CFG_SMBPRIORITY // printf ("this is raise smb priority"); if(pzfs-> b_renice == TRUE) { // printf ("raise sma success 222222222222...."); ZInfo4 (DBG_MISC,"will RaiseItsPriority."); if(RaiseSMBPriority() == 0) { ZInfo4 (DBG_MISC,"RaiseSMBPriority success."); } else { ZError (DBG_MISC,"RaiseSMBPriority failed."); } } #endif sleep (1); } return 0; }
int main(int argc, char* argv[]) { input_file = stdin; output_file = stdout; char *src = 0; char *dst = 0; size_t input_file_size = 0; size_t output_file_size = 0; char inputBuffer[1]; size_t bytesRead = 0; parseArgv(argc, argv); if(show_help) { printf("Quicklz implementation version 1:\n"); printf("\n"); printf("usage: quicklz [options]:\n"); printf("\n"); printf(" -f file - input file that will be compress or decompress. This can be stdin.\n"); printf(" -h - show this help message.\n"); printf(" -o file - output file. This can be stdout.\n"); printf(" -d - will decompress the file given via stdin or via -f option.\n"); printf("\n"); printf("Examples:.\n"); printf("\n"); printf(" cat file.qlz | quicklz -d > file\n"); printf(" cat file | quicklz > file.qlz\n"); printf(" quicklz -i file -o file.qlz\n"); printf(" quicklz -d -i file.qlz -o file\n"); exit(0); } do { bytesRead = fread( inputBuffer, 1, 1, input_file ); char *tmp = (char*)realloc(src, input_file_size + bytesRead); if (tmp) { src = tmp; memmove(&src[input_file_size], inputBuffer, bytesRead); input_file_size += bytesRead; } else { free(src); exit(1); } } while (!feof(input_file)); if(compress) { qlz_state_compress *state_compress = (qlz_state_compress *)malloc(sizeof(qlz_state_compress)); dst = (char*) malloc(input_file_size + 400); output_file_size = qlz_compress(src, dst, input_file_size, state_compress); } else if(decompress) { qlz_state_decompress *state_decompress = (qlz_state_decompress *)malloc(sizeof(qlz_state_decompress)); output_file_size = qlz_size_decompressed(src); dst = (char*) malloc(output_file_size); output_file_size = qlz_decompress(src, dst, state_decompress); } fwrite(dst, output_file_size, 1, output_file); fclose(input_file); fclose(output_file); return 0; }
int main( int argc, char *argv[] ) { //Argumente ARGV_STR argv_str; //Meldung ausgeben cout << "\nSSLR V" << VERSION << "\n"; cout << "(c) 2002-2005 by Sven Schmidt\n"; cout << "[email protected]\n\n"; #ifdef PUBLIC //Argumente einlesen if( !parseArgv( argc, argv, &argv_str ) ) { //keine Fehler in den Argumenten SSLEXScanner *s; //Grammatik-Datei einlesen if( readFile( argv[argc - 1] ) < 0 ) //Fehler return( -1 ); #else { //keine Fehler in den Argumenten SSLEXScanner *s; parseArgv( argc, argv, &argv_str ); //Grammatik-Datei einlesen // if( readFile( "/home/sschmidt/Develop/compilerbau/devel/sslr/src/sslr.sslr" ) < 0 ) if( readFile( "/home/sschmidt/Develop/compilerbau/devel/miniC/miniC.sslr" ) < 0 ) //Fehler return( -1 ); #endif //Scanner-Klasse erzeugen s = new SSLEXScanner( data, strlen( data ) ); //Dateinamen des Grammatik-Files aus den Command-Line-Arguments SSLRParser lr( s ); lr.giveArgs( &argv_str ); lr.yyParse(); //Speicher für den Scanner freigeben delete( s ); //Speicher für das Grammatik-File freigeben delete[] ( data ); } //Speicher freigeben delete[] ( argv_str.name ); //alles OK return EXIT_SUCCESS; } int parseArgv( int argc, char *argv[], ARGV_STR *argv_str ) { //Argumente parsen char *pos; int i, err = 1, argCnt = 0; //mit Standard-Werten initialisieren //keine Meldungen argv_str->verbose = 0; //FIRST-Mengen ausgeben argv_str->showFirst = false; //FOLLOW-Mengen ausgeben argv_str->showFollow = false; //Hüllen ausgeben argv_str->showHulle = false; //Debug-Modus argv_str->debug = false; //Grammatik-File ausgeben argv_str->outputGrammar = false; //LALR-Parser argv_str->type = SSLR_LALR; //Name der Grammatik-Datei argv_str->name = new( char[9] ); strcpy( argv_str->name, "sslr.gra" ); //Zähler i = 1; while( i < argc ) { //nun die Argumente lesen pos = argv[i++]; //Schalter? if( *pos == '-' ) { //ja, Optionen können von der Art -vd... sein pos++; while( *pos ) { //welcher Schalter? if( *pos == 'v' ) { //Level 1 argv_str->verbose = 1; //höhere Ausführlichkeit? if( pos[1] ) { //Zahl auswerten if( pos[1] == '0' ) //keine Meldungen argv_str->verbose = 0; else if( pos[1] == '1' ) //Level 1 argv_str->verbose = 1; else if( pos[1] == '2' ) //Level 2 argv_str->verbose = 2; else //Fehlermeldung cerr << "sslr: Use -v, -v0, -v1 and -v2!" << endl; //Zahl löschen pos++; } } else if( !strcmp( pos, "-help" ) ) { //Hilfe ausgeben cout << "\n"; cout << "usage: sslex [OPTIONS]... [GRAMMAR-FILE] ..\n\n"; cout << "-vX verbose mode (-v0, -v1, -v2)\n"; cout << "-d generate debug version of cpp-file\n"; cout << "-f1 output FIRST set\n"; cout << "-f2 output FOLLOW set\n"; cout << "-h output closure\n"; cout << "-o output grammar in BNF form in file sslr.gra\n"; cout << "-1 generate SLR parser\n"; cout << "-2 generate LALR parser\n"; cout << "-3 generate LR parser\n"; cout << "\n"; //nächstes Argument break; } else if( *pos == 'd' ) //Debug-Modus argv_str->debug = true; else if( !strncmp( "f1", pos, 2 ) ) { //FIRST-Mengen ausgeben argv_str->showFirst = true; //löschen pos++; } else if( !strncmp( "f2", pos, 2 ) ) { //FOLLOW-Mengen ausgeben argv_str->showFollow = true; //löschen pos++; } //Hüllen ausgeben? else if( *pos == 'h' ) //Hüllen ausgeben argv_str->showHulle = true; //Grammatik-Datei ausgeben? else if( *pos == 'o' ) //Grammatik in Datei ausgeben argv_str->outputGrammar = true; else if( *pos == '1' ) //SLR-Parser erzeugen argv_str->type = SSLR_SLR; else if( *pos == '2' ) //LALR-Parser erzeugen argv_str->type = SSLR_LALR; else if( *pos == '3' ) //LR-Parser erzeugen argv_str->type = SSLR_LR; else { //unbekannte Option cerr << "sslr: Unknown argument line option " << pos << "!\n"; cerr << "sslr: --help for more Information\n"; //Fehler err++; } //weiter pos++; } //Argumente zählen argCnt++; } else //ist keine Option, muss Grammatik-File sein err = 0; } //kein Grammatik-File angegeben? if( err ) //Fehlt cout << "sslr: No grammar file specified!" << endl; //etwaige Fehler return( err ); }
int main(int argc, char **argv) { while(1) //shell runs till user enters exit { char * cwd = malloc(256); //find current working directory for prompt assert(cwd != NULL); getCurrentDir(cwd); printf("\nMyShell:%s$ ", cwd); //print shell prompt free(cwd); char *consoleinput = malloc(256); assert(consoleinput != NULL); //TO DO: Change buffer size to variable readCommand(consoleinput); //accept input removeNewLineChar(consoleinput); //remove '\n' character from input removeWhiteSpaces(consoleinput); //remove all spaces before and after command if(strncmp(consoleinput, SUPPORTED_COMMANDS[1], 4) == 0) //exit { free(consoleinput); printf("\nMyShell Terminated\n"); return 0; } else if(strncmp(consoleinput, SUPPORTED_COMMANDS[0], 2) == 0) //cd { int result = runChangeDir(consoleinput); if(result!=0) { perror("cd error:"); } } else if(strncmp(consoleinput, SUPPORTED_COMMANDS[2], 4) == 0) //path { int result = runPath(consoleinput); if(result!=0) { errno = result; perror("path error:"); } } else { //handle pipes char **commands = parseArgv(consoleinput, SPECIAL_CHARS[4]); //input destoyed int numcommands = 0; while( commands[numcommands]!=NULL ) { numcommands++; } //printf("\nNumber of commands:[%d]", numcommands); const int numpipes = 2*(numcommands-1); //printf("\nNumber of pipe file descriptors:[%d]", numpipes); /*read and write ends of pipes stay apart by 3 -increment open pipe indexes by 2 after every command -close all pipes */ int pipefds[numpipes]; int i=0; for(i=0; i<numpipes;i=i+2) { pipe(pipefds+i); } //printf("\npipe() call successful"); // for(i=0;i<numpipes;i++) // { // printf("[%d]", pipefds[i]); // } int pipe_w = 1; int pipe_r = pipe_w - 3; int curcommand = 0; while(curcommand < numcommands) { //printf("\nCommand number:[%d]", curcommand); //printf("\ninside pipe loop for command [%s]", commands[curcommand]); //Parse Command and Arguments into formatneeded by execv char **argv = parseArgv(commands[curcommand], SPECIAL_CHARS[0]); //printf("\nCurrent Command:[%s]", argv[0]); if(findPath(argv) == 0) { //executeCommand(argv); int child_pid = fork(); //int child_status; if(child_pid < 0) { //errno = 3; perror("fork error:"); } else if(child_pid == 0) //fork success { if(pipe_w < numpipes) { //open write end //printf("\nWrite pipe:[%d] to stdout", pipefds[pipe_w]); if(dup2(pipefds[pipe_w], 1) < 0) { perror("pipe write-end error: "); } } if((pipe_r >= 0)&&(pipe_r < numpipes)) { //open read end //printf("\nRead pipe:[%d] to stdin", pipefds[pipe_r]); if(dup2(pipefds[pipe_r], 0) < 0) { perror("pipe read-end error: "); } } for(i=0;i<numpipes;i++) //close off all pipes { //printf("\nclosing all pipes"); close(pipefds[i]); } if(execv(argv[0], argv) == -1) { perror("Bad command or filename:"); exit(0); //TODO: child hangs here } //fflush(stdin); } } else { printf("\nBad command or filename"); //TODO: ForkBomb occuring here //exit(0); } free(argv); //printf("\nIncrementing pipe ends, moving to next command."); curcommand++; pipe_w = pipe_w + 2; pipe_r = pipe_r + 2; } //int i=0; for(i=0;i<numpipes;i++) //close off all pipes { //printf("\nclosing all pipes"); close(pipefds[i]); } int status; for(i=0;i<numcommands;i++) { wait(&status); } free(commands); } free(consoleinput); } freeList(pathlist); }