void FileBundlePackImport::CloseNoUpdate() { FlushWriteBuffer(); khLockGuard lock(modify_lock()); while (!SegmentsEmpty()) { FileBundleSegment *close_seg = PopBackSegment(); delete close_seg; } }
void CDeflateCompressor::FinishCompression(bool bAfterException) { m_stream.avail_in = 0; if (!bAfterException) { if (m_pFile->m_uMethod == methodDeflate) { int err; do { if (m_stream.avail_out == 0) { FlushWriteBuffer(); m_stream.avail_out = m_pBuffer.GetSize(); m_stream.next_out = (zarch_Bytef*)(char*)m_pBuffer; } ZIP_SIZE_TYPE uTotal = m_stream.total_out; err = zarch_deflate(&m_stream, Z_FINISH); m_uComprLeft += m_stream.total_out - uTotal; } while (err == Z_OK); if (err == Z_STREAM_END) err = Z_OK; CheckForError(err); if (m_uComprLeft > 0) FlushWriteBuffer(); CheckForError(zarch_deflateEnd(&m_stream)); } // it may be increased by the encrypted header size in CZipFileHeader::PrepareData m_pFile->m_uComprSize += m_stream.total_out; m_pFile->m_uUncomprSize = m_stream.total_in; } EmptyPtrList(); ReleaseBuffer(); }
void CDeflateCompressor::Compress(const void *pBuffer, DWORD uSize) { UpdateFileCrc(pBuffer, uSize); if (m_pFile->m_uMethod == methodDeflate) { m_stream.next_in = (zarch_Bytef*)pBuffer; m_stream.avail_in = uSize; while (m_stream.avail_in > 0) { if (m_stream.avail_out == 0) { FlushWriteBuffer(); m_stream.avail_out = m_pBuffer.GetSize(); m_stream.next_out = (zarch_Bytef*)(char*)m_pBuffer; } ZIP_ZLIB_TYPE uTotal = m_stream.total_out; CheckForError(zarch_deflate(&m_stream, Z_NO_FLUSH)); m_uComprLeft += m_stream.total_out - uTotal; } } else if (uSize > 0) { if (m_pCryptograph) { if (m_pBuffer.GetSize() < uSize) { m_pBuffer.Allocate(uSize); } memcpy(m_pBuffer, pBuffer, uSize); WriteBuffer(m_pBuffer, uSize); } else m_pStorage->Write(pBuffer, uSize, false); m_stream.total_in += uSize; m_stream.total_out += uSize; } }
/*----------------------------------------------------------------------------*/ static inline char * GetWriteBuffer(struct mtcp_thread_context *ctx, int method, int ifidx, int len) { struct ps_chunk *w_chunk = ctx->w_chunk; uint32_t *w_off = ctx->w_off; int w_idx; assert(w_chunk != NULL); assert(w_off != NULL); if (ifidx < 0 || ifidx >= g_config.mos->netdev_table->num ) return NULL; //pthread_mutex_lock(&ctx->send_lock); if (ctx->w_cur_idx[ifidx] + w_chunk[ifidx].cnt >= MAX_SEND_PCK_CHUNK) { if (method == BUF_RET_MAYBE) { return NULL; } else if (method == BUF_RET_ALWAYS) { if (FlushWriteBuffer(ctx, ifidx) <= 0) return NULL; } else { assert(0); } } assert(ctx->w_cur_idx[ifidx] + w_chunk[ifidx].cnt < MAX_SEND_PCK_CHUNK); assert(w_off[ifidx] < MAX_PACKET_SIZE * MAX_CHUNK_SIZE); w_idx = w_chunk[ifidx].cnt++; w_chunk[ifidx].info[w_idx].len = len; w_chunk[ifidx].info[w_idx].offset = w_off[ifidx]; w_off[ifidx] += (len + 63) / 64 * 64; //pthread_mutex_unlock(&ctx->send_lock); return (w_chunk[ifidx].buf + w_chunk[ifidx].info[w_idx].offset); }
bool SocketManager<B>::BufferWriteBytes(B &pkt_buf, size_t len, uchar type) { size_t window, pkt_buf_ptr = 0; int len_nb; // length in network byte order // check if we don't have enough space in the buffer if (wbuf.GetMaxSize() - wbuf.buf_ptr < 1 + sizeof(int32_t)) { // buffer needs to be flushed before adding header FlushWriteBuffer(); } // assuming wbuf is now large enough to // fit type and size fields in one go if (type != 0) { // type shouldn't be ignored wbuf.buf[wbuf.buf_ptr++] = type; } // make len include its field size as well len_nb = htonl(len + sizeof(int32_t)); // append the bytes of this integer in network-byte order std::copy(reinterpret_cast<uchar *>(&len_nb), reinterpret_cast<uchar *>(&len_nb) + 4, std::begin(wbuf.buf) + wbuf.buf_ptr); // move the write buffer pointer and update size of the socket buffer wbuf.buf_ptr += sizeof(int32_t); wbuf.buf_size = wbuf.buf_ptr; // fill the contents while (len) { window = wbuf.GetMaxSize() - wbuf.buf_ptr; if (len <= window) { // contents fit in the window, range copy "len" bytes std::copy(std::begin(pkt_buf) + pkt_buf_ptr, std::begin(pkt_buf) + pkt_buf_ptr + len, std::begin(wbuf.buf) + wbuf.buf_ptr); // Move the cursor and update size of socket buffer wbuf.buf_ptr += len; wbuf.buf_size = wbuf.buf_ptr; return true; } else { /* contents longer than socket buffer size, fill up the socket buffer * with "window" bytes */ std::copy(std::begin(pkt_buf) + pkt_buf_ptr, std::begin(pkt_buf) + pkt_buf_ptr + window, std::begin(wbuf.buf) + wbuf.buf_ptr); // move the packet's cursor pkt_buf_ptr += window; len -= window; wbuf.buf_size = wbuf.GetMaxSize(); // write failure if (!FlushWriteBuffer()) return false; } } return true; }
void FileBundleWriter::Checkpoint() { FlushWriteBuffer(); SaveHeaderFileWithLock(); }
void geFilePool::Writer::Pread(void *buffer, size_t size, off64_t offset) { FlushWriteBuffer(); fileref->Pread(buffer, size, offset); }
void geFilePool::Writer::SyncAndClose(void) { FlushWriteBuffer(); fileref->Close(); }