Boolean PosixBaseStorageObject::canSeek(int fd) { struct stat sb; if (fstat(fd, &sb) < 0 || !S_ISREG(sb.st_mode) || (startOffset_ = lseek(fd, off_t(0), SEEK_CUR)) < 0) return 0; else return 1; }
hostptr_t Memory::shadow(hostptr_t addr, size_t count) { TRACE(GLOBAL, "Getting shadow mapping for %p ("FMT_SIZE" bytes)", addr, count); FileMapEntry entry = Files.find(addr); if(entry.handle() == NULL) return NULL; off_t offset = off_t(addr - entry.address()); hostptr_t ret = (hostptr_t)MapViewOfFile(entry.handle(), FILE_MAP_WRITE, 0, (DWORD)offset, (DWORD)count); return ret; }
inline bool truncate_file (file_handle_t hnd, std::size_t size) { typedef boost::make_unsigned<off_t>::type uoff_t; if(uoff_t((std::numeric_limits<off_t>::max)()) < size){ errno = EINVAL; return false; } return 0 == ::ftruncate(hnd, off_t(size)); }
bool cRecorder::NextFile(void) { if (recordFile && frameDetector->IndependentFrame()) { // every file shall start with an independent frame if (fileSize > MEGABYTE(off_t(Setup.MaxVideoFileSize)) || RunningLowOnDiskSpace()) { recordFile = fileName->NextFile(); fileSize = 0; } } return recordFile != NULL; }
bool cLiveRecorder::NextFile(void) { if (recordFile && frameDetector->IndependentFrame()) { // every file shall start with an independent frame if(RunningLowOnDiskSpace() && index) ((cLiveIndex *)index)->DropFile(); if (fileSize > MEGABYTE(off_t(MaxFileSize)) || RunningLowOnDiskSpace()) { recordFile = fileName->NextFile(); fileSize = 0; } // if } // if return recordFile != NULL; } // cLiveRecorder::NextFile
std::string CaptureFD::readIncremental() { std::string filename = file_.path().string(); // Yes, I know that I could just keep the file open instead. So sue me. folly::File f(openNoInt(filename.c_str(), O_RDONLY), true); auto size = size_t(lseek(f.fd(), 0, SEEK_END) - readOffset_); std::unique_ptr<char[]> buf(new char[size]); auto bytes_read = folly::preadFull(f.fd(), buf.get(), size, readOffset_); PCHECK(ssize_t(size) == bytes_read); readOffset_ += off_t(size); chunkCob_(StringPiece(buf.get(), buf.get() + size)); return std::string(buf.get(), size); }
static int wrapPositional(F f, int fd, off_t offset, Args... args) { off_t origLoc = lseek(fd, 0, SEEK_CUR); if (origLoc == off_t(-1)) { return -1; } if (lseek(fd, offset, SEEK_SET) == off_t(-1)) { return -1; } int res = (int)f(fd, args...); int curErrNo = errno; if (lseek(fd, origLoc, SEEK_SET) == off_t(-1)) { if (res == -1) { errno = curErrNo; } return -1; } errno = curErrNo; return res; }
static int Seek(void* context, ogg_int64_t offset, int whence) { VorbisFileAdapter* adapter = (VorbisFileAdapter*)context; off_t origin = 0; switch(whence) { case SEEK_SET: origin = 0; break; case SEEK_CUR: origin = adapter->offset; break; case SEEK_END: origin = adapter->size+1; break; NODEFAULT; } adapter->offset = Clamp(off_t(origin+offset), off_t(0), adapter->size); return 0; }
OOBase::uint64_t OOBase::File::tell() const { #if defined(_WIN32) LARGE_INTEGER off,pos; off.QuadPart = 0; pos.QuadPart = 0; if (!::SetFilePointerEx(m_fd,off,&pos,FILE_CURRENT)) return uint64_t(-1); return pos.QuadPart; #else off_t s = ::lseek(m_fd,0,SEEK_CUR); if (s == off_t(-1)) return uint64_t(-1); return s; #endif }
TEST_F(LineBufferTest, single_line_no_newline) { std::string line_data; line_data += "Single line with no newline."; ASSERT_TRUE(TEMP_FAILURE_RETRY( write(tmp_file_->fd, line_data.c_str(), line_data.size())) != -1); ASSERT_TRUE(lseek(tmp_file_->fd, 0, SEEK_SET) != off_t(-1)); char buffer[100]; LineBuffer line_buf(tmp_file_->fd, buffer, sizeof(buffer)); char* line; size_t line_len; ASSERT_TRUE(line_buf.GetLine(&line, &line_len)); ASSERT_STREQ("Single line with no newline.", line); ASSERT_EQ(sizeof("Single line with no newline.") - 1, line_len); ASSERT_FALSE(line_buf.GetLine(&line, &line_len)); }
OOBase::uint64_t OOBase::File::seek(int64_t offset, enum seek_direction dir) { #if defined(_WIN32) DWORD d = FILE_CURRENT; switch (dir) { case seek_begin: d = FILE_BEGIN; break; case seek_current: break; case seek_end: d = FILE_END; break; } LARGE_INTEGER off,pos; off.QuadPart = offset; pos.QuadPart = 0; if (!::SetFilePointerEx(m_fd,off,&pos,d)) return uint64_t(-1); return pos.QuadPart; #else int d = SEEK_CUR; switch (dir) { case seek_begin: d = SEEK_SET; break; case seek_current: break; case seek_end: d = SEEK_END; break; } off_t s = ::lseek(m_fd,offset,d); if (s == off_t(-1)) return uint64_t(-1); return s; #endif }
SYSAPI int _Chela_IO_Seek(FILE_HANDLE stream, size_t offset, int origin) { int whence = 0; switch(origin) { case SO_Begin: whence = SEEK_SET; break; case SO_Current: whence = SEEK_CUR; break; case SO_End: whence = SEEK_END; break; default: _Chela_Sys_Fatal("Invalid seek origin value."); break; } return lseek((size_t)stream, offset, whence) != off_t(-1); }
/* * Find the zip Central Directory and memory-map it. * * On success, returns 0 after populating fields from the EOCD area: * mDirectoryOffset * mDirectoryMap * mNumEntries */ static int mapCentralDirectory(int fd, const char* debugFileName, ZipArchive* pArchive) { /* * Get and test file length. */ off_t fileLength = lseek(fd, 0, SEEK_END); if (fileLength < kEOCDLen) { LOGV("Zip: length %ld is too small to be zip", (long) fileLength); return -1; } /* * Perform the traditional EOCD snipe hunt. * * We're searching for the End of Central Directory magic number, * which appears at the start of the EOCD block. It's followed by * 18 bytes of EOCD stuff and up to 64KB of archive comment. We * need to read the last part of the file into a buffer, dig through * it to find the magic number, parse some values out, and use those * to determine the extent of the CD. * * We start by pulling in the last part of the file. */ size_t readAmount = kMaxEOCDSearch; if (fileLength < off_t(readAmount)) readAmount = fileLength; u1* scanBuf = (u1*) malloc(readAmount); if (scanBuf == NULL) { return -1; } int result = mapCentralDirectory0(fd, debugFileName, pArchive, fileLength, readAmount, scanBuf); free(scanBuf); return result; }
TEST_F(LineBufferTest, line_larger_than_buffer) { std::string line_data; line_data += "The first line.\n"; line_data += "Second line here.\n"; line_data += "This is a really, really, really, kind of long.\n"; line_data += "The fourth line.\n"; ASSERT_TRUE(TEMP_FAILURE_RETRY( write(tmp_file_->fd, line_data.c_str(), line_data.size())) != -1); ASSERT_TRUE(lseek(tmp_file_->fd, 0, SEEK_SET) != off_t(-1)); char buffer[25]; LineBuffer line_buf(tmp_file_->fd, buffer, sizeof(buffer)); char* line; size_t line_len; ASSERT_TRUE(line_buf.GetLine(&line, &line_len)); ASSERT_STREQ("The first line.", line); ASSERT_EQ(sizeof("The first line.") - 1, line_len); ASSERT_TRUE(line_buf.GetLine(&line, &line_len)); ASSERT_STREQ("Second line here.", line); ASSERT_EQ(sizeof("Second line here.") - 1, line_len); ASSERT_TRUE(line_buf.GetLine(&line, &line_len)); ASSERT_STREQ("This is a really, really", line); ASSERT_EQ(sizeof(buffer) - 1, line_len); ASSERT_TRUE(line_buf.GetLine(&line, &line_len)); ASSERT_STREQ(", really, kind of long.", line); ASSERT_EQ(sizeof(", really, kind of long.") - 1, line_len); line_data += "The fourth line.\n"; ASSERT_TRUE(line_buf.GetLine(&line, &line_len)); ASSERT_STREQ("The fourth line.", line); ASSERT_EQ(sizeof("The fourth line.") - 1, line_len); ASSERT_FALSE(line_buf.GetLine(&line, &line_len)); }
bool TripleIndBlockNode::rb_traverse(Context & i_ctxt, FileNode & i_fn, unsigned int i_flags, off_t i_base, off_t i_rngoff, size_t i_rngsize, BlockTraverseFunc & i_trav) { static off_t const refspan = NUMREF * NUMREF * BLKSZ; off_t startoff = max(i_rngoff, i_base); // Are we beyond the target range? if (i_base > i_rngoff + off_t(i_rngsize)) goto done; // Figure out which index we start with. for (off_t ndx = (startoff - i_base) / refspan; ndx < off_t(NUMREF); ++ndx) { off_t off = i_base + (ndx * refspan); // If we are beyond the traversal region we're done. if (off >= i_rngoff + off_t(i_rngsize)) goto done; // Find the block object to use. DoubleIndBlockNodeHandle nh; // Do we have one in the cache already? if (m_blkobj_X[ndx]) { // Yep, use it. nh = dynamic_cast<DoubleIndBlockNode *>(&*m_blkobj_X[ndx]); } else { // Nope, does it have a digest yet? if (m_blkref[ndx]) { // Does the clean cache have it? BlockNodeHandle bnh = i_ctxt.m_bncachep->lookup(m_blkref[ndx]); if (bnh) { // Yes, better be a DoubleIndBlockNode ... nh = dynamic_cast<DoubleIndBlockNode *>(&*bnh); } else { // Nope, read it from the blockstore. nh = new DoubleIndBlockNode(i_ctxt, m_blkref[ndx]); // Insert it in the clean cache. if (!(i_flags & RB_NOCACHE)) i_ctxt.m_bncachep->insert(nh); } } else if (i_flags & RB_MODIFY_X) { // Nope, create new block. nh = new DoubleIndBlockNode(); // Keep it in the dirty cache. m_blkobj_X[ndx] = nh; // Increment the block count. i_fn.blocks(i_fn.blocks() + 1); } else { // Use the zero singleton. nh = i_ctxt.m_zdinobj; // And *don't* keep it in the cache! } } // Recursively traverse ... if (nh->rb_traverse(i_ctxt, i_fn, i_flags, off, i_rngoff, i_rngsize, i_trav)) { if (i_flags & RB_MODIFY_X) { // The node is already marked dirty ... // Remove it from the clean cache. i_ctxt.m_bncachep->remove(nh->bn_blkref()); // Insert it in the dirty collection. m_blkobj_X[ndx] = nh; // We're dirty too. bn_isdirty(true); } } } done: // Return our dirty state. return bn_isdirty(); }
/* --- @bin_2_iso@ --- * * * Arguments: @file_ptrs *fptrs@ = pointer struct of source and destination file * @image_struct *img_struct@ = struct of image pregap * * Returns: Zeor on success, @-1@ on error. * * Use: Return the detection of the image. */ int bin_2_iso ( file_ptrs* fptrs, image_struct* img_struct ) { off_t n_loop = 0; off_t n_loop_incrementer = 0; off_t n_img_size = 0; int n_return_value = ERROR; int n_mode = 0; long n_iso_block_no = 0; unsigned const char synch_pattern [ 12 ] = { 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00 }; sync_header_block header; /* Sync Header Block */ off_t (* mode [ 5 ] ) ( file_ptrs* fptrs, off_t n_fptr_pos, off_t n_iso_block_no ) = { &mode_0, &mode_1, &mode_2, &mode_2_form_1_headerless, &mode_2_form_2_headerless }; if ( NULL== fptrs -> fsource ) return ( n_return_value ); /* The source file pointer is empty */ if ( ( n_img_size = get_file_size ( fptrs -> fsource ) ) < 1 ) return ( n_return_value ); /* The image file is empty */ for ( n_loop = ( off_t ) img_struct -> pregap; n_loop < n_img_size; ) { progress_bar ( ( int ) ( ( ( n_loop + 1 ) * 100 ) / n_img_size ) ); /* Initalize for the loop */ memset ( &header, 0, sizeof ( sync_header_block ) ); /* Initialize the file pointer to the start point */ set_file_pointer ( fptrs -> fsource, n_loop ); fread ( &header, 1, sizeof ( sync_header_block ), fptrs -> fsource ); /*printf ("Image size :%ld\n", n_img_size ); printf ( "LOOP NO :%d\n", n_loop ); print ( ( void* ) &header, 16 );*/ /* Revert back the file pointer as it has moved the * file pointer till the header (read 16 bytes of data) */ set_file_pointer ( fptrs -> fsource, n_loop ); if ( !memcmp ( &synch_pattern, &header, 12 ) ) { n_iso_block_no++; /* Image has 12 BYTE SYNC HEADER */ n_mode = ( (char) ( *( header.msf_block.mode ) ) ); if ( ( n_mode > -1 ) && ( n_mode < 3 ) ) /* Mode { 0, 1, 2 } */ n_loop_incrementer = ( *( mode [ n_mode ] ) ) ( fptrs, n_loop, n_iso_block_no ); /* Increment to the next block */ else printf ( "Weird Mode \n" ); if ( 0 < n_loop_incrementer ) { if ( ( 2448 == img_struct -> block ) || ( 2368 == img_struct -> block ) ) { n_loop += n_loop_incrementer; n_loop += ( ( off_t ) img_struct -> block - n_loop_incrementer ); n_loop_incrementer = 0; } else n_loop += n_loop_incrementer; } } else if ( ( !memcmp ( &header, ( ( (unsigned char*) (&header) ) + 4 ), 4 ) ) && ( 2336 == img_struct -> block ) ) { int n_mode_no_header = 0; n_iso_block_no++; /*print ( ( void* ) &header, 8 );*/ n_mode_no_header = ( (int) *( ( (unsigned char*) (&header) ) + 2 ) ) & 0x20; n_mode_no_header = ( n_mode_no_header == 32 ) ? 1 : 0; n_loop += ( *( mode [ 3 + n_mode_no_header ] ) ) ( fptrs, n_loop, n_iso_block_no ); /* Increment to the next block */ } else { /* Image does not have any standard header */ /*print ( ( void* ) &header, 16 );*/ n_loop++; /* Increment to the next location */ /*n_loop += img_struct -> block;*/ /* Increment to the next block */ } } set_file_pointer ( fptrs -> fsource, ( off_t ) 0 ); n_return_value = AOK; progress_bar ( 100 ); printf ( "\n" ); return ( n_return_value ); }
void _mapFuncNames(ThreadContext *context, FileSys::SeekableDescription *fdesc, VAddr addr, size_t len, off_t off){ typedef typename ElfDefs<mode>::Elf_Ehdr Elf_Ehdr; typedef typename ElfDefs<mode>::Elf_Shdr Elf_Shdr; typedef typename ElfDefs<mode>::Elf_Sym Elf_Sym; // Read in the ELF header Elf_Ehdr ehdr; ssize_t ehdrSiz=fdesc->pread(&ehdr,sizeof(Elf_Ehdr),0); I(ehdrSiz==sizeof(Elf_Ehdr)); cvtEndianEhdr<mode>(ehdr); // Read in section headers Elf_Shdr shdrs[ehdr.e_shnum]; ssize_t shdrsSiz=fdesc->pread(shdrs,sizeof(Elf_Shdr)*ehdr.e_shnum,ehdr.e_shoff); I(shdrsSiz==(ssize_t)(sizeof(Elf_Shdr)*ehdr.e_shnum)); I(shdrsSiz==(ssize_t)(sizeof(shdrs))); for(size_t sec=0;sec<ehdr.e_shnum;sec++) cvtEndianShdr<mode>(shdrs[sec]); // Read in section name strings I((ehdr.e_shstrndx>0)&&(ehdr.e_shstrndx<ehdr.e_shnum)); char secStrTab[shdrs[ehdr.e_shstrndx].sh_size]; ssize_t secStrTabSiz=fdesc->pread(secStrTab,shdrs[ehdr.e_shstrndx].sh_size,shdrs[ehdr.e_shstrndx].sh_offset); I(secStrTabSiz==(ssize_t)(shdrs[ehdr.e_shstrndx].sh_size)); // Iterate over all sections for(size_t sec=0;sec<ehdr.e_shnum;sec++){ switch(shdrs[sec].sh_type){ case SHT_PROGBITS: { if(!(shdrs[sec].sh_flags&SHF_EXECINSTR)) break; ssize_t loadBias=(addr-shdrs[sec].sh_addr)+(shdrs[sec].sh_offset-off); char *secNam=secStrTab+shdrs[sec].sh_name; size_t secNamLen=strlen(secNam); if((off_t(shdrs[sec].sh_offset)>=off)&&(shdrs[sec].sh_offset<off+len)){ char *begNam="SecBeg"; size_t begNamLen=strlen(begNam); char symNam[secNamLen+begNamLen+1]; strcpy(symNam,begNam); strcpy(symNam+begNamLen,secNam); VAddr symAddr=shdrs[sec].sh_addr+loadBias; context->getAddressSpace()->addFuncName(symAddr,symNam,fdesc->getName()); } if((off_t(shdrs[sec].sh_offset+shdrs[sec].sh_size)>off)&& (shdrs[sec].sh_offset+shdrs[sec].sh_size<=off+len)){ char *endNam="SecEnd"; size_t endNamLen=strlen(endNam); char symNam[secNamLen+endNamLen+1]; strcpy(symNam,endNam); strcpy(symNam+endNamLen,secNam); VAddr symAddr=shdrs[sec].sh_addr+shdrs[sec].sh_size+loadBias; context->getAddressSpace()->addFuncName(symAddr,symNam,fdesc->getName()); } } break; case SHT_SYMTAB: case SHT_DYNSYM: { I(shdrs[sec].sh_entsize==sizeof(Elf_Sym)); // Read in the symbols size_t symnum=shdrs[sec].sh_size/sizeof(Elf_Sym); Elf_Sym syms[symnum]; ssize_t symsSiz=fdesc->pread(syms,shdrs[sec].sh_size,shdrs[sec].sh_offset); I(symsSiz==(ssize_t)(sizeof(Elf_Sym)*symnum)); I(symsSiz==(ssize_t)(sizeof(syms))); for(size_t sym=0;sym<symnum;sym++) cvtEndianSym<mode>(syms[sym]); // Read in the symbol name strings char strTab[shdrs[shdrs[sec].sh_link].sh_size]; ssize_t strTabSiz=fdesc->pread(strTab,shdrs[shdrs[sec].sh_link].sh_size,shdrs[shdrs[sec].sh_link].sh_offset); I(strTabSiz==(ssize_t)(shdrs[shdrs[sec].sh_link].sh_size)); for(size_t sym=0;sym<symnum;sym++){ I(ELF32_ST_TYPE(syms[sym].st_info)==ELF64_ST_TYPE(syms[sym].st_info)); switch(ELF64_ST_TYPE(syms[sym].st_info)){ case STT_FUNC: { if(!syms[sym].st_shndx) break; ssize_t loadBias=(addr-shdrs[syms[sym].st_shndx].sh_addr)+ (shdrs[syms[sym].st_shndx].sh_offset-off); // printf("sh_type %s st_name %s st_value 0x%08x st_size 0x%08x st_shndx 0x%08x\n", // shdrs[sec].sh_type==SHT_SYMTAB?"SYMTAB":"DYNSYM", // strTab+syms[sym].st_name, // (int)(syms[sym].st_value),(int)(syms[sym].st_size),(int)(syms[sym].st_shndx)); char *symNam=strTab+syms[sym].st_name; VAddr symAddr=syms[sym].st_value+loadBias; if((symAddr<addr)||(symAddr>=addr+len)) break; context->getAddressSpace()->addFuncName(symAddr,symNam,fdesc->getName()); } break; } } } break; } } }
/* * Class: sun_jvm_hotspot_debugger_proc_ProcDebuggerLocal * Method: readBytesFromProcess0 * Signature: (JJ)[B * Description: read bytes from debuggee process/core */ JNIEXPORT jbyteArray JNICALL Java_sun_jvm_hotspot_debugger_proc_ProcDebuggerLocal_readBytesFromProcess0 (JNIEnv *env, jobject this_obj, jlong address, jlong numBytes) { jbyteArray array = env->NewByteArray(numBytes); CHECK_EXCEPTION_(0); jboolean isCopy; jbyte* bufPtr = env->GetByteArrayElements(array, &isCopy); CHECK_EXCEPTION_(0); jlong p_ps_prochandle = env->GetLongField(this_obj, p_ps_prochandle_ID); ps_err_e ret = ps_pread((struct ps_prochandle*) p_ps_prochandle, (psaddr_t)address, bufPtr, (size_t)numBytes); if (ret != PS_OK) { // part of the class sharing workaround. try shared heap area int classes_jsa_fd = env->GetIntField(this_obj, classes_jsa_fd_ID); if (classes_jsa_fd != -1 && address != (jlong)0) { print_debug("read failed at 0x%lx, attempting shared heap area\n", (long) address); struct FileMapHeader* pheader = (struct FileMapHeader*) env->GetLongField(this_obj, p_file_map_header_ID); // walk through the shared mappings -- we just have 4 of them. // so, linear walking is okay. for (int m = 0; m < NUM_SHARED_MAPS; m++) { // We can skip the non-read-only maps. These are mapped as MAP_PRIVATE // and hence will be read by libproc. Besides, the file copy may be // stale because the process might have modified those pages. if (pheader->_space[m]._read_only) { jlong baseAddress = (jlong) (uintptr_t) pheader->_space[m]._base; size_t usedSize = pheader->_space[m]._used; if (address >= baseAddress && address < (baseAddress + usedSize)) { // the given address falls in this shared heap area print_debug("found shared map at 0x%lx\n", (long) baseAddress); // If more data is asked than actually mapped from file, we need to zero fill // till the end-of-page boundary. But, java array new does that for us. we just // need to read as much as data available. #define MIN2(x, y) (((x) < (y))? (x) : (y)) jlong diff = address - baseAddress; jlong bytesToRead = MIN2(numBytes, usedSize - diff); off_t offset = pheader->_space[m]._file_offset + off_t(diff); ssize_t bytesRead = pread(classes_jsa_fd, bufPtr, bytesToRead, offset); if (bytesRead != bytesToRead) { env->ReleaseByteArrayElements(array, bufPtr, JNI_ABORT); print_debug("shared map read failed\n"); return jbyteArray(0); } else { print_debug("shared map read succeeded\n"); env->ReleaseByteArrayElements(array, bufPtr, 0); return array; } } // is in current map } // is read only map } // for shared maps } // classes_jsa_fd != -1 env->ReleaseByteArrayElements(array, bufPtr, JNI_ABORT); return jbyteArray(0); } else { env->ReleaseByteArrayElements(array, bufPtr, 0); return array; } }
bool CFileRegion::doesInclude(off_t offset) { return offset >= offset_ && offset < offset_ + off_t(size_); }
bool cRecorder::NextFile(void) { if (recordFile && frameDetector->IndependentFrame()) { // every file shall start with an independent frame #ifdef USE_HARDLINKCUTTER if (fileSize > fileName->MaxFileSize() || RunningLowOnDiskSpace()) { #else if (fileSize > MEGABYTE(off_t(Setup.MaxVideoFileSize)) || RunningLowOnDiskSpace()) { #endif /* HARDLINKCUTTER */ recordFile = fileName->NextFile(); fileSize = 0; } } return recordFile != NULL; } void cRecorder::Activate(bool On) { if (On) Start(); else Cancel(3); } void cRecorder::Receive(uchar *Data, int Length) { if (Running()) { int p = ringBuffer->Put(Data, Length); if (p != Length && Running()) ringBuffer->ReportOverflow(Length - p); } } void cRecorder::Action(void) { time_t t = time(NULL); bool InfoWritten = false; bool FirstIframeSeen = false; #ifdef USE_LIVEBUFFER double fps = DEFAULTFRAMESPERSECOND; #endif /*USE_LIVEBUFFER*/ while (Running()) { int r; uchar *b = ringBuffer->Get(r); if (b) { int Count = frameDetector->Analyze(b, r); if (Count) { if (!Running() && frameDetector->IndependentFrame()) // finish the recording before the next independent frame break; if (frameDetector->Synced()) { #ifdef USE_LIVEBUFFER if(index && (frameDetector->FramesPerSecond() != fps)) { fps = frameDetector->FramesPerSecond(); index->SetFramesPerSecond(fps); } // if #endif /*USE_LIVEBUFFER*/ if (!InfoWritten) { cRecordingInfo RecordingInfo(recordingName); if (RecordingInfo.Read()) { if (frameDetector->FramesPerSecond() > 0 && DoubleEqual(RecordingInfo.FramesPerSecond(), DEFAULTFRAMESPERSECOND) && !DoubleEqual(RecordingInfo.FramesPerSecond(), frameDetector->FramesPerSecond())) { RecordingInfo.SetFramesPerSecond(frameDetector->FramesPerSecond()); RecordingInfo.Write(); Recordings.UpdateByName(recordingName); } } InfoWritten = true; } /* if (frameDetector->NewPayload()) { // We're at the first TS packet of a new payload... if (Buffering) esyslog("ERROR: encountered new payload while buffering - dropping some data!"); if (!frameDetector->NewFrame()) { // ...but the frame type is yet unknown, so we need to buffer packets until we see the frame type if (!Buffer) { dsyslog("frame type not in first packet of payload - buffering"); if (!(Buffer = MALLOC(uchar, BUFFERSIZE))) { esyslog("ERROR: can't allocate frame type buffer"); break; } } BufferIndex = 0; Buffering = true; } } else if (frameDetector->NewFrame()) // now we know the frame type, so stop buffering Buffering = false; if (Buffering) { if (BufferIndex + Count <= BUFFERSIZE) { memcpy(Buffer + BufferIndex, b, Count); BufferIndex += Count; } else esyslog("ERROR: too many bytes for frame type buffer (%d > %d) - dropped %d bytes", BufferIndex + Count, int(BUFFERSIZE), Count); } else if (FirstIframeSeen || frameDetector->IndependentFrame()) { */ #ifdef USE_LIVEBUFFER if(!FirstIframeSeen) FillInitialData(b, r); #endif /*USE_LIVEBUFFER*/ if (FirstIframeSeen || frameDetector->IndependentFrame()) { FirstIframeSeen = true; // start recording with the first I-frame if (!NextFile()) break; if (index && frameDetector->NewFrame()) index->Write(frameDetector->IndependentFrame(), fileName->Number(), fileSize); if (frameDetector->IndependentFrame()) { recordFile->Write(patPmtGenerator.GetPat(), TS_SIZE); fileSize += TS_SIZE; int Index = 0; while (uchar *pmt = patPmtGenerator.GetPmt(Index)) { recordFile->Write(pmt, TS_SIZE); fileSize += TS_SIZE; } } if (recordFile->Write(b, Count) < 0) { LOG_ERROR_STR(fileName->Name()); break; } fileSize += Count; t = time(NULL); } } ringBuffer->Del(Count); } } #ifdef USE_LIVEBUFFER if (handleError && (time(NULL) - t > MAXBROKENTIMEOUT)) { #else if (time(NULL) - t > MAXBROKENTIMEOUT) { #endif #if REELVDR Skins.QueueMessage(mtError, tr("can't record - check your configuration")); #else esyslog("ERROR: video data stream broken. Requesting Emergency Exit."); ShutdownHandler.RequestEmergencyExit(); #endif /*REELVDR*/ t = time(NULL); } } }
void TopCanvas::Create(PixelSize new_size, bool full_screen, bool resizable) { #ifdef USE_FB assert(fd < 0); #ifdef USE_TTY InitialiseTTY(); #endif const char *path = "/dev/fb0"; fd = open(path, O_RDWR | O_NOCTTY | O_CLOEXEC); if (fd < 0) { fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno)); return; } struct fb_fix_screeninfo finfo; if (ioctl(fd, FBIOGET_FSCREENINFO, &finfo) < 0) { fprintf(stderr, "FBIOGET_FSCREENINFO failed: %s\n", strerror(errno)); Destroy(); return; } if (finfo.type != FB_TYPE_PACKED_PIXELS) { fprintf(stderr, "Unsupported console hardware\n"); Destroy(); return; } switch (finfo.visual) { case FB_VISUAL_TRUECOLOR: case FB_VISUAL_PSEUDOCOLOR: case FB_VISUAL_STATIC_PSEUDOCOLOR: case FB_VISUAL_DIRECTCOLOR: break; default: fprintf(stderr, "Unsupported console hardware\n"); Destroy(); return; } /* Memory map the device, compensating for buggy PPC mmap() */ const off_t page_size = getpagesize(); off_t offset = off_t(finfo.smem_start) - (off_t(finfo.smem_start) &~ (page_size - 1)); off_t map_size = finfo.smem_len + offset; map = mmap(nullptr, map_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0); if (map == (void *)-1) { fprintf(stderr, "Unable to memory map the video hardware: %s\n", strerror(errno)); map = nullptr; Destroy(); return; } /* Determine the current screen depth */ struct fb_var_screeninfo vinfo; if (ioctl(fd, FBIOGET_VSCREENINFO, &vinfo) < 0 ) { fprintf(stderr, "Couldn't get console pixel format: %s\n", strerror(errno)); Destroy(); return; } #ifdef GREYSCALE /* switch the frame buffer to 8 bits per pixel greyscale */ vinfo.bits_per_pixel = 8; vinfo.grayscale = true; if (ioctl(fd, FBIOPUT_VSCREENINFO, &vinfo) < 0) { fprintf(stderr, "Couldn't set greyscale pixel format: %s\n", strerror(errno)); Destroy(); return; } /* read new finfo */ ioctl(fd, FBIOGET_FSCREENINFO, &finfo); map_bpp = 1; #else map_bpp = vinfo.bits_per_pixel / 8; if (map_bpp != 2 && map_bpp != 4) { fprintf(stderr, "Unsupported console hardware\n"); Destroy(); return; } #endif map_pitch = finfo.line_length; epd_update_marker = 0; #ifdef KOBO int updateSheme = UPDATE_SCHEME_QUEUE_AND_MERGE; if(ioctl(fd, MXCFB_SET_UPDATE_SCHEME, &updateSheme) < 0) { fprintf(stderr, "Couldn't set update_scheme: %s\n", strerror(errno)); } KoboModel model = DetectKoboModel(); switch(model) { case KoboModel::UNKNOWN: frame_sync = true; break; case KoboModel::MINI: case KoboModel::TOUCH: case KoboModel::GLO: frame_sync = false; break; case KoboModel::GLOHD: frame_sync = true; break; default: frame_sync = true; break; }; #endif const unsigned width = vinfo.xres, height = vinfo.yres; #elif defined(USE_VFB) const unsigned width = new_size.cx, height = new_size.cy; #else #error No implementation #endif buffer.Allocate(width, height); }
bool pcl::io::LZFImageReader::loadImageBlob (const std::string &filename, std::vector<char> &data, uint32_t &uncompressed_size) { if (filename == "" || !boost::filesystem::exists (filename)) { PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Could not find file '%s'.\n", filename.c_str ()); return (false); } // Open for reading int fd = pcl_open (filename.c_str (), O_RDONLY); if (fd == -1) { PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Failure to open file %s\n", filename.c_str () ); return (false); } // Seek to the end of file to get the filesize off_t data_size = pcl_lseek (fd, 0, SEEK_END); if (data_size < 0) { pcl_close (fd); PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] lseek errno: %d strerror: %s\n", errno, strerror (errno)); PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Error during lseek ()!\n"); return (false); } pcl_lseek (fd, 0, SEEK_SET); #ifdef _WIN32 // As we don't know the real size of data (compressed or not), // we set dwMaximumSizeHigh = dwMaximumSizeLow = 0 so as to map the whole file HANDLE fm = CreateFileMapping ((HANDLE) _get_osfhandle (fd), NULL, PAGE_READONLY, 0, 0, NULL); // As we don't know the real size of data (compressed or not), // we set dwNumberOfBytesToMap = 0 so as to map the whole file char *map = static_cast<char*>(MapViewOfFile (fm, FILE_MAP_READ, 0, 0, 0)); if (map == NULL) { CloseHandle (fm); pcl_close (fd); PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Error mapping view of file, %s\n", filename.c_str ()); return (false); } #else char *map = static_cast<char*> (mmap (0, data_size, PROT_READ, MAP_SHARED, fd, 0)); if (map == reinterpret_cast<char*> (-1)) // MAP_FAILED { pcl_close (fd); PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Error preparing mmap for PCLZF file.\n"); return (false); } #endif // Check the header identifier here char header_string[5]; memcpy (&header_string, &map[0], 5); // PCLZF if (std::string (header_string).substr (0, 5) != "PCLZF") { PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Wrong signature header! Should be 'P'C'L'Z'F'.\n"); #ifdef _WIN32 UnmapViewOfFile (map); CloseHandle (fm); #else munmap (map, data_size); #endif return (false); } memcpy (&width_, &map[5], sizeof (uint32_t)); memcpy (&height_, &map[9], sizeof (uint32_t)); char imgtype_string[16]; memcpy (&imgtype_string, &map[13], 16); // BAYER8, RGB24_, YUV422_, ... image_type_identifier_ = std::string (imgtype_string).substr (0, 15); image_type_identifier_.insert (image_type_identifier_.end (), 1, '\0'); static const int header_size = LZF_HEADER_SIZE; uint32_t compressed_size; memcpy (&compressed_size, &map[29], sizeof (uint32_t)); if (compressed_size + header_size != data_size) { PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Number of bytes to decompress written in file (%u) differs from what it should be (%u)!\n", compressed_size, data_size - header_size); #ifdef _WIN32 UnmapViewOfFile (map); CloseHandle (fm); #else munmap (map, data_size); #endif return (false); } memcpy (&uncompressed_size, &map[33], sizeof (uint32_t)); data.resize (compressed_size); memcpy (&data[0], &map[header_size], compressed_size); #ifdef _WIN32 UnmapViewOfFile (map); CloseHandle (fm); #else if (munmap (map, data_size) == -1) PCL_ERROR ("[pcl::io::LZFImageReader::loadImage] Munmap failure\n"); #endif pcl_close (fd); data_size = off_t (compressed_size); // We only care about this from here on return (true); }
int TTask::setHttpHeader() { hcp->ClearRequestHdr(); //先写入上层传入的http头,如果该头和内部头重复,则会在后续处理中被覆盖 if(NULL != httpHdrs) { THttpHdrList * httpHdrlist = httpHdrs->GetHdrs(); THttpHdrList::iterator itr = httpHdrlist->begin(); for( ; itr != httpHdrlist->end(); ++itr ) { THttpHdr* pHdr = *itr; hcp->BuildCustomHdr(pHdr->GetKey().c_str(), pHdr->GetVal().c_str()); } } hcp->BuildAcceptHdr(); if(TASK_UPLOAD == task_type || TASK_QUERY == task_type) { // hcp->BuildCustomHdr("Referer", url->get_encoded_path()); // hcp->BuildCustomHdr("Accept-Language", "zh-cn"); //Post 方法需要写入post数据大小 // char contenttype[128] = {0}; // snprintf(contenttype, sizeof(contenttype), // "multipart/form-data; boundary=%s", __HEAD_BROUNDARY); // hcp->BuildContentType(contenttype); hcp->BuildContentType(); // hcp->BuildCustomHdr("Accept-Encoding", "gzip, deflate"); hcp->BuildUserAgentHdr(); hcp->BuildHostHdr(url->get_host(), url->get_port()); hcp->BuildContentLengthHdr(postDataSize); } else if(TASK_BINARY == task_type) { hcp->BuildUserAgentHdr(); hcp->BuildHostHdr(url->get_host(), url->get_port()); hcp->BuildContentLengthHdr(postDataSize); } else if(TASK_DOWNLOAD == task_type) { hcp->BuildUserAgentHdr(); hcp->BuildHostHdr(url->get_host(), url->get_port()); if((startSize != 0) || (endSize != 0)) { if(endSize == 0) { hcp->BuildRangeHdr(off_t(startSize), -1); } else { hcp->BuildRangeHdr(off_t(startSize), off_t(endSize)); } } } else if(TASK_HEAD == task_type) { hcp->BuildUserAgentHdr(); hcp->BuildHostHdr(url->get_host(), url->get_port()); } if(hcp->IsUseProxy() && hcp->GetProxy().type == HTTPDOWN_PROXY_HTTP) { if(hcp->GetProxy().domain != "") { //It's ntlm proxy hcp->processNtlmAuth(); hcp->BuildNtlmAuthHdr(hcp->getNtlmNegotiateStr().c_str()); hcp->BuildCustomHdr("Proxy-Connection", "Close"); // hcp->BuildCustomHdr("Connection", "Keep-Alive"); hcp->BuildConnectionHdr(); } else { hcp->BuildBasicAuthHdr(url->get_user(), url->get_password() ); if(!hcp->GetProxy().user.empty()) { hcp->BuildProxyAuthHdr(hcp->GetProxy().user.c_str(), hcp->GetProxy().pwd.c_str()); } hcp->BuildConnectionHdr(); } } else { //hcp->BuildPragmaHdr(); hcp->BuildConnectionHdr(); } //hcp->BuildCustomHdr("Cache-Control", "no-cache"); return RET_OK; }
virtual int Get(uint16_t FileNumber, off_t FileOffset) { for ( std::vector<tLiveIndex>::iterator item = idx.begin(); item != idx.end(); item++) if (item->number > FileNumber || ((item->number == FileNumber) && off_t(item->offset) >= FileOffset)) return item->index; return lastPos; }; // Get