void io_close(struct io_file *f) { if (NULL != f) { unbuffer(f); close(f->fd); if (NULL != f->map) munmap(f->map,f->map_size); free(f); } }
int io_out(struct io_file *f,int pos,const void *o,int len) { int end = pos + len; if (0 == len) return pos; if (NULL == f || -1 == pos) return -1; if (NULL == o) return pos + len; if (remap(f,pos,len)) return -1; if (pos < f->file_size) { assert(pos >= f->map_offset); if (pos >= f->buffer_offset && unbuffer(f)) return -1; if (end > (int)(f->map_offset + f->map_size)) end = f->map_offset + f->map_size; if (end > f->file_size) end = f->file_size; memcpy(pos - f->map_offset + (char *) f->map,o,end - pos); } else { if (pos < f->buffer_offset || pos > (int)(f->buffer_offset + f->buffer_size)) { if (unbuffer(f)) return -1; if (lseek(f->fd,pos,SEEK_SET) == (off_t) -1) { perror("lseek"); return -1; } assert(0 == f->buffer_size); f->buffer_offset = pos; } else if (pos == (int)(f->buffer_offset + sizeof f->buffer)) if (unbuffer(f)) return -1; assert(pos >= f->buffer_offset && pos <= (int)(f->buffer_offset + f->buffer_size)); if (end > (int)(f->buffer_offset + sizeof f->buffer)) end = f->buffer_offset + sizeof f->buffer; memcpy(&f->buffer[pos - f->buffer_offset],o,end - pos); if ((int)(end - f->buffer_offset) > (int)f->buffer_size) f->buffer_size = end - f->buffer_offset; } return io_out(f,end,end - pos + (char *) o,len + pos - end); }
/* Resets f->file_size to the actual size of the file. Returns nonzero iff failed. */ static int checksize(struct io_file *f) { struct stat buf; if (unbuffer(f)) return -1; if (fstat(f->fd,&buf)) { perror("fstat"); return -1; } f->file_size = buf.st_size; return 0; }
int io_in(struct io_file *f,int pos,void *i,int len) { int end = pos + len; if (0 == len) return pos; if (NULL == f || -1 == pos) return -1; if (NULL == i) return pos + len; if (remap(f,pos,len)) return -1; if (unbuffer(f)) return -1; if (pos >= f->file_size && checksize(f)) return -1; if (pos >= f->file_size) { /* TODO: fill with zeroes instead */ fputs("read: EOF\n",stderr); return -1; } if (end > (int)(f->map_offset + f->map_size)) end = f->map_offset + f->map_size; if (end > f->file_size) end = f->file_size; memcpy(i,pos - f->map_offset + (char *) f->map,end - pos); return io_in(f,end,end - pos + (char *) i,len + pos - end); }
void ScoredSeqFlipMinus::deepUnbuffer(){ unbuffer(); _innerSeq->deepUnbuffer(); }
virtual int_type put (char_type c) { int_type result = traits_type::to_int_type (c); try { bool defaulting = false; if (!hold_.empty () && hold_.back () == '(') { // We don't need to hold it any more. unbuffer (); if (c == '\n') indentation_.push (indentation_.top () + spaces_); else indentation_.push (position_); } switch (c) { case '\n': { hold_.push_back (c); position_ = 0; // Starting a new line. if (construct_ == JAVA_COMMENT) { //std::cerr << "end comment" << endl; construct_ = OTHER; } break; } case '{': { ensure_new_line (); output_indentation (); result = write (c); ensure_new_line (); indentation_.push (indentation_.top () + spaces_); break; } case '}': { if (indentation_.size () > 1) indentation_.pop (); // Reduce multiple newlines to one. while (hold_.size () > 1) { typename Hold::reverse_iterator i = hold_.rbegin (); if (*i == '\n' && *(i + 1) == '\n') hold_.pop_back (); else break; } ensure_new_line (); output_indentation (); hold_.push_back (c); // Add newline after '}'. // ensure_new_line (); break; } case ';': { if (paren_balance_ != 0) { // We are inside for (;;) statement. Nothing to do here. // defaulting = true; } else if (construct_ != STRING_LITERAL && construct_ != CHAR_LITERAL) { output_indentation (); result = write (c); ensure_new_line (); } break; } case '\\': { if (construct_ != JAVA_COMMENT) { output_indentation (); hold_.push_back (c); position_++; } else defaulting = true; break; } case '\"': { if (construct_ != JAVA_COMMENT && (hold_.empty () || hold_.back () != '\\')) { // not escape sequence if (construct_ == STRING_LITERAL) construct_ = OTHER; else construct_ = STRING_LITERAL; } defaulting = true; break; } case '\'': { if (construct_ != JAVA_COMMENT && (hold_.empty () || hold_.back () != '\\')) { // not escape sequence if (construct_ == CHAR_LITERAL) construct_ = OTHER; else { //std::cerr << "char literal" << endl; construct_ = CHAR_LITERAL; } } defaulting = true; break; } case '(': { if (construct_ == OTHER) { // Hold it so that we can see what's coming next. // output_indentation (); hold_.push_back (c); position_++; paren_balance_++; } else defaulting = true; break; } case ')': { if (construct_ == OTHER) { if (indentation_.size () > 1) indentation_.pop (); if (paren_balance_ > 0) paren_balance_--; } defaulting = true; break; } case '/': { if (construct_ == OTHER) { if (!hold_.empty () && hold_.back () == '/') { construct_ = JAVA_COMMENT; //std::cerr << "start comment" << endl; defaulting = true; } else { output_indentation (); hold_.push_back (c); position_++; } } else { defaulting = true; } break; } default: { defaulting = true; break; } } if (defaulting) { output_indentation (); result = write (c); position_++; } } catch (Full const&) { result = traits_type::eof (); } return result; }
int enc_main(int argc, char **argv) { static char buf[128]; static const char magic[] = "Salted__"; BIO *in = NULL, *out = NULL, *b64 = NULL, *benc = NULL, *rbio = NULL, *wbio = NULL; EVP_CIPHER_CTX *ctx = NULL; const EVP_CIPHER *cipher = NULL, *c; const EVP_MD *dgst = NULL; char *hkey = NULL, *hiv = NULL, *hsalt = NULL, *p; char *infile = NULL, *outfile = NULL, *prog; char *str = NULL, *passarg = NULL, *pass = NULL, *strbuf = NULL; char mbuf[sizeof magic - 1]; OPTION_CHOICE o; int bsize = BSIZE, verbose = 0, debug = 0, olb64 = 0, nosalt = 0; int enc = 1, printkey = 0, i, k; int base64 = 0, informat = FORMAT_BINARY, outformat = FORMAT_BINARY; int ret = 1, inl, nopad = 0, non_fips_allow = 0; unsigned char key[EVP_MAX_KEY_LENGTH], iv[EVP_MAX_IV_LENGTH]; unsigned char *buff = NULL, salt[PKCS5_SALT_LEN]; unsigned long n; #ifdef ZLIB int do_zlib = 0; BIO *bzl = NULL; #endif /* first check the program name */ prog = opt_progname(argv[0]); if (strcmp(prog, "base64") == 0) base64 = 1; #ifdef ZLIB else if (strcmp(prog, "zlib") == 0) do_zlib = 1; #endif else { cipher = EVP_get_cipherbyname(prog); if (cipher == NULL && strcmp(prog, "enc") != 0) { BIO_printf(bio_err, "%s is not a known cipher\n", prog); goto end; } } prog = opt_init(argc, argv, enc_options); while ((o = opt_next()) != OPT_EOF) { switch (o) { case OPT_EOF: case OPT_ERR: opthelp: BIO_printf(bio_err, "%s: Use -help for summary.\n", prog); goto end; case OPT_HELP: opt_help(enc_options); ret = 0; BIO_printf(bio_err, "Cipher Types\n"); OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH, show_ciphers, bio_err); BIO_printf(bio_err, "\n"); goto end; case OPT_E: enc = 1; break; case OPT_IN: infile = opt_arg(); break; case OPT_OUT: outfile = opt_arg(); break; case OPT_PASS: passarg = opt_arg(); break; case OPT_ENGINE: (void)setup_engine(opt_arg(), 0); break; case OPT_D: enc = 0; break; case OPT_P: printkey = 1; break; case OPT_V: verbose = 1; break; case OPT_NOPAD: nopad = 1; break; case OPT_SALT: nosalt = 0; break; case OPT_NOSALT: nosalt = 1; break; case OPT_DEBUG: debug = 1; break; case OPT_UPPER_P: printkey = 2; break; case OPT_UPPER_A: olb64 = 1; break; case OPT_A: base64 = 1; break; case OPT_Z: #ifdef ZLIB do_zlib = 1; #endif break; case OPT_BUFSIZE: p = opt_arg(); i = (int)strlen(p) - 1; k = i >= 1 && p[i] == 'k'; if (k) p[i] = '\0'; if (!opt_ulong(opt_arg(), &n)) goto opthelp; if (k) n *= 1024; bsize = (int)n; break; case OPT_K: str = opt_arg(); break; case OPT_KFILE: in = bio_open_default(opt_arg(), 'r', FORMAT_TEXT); if (in == NULL) goto opthelp; i = BIO_gets(in, buf, sizeof buf); BIO_free(in); in = NULL; if (i <= 0) { BIO_printf(bio_err, "%s Can't read key from %s\n", prog, opt_arg()); goto opthelp; } while (--i > 0 && (buf[i] == '\r' || buf[i] == '\n')) buf[i] = '\0'; if (i <= 0) { BIO_printf(bio_err, "%s: zero length password\n", prog); goto opthelp; } str = buf; break; case OPT_UPPER_K: hkey = opt_arg(); break; case OPT_UPPER_S: hsalt = opt_arg(); break; case OPT_IV: hiv = opt_arg(); break; case OPT_MD: if (!opt_md(opt_arg(), &dgst)) goto opthelp; break; case OPT_NON_FIPS_ALLOW: non_fips_allow = 1; break; case OPT_CIPHER: if (!opt_cipher(opt_unknown(), &c)) goto opthelp; cipher = c; break; case OPT_NONE: cipher = NULL; break; } } argc = opt_num_rest(); argv = opt_rest(); if (cipher && EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER) { BIO_printf(bio_err, "%s: AEAD ciphers not supported\n", prog); goto end; } if (cipher && (EVP_CIPHER_mode(cipher) == EVP_CIPH_XTS_MODE)) { BIO_printf(bio_err, "%s XTS ciphers not supported\n", prog); goto end; } if (dgst == NULL) dgst = EVP_sha256(); /* It must be large enough for a base64 encoded line */ if (base64 && bsize < 80) bsize = 80; if (verbose) BIO_printf(bio_err, "bufsize=%d\n", bsize); if (base64) { if (enc) outformat = FORMAT_BASE64; else informat = FORMAT_BASE64; } strbuf = app_malloc(SIZE, "strbuf"); buff = app_malloc(EVP_ENCODE_LENGTH(bsize), "evp buffer"); if (debug) { BIO_set_callback(in, BIO_debug_callback); BIO_set_callback(out, BIO_debug_callback); BIO_set_callback_arg(in, (char *)bio_err); BIO_set_callback_arg(out, (char *)bio_err); } if (infile == NULL) { unbuffer(stdin); in = dup_bio_in(informat); } else in = bio_open_default(infile, 'r', informat); if (in == NULL) goto end; if (!str && passarg) { if (!app_passwd(passarg, NULL, &pass, NULL)) { BIO_printf(bio_err, "Error getting password\n"); goto end; } str = pass; } if ((str == NULL) && (cipher != NULL) && (hkey == NULL)) { for (;;) { char prompt[200]; BIO_snprintf(prompt, sizeof prompt, "enter %s %s password:"******"encryption" : "decryption"); strbuf[0] = '\0'; i = EVP_read_pw_string((char *)strbuf, SIZE, prompt, enc); if (i == 0) { if (strbuf[0] == '\0') { ret = 1; goto end; } str = strbuf; break; } if (i < 0) { BIO_printf(bio_err, "bad password read\n"); goto end; } } } out = bio_open_default(outfile, 'w', outformat); if (out == NULL) goto end; rbio = in; wbio = out; #ifdef ZLIB if (do_zlib) { if ((bzl = BIO_new(BIO_f_zlib())) == NULL) goto end; if (enc) wbio = BIO_push(bzl, wbio); else rbio = BIO_push(bzl, rbio); } #endif if (base64) { if ((b64 = BIO_new(BIO_f_base64())) == NULL) goto end; if (debug) { BIO_set_callback(b64, BIO_debug_callback); BIO_set_callback_arg(b64, (char *)bio_err); } if (olb64) BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL); if (enc) wbio = BIO_push(b64, wbio); else rbio = BIO_push(b64, rbio); } if (cipher != NULL) { /* * Note that str is NULL if a key was passed on the command line, so * we get no salt in that case. Is this a bug? */ if (str != NULL) { /* * Salt handling: if encrypting generate a salt and write to * output BIO. If decrypting read salt from input BIO. */ unsigned char *sptr; if (nosalt) sptr = NULL; else { if (enc) { if (hsalt) { if (!set_hex(hsalt, salt, sizeof salt)) { BIO_printf(bio_err, "invalid hex salt value\n"); goto end; } } else if (RAND_bytes(salt, sizeof salt) <= 0) goto end; /* * If -P option then don't bother writing */ if ((printkey != 2) && (BIO_write(wbio, magic, sizeof magic - 1) != sizeof magic - 1 || BIO_write(wbio, (char *)salt, sizeof salt) != sizeof salt)) { BIO_printf(bio_err, "error writing output file\n"); goto end; } } else if (BIO_read(rbio, mbuf, sizeof mbuf) != sizeof mbuf || BIO_read(rbio, (unsigned char *)salt, sizeof salt) != sizeof salt) { BIO_printf(bio_err, "error reading input file\n"); goto end; } else if (memcmp(mbuf, magic, sizeof magic - 1)) { BIO_printf(bio_err, "bad magic number\n"); goto end; } sptr = salt; } if (!EVP_BytesToKey(cipher, dgst, sptr, (unsigned char *)str, strlen(str), 1, key, iv)) { BIO_printf(bio_err, "EVP_BytesToKey failed\n"); goto end; } /* * zero the complete buffer or the string passed from the command * line bug picked up by Larry J. Hughes Jr. <*****@*****.**> */ if (str == strbuf) OPENSSL_cleanse(str, SIZE); else OPENSSL_cleanse(str, strlen(str)); } if (hiv != NULL) { int siz = EVP_CIPHER_iv_length(cipher); if (siz == 0) { BIO_printf(bio_err, "warning: iv not use by this cipher\n"); } else if (!set_hex(hiv, iv, sizeof iv)) { BIO_printf(bio_err, "invalid hex iv value\n"); goto end; } } if ((hiv == NULL) && (str == NULL) && EVP_CIPHER_iv_length(cipher) != 0) { /* * No IV was explicitly set and no IV was generated during * EVP_BytesToKey. Hence the IV is undefined, making correct * decryption impossible. */ BIO_printf(bio_err, "iv undefined\n"); goto end; } if ((hkey != NULL) && !set_hex(hkey, key, EVP_CIPHER_key_length(cipher))) { BIO_printf(bio_err, "invalid hex key value\n"); goto end; } if ((benc = BIO_new(BIO_f_cipher())) == NULL) goto end; /* * Since we may be changing parameters work on the encryption context * rather than calling BIO_set_cipher(). */ BIO_get_cipher_ctx(benc, &ctx); if (non_fips_allow) EVP_CIPHER_CTX_set_flags(ctx, EVP_CIPH_FLAG_NON_FIPS_ALLOW); if (!EVP_CipherInit_ex(ctx, cipher, NULL, NULL, NULL, enc)) { BIO_printf(bio_err, "Error setting cipher %s\n", EVP_CIPHER_name(cipher)); ERR_print_errors(bio_err); goto end; } if (nopad) EVP_CIPHER_CTX_set_padding(ctx, 0); if (!EVP_CipherInit_ex(ctx, NULL, NULL, key, iv, enc)) { BIO_printf(bio_err, "Error setting cipher %s\n", EVP_CIPHER_name(cipher)); ERR_print_errors(bio_err); goto end; } if (debug) { BIO_set_callback(benc, BIO_debug_callback); BIO_set_callback_arg(benc, (char *)bio_err); } if (printkey) { if (!nosalt) { printf("salt="); for (i = 0; i < (int)sizeof(salt); i++) printf("%02X", salt[i]); printf("\n"); } if (cipher->key_len > 0) { printf("key="); for (i = 0; i < cipher->key_len; i++) printf("%02X", key[i]); printf("\n"); } if (cipher->iv_len > 0) { printf("iv ="); for (i = 0; i < cipher->iv_len; i++) printf("%02X", iv[i]); printf("\n"); } if (printkey == 2) { ret = 0; goto end; } } } /* Only encrypt/decrypt as we write the file */ if (benc != NULL) wbio = BIO_push(benc, wbio); for (;;) { inl = BIO_read(rbio, (char *)buff, bsize); if (inl <= 0) break; if (BIO_write(wbio, (char *)buff, inl) != inl) { BIO_printf(bio_err, "error writing output file\n"); goto end; } } if (!BIO_flush(wbio)) { BIO_printf(bio_err, "bad decrypt\n"); goto end; } ret = 0; if (verbose) { BIO_printf(bio_err, "bytes read :%8"PRIu64"\n", BIO_number_read(in)); BIO_printf(bio_err, "bytes written:%8"PRIu64"\n", BIO_number_written(out)); } end: ERR_print_errors(bio_err); OPENSSL_free(strbuf); OPENSSL_free(buff); BIO_free(in); BIO_free_all(out); BIO_free(benc); BIO_free(b64); #ifdef ZLIB BIO_free(bzl); #endif OPENSSL_free(pass); return (ret); }
ScoredSeqSubseq::~ScoredSeqSubseq(){ //_readCount--; unbuffer(); }
void ScoredSeqSubseq::deepUnbuffer(){ unbuffer(); _innerSeq->deepUnbuffer(); }