int impl_fuse_context::get_file_information( LPCWSTR file_name, LPBY_HANDLE_FILE_INFORMATION handle_file_information, PDOKAN_FILE_INFO dokan_file_info) { std::string fname = unixify(wchar_to_utf8_cstr(file_name)); if (!ops_.getattr) return -EINVAL; struct FUSE_STAT st = {0}; CHECKED(ops_.getattr(fname.c_str(), &st)); if (S_ISLNK(st.st_mode)) { std::string resolved; CHECKED(resolve_symlink(fname, &resolved)); CHECKED(ops_.getattr(resolved.c_str(), &st)); } handle_file_information->nNumberOfLinks = st.st_nlink; if ((st.st_mode & S_IFDIR) == S_IFDIR) dokan_file_info->IsDirectory = TRUE; convertStatlikeBuf(&st, fname, handle_file_information); uint32_t attrs = 0xFFFFFFFFu; if (ops_.win_get_attributes) attrs = ops_.win_get_attributes(fname.c_str()); if (attrs != 0xFFFFFFFFu) handle_file_information->dwFileAttributes = attrs; return 0; }
int impl_fuse_context::walk_directory(void *buf, const char *name, const struct stat *stbuf, FUSE_OFF_T off) { walk_data *wd=(walk_data*)buf; WIN32_FIND_DATAW find_data={0}; utf8_to_wchar_buf(name,find_data.cFileName,MAX_PATH); GetShortPathNameW(find_data.cFileName,find_data.cAlternateFileName,MAX_PATH); struct FUSE_STAT stat={0}; if (stbuf!=NULL) stat=*stbuf; else { //No stat buffer - use 'getattr'. //TODO: fill directory params here!!! if (strcmp(name,".")==0 || strcmp(name,"..")==0) //Special entries stat.st_mode|=S_IFDIR; else CHECKED(wd->ctx->ops_.getattr((wd->dirname+name).c_str(),&stat)); } if (S_ISLNK(stat.st_mode)) { std::string resolved; CHECKED(wd->ctx->resolve_symlink(wd->dirname+name,&resolved)); CHECKED(wd->ctx->ops_.getattr(resolved.c_str(),&stat)); } convertStatlikeBuf(&stat,name,&find_data); return wd->delegate(&find_data,wd->DokanFileInfo); }
win_error impl_fuse_context::create_file(LPCWSTR file_name, DWORD access_mode, DWORD share_mode, DWORD creation_disposition, DWORD flags_and_attributes, PDOKAN_FILE_INFO dokan_file_info) { std::string fname=unixify(wchar_to_utf8_cstr(file_name)); dokan_file_info->Context=0; if (!ops_.getattr) return -EINVAL; struct FUSE_STAT stbuf={0}; //Check if the target file/directory exists if (ops_.getattr(fname.c_str(),&stbuf)<0) { //Nope. if (dokan_file_info->IsDirectory) return -EINVAL; //We can't create directories using CreateFile return do_create_file(file_name, creation_disposition, share_mode, access_mode, dokan_file_info); } else { if (S_ISLNK(stbuf.st_mode)) { //Get link's target CHECKED(resolve_symlink(fname,&fname)); CHECKED(ops_.getattr(fname.c_str(),&stbuf)); } if ((stbuf.st_mode&S_IFDIR)==S_IFDIR) { //Existing directory //TODO: add access control dokan_file_info->IsDirectory=TRUE; return do_open_dir(file_name,dokan_file_info); } else { //Existing file //Check if we'll be able to truncate or delete the opened file //TODO: race condition here? if (creation_disposition==CREATE_ALWAYS) { if (!ops_.unlink) return -EINVAL; CHECKED(ops_.unlink(fname.c_str())); //Delete file //And create it! return do_create_file(file_name,creation_disposition, share_mode, access_mode,dokan_file_info); } else if (creation_disposition==TRUNCATE_EXISTING) { if (!ops_.truncate) return -EINVAL; CHECKED(ops_.truncate(fname.c_str(),0)); } else if (creation_disposition==CREATE_NEW) { return win_error(ERROR_FILE_EXISTS, true); } return do_open_file(file_name, share_mode, access_mode, dokan_file_info); } } }
int VM::New(VMStartParams ¶ms, Box<VM> &result) { int status__; { if (!vmKey.IsValid()) CHECKED_MEM(vmKey.Alloc()); Box<VM> vm(new(std::nothrow) VM(params)); CHECKED_MEM(vm.get()); // Most things rely on static strings, so initialize them first. CHECKED_MEM(vm->strings = StaticStrings::New()); CHECKED_MEM(vm->mainThread = Thread::New(vm.get())); CHECKED_MEM(vm->gc = GC::New(vm.get())); CHECKED_MEM(vm->standardTypeCollection = StandardTypeCollection::New(vm.get())); CHECKED_MEM(vm->modules = ModulePool::New(10)); CHECKED_MEM(vm->refSignatures = Box<RefSignaturePool>(new(std::nothrow) RefSignaturePool())); CHECKED(vm->LoadModules(params)); CHECKED(vm->InitArgs(params.argc, params.argv)); result = std::move(vm); } status__ = OVUM_SUCCESS; retStatus__: return status__; }
int impl_fuse_context::open_directory(LPCWSTR file_name, PDOKAN_FILE_INFO dokan_file_info) { std::string fname=unixify(wchar_to_utf8_cstr(file_name)); if (ops_.opendir) return do_open_dir(file_name,dokan_file_info); //We don't have opendir(), so the most we can do is make sure //that the target is indeed a directory struct FUSE_STAT st={0}; CHECKED(ops_.getattr(fname.c_str(),&st)); if (S_ISLNK(st.st_mode)) { std::string resolved; CHECKED(resolve_symlink(fname,&resolved)); CHECKED(ops_.getattr(resolved.c_str(),&st)); } //Not a directory if ((st.st_mode&S_IFDIR)!=S_IFDIR) return -ENOTDIR; dokan_file_info->Context=(ULONG64)NULL; //Do not want to attach anything return 0; //Use readdir here? }
int impl_fuse_context::do_create_file(LPCWSTR FileName, DWORD Disposition, DWORD share_mode, DWORD Flags, PDOKAN_FILE_INFO DokanFileInfo) { std::string fname=unixify(wchar_to_utf8_cstr(FileName)); //Create file? if (Disposition!=CREATE_NEW && Disposition!=CREATE_ALWAYS && Disposition!=OPEN_ALWAYS) return -ENOENT; //No, we're trying to open an existing file! if (!ops_.create) { //Use mknod+open. if (!ops_.mknod || !ops_.open) return -EINVAL; CHECKED(ops_.mknod(fname.c_str(),filemask_,0)); return do_open_file(FileName, share_mode, Flags, DokanFileInfo); } std::auto_ptr<impl_file_handle> file; CHECKED(file_locks.get_file(fname,false,Flags,share_mode,file)); fuse_file_info finfo={0}; finfo.flags=O_CREAT | O_EXCL | convert_flags(Flags); //TODO: these flags should be OK for new files? CHECKED(ops_.create(fname.c_str(),filemask_,&finfo)); DokanFileInfo->Context=reinterpret_cast<ULONG64>(file.release()); return 0; }
int impl_fuse_context::move_file(LPCWSTR file_name, LPCWSTR new_file_name, BOOL replace_existing, PDOKAN_FILE_INFO dokan_file_info) { if (!ops_.rename || !ops_.getattr) return -EINVAL; std::string name = unixify(wchar_to_utf8_cstr(file_name)); std::string new_name = unixify(wchar_to_utf8_cstr(new_file_name)); struct FUSE_STAT stbuf = {0}; if (ops_.getattr(new_name.c_str(), &stbuf) != -ENOENT) { if (!replace_existing) return -EEXIST; // Cannot delete directory if ((stbuf.st_mode & S_IFDIR) != 0) return -EISDIR; if (!ops_.unlink) return -EINVAL; CHECKED(ops_.unlink(new_name.c_str())); } // this can happen cause DeleteFile in Windows can return success even if // file is still in the file system if (ops_.getattr(new_name.c_str(), &stbuf) != -ENOENT) { return -EEXIST; } CHECKED(ops_.rename(name.c_str(), new_name.c_str())); file_locks.renamed_file(name, new_name); return 0; }
int impl_fuse_context::check_and_resolve(std::string *name) { if (!ops_.getattr) return -EINVAL; struct FUSE_STAT stat = {0}; CHECKED(ops_.getattr(name->c_str(), &stat)); if (S_ISLNK(stat.st_mode)) CHECKED(resolve_symlink(*name, name)); return 0; }
~mmio_stream_raii() { data_info.dwFlags |= MMIO_DIRTY; CHECKED(mmioSetInfo( mmio, &data_info, 0 )); CHECKED(mmioAscend( mmio, &data_chunk, 0 )); CHECKED(mmioAscend( mmio, &WAVE_chunk, 0 )); CHECKED(mmioClose( mmio, 0 )); mmio = NULL; }
int impl_fuse_context::walk_directory(void *buf, const char *name, const struct FUSE_STAT *stbuf, FUSE_OFF_T off) { walk_data *wd=(walk_data*)buf; WIN32_FIND_DATAW find_data={0}; utf8_to_wchar_buf(name,find_data.cFileName,MAX_PATH); // fix name if wrong encoding if (!find_data.cFileName[0]) { struct FUSE_STAT stbuf={0}; utf8_to_wchar_buf_old(name,find_data.cFileName,MAX_PATH); std::string new_name = wchar_to_utf8_cstr(find_data.cFileName); if (wd->ctx->ops_.getattr && wd->ctx->ops_.rename && new_name.length() && wd->ctx->ops_.getattr(new_name.c_str(),&stbuf) == -ENOENT) wd->ctx->ops_.rename(name, new_name.c_str()); } memset(find_data.cAlternateFileName, 0, sizeof(find_data.cAlternateFileName)); struct FUSE_STAT stat={0}; if (stbuf!=NULL) stat=*stbuf; else { //No stat buffer - use 'getattr'. //TODO: fill directory params here!!! if (strcmp(name,".")==0 || strcmp(name,"..")==0) //Special entries stat.st_mode|=S_IFDIR; else CHECKED(wd->ctx->ops_.getattr((wd->dirname+name).c_str(),&stat)); } if (S_ISLNK(stat.st_mode)) { std::string resolved; CHECKED(wd->ctx->resolve_symlink(wd->dirname+name,&resolved)); CHECKED(wd->ctx->ops_.getattr(resolved.c_str(),&stat)); } convertStatlikeBuf(&stat,name,&find_data); uint32_t attrs = 0xFFFFFFFFu; if (wd->ctx->ops_.win_get_attributes) attrs = wd->ctx->ops_.win_get_attributes((wd->dirname+name).c_str()); if (attrs != 0xFFFFFFFFu) find_data.dwFileAttributes = attrs; return wd->delegate(&find_data,wd->DokanFileInfo); }
int impl_fuse_context::move_file(LPCWSTR file_name, LPCWSTR new_file_name, BOOL replace_existing, PDOKAN_FILE_INFO dokan_file_info) { if (!ops_.rename || !ops_.getattr) return -EINVAL; std::string name=unixify(wchar_to_utf8_cstr(file_name)); std::string new_name=unixify(wchar_to_utf8_cstr(new_file_name)); struct FUSE_STAT stbuf={0}; if (ops_.getattr(new_name.c_str(),&stbuf)!=-ENOENT) { //Cannot delete directory if ((stbuf.st_mode&S_IFDIR)==0 && ops_.unlink) { if (replace_existing) { CHECKED(ops_.unlink(new_name.c_str())); } else { return -EEXIST; } } } return ops_.rename(name.c_str(),new_name.c_str()); }
int impl_fuse_context::do_open_file(LPCWSTR FileName, DWORD Flags, PDOKAN_FILE_INFO DokanFileInfo) { if (!ops_.open) return -EINVAL; std::string fname=unixify(wchar_to_utf8_cstr(FileName)); CHECKED(check_and_resolve(&fname)); fuse_file_info finfo={0}; //if ((ShareMode & FILE_SHARE_READ) || (ShareMode & FILE_SHARE_DELETE)) //TODO: add sharing support? finfo.flags=convert_flags(Flags); CHECKED(ops_.open(fname.c_str(),&finfo)); DokanFileInfo->Context=reinterpret_cast<ULONG64>(new impl_file_handle(fname,false,&finfo)); return 0; }
int impl_fuse_context::write_file(LPCWSTR /*file_name*/, LPCVOID buffer, DWORD num_bytes_to_write,LPDWORD num_bytes_written, LONGLONG offset, PDOKAN_FILE_INFO dokan_file_info) { //Please note, that we ifnore file_name here, because it might //have been retargeted by a symlink. *num_bytes_written=0; //Conform to ReadFile semantics if (!ops_.write) return -EINVAL; impl_file_handle *hndl=reinterpret_cast<impl_file_handle*>(dokan_file_info->Context); if (!hndl) return -EINVAL; if (hndl->is_dir()) return -EACCES; //Clip the maximum write size if (num_bytes_to_write>conn_info_.max_write) num_bytes_to_write=conn_info_.max_write; FUSE_OFF_T off; CHECKED(cast_from_longlong(offset,&off)); fuse_file_info finfo(hndl->make_finfo()); int res=ops_.write(hndl->get_name().c_str(),(const char*)buffer, num_bytes_to_write, off,&finfo); if (res<0) return res; //Error //OK! *num_bytes_written=res; return 0; }
int impl_fuse_context::unlock_file(LPCWSTR file_name, LONGLONG byte_offset, LONGLONG length, PDOKAN_FILE_INFO dokan_file_info) { impl_file_handle *hndl = reinterpret_cast<impl_file_handle *>(dokan_file_info->Context); if (!hndl) return -EINVAL; if (hndl->is_dir()) return -EACCES; FUSE_OFF_T off; CHECKED(cast_from_longlong(byte_offset, &off)); if (ops_.lock) { fuse_file_info finfo(hndl->make_finfo()); struct flock lock; lock.l_type = F_UNLCK; lock.l_whence = SEEK_SET; lock.l_start = off; lock.l_len = length; return ops_.lock(hndl->get_name().c_str(), &finfo, F_SETLK, &lock); } return hndl->unlock(byte_offset, length); }
void DesktopDuplication::init() { IDXGIFactory1* dxgiFactory = nullptr; CHECKED(hr, CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&dxgiFactory))); IDXGIAdapter1* dxgiAdapter = nullptr; CHECKED(hr, dxgiFactory->EnumAdapters1(adapter, &dxgiAdapter)); dxgiFactory->Release(); CHECKED(hr, D3D11CreateDevice(dxgiAdapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, NULL, NULL, NULL, D3D11_SDK_VERSION, &d3dDevice, NULL, &d3dContext)); IDXGIOutput* dxgiOutput = nullptr; CHECKED(hr, dxgiAdapter->EnumOutputs(output, &dxgiOutput)); dxgiAdapter->Release(); IDXGIOutput1* dxgiOutput1 = nullptr; CHECKED(hr, dxgiOutput->QueryInterface(__uuidof(dxgiOutput1), reinterpret_cast<void**>(&dxgiOutput1))); dxgiOutput->Release(); IDXGIDevice* dxgiDevice = nullptr; CHECKED(hr, d3dDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice))); CHECKED(hr, dxgiOutput1->DuplicateOutput(dxgiDevice, &outputDuplication)); dxgiOutput1->Release(); dxgiDevice->Release(); }
mmio_stream_raii( const std::string & filename, const commandlineflags & flags_ ) : flags(flags_), mmio(NULL) { ZeroMemory( &waveformatex, sizeof( WAVEFORMATEX ) ); waveformatex.cbSize = 0; waveformatex.wFormatTag = flags.use_float ? WAVE_FORMAT_IEEE_FLOAT : WAVE_FORMAT_PCM; waveformatex.nChannels = flags.channels; waveformatex.nSamplesPerSec = flags.samplerate; waveformatex.wBitsPerSample = flags.use_float ? 32 : 16; waveformatex.nBlockAlign = flags.channels * ( waveformatex.wBitsPerSample / 8 ); waveformatex.nAvgBytesPerSec = waveformatex.nSamplesPerSec * waveformatex.nBlockAlign; #if defined(WIN32) && defined(UNICODE) wchar_t * tmp = wcsdup( utf8_to_wstring( filename ).c_str() ); mmio = mmioOpen( tmp, NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE ); free( tmp ); tmp = 0; #else char * tmp = strdup( filename.c_str() ); mmio = mmioOpen( tmp, NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE ); free( tmp ); tmp = 0; #endif ZeroMemory( &WAVE_chunk, sizeof( MMCKINFO ) ); WAVE_chunk.fccType = mmioFOURCC('W', 'A', 'V', 'E'); CHECKED(mmioCreateChunk( mmio, &WAVE_chunk, MMIO_CREATERIFF )); ZeroMemory( &fmt__chunk, sizeof( MMCKINFO ) ); fmt__chunk.ckid = mmioFOURCC('f', 'm', 't', ' '); fmt__chunk.cksize = sizeof( WAVEFORMATEX ); CHECKED(mmioCreateChunk( mmio, &fmt__chunk, 0 )); mmioWrite( mmio, (const char*)&waveformatex, sizeof( WAVEFORMATEX ) ); CHECKED(mmioAscend( mmio, &fmt__chunk, 0 )); ZeroMemory( &data_chunk, sizeof( MMCKINFO ) ); data_chunk.ckid = mmioFOURCC('d', 'a', 't', 'a'); data_chunk.cksize = 0; CHECKED(mmioCreateChunk( mmio, &data_chunk, 0 )); ZeroMemory( &data_info, sizeof( MMIOINFO ) ); CHECKED(mmioGetInfo( mmio, &data_info, 0 )); }
int impl_fuse_context::set_end_of_file(LPCWSTR file_name, LONGLONG byte_offset, PDOKAN_FILE_INFO dokan_file_info) { FUSE_OFF_T off; CHECKED(cast_from_longlong(byte_offset, &off)); std::string fname = unixify(wchar_to_utf8_cstr(file_name)); CHECKED(check_and_resolve(&fname)); impl_file_handle *hndl = reinterpret_cast<impl_file_handle *>(dokan_file_info->Context); if (hndl && ops_.ftruncate) { fuse_file_info finfo(hndl->make_finfo()); return ops_.ftruncate(hndl->get_name().c_str(), off, &finfo); } if (!ops_.truncate) return -EINVAL; return ops_.truncate(fname.c_str(), off); }
ABool path_exists( const char* path ) { int ret; if (path == NULL) return 0; CHECKED(ret, access(path, F_OK)); return (ret == 0) || (errno != ENOENT); }
ABool path_can_exec( const char* path ) { int ret; if (path == NULL) return 0; CHECKED(ret, access(path, X_OK)); return (ret == 0); }
int impl_fuse_context::set_file_time(PCWSTR file_name, const FILETIME *creation_time, const FILETIME *last_access_time, const FILETIME *last_write_time, PDOKAN_FILE_INFO dokan_file_info) { if (!ops_.utimens && !ops_.utime && !ops_.win_set_times) return -EINVAL; if (ops_.win_set_times) { std::string fname = unixify(wchar_to_utf8_cstr(file_name)); CHECKED(check_and_resolve(&fname)); impl_file_handle *hndl = reinterpret_cast<impl_file_handle *>(dokan_file_info->Context); if (!hndl) return ops_.win_set_times(fname.c_str(), NULL, creation_time, last_access_time, last_write_time); if (hndl->is_dir()) return -EACCES; fuse_file_info finfo(hndl->make_finfo()); return ops_.win_set_times(fname.c_str(), &finfo, creation_time, last_access_time, last_write_time); } if (!ops_.getattr) return -EINVAL; std::string fname = unixify(wchar_to_utf8_cstr(file_name)); CHECKED(check_and_resolve(&fname)); struct FUSE_STAT st = {0}; CHECKED(ops_.getattr(fname.c_str(), &st)); if (ops_.utimens) { struct timespec tv[2] = {0}; // TODO: support nanosecond resolution // Access time CHECKED(helper_set_time_struct(last_access_time, st.st_atim.tv_sec, &(tv[0].tv_sec))); // Modification time CHECKED(helper_set_time_struct(last_write_time, st.st_mtim.tv_sec, &(tv[1].tv_sec))); return ops_.utimens(fname.c_str(), tv); } else { struct utimbuf ut = {0}; // Access time CHECKED(helper_set_time_struct(last_access_time, st.st_atim.tv_sec, &(ut.actime))); // Modification time CHECKED(helper_set_time_struct(last_write_time, st.st_mtim.tv_sec, &(ut.modtime))); return ops_.utime(fname.c_str(), &ut); } }
int impl_fuse_context::find_files(LPCWSTR file_name, PFillFindData fill_find_data, PDOKAN_FILE_INFO dokan_file_info) { if ((!ops_.readdir && !ops_.getdir) || !ops_.getattr) return -EINVAL; std::string fname = unixify(wchar_to_utf8_cstr(file_name)); CHECKED(check_and_resolve(&fname)); walk_data wd; wd.ctx = this; wd.dirname = fname; if (*fname.rbegin() != '/') wd.dirname.append("/"); wd.delegate = fill_find_data; wd.DokanFileInfo = dokan_file_info; if (ops_.readdir) { impl_file_handle *hndl = reinterpret_cast<impl_file_handle *>(dokan_file_info->Context); if (hndl != NULL) { fuse_file_info finfo(hndl->make_finfo()); return ops_.readdir(fname.c_str(), &wd, &walk_directory, 0, &finfo); } else return ops_.readdir(fname.c_str(), &wd, &walk_directory, 0, NULL); } else { CHECKED( ops_.getdir(fname.c_str(), (fuse_dirh_t)&wd, &walk_directory_getdir)); // Convert returned data The getdir_data array will be filled during // getdir() call. // We emulate FUSE behavior and do not pass information directly to Dokan // in walk_directory_getdir callback. This can cause excessive network // traffic // in sshfs because it populates stat buffer cache AFTER calling our // callback. // See: cache.c file, function cache_dirfill() in SSHFS 2.2 for (std::vector<std::string>::const_iterator f = wd.getdir_data.begin(); f != wd.getdir_data.end(); ++f) CHECKED(walk_directory(&wd, f->c_str(), 0, 0)); } return 0; }
int impl_fuse_context::do_open_file(LPCWSTR FileName, DWORD share_mode, DWORD Flags, PDOKAN_FILE_INFO DokanFileInfo) { if (!ops_.open) return -EINVAL; std::string fname=unixify(wchar_to_utf8_cstr(FileName)); CHECKED(check_and_resolve(&fname)); std::auto_ptr<impl_file_handle> file; CHECKED(file_locks.get_file(fname,false,Flags,share_mode,file)); fuse_file_info finfo={0}; finfo.flags=convert_flags(Flags); CHECKED(ops_.open(fname.c_str(),&finfo)); file->set_finfo(finfo); DokanFileInfo->Context=reinterpret_cast<ULONG64>(file.release()); return 0; }
int impl_fuse_context::do_open_dir(LPCWSTR FileName, PDOKAN_FILE_INFO DokanFileInfo) { if (ops_.opendir) { std::string fname=unixify(wchar_to_utf8_cstr(FileName)); std::auto_ptr<impl_file_handle> file; // TODO access_mode CHECKED(file_locks.get_file(fname,true,0,FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,file)); fuse_file_info finfo={0}; CHECKED(ops_.opendir(fname.c_str(),&finfo)); file->set_finfo(finfo); DokanFileInfo->Context=reinterpret_cast<ULONG64>(file.release()); return 0; } DokanFileInfo->Context=0; return 0; }
int impl_fuse_context::do_create_file(LPCWSTR FileName, DWORD Disposition, DWORD share_mode, DWORD Flags, PDOKAN_FILE_INFO DokanFileInfo) // Kernel mappsings: // Disposition = CreateDisposition // Flags = DesiredAccess // share_mode = ShareAccess { std::string fname = unixify(wchar_to_utf8_cstr(FileName)); // Create file? if (Disposition != FILE_CREATE && Disposition != FILE_SUPERSEDE && Disposition != FILE_OPEN_IF && Disposition != FILE_OVERWRITE_IF) { SetLastError(ERROR_FILE_NOT_FOUND); return -ENOENT; // No, we're trying to open an existing file! } if (!ops_.create) { // Use mknod+open. if (!ops_.mknod || !ops_.open) return -EINVAL; CHECKED(ops_.mknod(fname.c_str(), filemask_, 0)); return do_open_file(FileName, share_mode, Flags, DokanFileInfo); } std::unique_ptr<impl_file_handle> file; CHECKED(file_locks.get_file(fname, false, Flags, share_mode, file)); fuse_file_info finfo = {0}; finfo.flags = O_CREAT | O_EXCL | convert_flags(Flags); // TODO: these flags should be OK for new files? CHECKED(ops_.create(fname.c_str(), filemask_, &finfo)); file->set_finfo(finfo); DokanFileInfo->Context = reinterpret_cast<ULONG64>(file.release()); return 0; }
AVES_API BEGIN_NATIVE_FUNCTION(aves_Utf16Encoding_getByteCount) { // getByteCount(str) CHECKED(StringFromValue(thread, args + 1)); Utf16Encoding *encoding = THISV.Get<Utf16Encoding>(); Utf16Encoder enc(encoding->bigEndian); ssize_t byteCount = enc.GetByteCount(thread, args[1].v.string, true); VM_PushInt(thread, byteCount); }
void write( const std::vector<std::int16_t*> buffers, std::size_t frames ) { for ( std::size_t frame = 0; frame < frames; frame++ ) { for ( std::size_t channel = 0; channel < buffers.size(); channel++ ) { if ( data_info.pchEndWrite - data_info.pchNext < static_cast<long>( sizeof( std::int16_t ) ) ) { data_info.dwFlags |= MMIO_DIRTY; CHECKED(mmioAdvance( mmio, &data_info, MMIO_WRITE )); } std::memcpy( data_info.pchNext, &( buffers[channel][frame] ), sizeof( std::int16_t ) ); data_info.pchNext += sizeof( std::int16_t ); } } }
/* try to make a directory. returns 0 on success, -1 on failure * (error code in errno) */ APosixStatus path_mkdir( const char* path, int mode ) { #ifdef _WIN32 (void)mode; return _mkdir(path); #else int ret; CHECKED(ret, mkdir(path, mode)); return ret; #endif }
int impl_fuse_context::set_file_time(PCWSTR file_name, const FILETIME* creation_time, const FILETIME* last_access_time, const FILETIME* last_write_time, PDOKAN_FILE_INFO dokan_file_info) { if (!ops_.utimens && !ops_.utime) return -EINVAL; if (!ops_.getattr) return -EINVAL; std::string fname=unixify(wchar_to_utf8_cstr(file_name)); CHECKED(check_and_resolve(&fname)); struct FUSE_STAT st={0}; CHECKED(ops_.getattr(fname.c_str(),&st)); if (ops_.utimens) { struct timespec tv[2]={{0,},}; //TODO: support nanosecond resolution //Access time CHECKED(helper_set_time_struct(last_access_time,st.st_atime,&(tv[0].tv_sec))); //Modification time CHECKED(helper_set_time_struct(last_write_time,st.st_mtime,&(tv[1].tv_sec))); return ops_.utimens(fname.c_str(),tv); } else { struct utimbuf ut={0}; //Access time CHECKED(helper_set_time_struct(last_access_time,st.st_atime,&(ut.actime))); //Modification time CHECKED(helper_set_time_struct(last_write_time,st.st_mtime,&(ut.modtime))); return ops_.utime(fname.c_str(),&ut); } }
/* checks that a path points to a directory */ ABool path_is_dir( const char* path ) { int ret; struct stat st; if (path == NULL) return 0; CHECKED(ret, stat(path, &st)); if (ret < 0) return 0; return S_ISDIR(st.st_mode); }
ID3D11Texture2D* DesktopDuplication::copyToStaging(ID3D11Texture2D* tex) { D3D11_TEXTURE2D_DESC texDesc; tex->GetDesc(&texDesc); stagingTexDesc = getStagingTexDesc(texDesc); ID3D11Texture2D* stagingTex; CHECKED(hr, d3dDevice->CreateTexture2D(&stagingTexDesc, nullptr, &stagingTex)); d3dContext->CopyResource(stagingTex, tex); return stagingTex; }