int lf_get_next_entry(int logfile_fd, lf_entry *nextentry, int vers) { unsigned char blockbuf[60], *tmp; int uln, ret; if ((ret = correct_read(logfile_fd, (void *) blockbuf, (size_t) 60)) != 60) { if (ret == 0) return 1; /* fprintf(stderr, "read 60 failed...%d\n", ret); */ return 2; } /* We got one! */ nextentry->version = vers; memcpy( &(nextentry->crs), blockbuf+0, 4); memcpy( &(nextentry->cru), blockbuf+4, 4); memcpy( &(nextentry->srs), blockbuf+8, 4); memcpy( &(nextentry->sru), blockbuf+12, 4); memcpy( &(nextentry->sls), blockbuf+16, 4); memcpy( &(nextentry->slu), blockbuf+20, 4); memcpy( &(nextentry->cip), blockbuf+24, 4); memcpy( &(nextentry->cpt), blockbuf+28, 2); memcpy( &(nextentry->sip), blockbuf+30, 4); memcpy( &(nextentry->spt), blockbuf+34, 2); memcpy( &(nextentry->cprg), blockbuf+36, 1); memcpy( &(nextentry->sprg), blockbuf+37, 1); memcpy( &(nextentry->cims), blockbuf+38, 4); memcpy( &(nextentry->sexp), blockbuf+42, 4); memcpy( &(nextentry->slmd), blockbuf+46, 4); memcpy( &(nextentry->rhl), blockbuf+50, 4); memcpy( &(nextentry->rdl), blockbuf+54, 4); memcpy( &(nextentry->urllen), blockbuf+58, 2); /* Now let's read in that url */ uln = ntohs(nextentry->urllen); nextentry->url = (unsigned char *) malloc(sizeof(char) * (int) (uln + 1)); if (nextentry->url == NULL) { fprintf(stderr, "out of memory in lf_get_next_netry!\n"); exit(1); } if ((ret = correct_read(logfile_fd, (void *) (nextentry->url), (size_t) uln)) != uln ) { if (ret == 0) { free(nextentry->url); return 1; } fprintf(stderr, "read of %d failed %d\n", (size_t) uln, ret); perror("aargh."); free(nextentry->url); return 2; } tmp = nextentry->url; *(tmp + uln) = '\0'; return 0; }
char *read_request(int fd) { char *request = (char *) malloc(REQUEST_SIZE * sizeof(char)); int ret; if (request == NULL) { fprintf(stderr, "(SERVER): out of memory!\n"); exit(-1); } ret = correct_read(fd, request, REQUEST_SIZE); if (ret != REQUEST_SIZE) { free(request); request = NULL; } return request; }
int main(int argc, char **argv) { int socket_talk, i; char request[REQUEST_SIZE]; char response[RESPONSE_SIZE]; if (argc != 3) { fprintf(stderr, "(CLIENT): Invoke as 'client machine.name.address socknum'\n"); exit(1); } // initialize request to some silly data for (i=0; i<REQUEST_SIZE; i++) { request[i] = (char) i%255; } // spin forever, opening connections, and pushing requests while(1) { int result; // open up a connection to the server if ((socket_talk = sconnect(argv[1], argv[2])) < 0) { perror("(CLIENT): sconnect"); exit(1); } // write the request result = correct_write(socket_talk, request, REQUEST_SIZE); if (result == REQUEST_SIZE) { // read the response result = correct_read(socket_talk, response, RESPONSE_SIZE); } fprintf(stderr, "Result from server = %d", result); close(socket_talk); } return 0; }
void C_correct_errors::correct_errors_in_reads(const C_arg& c_inst_args, const std::string& error_correction_info_file_name, CKMCFile& kmc_file) { std::ofstream& f_log = Log::get_stream(); std::size_t current_chunk = 0; std::size_t NN = 0; #ifdef USE_THREADS #pragma omp parallel num_threads(c_inst_args.n_threads) #endif { std::size_t local_chunk = 0; #ifdef USE_FILE_READER FileReader f_read; #else std::ifstream f_read; #endif std::size_t total_num_corrected_errors_step1_1(0); std::size_t total_num_corrected_errors_step1_2(0); std::size_t total_num_corrected_errors_step1_3(0); std::size_t total_num_corrected_errors_step2_1(0); std::size_t total_num_corrected_errors_step2_2(0); std::size_t num_corrected_errors_step1_1(0); std::size_t num_corrected_errors_step1_2(0); std::size_t num_corrected_errors_step1_3(0); std::size_t num_corrected_errors_step2_1(0); std::size_t num_corrected_errors_step2_2(0); std::size_t num_corrected_reads(0); C_correct_read correct_read(quality_score_offset, c_inst_args.kmer_length, c_inst_args.extend, max_read_length, read_file_name, num_corrected_errors_step1_1, num_corrected_errors_step1_2, num_corrected_errors_step1_3, num_corrected_errors_step2_1, num_corrected_errors_step2_2, kmc_file); // perform correction while some chunks are available while (true) { bool exit_loop = false; #ifdef USE_THREADS #pragma omp critical #endif { if (current_chunk >= n_chunks) { exit_loop = true; } local_chunk = current_chunk++; } if (exit_loop) { break; } // open error correction information files std::ofstream f_error_correction; f_error_correction.open(get_error_correction_info_file_name(error_correction_info_file_name, local_chunk).c_str(), std::ios::binary); // check error correction information files if (f_error_correction.is_open() == false) { std::cout << std::endl << "ERROR: Cannot open " << get_error_correction_info_file_name(error_correction_info_file_name, local_chunk) << std::endl << std::endl; f_log << std::endl << "ERROR: Cannot open " << get_error_correction_info_file_name(error_correction_info_file_name, local_chunk) << std::endl << std::endl; exit(EXIT_FAILURE); } #ifdef USE_FILE_READER // open read files f_read.setFileName(read_file_name, read_file_type); // iterate reads if (f_read.openFile(FileReader::READ)) { f_read.seekPos(chunks[local_chunk]); // header f_read.getLine(correct_read.header); #else // open read files f_read.open(read_file_name.c_str()); // iterate reads if (f_read.is_open()) { f_read.seekg(chunks[local_chunk]); // header getline(f_read, correct_read.header); #endif std::string& sequence_modification = correct_read.sequence_modification; const std::size_t chunk_size = n_chunks == 1 ? 0 : num_reads / (n_chunks - 1); const std::size_t rest_size = n_chunks == 1 ? num_reads : num_reads % (n_chunks - 1); std::size_t local_read = 0; // perform correction for every read in current chunk while ((local_chunk < (n_chunks - 1) && local_read < chunk_size) || (local_chunk == (n_chunks - 1) && local_read < rest_size)) { if (f_read.eof()) { std::cout << "Erroneous chunk size (reads missing)." << std::endl; f_log << "Erroneous chunk size (reads missing)." << std::endl; exit(EXIT_FAILURE); } num_corrected_errors_step1_1 = 0; num_corrected_errors_step1_2 = 0; num_corrected_errors_step1_3 = 0; num_corrected_errors_step2_1 = 0; num_corrected_errors_step2_2 = 0; ++local_read; #ifdef USE_FILE_READER // DNA sequence f_read.getLine(correct_read.sequence); std::size_t current_read_length = correct_read.sequence.length(); // "+" f_read.getLine(correct_read.connector); // quality score f_read.getLine(correct_read.quality_score); #else // DNA sequence getline(f_read, correct_read.sequence); std::size_t current_read_length = correct_read.sequence.length(); // "+" getline(f_read, correct_read.connector); // quality score getline(f_read, correct_read.quality_score); #endif bool too_many_errors(false); std::fill(sequence_modification.begin(), sequence_modification.begin() + current_read_length, '0'); if (current_read_length > correct_read.kmer_length) { // change sequences to upper case transform(correct_read.sequence.begin(), correct_read.sequence.end(), correct_read.sequence.begin(), ::toupper); // count and substitute Ns other characters std::size_t number_of_Ns = 0; for (std::size_t it = 0; it < current_read_length; ++it) { bool is_nucleotide = false; for (std::size_t it_nucl = 0; it_nucl < NUM_NEOCLEOTIDE; ++it_nucl) { if (correct_read.sequence[it] == NEOCLEOTIDE[it_nucl]) { is_nucleotide = true; break; } } if (!is_nucleotide) { ++number_of_Ns; correct_read.sequence[it] = SUBST_CHAR; } } ++NN; //---------------------------------------------------------------------- // correct errors in a read //---------------------------------------------------------------------- #ifdef USE_THREADS #ifndef DONT_PRINT_COUNTER #pragma omp critical #endif #endif { #ifndef DONT_PRINT_COUNTER if (NN % COUNTER_FREQ == 0) { std::cout << NN << "\r"; std::cout.flush(); } #endif } // update num_corrected_reads if (number_of_Ns < current_read_length * MAX_N_RATE) { correct_read.read_length = current_read_length; correct_read.correct_errors_in_a_read_fastq(); std::size_t sum_errors = num_corrected_errors_step1_1 + num_corrected_errors_step1_2 + num_corrected_errors_step1_3 + num_corrected_errors_step2_1 + num_corrected_errors_step2_2; if (sum_errors > (current_read_length * MAX_ERROR_RATE)) { too_many_errors = true; } else if (sum_errors > 0) { total_num_corrected_errors_step1_1 += num_corrected_errors_step1_1; total_num_corrected_errors_step1_2 += num_corrected_errors_step1_2; total_num_corrected_errors_step1_3 += num_corrected_errors_step1_3; total_num_corrected_errors_step2_1 += num_corrected_errors_step2_1; total_num_corrected_errors_step2_2 += num_corrected_errors_step2_2; num_corrected_reads++; } } else { too_many_errors = true; } } write_single_read(correct_read.sequence, sequence_modification, current_read_length, too_many_errors, f_error_correction); #ifdef USE_FILE_READER // header f_read.getLine(correct_read.header); #else // header getline(f_read, correct_read.header); #endif } } else { std::cout << std::endl << "ERROR: Cannot open " << read_file_name << std::endl << std::endl; f_log << std::endl << "ERROR: Cannot open " << read_file_name << std::endl << std::endl; exit(EXIT_FAILURE); } // close read files f_read.close(); // close error correction information files f_error_correction.close(); } #ifdef USE_THREADS #pragma omp critical #endif { global_num_corrected_reads += num_corrected_reads; } } std::cout << " Number of corrected reads : " << std::setw(10) << global_num_corrected_reads << std::endl; std::cout << " Correcting errors in reads: done" << std::endl << std::endl; f_log << " Number of corrected reads : " << std::setw(10) << global_num_corrected_reads << std::endl; f_log << " Correcting errors in reads: done" << std::endl << std::endl; } //---------------------------------------------------------------------- // Saves corrected read into a temporary file. //---------------------------------------------------------------------- void C_correct_errors::write_single_read(const std::string& correct_read_sequence, const std::string& sequence_modification, const std::size_t read_length, const bool too_many_errors, std::ofstream& f_error_correction) { // write remaining bps into the vectors const std::size_t residue_read(read_length % BPS_PER_BYTE); //---------------------------------------------------------------------- // write error correction information to files //---------------------------------------------------------------------- char buffer = ZERO; std::size_t it_mod; for (it_mod = 0; it_mod < read_length; it_mod++) { if (too_many_errors == true) { encode_correction_info(buffer, correct_read_sequence[it_mod], '0'); } else { encode_correction_info(buffer, correct_read_sequence[it_mod], sequence_modification[it_mod]); } if ((it_mod % BPS_PER_BYTE) == (BPS_PER_BYTE - 1)) { // update write_buffer* f_error_correction.write(&buffer, 1); // initialize buffer buffer &= ZERO; } } // read_length is a multiple of BPS_PER_BYTE // do nothing if (residue_read == 0) { } // read_length is not a multiple of BPS_PER_BYTE else { for (std::size_t it_fill = 0; it_fill < (BPS_PER_BYTE - residue_read); it_fill++) { buffer = buffer << 2; } // fill the last entry f_error_correction.write(&buffer, 1); } } //---------------------------------------------------------------------- // Saves read symbol in two bits. //---------------------------------------------------------------------- inline void C_correct_errors::encode_correction_info(char& buffer, const char char_in_read, const char char_in_info) { buffer <<= 2; if (char_in_info != '0') { unsigned char read_id; unsigned char in_id; switch (char_in_info) { case 'A': in_id = 0; break; case 'C': in_id = 1; break; case 'G': in_id = 2; break; case 'T': in_id = 3; break; default: return; } switch (char_in_read) { case 'A': read_id = 0; break; case 'C': read_id = 1; break; case 'G': read_id = 2; break; case 'T': read_id = 3; break; default: return; } buffer |= (in_id - read_id + 4) % 4; } }