func NewCFile(client *client.Client, name string) nodefs.File {
	f := new(CFile)
	f.client = client
	f.File = nodefs.NewDefaultFile()
	f.name = name
	return f
}

func (rfs *ReverseFS) newVirtualFile(content []byte, parentFile string) (nodefs.File, fuse.Status) {
	return &virtualFile{
		File:       nodefs.NewDefaultFile(),
		content:    content,
		parentFile: parentFile,
		ino:        rfs.inoGen.next(),
	}, fuse.OK
}

func (n *blobNode) LoadMemory() (nodefs.File, error) {
	blob, err := n.fs.repo.LookupBlob(n.id)
	if err != nil {
		return nil, err
	}
	return &memoryFile{
		File: nodefs.NewDefaultFile(),
		blob: blob,
	}, nil
}

func (n *folderNode) Create(name string, flags uint32, mode uint32, context *fuse.Context) (nodefs.File, *nodefs.Inode, fuse.Status) {
	if !n.fetch() {
		return nil, nil, fuse.EIO
	}

	obj := mtp.ObjectInfo{
		StorageID:        n.StorageID(),
		Filename:         name,
		ObjectFormat:     mtp.OFC_Undefined,
		ModificationDate: time.Now(),
		ParentObject:     n.Handle(),
		CompressedSize:   0,
	}

	var file nodefs.File
	var fsNode nodefs.Node
	if n.fs.options.Android {
		_, _, handle, err := n.fs.dev.SendObjectInfo(n.StorageID(), n.Handle(), &obj)
		if err != nil {
			log.Println("SendObjectInfo failed", err)
			return nil, nil, fuse.EIO
		}

		err = n.fs.dev.SendObject(&bytes.Buffer{}, 0)
		if err != nil {
			log.Println("SendObject failed:", err)
			return nil, nil, fuse.EIO
		}

		aNode := &androidNode{
			mtpNodeImpl: mtpNodeImpl{
				Node:   nodefs.NewDefaultNode(),
				obj:    &obj,
				fs:     n.fs,
				handle: handle,
			},
		}

		if !aNode.startEdit() {
			return nil, nil, fuse.EIO
		}
		file = &androidFile{
			File: nodefs.NewDefaultFile(),
			node: aNode,
		}
		fsNode = aNode
	} else {
		var err error
		file, fsNode, err = n.fs.createClassicFile(obj)
		if err != nil {
			return nil, nil, fuse.ToStatus(err)
		}
	}
	return file, n.Inode().NewChild(name, false, fsNode), fuse.OK
}

func (m *MNode) Open(flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) {
	m.obj.Lock()
	defer m.obj.Unlock()
	j,ok := m.obj.Obj.(*joinf.JoinFile)
	if !ok { return nil,fuse.EINVAL }
	if (flags&uint32(os.O_TRUNC))!=0 {
		e := j.Truncate(0)
		if e!=nil { return nil,fuse.ToStatus(e) }
	}
	return &MFile{nodefs.NewDefaultFile(),m.obj,j},fuse.OK
}

// NewAdbFile returns a File that reads and writes to name on the device.
// perms should be set from the existing file if it exists, or to the desired new permissions if new.
func NewAdbFile(opts AdbFileOpenOptions) nodefs.File {
	logEntry := StartFileOperation("New", opts.FileBuffer.Path, fmt.Sprint(opts))
	defer logEntry.FinishOperation()

	adbFile := &AdbFile{
		// Log all the operations we don't implement.
		File:               newLoggingFile(nodefs.NewDefaultFile(), opts.FileBuffer.Path),
		AdbFileOpenOptions: opts,
	}

	return nodefs.NewReadOnlyFile(adbFile)
}

func NewObjectFile(name string, obj mapper.Object) *ObjectFile {
	f := &ObjectFile{
		name:       name,
		object:     obj,
		lock:       sync.Mutex{},
		needUpload: false,

		File: nodefs.NewDefaultFile(),
	}

	return f
}

func (fs *nomsFS) Open(path string, flags uint32, context *fuse.Context) (nodefs.File, fuse.Status) {
	fs.mdLock.Lock()
	defer fs.mdLock.Unlock()
	np, code := fs.getPath(path)
	if code != fuse.OK {
		return nil, code
	}

	nfile := nomsFile{
		File: nodefs.NewDefaultFile(),

		fs:   fs,
		node: np,
	}

	return nfile, fuse.OK
}

func (fs *nomsFS) Create(path string, flags uint32, mode uint32, context *fuse.Context) (nodefs.File, fuse.Status) {
	fs.mdLock.Lock()
	defer fs.mdLock.Unlock()
	np, code := fs.createCommon(path, mode, func() types.Value {
		blob := types.NewEmptyBlob()
		return types.NewStructWithType(fileType, types.ValueSlice{fs.ds.Database().WriteValue(blob)})
	})
	if code != fuse.OK {
		return nil, code
	}

	nfile := nomsFile{
		File: nodefs.NewDefaultFile(),

		fs:   fs,
		node: np,
	}
	return nfile, fuse.OK
}

func (fs *deviceFS) createClassicFile(obj mtp.ObjectInfo) (file nodefs.File, node nodefs.Node, err error) {
	backingFile, err := ioutil.TempFile(fs.options.Dir, "")
	cl := &classicNode{
		mtpNodeImpl: mtpNodeImpl{
			Node: nodefs.NewDefaultNode(),
			obj:  &obj,
			fs:   fs,
		},
		dirty:   true,
		backing: backingFile.Name(),
	}
	file = &pendingFile{
		loopback: nodefs.NewLoopbackFile(backingFile),
		node:     cl,
		File:     nodefs.NewDefaultFile(),
	}

	node = cl
	return
}

func (fs *objectFileSystem) Create(name string, flags uint32, mode uint32, context *fuse.Context) (nodefs.File, fuse.Status) {
	log.Debugf("Create: %s, flags: %d", name, flags)

	fs.lock.Lock()
	defer fs.lock.Unlock()

	// Add to mapper
	obj, err := fs.mapper.Create(name)
	if err != nil {
		log.Warnf("Can't append to mapper %v", err)
		return nodefs.NewDefaultFile(), fuse.EIO
	}

	file := NewObjectFile(name, obj)
	if err := file.OpenLocalFile(flags, mode); err != nil {
		log.Warnf("Create: OpenLocalFile() error %v", err)
		return file, fuse.EIO
	}

	return file, fuse.OK
}

func (rfs *ReverseFS) newFile(relPath string, flags uint32) (nodefs.File, fuse.Status) {
	absPath, err := rfs.abs(rfs.decryptPath(relPath))
	if err != nil {
		return nil, fuse.ToStatus(err)
	}
	fd, err := os.OpenFile(absPath, int(flags), 0666)
	if err != nil {
		return nil, fuse.ToStatus(err)
	}
	id := derivePathIV(relPath, ivPurposeFileID)
	header := contentenc.FileHeader{
		Version: contentenc.CurrentVersion,
		ID:      id,
	}
	return &reverseFile{
		File:       nodefs.NewDefaultFile(),
		fd:         fd,
		header:     header,
		block0IV:   derivePathIV(relPath, ivPurposeBlock0IV),
		contentEnc: rfs.contentEnc,
	}, fuse.OK
}

func (n *androidNode) Open(flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) {
	return &androidFile{
		node: n,
		File: nodefs.NewDefaultFile(),
	}, fuse.OK
}

func NewOssFile(bucket string, fileName string, ossClient *oss.Client, lock *sync.Mutex, size int64, bufFile *BufFile) (ossFile *OssFile) {
	ossFile = &OssFile{bucket: bucket, fileName: fileName, ossClient: ossClient, lock: lock, size: size, bufFile: bufFile}
	ossFile.File = nodefs.NewDefaultFile()
	return ossFile
}

func (n *classicNode) Open(flags uint32, context *fuse.Context) (file nodefs.File, code fuse.Status) {
	return &pendingFile{
		File: nodefs.NewDefaultFile(),
		node: n,
	}, fuse.OK
}

func newFile(s store.Store, kv *store.KVPair) nodefs.File {
	return &file{s, kv, nodefs.NewDefaultFile()}
}

func NewFile() *MutableDataFile {
	return &MutableDataFile{File: nodefs.NewDefaultFile()}
}

func (fs *DefaultReadFS) Open(name string, f uint32, context *fuse.Context) (nodefs.File, fuse.Status) {
	return nodefs.NewDefaultFile(), fuse.OK
}

func (f *FileObj) Init() {
	f.File = nodefs.NewDefaultFile()
}