int compress_data(void *in_buf, size_t in_len, void *out_buf, size_t *out_len, int type) { int ret; if (in_len < UBIFS_MIN_COMPR_LEN) { no_compress(in_buf, in_len, out_buf, out_len); return MKFS_UBIFS_COMPR_NONE; } if (c->favor_lzo) ret = favor_lzo_compress(in_buf, in_len, out_buf, out_len, &type); else { switch (type) { case MKFS_UBIFS_COMPR_LZO: ret = lzo_compress(in_buf, in_len, out_buf, out_len); break; case MKFS_UBIFS_COMPR_ZLIB: ret = zlib_deflate(in_buf, in_len, out_buf, out_len); break; case MKFS_UBIFS_COMPR_NONE: ret = 1; break; default: errcnt += 1; ret = 1; break; } } if (ret || *out_len >= in_len) { no_compress(in_buf, in_len, out_buf, out_len); return MKFS_UBIFS_COMPR_NONE; } return type; }
/* delete = 1 Do delete dbdata delete = 0 Do not delete dbdta */ unsigned int file_commit_block(unsigned char *dbdata, INOBNO inobno, off_t offset) { unsigned char *stiger; compr *compressed; INUSE *inuse; OFFHASH *offhash; unsigned int ret = 0; #ifndef SHA3 word64 res[3]; #endif FUNC; #ifdef SHA3 stiger=sha_binhash(dbdata, BLKSIZE); #else binhash(dbdata, BLKSIZE, res); stiger=(unsigned char *)&res; #endif #ifdef LZO compressed = lzo_compress((unsigned char *) dbdata, BLKSIZE); #else compressed = clz_compress((unsigned char *) dbdata, BLKSIZE); #endif ret = compressed->size; inuse = file_get_inuse(stiger); if (NULL == inuse) { loghash("commit_block : write hash with file_qdta", stiger); inuse = s_malloc(sizeof(INUSE)); inuse->inuse = 0; inuse->offset = get_offset(compressed->size); inuse->size = compressed->size; file_qdta(&inobno, stiger, compressed->data, compressed->size, inuse->offset); } else loghash("commit_block : only updated inuse for hash ", stiger); inuse->inuse++; file_update_inuse(stiger, inuse); comprfree(compressed); offhash = s_malloc(sizeof(OFFHASH)); offhash->offset = offset; memcpy(offhash->stiger, stiger, config->hashlen); write_dbb_to_cache(&inobno, offhash); #ifdef SHA3 free(stiger); #endif free(inuse); return (ret); }
static int favor_lzo_compress(void *in_buf, size_t in_len, void *out_buf, size_t *out_len, int *type) { int lzo_ret, zlib_ret; size_t lzo_len, zlib_len; lzo_len = zlib_len = *out_len; lzo_ret = lzo_compress(in_buf, in_len, out_buf, &lzo_len); zlib_ret = zlib_deflate(in_buf, in_len, zlib_buf, &zlib_len); if (lzo_ret && zlib_ret) /* Both compressors failed */ return -1; if (!lzo_ret && !zlib_ret) { double percent; /* Both compressors succeeded */ if (lzo_len <= zlib_len ) goto select_lzo; percent = (double)zlib_len / (double)lzo_len; percent *= 100; if (percent > 100 - c->favor_percent) goto select_lzo; goto select_zlib; } if (lzo_ret) /* Only zlib compressor succeeded */ goto select_zlib; /* Only LZO compressor succeeded */ select_lzo: *out_len = lzo_len; *type = MKFS_UBIFS_COMPR_LZO; return 0; select_zlib: *out_len = zlib_len; *type = MKFS_UBIFS_COMPR_ZLIB; memcpy(out_buf, zlib_buf, zlib_len); return 0; }
/* * Compress, fragment, encrypt and HMAC-sign an outgoing packet. * Input: c->c2.buf * Output: c->c2.to_link */ void encrypt_sign (struct context *c, bool comp_frag) { struct context_buffers *b = c->c2.buffers; const uint8_t *orig_buf = c->c2.buf.data; #if P2MP_SERVER /* * Drop non-TLS outgoing packet if client-connect script/plugin * has not yet succeeded. */ if (c->c2.context_auth != CAS_SUCCEEDED) c->c2.buf.len = 0; #endif if (comp_frag) { #ifdef ENABLE_LZO /* Compress the packet. */ if (lzo_defined (&c->c2.lzo_compwork)) lzo_compress (&c->c2.buf, b->lzo_compress_buf, &c->c2.lzo_compwork, &c->c2.frame); #endif #ifdef ENABLE_FRAGMENT if (c->c2.fragment) fragment_outgoing (c->c2.fragment, &c->c2.buf, &c->c2.frame_fragment); #endif } #ifdef ENABLE_CRYPTO #ifdef ENABLE_SSL /* * If TLS mode, get the key we will use to encrypt * the packet. */ if (c->c2.tls_multi) { tls_pre_encrypt (c->c2.tls_multi, &c->c2.buf, &c->c2.crypto_options); } #endif /* * Encrypt the packet and write an optional * HMAC signature. */ openvpn_encrypt (&c->c2.buf, b->encrypt_buf, &c->c2.crypto_options, &c->c2.frame); #endif /* * Get the address we will be sending the packet to. */ link_socket_get_outgoing_addr (&c->c2.buf, get_link_socket_info (c), &c->c2.to_link_addr); #ifdef ENABLE_CRYPTO #ifdef ENABLE_SSL /* * In TLS mode, prepend the appropriate one-byte opcode * to the packet which identifies it as a data channel * packet and gives the low-permutation version of * the key-id to the recipient so it knows which * decrypt key to use. */ if (c->c2.tls_multi) { tls_post_encrypt (c->c2.tls_multi, &c->c2.buf); } #endif #endif /* if null encryption, copy result to read_tun_buf */ buffer_turnover (orig_buf, &c->c2.to_link, &c->c2.buf, &b->read_tun_buf); }
lzo_bool x_compress(file_t *fip, file_t *fop, header_t *h) { lzo_bool ok = 0; init_compress_header(h,fip,fop); switch (h->method) { #if defined(WITH_LZO) case M_LZO1X_1: case M_LZO1X_1_15: case M_LZO1X_999: lzo_init_compress_header(h); break; #endif #if defined(WITH_NRV) case M_NRV1A: case M_NRV1B: case M_NRV2A: case M_NRV2B: nrv_init_compress_header(h); break; #endif #if defined(WITH_ZLIB) case M_ZLIB: zlib_init_compress_header(h); break; #endif default: fatal(fip,"Internal error"); break; } if (!x_enter(h)) e_memory(); if (opt_verbose > 1) { if (opt_unlink) fprintf(con_term,"replacing %s with %s", fip->name, fop->name); else fprintf(con_term,"compressing %s into %s", fip->name, fop->name); fflush(con_term); set_err_nl(1); } write_header(fop,h); fip->bytes_processed = fop->bytes_processed = 0; switch (h->method) { #if defined(WITH_LZO) case M_LZO1X_1: case M_LZO1X_1_15: case M_LZO1X_999: ok = lzo_compress(fip,fop,h); break; #endif #if defined(WITH_NRV) case M_NRV1A: case M_NRV1B: case M_NRV2A: case M_NRV2B: ok = nrv_compress(fip,fop,h); break; #endif #if defined(WITH_ZLIB) case M_ZLIB: ok = zlib_compress(fip,fop,h); break; #endif default: fatal(fip,"Internal error"); ok = 0; break; } if (opt_cmd == CMD_COMPRESS && opt_verbose > 1) { fprintf(con_term, ok ? "\n" : " FAILED\n"); fflush(con_term); } set_err_nl(0); x_leave(h); return ok; }
void add_file_block(BLKDTA * blkdta) { INOBNO inobno; DBT *cachedata = NULL; INUSE *inuse; OFFHASH *offhash; inobno.inode = blkdta->inode; inobno.blocknr = blkdta->blocknr; FUNC; LDEBUG("add_file_block : inode %llu - %llu", inobno.inode, inobno.blocknr); if (blkdta->bsize + blkdta->offsetblock < BLKSIZE) { // Flush the blockcache before overwriting. cachedata = try_block_cache(blkdta->inode, blkdta->blocknr, 0); if (cachedata) DBTfree(cachedata); add_blk_to_cache(blkdta->inode, blkdta->blocknr, blkdta->bsize + blkdta->offsetblock, blkdta->blockfiller, blkdta->offsetfile); LDEBUG ("add_file_block : wrote with add_blk_to_cache : inode %llu - %llu size %i", inobno.inode, inobno.blocknr, blkdta->bsize); update_filesize(blkdta->inode, blkdta->bsize, blkdta->offsetblock, blkdta->blocknr, blkdta->sparse, 0, 0); return; } inuse = file_get_inuse(blkdta->stiger); if (inuse == NULL) { if (NULL == blkdta->compressed) { #ifdef LZO blkdta->compressed = lzo_compress(blkdta->blockfiller, BLKSIZE); #else blkdta->compressed = clz_compress(blkdta->blockfiller, BLKSIZE); #endif } LDEBUG("Compressed %i bytes to %lu bytes", BLKSIZE, blkdta->compressed->size); loghash("add_file_block call qdta for hash :", blkdta->stiger); inuse = s_malloc(sizeof(INUSE)); inuse->inuse = 0; inuse->offset = get_offset(blkdta->compressed->size); LDEBUG("add to offset %llu", inuse->offset); inuse->size = blkdta->compressed->size; file_qdta(&inobno, blkdta->stiger, blkdta->compressed->data, blkdta->compressed->size, inuse->offset); loghash("add_file_block queued with qdta", blkdta->stiger); update_filesize(blkdta->inode, blkdta->bsize, blkdta->offsetblock, blkdta->blocknr, blkdta->sparse, blkdta->compressed->size, 0); } else { update_filesize(blkdta->inode, blkdta->bsize, blkdta->offsetblock, blkdta->blocknr, blkdta->sparse, 0, 1); } if (NULL != blkdta->compressed) comprfree(blkdta->compressed); inuse->inuse = inuse->inuse + 1; file_update_inuse(blkdta->stiger, inuse); offhash = s_malloc(sizeof(OFFHASH)); offhash->offset = blkdta->offsetfile; memcpy(offhash->stiger, blkdta->stiger, config->hashlen); write_dbb_to_cache(&inobno, offhash); free(offhash); free(inuse); EFUNC; return; }