static svn_error_t * test_spillbuf__interleaving(apr_pool_t *pool, svn_spillbuf_t* buf) { SVN_ERR(svn_spillbuf__write(buf, "abcdef", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ghijkl", 6, pool)); /* now: two blocks: 8 and 4 bytes */ CHECK_READ(buf, 12, "abcdefgh", pool); /* now: one block: 4 bytes */ SVN_ERR(svn_spillbuf__write(buf, "mnopqr", 6, pool)); /* now: two blocks: 8 and 2 bytes */ CHECK_READ(buf, 10, "ijklmnop", pool); /* now: one block: 2 bytes */ SVN_ERR(svn_spillbuf__write(buf, "stuvwx", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ABCDEF", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "GHIJKL", 6, pool)); /* now: two blocks: 8 and 6 bytes, and 6 bytes spilled to a file */ CHECK_READ(buf, 20, "qrstuvwx", pool); CHECK_READ(buf, 12, "ABCDEF", pool); CHECK_READ(buf, 6, "GHIJKL", pool); SVN_TEST_ASSERT(svn_spillbuf__get_size(buf) == 0); return SVN_NO_ERROR; }
static svn_error_t * test_spillbuf__basic(apr_pool_t *pool, apr_size_t len, svn_spillbuf_t *buf) { int i; const char *readptr; apr_size_t readlen; /* It starts empty. */ SVN_TEST_ASSERT(svn_spillbuf__get_size(buf) == 0); /* Place enough data into the buffer to cause a spill to disk. */ for (i = 20; i--; ) SVN_ERR(svn_spillbuf__write(buf, basic_data, len, pool)); /* And now has content. */ SVN_TEST_ASSERT(svn_spillbuf__get_size(buf) > 0); /* Verify that we can read 20 copies of basic_data from the buffer. */ for (i = 20; i--; ) CHECK_READ(buf, (i + 1) * len, basic_data, pool); /* And after precisely 20 reads, it should be empty. */ SVN_ERR(svn_spillbuf__read(&readptr, &readlen, buf, pool)); SVN_TEST_ASSERT(readptr == NULL); SVN_TEST_ASSERT(svn_spillbuf__get_size(buf) == 0); return SVN_NO_ERROR; }
static svn_error_t * test_spillbuf__rwfile(apr_pool_t *pool, svn_spillbuf_t *buf) { SVN_ERR(svn_spillbuf__write(buf, "abcdef", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ghijkl", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "mnopqr", 6, pool)); /* now: two blocks: 4 and 2 bytes, and 12 bytes in spill file. */ CHECK_READ(buf, 18, "abcd", pool); /* now: one block: 2 bytes, and 12 bytes in spill file. */ CHECK_READ(buf, 14, "ef", pool); /* now: no blocks, and 12 bytes in spill file. */ CHECK_READ(buf, 12, "ghij", pool); /* now: no blocks, and 8 bytes in spill file. */ /* Write more data. It should be appended to the spill file. */ SVN_ERR(svn_spillbuf__write(buf, "stuvwx", 6, pool)); /* now: no blocks, and 14 bytes in spill file. */ CHECK_READ(buf, 14, "klmn", pool); /* now: no blocks, and 10 bytes in spill file. */ CHECK_READ(buf, 10, "opqr", pool); /* now: no blocks, and 6 bytes in spill file. */ CHECK_READ(buf, 6, "stuv", pool); /* now: no blocks, and 2 bytes in spill file. */ CHECK_READ(buf, 2, "wx", pool); /* now: no blocks, and no spill file. */ return SVN_NO_ERROR; }
bool WASMReader::readFloat(float& result) { CHECK_READ(4); union { uint8_t bytes[4]; float floatValue; } u = { #if CPU(BIG_ENDIAN) { m_cursor[3], m_cursor[2], m_cursor[1], m_cursor[0] } #else { m_cursor[0], m_cursor[1], m_cursor[2], m_cursor[3] } #endif };
Ref<Object> Type::Array::read(PyPP__ARGS){ WRef<Message> msg; PyPP__ARG_PARSE(1, arg("message"_py, msg)); auto res=PyPP::List::new_(0); Ref<Object> func=of->py_getattr("read"_py); CHECK_READ(sd_bus_message_enter_container)(msg->handle, 'a', of->signature); while(true){ if(CHECK(sd_bus_message_at_end)(msg->handle, 0)) break; auto next=func->py_callv(msg); res->list_append(next); } CHECK(sd_bus_message_exit_container)(msg->handle); return res; }
static svn_error_t * test_spillbuf__eof(apr_pool_t *pool, svn_spillbuf_t *buf) { SVN_ERR(svn_spillbuf__write(buf, "abcdef", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ghijkl", 6, pool)); /* now: two blocks: 4 and 2 bytes, and 6 bytes in spill file. */ CHECK_READ(buf, 12, "abcd", pool); CHECK_READ(buf, 8, "ef", pool); CHECK_READ(buf, 6, "ghij", pool); CHECK_READ(buf, 2, "kl", pool); /* The spill file should have been emptied and forgotten. */ /* Assuming the spill file has been forgotten, this should result in precisely the same behavior. Specifically: the initial write should create two blocks, and the second write should be spilled. If there *was* a spill file, then this written data would go into the file. */ SVN_ERR(svn_spillbuf__write(buf, "abcdef", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ghijkl", 6, pool)); CHECK_READ(buf, 12, "abcd", pool); CHECK_READ(buf, 8, "ef", pool); CHECK_READ(buf, 6, "ghij", pool); CHECK_READ(buf, 2, "kl", pool); /* The spill file should have been emptied and forgotten. */ /* Now, let's do a sequence where we arrange to hit EOF precisely on a block-sized read. Note: the second write must be more than 4 bytes, or it will not cause a spill. We use 8 to get the right boundary. */ SVN_ERR(svn_spillbuf__write(buf, "abcdef", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ghijklmn", 8, pool)); CHECK_READ(buf, 14, "abcd", pool); CHECK_READ(buf, 10, "ef", pool); CHECK_READ(buf, 8, "ghij", pool); CHECK_READ(buf, 4, "klmn", pool); /* We discard the spill file when we know it has no data, rather than upon hitting EOF (upon a read attempt). Thus, the spill file should be gone. */ /* Verify the forgotten spill file. */ SVN_ERR(svn_spillbuf__write(buf, "abcdef", 6, pool)); SVN_ERR(svn_spillbuf__write(buf, "ghijkl", 6, pool)); CHECK_READ(buf, 12, "abcd", pool); CHECK_READ(buf, 8, "ef", pool); CHECK_READ(buf, 6, "ghij", pool); /* Two unread bytes remaining in the spill file. */ SVN_TEST_ASSERT(svn_spillbuf__get_size(buf) == 2); return SVN_NO_ERROR; }
static struct tevent_req *smbd_smb2_read_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct smbd_smb2_request *smb2req, uint32_t in_smbpid, uint64_t in_file_id_volatile, uint32_t in_length, uint64_t in_offset, uint32_t in_minimum, uint32_t in_remaining) { NTSTATUS status; struct tevent_req *req = NULL; struct smbd_smb2_read_state *state = NULL; struct smb_request *smbreq = NULL; connection_struct *conn = smb2req->tcon->compat_conn; files_struct *fsp = NULL; ssize_t nread = -1; struct lock_struct lock; int saved_errno; req = tevent_req_create(mem_ctx, &state, struct smbd_smb2_read_state); if (req == NULL) { return NULL; } state->smb2req = smb2req; state->in_length = in_length; state->in_offset = in_offset; state->in_minimum = in_minimum; state->out_data = data_blob_null; state->out_remaining = 0; DEBUG(10,("smbd_smb2_read: file_id[0x%016llX]\n", (unsigned long long)in_file_id_volatile)); smbreq = smbd_smb2_fake_smb_request(smb2req); if (tevent_req_nomem(smbreq, req)) { return tevent_req_post(req, ev); } fsp = file_fsp(smbreq, (uint16_t)in_file_id_volatile); if (fsp == NULL) { tevent_req_nterror(req, NT_STATUS_FILE_CLOSED); return tevent_req_post(req, ev); } if (conn != fsp->conn) { tevent_req_nterror(req, NT_STATUS_FILE_CLOSED); return tevent_req_post(req, ev); } if (smb2req->session->vuid != fsp->vuid) { tevent_req_nterror(req, NT_STATUS_FILE_CLOSED); return tevent_req_post(req, ev); } if (fsp->is_directory) { tevent_req_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST); return tevent_req_post(req, ev); } state->fsp = fsp; state->in_file_id_volatile = in_file_id_volatile; if (IS_IPC(smbreq->conn)) { struct tevent_req *subreq = NULL; state->out_data = data_blob_talloc(state, NULL, in_length); if (in_length > 0 && tevent_req_nomem(state->out_data.data, req)) { return tevent_req_post(req, ev); } if (!fsp_is_np(fsp)) { tevent_req_nterror(req, NT_STATUS_FILE_CLOSED); return tevent_req_post(req, ev); } subreq = np_read_send(state, server_event_context(), fsp->fake_file_handle, state->out_data.data, state->out_data.length); if (tevent_req_nomem(subreq, req)) { return tevent_req_post(req, ev); } tevent_req_set_callback(subreq, smbd_smb2_read_pipe_done, req); return req; } if (!CHECK_READ(fsp, smbreq)) { tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED); return tevent_req_post(req, ev); } status = schedule_smb2_aio_read(fsp->conn, smbreq, fsp, state, &state->out_data, (SMB_OFF_T)in_offset, (size_t)in_length); if (NT_STATUS_IS_OK(status)) { /* * Doing an async read. Don't * send a "gone async" message * as we expect this to be less * than the client timeout period. * JRA. FIXME for offline files.. * FIXME. Add cancel code.. */ smb2req->async = true; return req; } if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) { /* Real error in setting up aio. Fail. */ tevent_req_nterror(req, NT_STATUS_FILE_CLOSED); return tevent_req_post(req, ev); } /* Fallback to synchronous. */ init_strict_lock_struct(fsp, in_file_id_volatile, in_offset, in_length, READ_LOCK, &lock); if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) { tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT); return tevent_req_post(req, ev); } /* Try sendfile in preference. */ status = schedule_smb2_sendfile_read(smb2req, state); if (NT_STATUS_IS_OK(status)) { tevent_req_done(req); return tevent_req_post(req, ev); } else { if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) { SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock); tevent_req_nterror(req, status); return tevent_req_post(req, ev); } } /* Ok, read into memory. Allocate the out buffer. */ state->out_data = data_blob_talloc(state, NULL, in_length); if (in_length > 0 && tevent_req_nomem(state->out_data.data, req)) { SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock); return tevent_req_post(req, ev); } nread = read_file(fsp, (char *)state->out_data.data, in_offset, in_length); saved_errno = errno; SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock); DEBUG(10,("smbd_smb2_read: file %s handle [0x%016llX] offset=%llu " "len=%llu returned %lld\n", fsp_str_dbg(fsp), (unsigned long long)in_file_id_volatile, (unsigned long long)in_offset, (unsigned long long)in_length, (long long)nread)); status = smb2_read_complete(req, nread, saved_errno); if (!NT_STATUS_IS_OK(status)) { tevent_req_nterror(req, status); } else { /* Success. */ tevent_req_done(req); } return tevent_req_post(req, ev); }
cdrom_error_t sector_source_read_sectors( sector_source_t device, cdrom_lba_t lba, cdrom_count_t block_count, cdrom_read_mode_t mode, unsigned char *buf, size_t *length ) { CHECK_READ(device,lba,block_count); return device->read_sectors(device, lba, block_count, mode, buf, length); }
/********************* Public functions *************************/ cdrom_error_t sector_source_read( sector_source_t device, cdrom_lba_t lba, cdrom_count_t block_count, unsigned char *buf ) { CHECK_READ(device,lba,block_count); return device->read_blocks(device, lba, block_count, buf); }
GCORE_MODULE_API gimg::Image* readImage(const char *filepath) { // dib is not in the format we want // PF_RGB | PF_RGBA (24 or 32 bits) // -> NOT BGR beware ! gimg::Image *bmp = 0; BITMAPFILEHEADER bf; BITMAPINFOHEADER bi; memset(&bf, 0, BF_SIZE); memset(&bi, 0, BI_SIZE); FILE *bitmap = fopen(filepath, "rb"); if (bitmap) { // Read file header and check CHECK_READ(&(bf.bfType), WORD, bitmap, "type"); if (bf.bfType != BM) { std::cerr << "Un-supported BMP type" << std::endl; return 0; } CHECK_READ(&(bf.bfSize), DWORD, bitmap, "header size"); CHECK_READ(&(bf.bfReserved1), WORD, bitmap, "reserved1"); CHECK_READ(&(bf.bfReserved2), WORD, bitmap, "reserved2"); CHECK_READ(&(bf.bfOffBits), DWORD, bitmap, "data offset"); // Read info header and check CHECK_READ(&(bi.biSize), DWORD, bitmap, "info size"); if (bi.biSize <= sizeof(BITMAPCOREHEADER)) { std::cerr << "BMP file format not supported" << std::endl; } CHECK_READ(&(bi.biWidth), LONG, bitmap, "width"); CHECK_READ(&(bi.biHeight), LONG, bitmap, "height"); CHECK_READ(&(bi.biPlanes), WORD, bitmap, "planes"); CHECK_READ(&(bi.biBitCount), WORD, bitmap, "bpp"); if (bi.biBitCount < 24) { std::cerr << "BMP file format not supported, expected 24/32 bits color type" << std::endl; return 0; } #ifdef _DEBUG std::cout << "BMP: " << bi.biWidth << "x" << bi.biHeight << ":" << bi.biBitCount << std::endl; #endif CHECK_READ(&(bi.biCompression), DWORD, bitmap, "compression"); if (bi.biCompression > BI_RGB) { std::cerr << "BMP file format not supported, expected non-compressed data" << std::endl; return 0; } CHECK_READ(&(bi.biSizeImage), DWORD, bitmap, "data size"); CHECK_READ(&(bi.biXPelsPerMeter), LONG, bitmap, "x units"); CHECK_READ(&(bi.biYPelsPerMeter), LONG, bitmap, "y units"); CHECK_READ(&(bi.biClrUsed), DWORD, bitmap, "used color count"); if (bi.biClrUsed > 0) { std::cerr << "Indexed color BMP files not suppored" << std::endl; return 0; } CHECK_READ(&(bi.biClrImportant), DWORD, bitmap, "important color count"); // beware bi.biHeight could be < 0 -> origin top left bool hflip = false; if (bi.biHeight < 0) { hflip = true; bi.biHeight = -bi.biHeight; } // pitch is not just BytesPerPixel * W // in bitmap file, scanline byte size is adjusted to nearest multiple of 4 size // the " >> 3" is to convert bit size to byte size // +31 is to make sure we will not reduce the width when rounding up // ~31 clear the last 5 bits (summing to 31) in order to make size a multiple of 32 unsigned long pitch = (((bi.biWidth * bi.biBitCount) + 31) & ~31) >> 3; unsigned long imgsz = bi.biSizeImage; #ifdef _DEBUG std::cout << "gimg::Image picth: " << (bi.biWidth * 3) << std::endl; std::cout << "BMP image picth: " << pitch << std::endl; #endif if (imgsz == 0) { imgsz = pitch * bi.biHeight; } void *dib = malloc(imgsz); if (!dib) { std::cerr << "Could not allocate memory to read BMP file data" << std::endl; return 0; } if (bf.bfOffBits != 0) { #ifdef _DEBUG std::cout << "BMP file offset set: " << bf.bfOffBits << std::endl; #endif fseek(bitmap, bf.bfOffBits, SEEK_SET); } if (fread(dib, 1, imgsz, bitmap) != imgsz) { free(dib); std::cerr << "Could not read BMP file data" << std::endl; return 0; } // now copy scanlines and we are done, use RGBQUAD because bitmap are store in BGR format // there absolutely no alpha in bitmap (even on 32 mode ?) // should be pretty easy from here gimg::PixelDesc desc(gimg::PF_RGB, gimg::PT_INT_8); bmp = new gimg::Image(desc, bi.biWidth, bi.biHeight); size_t srcPixSize = bi.biBitCount >> 3; void *dstPixels = bmp->getPixels(); size_t dstPitch = bi.biWidth * desc.getBytesPerPixel(); #ifdef _DEBUG std::cout << "gimg::Image pitch (from PixelDesc): " << dstPitch << std::endl; #endif for (LONG y=0; y<bi.biHeight; ++y) { // top rows coming first unsigned char* dibScanline = (unsigned char*)dib + (((bi.biHeight - 1) - y) * pitch); unsigned char* bmpScanline = ((unsigned char*)dstPixels) + (y * dstPitch); for (LONG x=0; x<bi.biWidth; ++x) { bmpScanline[3*x+0] = dibScanline[2]; bmpScanline[3*x+1] = dibScanline[1]; bmpScanline[3*x+2] = dibScanline[0]; dibScanline += srcPixSize; } } free(dib); fclose(bitmap); } #ifdef _DEBUG std::cout << "Image read successfully !" << std::endl; #endif return bmp; }
static struct tevent_req *smbd_smb2_read_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct smbd_smb2_request *smb2req, struct files_struct *fsp, uint32_t in_length, uint64_t in_offset, uint32_t in_minimum, uint32_t in_remaining) { NTSTATUS status; struct tevent_req *req = NULL; struct smbd_smb2_read_state *state = NULL; struct smb_request *smbreq = NULL; connection_struct *conn = smb2req->tcon->compat; ssize_t nread = -1; struct lock_struct lock; int saved_errno; req = tevent_req_create(mem_ctx, &state, struct smbd_smb2_read_state); if (req == NULL) { return NULL; } state->smb2req = smb2req; state->in_length = in_length; state->in_offset = in_offset; state->in_minimum = in_minimum; state->out_data = data_blob_null; state->out_remaining = 0; DEBUG(10,("smbd_smb2_read: %s - %s\n", fsp_str_dbg(fsp), fsp_fnum_dbg(fsp))); smbreq = smbd_smb2_fake_smb_request(smb2req); if (tevent_req_nomem(smbreq, req)) { return tevent_req_post(req, ev); } state->smbreq = smbreq; if (fsp->is_directory) { tevent_req_nterror(req, NT_STATUS_INVALID_DEVICE_REQUEST); return tevent_req_post(req, ev); } state->fsp = fsp; if (IS_IPC(smbreq->conn)) { struct tevent_req *subreq = NULL; state->out_data = data_blob_talloc(state, NULL, in_length); if (in_length > 0 && tevent_req_nomem(state->out_data.data, req)) { return tevent_req_post(req, ev); } if (!fsp_is_np(fsp)) { tevent_req_nterror(req, NT_STATUS_FILE_CLOSED); return tevent_req_post(req, ev); } subreq = np_read_send(state, ev, fsp->fake_file_handle, state->out_data.data, state->out_data.length); if (tevent_req_nomem(subreq, req)) { return tevent_req_post(req, ev); } tevent_req_set_callback(subreq, smbd_smb2_read_pipe_done, req); return req; } if (!CHECK_READ(fsp, smbreq)) { tevent_req_nterror(req, NT_STATUS_ACCESS_DENIED); return tevent_req_post(req, ev); } status = schedule_smb2_aio_read(fsp->conn, smbreq, fsp, state, &state->out_data, (off_t)in_offset, (size_t)in_length); if (NT_STATUS_IS_OK(status)) { /* * Doing an async read, allow this * request to be canceled */ tevent_req_set_cancel_fn(req, smbd_smb2_read_cancel); return req; } if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) { /* Real error in setting up aio. Fail. */ tevent_req_nterror(req, status); return tevent_req_post(req, ev); } /* Fallback to synchronous. */ init_strict_lock_struct(fsp, fsp->op->global->open_persistent_id, in_offset, in_length, READ_LOCK, &lock); if (!SMB_VFS_STRICT_LOCK(conn, fsp, &lock)) { tevent_req_nterror(req, NT_STATUS_FILE_LOCK_CONFLICT); return tevent_req_post(req, ev); } /* Try sendfile in preference. */ status = schedule_smb2_sendfile_read(smb2req, state); if (NT_STATUS_IS_OK(status)) { tevent_req_done(req); return tevent_req_post(req, ev); } else { if (!NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) { SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock); tevent_req_nterror(req, status); return tevent_req_post(req, ev); } } /* Ok, read into memory. Allocate the out buffer. */ state->out_data = data_blob_talloc(state, NULL, in_length); if (in_length > 0 && tevent_req_nomem(state->out_data.data, req)) { SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock); return tevent_req_post(req, ev); } nread = read_file(fsp, (char *)state->out_data.data, in_offset, in_length); saved_errno = errno; SMB_VFS_STRICT_UNLOCK(conn, fsp, &lock); DEBUG(10,("smbd_smb2_read: file %s, %s, offset=%llu " "len=%llu returned %lld\n", fsp_str_dbg(fsp), fsp_fnum_dbg(fsp), (unsigned long long)in_offset, (unsigned long long)in_length, (long long)nread)); status = smb2_read_complete(req, nread, saved_errno); if (!NT_STATUS_IS_OK(status)) { tevent_req_nterror(req, status); } else { /* Success. */ tevent_req_done(req); } return tevent_req_post(req, ev); }