C++ CHECKED函数代码示例

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 &params, 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::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::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 ));

	}

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);
}