vfs_smb2.c

samba最新软件

  query info on a open file
*/
static NTSTATUS cvfs_qfileinfo(struct ntvfs_module_context *ntvfs, 
			       struct ntvfs_request *req, union smb_fileinfo *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}


/*
  set info on a pathname
*/
static NTSTATUS cvfs_setpathinfo(struct ntvfs_module_context *ntvfs, 
				 struct ntvfs_request *req, union smb_setfileinfo *st)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}


/*
  open a file
*/
static NTSTATUS cvfs_open(struct ntvfs_module_context *ntvfs, 
			  struct ntvfs_request *req, union smb_open *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  create a directory
*/
static NTSTATUS cvfs_mkdir(struct ntvfs_module_context *ntvfs, 
			   struct ntvfs_request *req, union smb_mkdir *md)
{
	struct cvfs_private *private = ntvfs->private_data;
	struct composite_context *c_req;

	CHECK_ASYNC(req);

	c_req = smb2_composite_mkdir_send(private->tree, md);

	SIMPLE_COMPOSITE_TAIL;
}

/*
  remove a directory
*/
static NTSTATUS cvfs_rmdir(struct ntvfs_module_context *ntvfs, 
			   struct ntvfs_request *req, struct smb_rmdir *rd)
{
	struct cvfs_private *private = ntvfs->private_data;
	struct composite_context *c_req;

	CHECK_ASYNC(req);

	c_req = smb2_composite_rmdir_send(private->tree, rd);

	SIMPLE_COMPOSITE_TAIL;
}

/*
  rename a set of files
*/
static NTSTATUS cvfs_rename(struct ntvfs_module_context *ntvfs, 
			    struct ntvfs_request *req, union smb_rename *ren)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  copy a set of files
*/
static NTSTATUS cvfs_copy(struct ntvfs_module_context *ntvfs, 
			  struct ntvfs_request *req, struct smb_copy *cp)
{
	return NT_STATUS_NOT_SUPPORTED;
}

/*
  read from a file
*/
static NTSTATUS cvfs_read(struct ntvfs_module_context *ntvfs, 
			  struct ntvfs_request *req, union smb_read *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  write to a file
*/
static NTSTATUS cvfs_write(struct ntvfs_module_context *ntvfs, 
			   struct ntvfs_request *req, union smb_write *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  seek in a file
*/
static NTSTATUS cvfs_seek(struct ntvfs_module_context *ntvfs, 
			  struct ntvfs_request *req,
			  union smb_seek *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  flush a file
*/
static NTSTATUS cvfs_flush(struct ntvfs_module_context *ntvfs, 
			   struct ntvfs_request *req,
			   union smb_flush *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  close a file
*/
static NTSTATUS cvfs_close(struct ntvfs_module_context *ntvfs, 
			   struct ntvfs_request *req, union smb_close *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  exit - closing files open by the pid
*/
static NTSTATUS cvfs_exit(struct ntvfs_module_context *ntvfs, 
			  struct ntvfs_request *req)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  logoff - closing files open by the user
*/
static NTSTATUS cvfs_logoff(struct ntvfs_module_context *ntvfs, 
			    struct ntvfs_request *req)
{
	/* we can't do this right in the cifs backend .... */
	return NT_STATUS_OK;
}

/*
  setup for an async call - nothing to do yet
*/
static NTSTATUS cvfs_async_setup(struct ntvfs_module_context *ntvfs, 
				 struct ntvfs_request *req, 
				 void *private)
{
	return NT_STATUS_OK;
}

/*
  cancel an async call
*/
static NTSTATUS cvfs_cancel(struct ntvfs_module_context *ntvfs, 
			    struct ntvfs_request *req)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  lock a byte range
*/
static NTSTATUS cvfs_lock(struct ntvfs_module_context *ntvfs, 
			  struct ntvfs_request *req, union smb_lock *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  set info on a open file
*/
static NTSTATUS cvfs_setfileinfo(struct ntvfs_module_context *ntvfs, 
				 struct ntvfs_request *req, 
				 union smb_setfileinfo *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}


/*
  a handler for async fsinfo replies
 */
static void async_fsinfo(struct smb2_request *c_req)
{
	struct async_info *async = c_req->async.private_data;
	struct ntvfs_request *req = async->req;
	req->async_states->status = smb2_getinfo_fs_recv(c_req, req, async->parms);
	talloc_free(async);
	req->async_states->send_fn(req);
}

/*
  return filesystem space info
*/
static NTSTATUS cvfs_fsinfo(struct ntvfs_module_context *ntvfs, 
			    struct ntvfs_request *req, union smb_fsinfo *fs)
{
	struct cvfs_private *private = ntvfs->private_data;
	struct smb2_request *c_req;
	enum smb_fsinfo_level level = fs->generic.level;

	CHECK_ASYNC(req);

	switch (level) {
		/* some levels go straight through */
	case RAW_QFS_VOLUME_INFORMATION:
	case RAW_QFS_SIZE_INFORMATION:
	case RAW_QFS_DEVICE_INFORMATION:
	case RAW_QFS_ATTRIBUTE_INFORMATION:
	case RAW_QFS_QUOTA_INFORMATION:
	case RAW_QFS_FULL_SIZE_INFORMATION:
	case RAW_QFS_OBJECTID_INFORMATION:
		break;

		/* some get mapped */
	case RAW_QFS_VOLUME_INFO:
		level = RAW_QFS_VOLUME_INFORMATION;
		break;
	case RAW_QFS_SIZE_INFO:
		level = RAW_QFS_SIZE_INFORMATION;
		break;
	case RAW_QFS_DEVICE_INFO:
		level = RAW_QFS_DEVICE_INFORMATION;
		break;
	case RAW_QFS_ATTRIBUTE_INFO:
		level = RAW_QFS_ATTRIBUTE_INFO;
		break;

	default:
		/* the rest get refused for now */
		DEBUG(0,("fsinfo level %u not possible on SMB2\n",
			 (unsigned)fs->generic.level));
		break;
	}

	fs->generic.level = level;
	fs->generic.handle = private->roothandle;

	c_req = smb2_getinfo_fs_send(private->tree, fs);

	ASYNC_RECV_TAIL(fs, async_fsinfo);
}

/*
  return print queue info
*/
static NTSTATUS cvfs_lpq(struct ntvfs_module_context *ntvfs, 
			 struct ntvfs_request *req, union smb_lpq *lpq)
{
	return NT_STATUS_NOT_SUPPORTED;
}

/* 
   list files in a directory matching a wildcard pattern
*/
static NTSTATUS cvfs_search_first(struct ntvfs_module_context *ntvfs, 
				  struct ntvfs_request *req, union smb_search_first *io, 
				  void *search_private, 
				  bool (*callback)(void *, const union smb_search_data *))
{
	struct cvfs_private *private = ntvfs->private_data;
	struct smb2_find f;
	enum smb_search_data_level smb2_level;
	uint_t count, i;
	union smb_search_data *data;
	NTSTATUS status;

	if (io->generic.level != RAW_SEARCH_TRANS2) {
		DEBUG(0,("We only support trans2 search in smb2 backend\n"));
		return NT_STATUS_NOT_SUPPORTED;
	}

	switch (io->generic.data_level) {
	case RAW_SEARCH_DATA_DIRECTORY_INFO:
		smb2_level = SMB2_FIND_DIRECTORY_INFO;
		break;
	case RAW_SEARCH_DATA_FULL_DIRECTORY_INFO:
		smb2_level = SMB2_FIND_FULL_DIRECTORY_INFO;
		break;
	case RAW_SEARCH_DATA_BOTH_DIRECTORY_INFO:
		smb2_level = SMB2_FIND_BOTH_DIRECTORY_INFO;
		break;
	case RAW_SEARCH_DATA_NAME_INFO:
		smb2_level = SMB2_FIND_NAME_INFO;
		break;
	case RAW_SEARCH_DATA_ID_FULL_DIRECTORY_INFO:
		smb2_level = SMB2_FIND_ID_FULL_DIRECTORY_INFO;
		break;
	case RAW_SEARCH_DATA_ID_BOTH_DIRECTORY_INFO:
		smb2_level = SMB2_FIND_ID_BOTH_DIRECTORY_INFO;
		break;
	default:
		DEBUG(0,("Unsupported search level %u for smb2 backend\n",
			 (unsigned)io->generic.data_level));
		return NT_STATUS_INVALID_INFO_CLASS;
	}

	/* we do the search on the roothandle. This only works because
	   search is synchronous, otherwise we'd have no way to
	   distinguish multiple searches happening at once
	*/
	ZERO_STRUCT(f);
	f.in.file.handle	= private->roothandle;
	f.in.level              = smb2_level;
	f.in.pattern		= io->t2ffirst.in.pattern;
	while (f.in.pattern[0] == '\\') {
		f.in.pattern++;
	}
	f.in.continue_flags	= 0;
	f.in.max_response_size	= 0x10000;

	status = smb2_find_level(private->tree, req, &f, &count, &data);
	NT_STATUS_NOT_OK_RETURN(status);	

	for (i=0;i<count;i++) {
		if (!callback(search_private, &data[i])) break;
	}

	io->t2ffirst.out.handle = 0;
	io->t2ffirst.out.count = i;
	/* TODO: fix end_of_file */
	io->t2ffirst.out.end_of_search = 1;

	talloc_free(data);
	
	return NT_STATUS_OK;
}

/* continue a search */
static NTSTATUS cvfs_search_next(struct ntvfs_module_context *ntvfs, 
				 struct ntvfs_request *req, union smb_search_next *io, 
				 void *search_private, 
				 bool (*callback)(void *, const union smb_search_data *))
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/* close a search */
static NTSTATUS cvfs_search_close(struct ntvfs_module_context *ntvfs, 
				  struct ntvfs_request *req, union smb_search_close *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/* SMBtrans - not used on file shares */
static NTSTATUS cvfs_trans(struct ntvfs_module_context *ntvfs, 
			   struct ntvfs_request *req,
			   struct smb_trans2 *trans2)
{
	return NT_STATUS_ACCESS_DENIED;
}

/* change notify request - always async */
static NTSTATUS cvfs_notify(struct ntvfs_module_context *ntvfs, 
			    struct ntvfs_request *req,
			    union smb_notify *io)
{
	return NT_STATUS_NOT_IMPLEMENTED;
}

/*
  initialise the CIFS->CIFS backend, registering ourselves with the ntvfs subsystem
 */
NTSTATUS ntvfs_smb2_init(void)
{
	NTSTATUS ret;
	struct ntvfs_ops ops;
	NTVFS_CURRENT_CRITICAL_SIZES(vers);

	ZERO_STRUCT(ops);

	/* fill in the name and type */
	ops.name = "smb2";
	ops.type = NTVFS_DISK;
	
	/* fill in all the operations */
	ops.connect = cvfs_connect;
	ops.disconnect = cvfs_disconnect;
	ops.unlink = cvfs_unlink;
	ops.chkpath = cvfs_chkpath;
	ops.qpathinfo = cvfs_qpathinfo;
	ops.setpathinfo = cvfs_setpathinfo;
	ops.open = cvfs_open;
	ops.mkdir = cvfs_mkdir;
	ops.rmdir = cvfs_rmdir;
	ops.rename = cvfs_rename;
	ops.copy = cvfs_copy;
	ops.ioctl = cvfs_ioctl;
	ops.read = cvfs_read;
	ops.write = cvfs_write;
	ops.seek = cvfs_seek;
	ops.flush = cvfs_flush;	
	ops.close = cvfs_close;
	ops.exit = cvfs_exit;
	ops.lock = cvfs_lock;
	ops.setfileinfo = cvfs_setfileinfo;
	ops.qfileinfo = cvfs_qfileinfo;
	ops.fsinfo = cvfs_fsinfo;
	ops.lpq = cvfs_lpq;
	ops.search_first = cvfs_search_first;
	ops.search_next = cvfs_search_next;
	ops.search_close = cvfs_search_close;
	ops.trans = cvfs_trans;
	ops.logoff = cvfs_logoff;
	ops.async_setup = cvfs_async_setup;
	ops.cancel = cvfs_cancel;
	ops.notify = cvfs_notify;

	/* register ourselves with the NTVFS subsystem. We register
	   under the name 'smb2'. */
	ret = ntvfs_register(&ops, &vers);

	if (!NT_STATUS_IS_OK(ret)) {
		DEBUG(0,("Failed to register SMB2 backend\n"));
	}
	
	return ret;
}