Exemple #1
0
int addInFileAndClose(char *firstLine, char *filename) {
	FILE *fptmp;
	FILE *fp;
	char buffer[BUFF_DEFAULT_SIZE];

	if ((fptmp = fopen(TEMP_FILE_PATH, "w")) == NULL) {
		exitWithError();
	}
	if ((fp = fopen(filename, "r")) == NULL) {
		exitWithError();
	}
	if (fputs(firstLine, fptmp) == EOF) {
		exitWithError();
	}
	while (fgets(buffer, BUFF_DEFAULT_SIZE, fp) != NULL) {
		fputs(buffer, fptmp);
	}
	fclose(fptmp);
	fclose(fp);
	if (remove(filename) != 0) {
		exitWithError();
	}
	if (rename(TEMP_FILE_PATH, filename) < 0) {
		exitWithError();
	}
	return 0;
}
Exemple #2
0
void connectToSwitch(Switch *switchTrans, BankAuthorizer *autorizer) {
	struct sockaddr_in switchAddress;
	struct hostent *switchHost;

	// creo el scoket para conectarme
	switchTrans->fd = socket(AF_INET, SOCK_STREAM, 0);

	if (switchTrans->fd < 0) {
		exitWithError();
	}

	// La dirección a la cual conectarse
	switchHost = gethostbyname(switchTrans->host);
	switchAddress.sin_family = AF_INET;
	switchAddress.sin_port = htons(switchTrans->port);

	bcopy((char *) switchHost->h_addr, (char *) &switchAddress.sin_addr.s_addr,
			switchHost->h_length);

	// me conecto al server
	if (connect(switchTrans->fd, (struct sockaddr*) &switchAddress,
			(socklen_t) sizeof(struct sockaddr_in)) < 0) {
		puts("Error conectandose al servidor");
		exitWithError();
	}

	if (!authenticateBank(switchTrans, autorizer)) {
		printf("Error de autenticación");
		exit(EXIT_FAILURE);
	}

	sendServicePortToSwitch(switchTrans);
}
void mapThreadsSpawn (Parameters *P, ReadAlignChunk** RAchunk) {
    for (int ithread=1;ithread<P->runThreadN;ithread++) {//spawn threads
        int threadStatus=pthread_create(&g_threadChunks.threadArray[ithread], NULL, &g_threadChunks.threadRAprocessChunks, (void *) RAchunk[ithread]);
        if (threadStatus>0) {//something went wrong with one of threads
                ostringstream errOut;
                errOut << "EXITING because of FATAL ERROR: phtread error while creating thread # " << ithread <<", error code: "<<threadStatus ;
                exitWithError(errOut.str(),std::cerr, P->inOut->logMain, 1, *P);
        };
        pthread_mutex_lock(&g_threadChunks.mutexLogMain);
        P->inOut->logMain << "Created thread # " <<ithread <<"\n"<<flush;
        pthread_mutex_unlock(&g_threadChunks.mutexLogMain);
    };

    RAchunk[0]->processChunks(); //start main thread

    for (int ithread=1;ithread<P->runThreadN;ithread++) {//wait for all threads to complete
        int threadStatus = pthread_join(g_threadChunks.threadArray[ithread], NULL);
        if (threadStatus>0) {//something went wrong with one of threads
                ostringstream errOut;
                errOut << "EXITING because of FATAL ERROR: phtread error while joining thread # " << ithread <<", error code: "<<threadStatus ;
                exitWithError(errOut.str(),std::cerr, P->inOut->logMain, 1, *P);
        };
        pthread_mutex_lock(&g_threadChunks.mutexLogMain);
        P->inOut->logMain << "Joined thread # " <<ithread <<"\n"<<flush;
        pthread_mutex_unlock(&g_threadChunks.mutexLogMain);
    };
};
uint genomeScanFastaFiles (Parameters *P, char* G, bool flagRun) {//scans fasta files. flagRun=false: check and find full size, flaRun=true: collect all the data

    uint N=0;//total number of bases in the genome, including chr "spacers"
    if (!flagRun && P->chrLength.size()>0)
    {//previous chr records exist
       P->chrStart.pop_back();//remove last record, it will be recorded again
       N =  P->chrStart.back()+P->chrLength.back();
       P->chrLength.pop_back();//remove last record, it will be recorded again
    };

    ifstream fileIn;
    for (uint ii=0;ii<P->genomeFastaFiles.size();ii++) {//all the input files
        fileIn.open(P->genomeFastaFiles.at(ii).c_str());
        if ( !fileIn.good() )
        {//
            ostringstream errOut;
            errOut << "EXITING because of INPUT ERROR: could not open genomeFastaFile: " <<P->genomeFastaFiles.at(ii) <<"\n";
            exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_INPUT_FILES, *P);
        };
        char cc=fileIn.peek();
        if ( !fileIn.good() )
        {//
            ostringstream errOut;
            errOut << "EXITING because of INPUT ERROR: could not read from genomeFastaFile: " <<P->genomeFastaFiles.at(ii) <<"\n";
            exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_INPUT_FILES, *P);
        };
        if (cc!='>')
        {
            ostringstream errOut;
            errOut << "EXITING because of INPUT ERROR: the file format of the genomeFastaFile: " <<P->genomeFastaFiles.at(ii) << "is not fasta:";
            errOut << " the first character is " <<cc<<" , not > .\n";
            errOut << " Solution: check formatting of the fasta file. Make sure the file is uncompressed (unzipped).\n";
            exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_INPUT_FILES, *P);
        };         while(!fileIn.eof()) {//read each file until eof
            string lineIn (4096,'.');
            getline(fileIn,lineIn);
            if (lineIn[0]=='>') {//new chromosome
                if (!flagRun) {
                    istringstream lineInStream (lineIn);
                    lineInStream.ignore(1,' ');
                    string chrName1;
                    lineInStream >> chrName1;
                    P->chrName.push_back(chrName1);
                };

                if (!flagRun && P->chrStart.size()>0) P->chrLength.push_back(N-P->chrStart.at(P->chrStart.size()-1)); //true length of the chr

                if (N>0) {//pad the chromosomes to bins boudnaries
                    N = ( (N+1)/P->genomeChrBinNbases+1 )*P->genomeChrBinNbases;
                };

                if (!flagRun) {
                    P->chrStart.push_back(N);
                    P->inOut->logMain << P->genomeFastaFiles.at(ii)<<" : chr # " << P->chrStart.size()-1 << "  \""<<P->chrName.at(P->chrStart.size()-1)<<"\" chrStart: "<<N<<"\n"<<flush;
                };
            } else {//char lines
                if (flagRun) lineIn.copy(G+N,lineIn.size(),0);
                N += lineIn.size();
            };
        };
int main(int argc, char *argv[])
{
    int sock;                        /* Socket */
    struct sockaddr_in echoServAddr; /* Local address */
    struct sockaddr_in echoClntAddr; /* Client address */
    unsigned int cliAddrLen;         /* Length of incoming message */
    char echoBuffer[ECHOMAX];                /* Buffer for echo string */
    unsigned short echoServPort;     /* Server port */
    int recvMsgSize;                 /* Size of received message */

    if (argc != 2)         /* Test for correct number of parameters */
    {
        fprintf(stderr,"Usage:  %s <UDP SERVER PORT>\n", argv[0]);
        exit(1);
    }

    echoServPort = atoi(argv[1]);  /* First arg:  local port */

    /* Create socket for sending/receiving datagrams */
    if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
        exitWithError("socket() failed");

    /* Construct local address structure */
    memset(&echoServAddr, 0, sizeof(echoServAddr));   /* Zero out structure */
    echoServAddr.sin_family = AF_INET;                /* Internet address family */
    echoServAddr.sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */
    echoServAddr.sin_port = htons(echoServPort);      /* Local port */

    /* Bind to the local address */
    if (bind(sock, (struct sockaddr *) &echoServAddr, sizeof(echoServAddr)) < 0)
        exitWithError("bind() failed");

    for (;;) /* Run forever */
    {
        /* Set the size of the in-out parameter */
        cliAddrLen = sizeof(echoClntAddr);

        /* Block until receive message from a client */
        if ((recvMsgSize = recvfrom(sock,
                                    echoBuffer,
                                    ECHOMAX,
                                    0,
                                    (struct sockaddr *) &echoClntAddr,
                                    &cliAddrLen)
                                  ) < 0)
            exitWithError("recvfrom() failed");

        printf("Handling client %s\n", inet_ntoa(echoClntAddr.sin_addr));

        // Create thread to handle client
        std::thread clientThread(handleClient, echoBuffer, sock, recvMsgSize, echoClntAddr);
        // Let the thread run independently
        clientThread.detach();

        }

    /* NOT REACHED */
}
bool ScriptReaderBase::exitWithError(const io::stringc &Message, bool AppendTokenPos)
{
    if (AppendTokenPos && Tkn_)
        return exitWithError(Message, Tkn_);
    io::Log::error(Message);
    return false;
}
Exemple #7
0
int changeAmmount(CreditCard *creditCard, float ammout) {
	FILE *fp;
	char buffer[BUFF_DEFAULT_SIZE];
	char path[BUFF_DEFAULT_SIZE];
	float balance = 0;

	sprintf(path, "./%s",
			creditCard->number);
	if ((fp = fopen(path, "r")) == NULL) {
		//exitWithError();
		return -1;
	}
	if (fgets(buffer, BUFF_DEFAULT_SIZE, fp) < 0) {
		exitWithError();
	}
	char *s = strtok(buffer, ":\n");
	s = strtok(NULL, ":\n");
	s = strtok(NULL, ":\n");
	balance = atof(s);
	if (balance + ammout < 0) {
		return -1;
	}
	sprintf(buffer, "%s:%.2f:%.2f\n", ammout >= 0 ? "CRE" : "DEB", ammout,
			balance + ammout);
	fclose(fp);
	return addInFileAndClose(buffer, path);
}
Exemple #8
0
void sendServicePortToSwitch(Switch *switchTrans) {
	char buffer[BUFF_DEFAULT_SIZE];
	sprintf(buffer, "%d", DEFAULT_BANK_PORT);
	if (write(switchTrans->fd, buffer, strlen(buffer) + 1) < 0) {
		exitWithError();
	}
}
bool ScriptReaderBase::validateBrackets()
{
    const SToken* InvalidToken = 0;
    
    switch (TokenStream_->validateBrackets(InvalidToken))
    {
        case VALIDATION_ERROR_UNEXPECTED:
            return exitWithError("Unexpected bracket token", InvalidToken);
        case VALIDATION_ERROR_UNCLOSED:
            return exitWithError("Unclosed brackets", InvalidToken);
        default:
            break;
    }
    
    return true;
}
Exemple #10
0
/* Creates Distributed Block Cyclic Layout Matrix
  Requires:
   - p * q = size of communication group
   - m % p*bm == 0
   - n % q*bn == 0
*/
void dist_matrix_init(MPI_Comm comm, struct dbcl_t *mat,
		int p, int q,
		int bm, int bn,
		int m, int n,
		double (*f)(int i, int j)) {

  int rank, size;
  
  MPI_Comm_rank(comm, &rank);
  MPI_Comm_size(comm, &size);

  assert(p*q == size);
  assert(m % p*bm == 0);
  assert(n % q*bn == 0);

  // M,N are the number of blocks
  int gM = m / bm;
  int gN = n / bn;
  
  int lM = gM / p;
  int lN = gN / q;

  // Initialize datastructure
  MPI_Comm_dup(comm, &(mat->comm));
  mat->p = p; mat->q = q;
  mat->lM = lM; mat->lN = lN;
  mat->bm = bm; mat->bn = bn;
  mat->m = m; mat->n = n;
  mat->value = malloc(sizeof(double) * (bm * bn) * (lM * lN));

  if (mat->value == NULL)
    exitWithError("dist_matrix_init: malloc failed ( mat->value )");
  
  // Fill matrix will values supplied from function f(i, j)
  int lbi, lbj;
  for ( lbj=0; lbj<lN; lbj++ ) {
    for ( lbi=0; lbi<lM; lbi++ ) {
      
      int block_offset = (lbi + lbj * lM) * (bm * bn);

      int i, j; 
      for (i=0; i<bm; i++ ) {
	for (j=0; j<bn; j++ ) {
	  
	  int gi = (rank % p) * bm + lbi * (p * bm) + i;
	  int gj = (rank / p) * bn + lbj * (q * bn) + j;

	  int offset = i + (j * bm);
	  if (gi < m && gj < n) {
	    mat->value[block_offset + offset] = f(gi, gj);
	  } else {
	    mat->value[block_offset + offset] = 0.0; 
	  }
	}
      }
    }
  }
}
Exemple #11
0
void dist_matrix_print(struct dbcl_t *mat) {
  int rank, size;

  MPI_Comm_rank(mat->comm, &rank);
  MPI_Comm_size(mat->comm, &size);

  double *global_mat;
  
  if (rank == ROOT) {
    global_mat = malloc(sizeof(double) * (mat->m * mat->n));
    if (global_mat == NULL)
      exitWithError("dist_matrix_print: malloc failed( global_mat )\n");
  }
  
  int send_size = (mat->lM * mat->lN) * (mat->bm * mat->bn);
  int recv_size = send_size;

  MPI_Gather(mat->value, send_size, MPI_DOUBLE, global_mat, recv_size, MPI_DOUBLE, ROOT, mat->comm);
  
  if (rank == ROOT) {
    printf("Print Matrix >>> (m, n): %d %d (lM, lN): %d %d (bm, bn): %d %d (p, q): %d %d\n", mat->m, mat->n, mat->lM, mat->lN, mat->bm, mat->bn, mat->p, mat->q);

    int colors[] = {31, 32, 33, 34, 35, 36, 37, 90, 91, 92, 93, 94, 95, 96};
    int background[] = {003, 007};

    int gi, gj;
    for (gi=0; gi<mat->m; gi++ ) {
      for (gj=0; gj<mat->n; gj++ ) {
	int i_rank = (gi / mat->bm) % mat->p + ((gj / mat->bn) % mat->q) * mat->p;
	int proc_offset = i_rank * (mat->lM * mat->lN) * (mat->bm * mat->bn);

	int lbi = gi / (mat->bm * mat->p);
	int lbj = gj / (mat->bn * mat->q);

	int block_offset = (lbi + lbj * mat->lM) * (mat->bm * mat->bn);

	int i = gi % mat->bm;
	int j = gj % mat->bn;
	
	int index_offset = i + (j * mat->bm);

	char format_buffer[16];
	sprintf(format_buffer, "\033[%d;%dm", background[(lbi + lbj) % 2], colors[i_rank % 14]);
	printf("%s%2.1f\033[0m ", format_buffer, global_mat[proc_offset + block_offset + index_offset]);
      }
      printf("\n");
    }
    printf("\n");
    
    free(global_mat);
  }

  MPI_Barrier(mat->comm);
}
Exemple #12
0
void ofstrOpen (std::string fileName, std::string errorID, Parameters *P, ofstream & ofStream) {//open file 'fileName', generate error if cannot open
    ofStream.open(fileName.c_str(), std::fstream::out | std::fstream::trunc);
    if (ofStream.fail()) {//
//         dir1=fileName.substr(0,fileName.find_last_of("/")+1);
//         if (dir1=="") dir1="./";
        ostringstream errOut;
        errOut << errorID<<": exiting because of *OUTPUT FILE* error: could not create output file "<< fileName <<"\n";
        errOut << "Solution: check that the path exists and you have write permission for this file\n";
        exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_FILE_OPEN, *P);
    };    
};
Exemple #13
0
void Genome::HandleSharedMemoryException(const SharedMemoryException & exc, uint64 shmSize)
{
    ostringstream errOut;
    errOut << "Shared memory error: " << exc.GetErrorCode() << ", errno: " << strerror(exc.GetErrorDetail()) << "(" << errno << ")" << endl;

    int exitCode = EXIT_CODE_SHM;
    switch (exc.GetErrorCode())
    {
        case EOPENFAILED:            
            errOut << "EXITING because of FATAL ERROR: problems with shared memory: error from shmget() or shm_open()." << endl << flush;
            errOut << "SOLUTION: check shared memory settings as explained in STAR manual, OR run STAR with --genomeLoad NoSharedMemory to avoid using shared memory" << endl << flush;     
            break;
        case EEXISTS:
            errOut << "EXITING: fatal error from shmget() trying to allocate shared memory piece." << endl;
            errOut << "Possible cause 1: not enough RAM. Check if you have enough RAM of at least " << shmSize+2000000000 << " bytes" << endl;
            errOut << "Possible cause 2: not enough virtual memory allowed with ulimit. SOLUTION: run ulimit -v " <<  shmSize+2000000000 << endl;
            errOut << "Possible cause 3: allowed shared memory size is not large enough. SOLUTIONS: (i) consult STAR manual on how to increase shared memory allocation; " \
            "(ii) ask your system administrator to increase shared memory allocation; (iii) run STAR with --genomeLoad NoSharedMemory" << endl<<flush;
            break;
        case EFTRUNCATE:
            errOut << "EXITING: fatal error from ftruncate() error shared memory."  << endl;
            errOut << "Possible cause 1: not enough RAM. Check if you have enough RAM of at least " << shmSize+2000000000 << " bytes" << endl << flush;
            exitCode = EXIT_CODE_MEMORY_ALLOCATION;
            break;
        case EMAPFAILED:
            errOut << "EXITING because of FATAL ERROR: problems with shared memory: error from shmat() while trying to get address of the shared memory piece." << endl << flush;
            errOut << "SOLUTION: check shared memory settings as explained in STAR manual, OR run STAR with --genomeLoad NoSharedMemory to avoid using shared memory" << endl << flush;     
            break;
        case ECLOSE:
            errOut << "EXITING because of FATAL ERROR: could not close the shared memory object." << endl << flush;     
            break;
        case EUNLINK:
            #ifdef POSIX_SHARED_MEM
            errOut << "EXITING because of FATAL ERROR:  could not delete the shared object." << endl << flush;
            #else
            errOut << "EXITING because of FATAL ERROR: problems with shared memory: error from shmctl() while trying to remove shared memory piece." << endl << flush;
            errOut << "SOLUTION: check shared memory settings as explained in STAR manual, OR run STAR with --genomeLoad NoSharedMemory to avoid using shared memory" << endl << flush;     
            #endif
            break;
        default:
            errOut << "EXITING because of FATAL ERROR: There was an issue with the shared memory allocation. Try running STAR with --genomeLoad NoSharedMemory to avoid using shared memory.";
            break;
    }      

    try 
    {
        if (sharedMemory != NULL)
            sharedMemory->Clean();
    }
    catch(...)
    {}

    exitWithError(errOut.str(),std::cerr, P->inOut->logMain, exitCode, *P);
};
void BAMbinSortByCoordinate(uint32 iBin, uint binN, uint binS, uint nThreads, string dirBAMsort, Parameters *P) {
      
    if (binS==0) return; //nothing to do for empty bins
    //allocate arrays
    char *bamIn=new char[binS];
    uint *startPos=new uint[binN*3];

    uint bamInBytes=0;
    //load all aligns
    for (uint it=0; it<nThreads; it++) {
        string bamInFile=dirBAMsort+to_string(it)+"/"+to_string((uint) iBin);
        ifstream bamInStream (bamInFile.c_str());
        bamInStream.read(bamIn+bamInBytes,binS);//read the whole file
        bamInBytes += bamInStream.gcount();
        bamInStream.close();
        remove(bamInFile.c_str());
    };
    if (bamInBytes!=binS) {
        ostringstream errOut;
        errOut << "EXITING because of FATAL ERROR: number of bytes expected from the BAM bin does not agree with the actual size on disk: ";
        errOut << binS <<"   "<< bamInBytes <<"   "<< iBin <<"\n";
        exitWithError(errOut.str(),std::cerr, P->inOut->logMain, 1, *P);
    };
  
    //extract coordinates
    
    for (uint ib=0,ia=0;ia<binN;ia++) {
        uint32 *bamIn32=(uint32*) (bamIn+ib);
        startPos[ia*3]  =( ((uint) bamIn32[1]) << 32) | ( (uint)bamIn32[2] );
        startPos[ia*3+2]=ib;      
        ib+=bamIn32[0]+sizeof(uint32);//note that size of the BAM record does not include the size record itself
        startPos[ia*3+1]=*( (uint*) (bamIn+ib) ); //read order
        ib+=sizeof(uint);
    };
        
    //sort
    qsort((void*) startPos, binN, sizeof(uint)*3, funCompareUint2);
    
    BGZF *bgzfBin;
    bgzfBin=bgzf_open((dirBAMsort+"/b"+to_string((uint) iBin)).c_str(),("w"+to_string((long long) P->outBAMcompression)).c_str());
    outBAMwriteHeader(bgzfBin,P->samHeaderSortedCoord,P->chrName,P->chrLength);
    //send ordered aligns to bgzf one-by-one
    for (uint ia=0;ia<binN;ia++) {
        char* ib=bamIn+startPos[ia*3+2];
        bgzf_write(bgzfBin,ib, *((uint32*) ib)+sizeof(uint32) ); 
    };
    
    bgzf_flush(bgzfBin);
    bgzf_close(bgzfBin);
    //release memory
    delete [] bamIn;
    delete [] startPos;
};
Exemple #15
0
int* prepareDataFile(const char* imagePath)
{
    // Create a buffer for the name of the image
    char out_name[256];
    // Set the name of the image
    sprintf(out_name, "%s/out.data", imagePath);
    // Create an output file
    int* fout = (int*)malloc(sizeof(int));
    *fout = open(out_name, O_CREAT | O_RDWR | O_NONBLOCK, 000777);
	if (*fout == -1) exitWithError(out_name);
	return fout;
}
Exemple #16
0
// Open the camera device as a file
void openDevice(const char* location, int* fd)
{
	*fd = open(location, O_RDWR, 0);
	if(*fd==1)
	{
		exitWithError("Open camera failed");
	}
	else
	{
		printf("Opened Camera");
	}
}
Exemple #17
0
int main(int argc, char *argv[]) {
	int 		*fd = (int*)malloc(sizeof(int)), qual = 0, fps = 0, bufSize = 0;
	char 		*camera;
	if(argc != 5) 						// Check correct number of args
	{
		char errorMsg[256];
		sprintf(errorMsg, "usage: %s cameraDevice JpegQuality fps bufferSize",
				argv[0]);
		exitWithError(errorMsg);
	}
	else
	{
		camera = argv[1];	// camera location
		// Image quality
		if(atoi(argv[2]) > 0 && atoi(argv[2]) <= 100) qual = atoi(argv[2]);
		else exitWithError("Set JpegQuality between 1 and 100 inclusive.");
		// frame delay
		if(atoi(argv[3]) > 0) fps = atoi(argv[3]);
		// list size
		if(atoi(argv[4]) > 0) bufSize = atoi(argv[4]);
	}
	printf("Camera Interface  Copyright (C) 2012  Jacob Appleton\n\n");
	printf("This program comes with ABSOLUTELY NO WARRANTY;\n");
    printf("This is free software, and you are welcome to redistribute it \n");
    printf("under certain conditions.\n");
    printf("Visit http://www.gnu.org/licenses/gpl.html for more details.\n\n");
	*fd = -1;
	openDevice(camera, fd);
	getCapabilities(fd);
	int* imageCaptureType = (int*)malloc(sizeof(int));
	*imageCaptureType = V4L2_BUF_TYPE_VIDEO_CAPTURE;
	getFrames(1, 1, fd, imageCaptureType, qual, fps, bufSize);
    // Turn the stream off - this will turn off the camera's LED light
    ioctl(*fd, VIDIOC_STREAMOFF, imageCaptureType);
	closeDevice(fd);
	free(fd);
	free(imageCaptureType);
	pthread_exit(NULL);
	return 0;
}
Exemple #18
0
int authenticateBank(Switch *switchTrans, BankAuthorizer *user) {
	printf("Usuario: %ld\n", user->id);
	printf("Password: %s\n", user->password);
	char buffer[BUFF_DEFAULT_SIZE];

	if (write(switchTrans->fd, "authbanco", 16) < 0) {
		exitWithError();
	}
	if (read(switchTrans->fd, buffer, BUFF_DEFAULT_SIZE) < 0) {
		exitWithError();
	}
	sprintf(buffer, "%ld", user->id);
	if (write(switchTrans->fd, buffer, strlen(buffer) + 1) < 0) {
		exitWithError();
	}
	if (read(switchTrans->fd, buffer, BUFF_DEFAULT_SIZE) < 0) {
		exitWithError();
	}
	if (write(switchTrans->fd, user->password, strlen(user->password) + 1)
			< 0) {
		exitWithError();
	}
	if (read(switchTrans->fd, buffer, BUFF_DEFAULT_SIZE) < 0) {
		exitWithError();
	}
	return atoi(buffer);
}
Exemple #19
0
void ifstrOpen (std::string fileName, std::string errorID, std::string solutionString, Parameters *P, ifstream & ifStream) {
    //open file 'fileName', generate error if cannot open
    ifStream.open(fileName.c_str());
    if (ifStream.fail()) {//
        ostringstream errOut;
        errOut << errorID<<": exiting because of *INPUT FILE* error: could not open input file "<< fileName <<"\n";
        errOut << "Solution: check that the file exists and you have read permission for this file\n";
        if (solutionString.size()>0) {
            errOut << "          "<< solutionString <<"\n";
        };
        exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_FILE_OPEN, *P);
    };    
};
Exemple #20
0
void processTransactions() {
	int sockopt = 1;
	int fd, fd2; /* los ficheros descriptores */

	struct sockaddr_in server;
	/* para la información de la dirección del servidor */

	struct sockaddr_in client;
	/* para la información de la dirección del cliente */

	socklen_t sin_size;

	/* A continuación la llamada a socket() */
	if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
		exitWithError();
	}

	server.sin_family = AF_INET;

	server.sin_port = htons(DEFAULT_BANK_PORT);

	server.sin_addr.s_addr = INADDR_ANY;
	/* INADDR_ANY coloca nuestra dirección IP automáticamente */

	bzero(&(server.sin_zero), 8);
	/* escribimos ceros en el reto de la estructura */

	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &sockopt, sizeof(int)) == -1) {
		exitWithError();
	}

	/* A continuación la llamada a bind() */
	if (bind(fd, (struct sockaddr*) &server, sizeof(struct sockaddr)) == -1) {
		exitWithError();
	}

	if (listen(fd, 5) == -1) { /* llamada a listen() */
		exitWithError();
	}

	if (signal(SIGINT, intHandler) == SIG_ERR) {
		exitWithError();
	}

	while (keepRunning) {
		sin_size = sizeof(struct sockaddr_in);
		/* A continuación la llamada a accept() */
		if ((fd2 = accept(fd, (struct sockaddr *) &client, &sin_size)) == -1) {
			exitWithError();
		}

		hablar(fd2);

		close(fd2); /* cierra fd2 */
	}

	printf("deslogeandose\n");
}
Exemple #21
0
// Get a frame from the camera device
void getFrames(int noFrames, int minNoFrames, int* fd, int* imgCaptureType,
			   int cqual, int fps, int bufferSize)
{
	struct v4l2_buffer 			buf;
	struct buffer* 				bufs;
	struct v4l2_requestbuffers 	reqbuf = getReqBufs(noFrames, minNoFrames, fd);
	unsigned int 				n_buffers, i, ctr = 0;
    bool 						started = FALSE, streamOn = false;
    struct lstnode* cNode = allocate(bufferSize);
    pthread_mutex_t* mutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
    pthread_mutex_init(mutex, NULL);
	struct imgDetails det = getFrameFormat(fd); // get video format details
	bufs = (struct buffer*)calloc(reqbuf.count, sizeof(*bufs)); // alloc buffers
	// If allocation fails
	if (bufs == NULL) exitWithError("Could not allocate buffers.");
	// Map the memory in kernel space to user space to access video efficiently
	for (n_buffers = 0; n_buffers < reqbuf.count; n_buffers++)
	{
		mapBuffer(reqbuf, n_buffers, buf, bufs, fd);
	}
	// Queue the request struct to v4l2 to retrieve the video data mem location
	for(i = 0; i < reqbuf.count; i++)	queueBuffer(i, buf, fd);
	streamOn = turnOnCamera(fd, streamOn, imgCaptureType); // turn on camera
    while(true) //forever
    {
		if(!started) // if the write data thread has not yet been started
		{
			started = TRUE;
			createThread(cNode, mutex);
		}
		for(i = 0; i < reqbuf.count; i++) // for each frame returned
		{
			usleep(fps); // maintain steady frame rate
			pthread_mutex_lock(mutex); // lock pointers
			createImage(buf, bufs, i, cNode, fd, det, cqual);
			cNode = cNode->next; // work with the next node in the list
			printf("|%d|\n", ctr++);
			pthread_mutex_unlock(mutex); // release locks
			queueBuffer(i, buf, fd); // queue up a new buffer
		}
    }
    for (i = 0; i < reqbuf.count; ++i) // unmap memory
    {
    	munmap(bufs[i].start, bufs[i].length);
    }
    free(mutex);
    free(cNode);
    free(bufs);
}
Exemple #22
0
void sjdbLoadFromFiles(Parameters *P, SjdbClass &sjdbLoci) {
   
    if (P->sjdbFileChrStartEnd.at(0)!="-") {       
        for (uint ifile=0;ifile<P->sjdbFileChrStartEnd.size(); ifile++) {
            ifstream sjdbStreamIn ( P->sjdbFileChrStartEnd.at(ifile).c_str() );   
            if (sjdbStreamIn.fail()) {
                ostringstream errOut;
                errOut << "FATAL INPUT error, could not open input file sjdbFileChrStartEnd=" << P->sjdbFileChrStartEnd.at(ifile) <<"\n";
                exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_INPUT_FILES, *P);
            };

            sjdbLoadFromStream(sjdbStreamIn, sjdbLoci);

            P->inOut->logMain << "Loaded database junctions from file: " << P->sjdbFileChrStartEnd.at(ifile) <<", total number of junctions: "<<sjdbLoci.chr.size()<<" junctions\n\n";
        };
    }; //if (P->sjdbFileChrStartEnd!="-")

};
void sjdbInsertJunctions(Parameters *P, Genome &genome) {
        
    SjdbClass sjdbLoci;        
    time_t rawtime;

    //load 1st pass junctions
    if (P->twoPass.pass1sjFile.size()>0)
    {
        ifstream sjdbStreamIn ( P->twoPass.pass1sjFile.c_str() );   
        if (sjdbStreamIn.fail()) {
            ostringstream errOut;
            errOut << "FATAL INPUT error, could not open input file with junctions from the 1st pass="******"\n";
            exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_INPUT_FILES, *P);
        };
        sjdbLoadFromStream(sjdbStreamIn, sjdbLoci);
        time ( &rawtime );
        P->inOut->logMain << timeMonthDayTime(rawtime) << "   Loaded database junctions from the 1st pass file: " << P->twoPass.pass1sjFile <<": "<<sjdbLoci.chr.size()<<" total junctions\n\n";
    };
    
    //load from junction files
    if (P->sjdbFileChrStartEnd.at(0)!="-")
    {
        sjdbLoadFromFiles(P,sjdbLoci);
        P->inOut->logMain << timeMonthDayTime(rawtime) << "   Loaded database junctions from the sjdbFileChrStartEnd file(s), " << sjdbLoci.chr.size()<<" total junctions\n\n";        
    };
    
    //load from GTF
    if (P->sjdbGTFfile!="-")
    {
        loadGTF(sjdbLoci, P, P->genomeDirOut);
        P->inOut->logMain << timeMonthDayTime(rawtime) << "   Loaded database junctions from the GTF file: " << P->sjdbGTFfile<<": "<<sjdbLoci.chr.size()<<" total junctions\n\n";
    };

    sjdbPrepare (sjdbLoci, P, genome.G, P->nGenome, P->twoPass.dir);//P->nGenome - change when replacing junctions
    time ( &rawtime );
    P->inOut->logMain  << timeMonthDayTime(rawtime) << "   Finished preparing junctions" <<endl;

    //insert junctions into the genome and SA and SAi
    sjdbBuildIndex (P, genome.G, genome.SA, genome.SA2, genome.SAi);
    time ( &rawtime ); 
    *P->inOut->logStdOut  << timeMonthDayTime(rawtime) << " ..... Finished inserting 1st pass junctions into genome" <<endl;
    //re-calculate genome-related parameters
    P->winBinN = P->nGenome/(1LLU << P->winBinNbits)+1;
};
int main(int argc, char *argv[]) {

	if(argc != 3)
	{
		exitWithError("Usage: tstream2jpeg data_file_path outputPath");
	}
	char* 	tStreamPath = argv[1];  		  // Set the file in path
	char 	jpegPath[255];   				  // Buffer for current working dir
	int 	i = 0, len, ctr = 0;
	char*   workingDir = argv[2];

	//getcwd(workingDir, 255); 				  // Get current working directory
	FILE* tstream = fopen(tStreamPath, "rb"); // Open the telemetry stream
	fseek(tstream, 0, SEEK_END);			  // Seek to EOF
	len = ftell(tstream);					  // Find file size
	fseek(tstream, 0, SEEK_SET);			  // Seek to beginning of file
	byte* buf = (byte*)malloc(len);			  // Allocate file in memory
	fread(buf, 1, len-1, tstream);			  // Read file into memory
	sprintf(jpegPath, "%s/image%d.jpeg", workingDir, i++);
	FILE* jpeg = fopen(jpegPath, "wb");
	while(ctr < len)						  // While not at end of buffer
	{
		ctr++;								  // Ignore first 0xAA
		ctr += 2;							  // Ignore bytes received
		byte conBytes[2];					  // Buffer for bytes contained
		conBytes[1] = *(buf+(ctr++));		  // Fill buffer
		conBytes[0] = *(buf+(ctr++));		  // Fill buffer
		uint16_t con = byteToInt(conBytes);	  // Get int of bytes contained
		printf("Creating image of size %d bytes\n", con);
		if(*(buf+ctr) == 0xFF && *(buf+ctr+1) == 0xD8)
		{
			fclose(jpeg);
			sprintf(jpegPath, "%s/image%d.jpeg", workingDir, i++);
			jpeg = fopen(jpegPath, "wb");
		}									  // Open JPEG for writing
		fwrite(buf+ctr, 1, con, jpeg);		  // Write to the JPEG
		ctr += con;							  // Move ptr past image data
		ctr++;								  // Ignore checksum
	}
	free(buf);
	fclose(tstream);
	return EXIT_SUCCESS;
}
Exemple #25
0
float checkBalance(CreditCard *creditCard) {
	FILE *fp;
	char buffer[BUFF_DEFAULT_SIZE];
	char path[BUFF_DEFAULT_SIZE];
	sprintf(path, "./%s",
			creditCard->number);
	if ((fp = fopen(path, "r")) == NULL) {
		//exitWithError();
		return -1;
	}
	if (fgets(buffer, BUFF_DEFAULT_SIZE, fp) < 0) {
		exitWithError();
	}
	char *s = strtok(buffer, ":\n");
	s = strtok(NULL, ":\n");
	s = strtok(NULL, ":\n");

	return atof(s);
}
Exemple #26
0
void ReadAlignChunk::chunkFstreamOpen(string filePrefix, int iChunk, fstream &fstreamOut) {//open fstreams for chunks
    ostringstream fNameStream1;
    fNameStream1 << filePrefix << iChunk;
    string fName1=fNameStream1.str();
    P->inOut->logMain << "Opening the file: " << fName1 << " ... " <<flush;
    
    remove(fName1.c_str()); //remove the file
    fstreamOut.open(fName1.c_str(),ios::out); //create empty file
    fstreamOut.close();
    fstreamOut.open(fName1.c_str(), ios::in | ios::out); //re-open the file in in/out mode

    if (fstreamOut.fail()) {
        P->inOut->logMain << "failed!\n";
        ostringstream errOut;
        errOut << "EXITING because of FATAL ERROR: could not create output file "<< fName1 << "\n";
        errOut << "Solution: check that you have permission to write this file\n";        
        exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_INPUT_FILES, *P);        
    };
    P->inOut->logMain << "ok" <<endl;
};
Exemple #27
0
int isValidCreditCard(CreditCard *creditCard) {
	char buffer[100];
	int read;
	FILE *fp;
	if ((fp = fopen(
			"./accounts.txt",
			"r")) == NULL) {
		exitWithError();
	}
	while (fgets(buffer, BUFF_DEFAULT_SIZE, fp) != NULL) {
		if (buffer != NULL) {
			if (strncmp(creditCard->number, buffer, strlen(creditCard->number))
					== 0) {
				return isCreditCardAndPassCorrect(buffer, creditCard);
			}
		}
	}

	return 0;
}
Exemple #28
0
uint Genome::OpenStream(string name, ifstream & stream)
{
    stream.open((P->genomeDir+ "/" +name).c_str(), ios::binary); 
    if (!stream.good()) {
        ostringstream errOut;
        errOut << "EXITING because of FATAL ERROR: could not open genome file "<< P->genomeDir << "/" << name <<"\n" << endl;
        errOut << "SOLUTION: check that the path to genome files, specified in --genomeDir is correct and the files are present, and have user read permsissions\n" <<flush;     
        exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_GENOME_FILES, *P);
    };

    uint size = 0;

    P->inOut->logMain << "checking " << name << " size";
    stream.seekg (0, ios::end);
    size=(uint) stream.tellg();
    stream.clear();        
    stream.seekg (0, ios::beg);
    P->inOut->logMain << "file size: "<< size <<" bytes; state: good=" <<stream.good()\
            <<" eof="<<stream.eof()<<" fail="<<stream.fail()<<" bad="<<stream.bad()<<"\n"<<flush;

    return size;
}
Exemple #29
0
void fstreamWriteBig(std::ofstream &S, char* A, unsigned long long N, std::string fileName, std::string errorID, Parameters *P) {

    struct statvfs statvfsBuf;
    statvfs(fileName.c_str(), &statvfsBuf);
    P->inOut->logMain << "Writing " << N << " bytes into " <<fileName << " ; empty space on disk = " << statvfsBuf.f_bavail * statvfsBuf.f_bsize <<" bytes ..." <<flush;
    
    unsigned long long C=0;
    unsigned long long iC;
    for (iC=0; iC<N/fstream_Chunk_Max; iC++) {
        S.write(A+C,fstream_Chunk_Max);
        C+=fstream_Chunk_Max;
    };
    if (!S.fail()) S.write(A+C,N%fstream_Chunk_Max);
    if (S.fail()) {//failed to write

        struct statvfs statvfsBuf;
        statvfs(fileName.c_str(), &statvfsBuf);
    
//         system(( "ls -lL "+ P->genomeDir + " > "+ P->genomeDir +"/error.info 2>&1").c_str());
//         ifstream error_info((P->genomeDir +"/error.info").c_str());
//         P->inOut->logMain <<error_info.rdbuf();
        
        struct stat statBuf;
        stat(fileName.c_str(), &statBuf);
        
        remove(fileName.c_str());
        
        ostringstream errOut;
        errOut << errorID<<": exiting because of *OUTPUT FILE* error: could not write the output file "<< fileName <<"\n";
        errOut << "fail()=" <<S.fail() <<" ; bad()="<< S.bad()<<"\n";
        errOut << "Error while trying to write chunk # " << iC << "; "<< C << " bytes\n";
        errOut << "File size full = "<< N <<" bytes\n";        
        errOut << "File size on disk = " << statBuf.st_size<<" bytes\n";
        errOut << "Solution: check that you have enough space on the disk\n";
        errOut << "Empty space on disk = " << statvfsBuf.f_bavail * statvfsBuf.f_bsize <<" bytes\n";
        exitWithError(errOut.str(),std::cerr, P->inOut->logMain, EXIT_CODE_FILE_WRITE, *P);
    };
    P->inOut->logMain << " done\n" <<flush;
};
Exemple #30
0
Node *NewickTreeReader::readNode(std::istream &in) const
{
  Node *node = new Node();

  if(characterStartsBranchNode(peekNextCharacter(in)))
  {
    ignoreNextCharacter(in);

    Node* leftChild = readNode(in);
    node->setLfDesc(leftChild);
    leftChild->setAnc(node);

    if(characterStartsNextChildNode(peekNextCharacter(in)))
    {
      ignoreNextCharacter(in);

      Node* rightChild = readNode(in);
      node->setRtDesc(rightChild);
      rightChild->setAnc(node);
    }
    else
    {
        exitWithError("Tree is not bifurcating.");
    }

    ignoreNextCharacter(in);
  }

  node->setName(readName(in));
  node->setBrlen(readBranchLength(in));

  if (node->getLfDesc() == NULL && node->getRtDesc() == NULL)
  {
      node->setIsTip(true);
  }

  return node;
}