xref: /linux/fs/smb/client/ioctl.c (revision b58b13f156c00c2457035b7071eaaac105fe6836)
1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3  *
4  *   vfs operations that deal with io control
5  *
6  *   Copyright (C) International Business Machines  Corp., 2005,2013
7  *   Author(s): Steve French (sfrench@us.ibm.com)
8  *
9  */
10 
11 #include <linux/fs.h>
12 #include <linux/file.h>
13 #include <linux/mount.h>
14 #include <linux/mm.h>
15 #include <linux/pagemap.h>
16 #include "cifspdu.h"
17 #include "cifsglob.h"
18 #include "cifsproto.h"
19 #include "cifs_debug.h"
20 #include "cifsfs.h"
21 #include "cifs_ioctl.h"
22 #include "smb2proto.h"
23 #include "smb2glob.h"
24 #include <linux/btrfs.h>
25 
26 static long cifs_ioctl_query_info(unsigned int xid, struct file *filep,
27 				  unsigned long p)
28 {
29 	struct inode *inode = file_inode(filep);
30 	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
31 	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
32 	struct dentry *dentry = filep->f_path.dentry;
33 	const unsigned char *path;
34 	void *page = alloc_dentry_path();
35 	__le16 *utf16_path = NULL, root_path;
36 	int rc = 0;
37 
38 	path = build_path_from_dentry(dentry, page);
39 	if (IS_ERR(path)) {
40 		free_dentry_path(page);
41 		return PTR_ERR(path);
42 	}
43 
44 	cifs_dbg(FYI, "%s %s\n", __func__, path);
45 
46 	if (!path[0]) {
47 		root_path = 0;
48 		utf16_path = &root_path;
49 	} else {
50 		utf16_path = cifs_convert_path_to_utf16(path + 1, cifs_sb);
51 		if (!utf16_path) {
52 			rc = -ENOMEM;
53 			goto ici_exit;
54 		}
55 	}
56 
57 	if (tcon->ses->server->ops->ioctl_query_info)
58 		rc = tcon->ses->server->ops->ioctl_query_info(
59 				xid, tcon, cifs_sb, utf16_path,
60 				filep->private_data ? 0 : 1, p);
61 	else
62 		rc = -EOPNOTSUPP;
63 
64  ici_exit:
65 	if (utf16_path != &root_path)
66 		kfree(utf16_path);
67 	free_dentry_path(page);
68 	return rc;
69 }
70 
71 static long cifs_ioctl_copychunk(unsigned int xid, struct file *dst_file,
72 			unsigned long srcfd)
73 {
74 	int rc;
75 	struct fd src_file;
76 	struct inode *src_inode;
77 
78 	cifs_dbg(FYI, "ioctl copychunk range\n");
79 	/* the destination must be opened for writing */
80 	if (!(dst_file->f_mode & FMODE_WRITE)) {
81 		cifs_dbg(FYI, "file target not open for write\n");
82 		return -EINVAL;
83 	}
84 
85 	/* check if target volume is readonly and take reference */
86 	rc = mnt_want_write_file(dst_file);
87 	if (rc) {
88 		cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc);
89 		return rc;
90 	}
91 
92 	src_file = fdget(srcfd);
93 	if (!src_file.file) {
94 		rc = -EBADF;
95 		goto out_drop_write;
96 	}
97 
98 	if (src_file.file->f_op->unlocked_ioctl != cifs_ioctl) {
99 		rc = -EBADF;
100 		cifs_dbg(VFS, "src file seems to be from a different filesystem type\n");
101 		goto out_fput;
102 	}
103 
104 	src_inode = file_inode(src_file.file);
105 	rc = -EINVAL;
106 	if (S_ISDIR(src_inode->i_mode))
107 		goto out_fput;
108 
109 	rc = cifs_file_copychunk_range(xid, src_file.file, 0, dst_file, 0,
110 					src_inode->i_size, 0);
111 	if (rc > 0)
112 		rc = 0;
113 out_fput:
114 	fdput(src_file);
115 out_drop_write:
116 	mnt_drop_write_file(dst_file);
117 	return rc;
118 }
119 
120 static long smb_mnt_get_tcon_info(struct cifs_tcon *tcon, void __user *arg)
121 {
122 	int rc = 0;
123 	struct smb_mnt_tcon_info tcon_inf;
124 
125 	tcon_inf.tid = tcon->tid;
126 	tcon_inf.session_id = tcon->ses->Suid;
127 
128 	if (copy_to_user(arg, &tcon_inf, sizeof(struct smb_mnt_tcon_info)))
129 		rc = -EFAULT;
130 
131 	return rc;
132 }
133 
134 static long smb_mnt_get_fsinfo(unsigned int xid, struct cifs_tcon *tcon,
135 				void __user *arg)
136 {
137 	int rc = 0;
138 	struct smb_mnt_fs_info *fsinf;
139 
140 	fsinf = kzalloc(sizeof(struct smb_mnt_fs_info), GFP_KERNEL);
141 	if (fsinf == NULL)
142 		return -ENOMEM;
143 
144 	fsinf->version = 1;
145 	fsinf->protocol_id = tcon->ses->server->vals->protocol_id;
146 	fsinf->tcon_flags = tcon->Flags;
147 	fsinf->device_characteristics =
148 			le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics);
149 	fsinf->device_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);
150 	fsinf->fs_attributes = le32_to_cpu(tcon->fsAttrInfo.Attributes);
151 	fsinf->max_path_component =
152 		le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength);
153 	fsinf->vol_serial_number = tcon->vol_serial_number;
154 	fsinf->vol_create_time = le64_to_cpu(tcon->vol_create_time);
155 	fsinf->share_flags = tcon->share_flags;
156 	fsinf->share_caps = le32_to_cpu(tcon->capabilities);
157 	fsinf->sector_flags = tcon->ss_flags;
158 	fsinf->optimal_sector_size = tcon->perf_sector_size;
159 	fsinf->max_bytes_chunk = tcon->max_bytes_chunk;
160 	fsinf->maximal_access = tcon->maximal_access;
161 	fsinf->cifs_posix_caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
162 
163 	if (copy_to_user(arg, fsinf, sizeof(struct smb_mnt_fs_info)))
164 		rc = -EFAULT;
165 
166 	kfree(fsinf);
167 	return rc;
168 }
169 
170 static int cifs_shutdown(struct super_block *sb, unsigned long arg)
171 {
172 	struct cifs_sb_info *sbi = CIFS_SB(sb);
173 	__u32 flags;
174 
175 	if (!capable(CAP_SYS_ADMIN))
176 		return -EPERM;
177 
178 	if (get_user(flags, (__u32 __user *)arg))
179 		return -EFAULT;
180 
181 	if (flags > CIFS_GOING_FLAGS_NOLOGFLUSH)
182 		return -EINVAL;
183 
184 	if (cifs_forced_shutdown(sbi))
185 		return 0;
186 
187 	cifs_dbg(VFS, "shut down requested (%d)", flags);
188 /*	trace_cifs_shutdown(sb, flags);*/
189 
190 	/*
191 	 * see:
192 	 *   https://man7.org/linux/man-pages/man2/ioctl_xfs_goingdown.2.html
193 	 * for more information and description of original intent of the flags
194 	 */
195 	switch (flags) {
196 	/*
197 	 * We could add support later for default flag which requires:
198 	 *     "Flush all dirty data and metadata to disk"
199 	 * would need to call syncfs or equivalent to flush page cache for
200 	 * the mount and then issue fsync to server (if nostrictsync not set)
201 	 */
202 	case CIFS_GOING_FLAGS_DEFAULT:
203 		cifs_dbg(FYI, "shutdown with default flag not supported\n");
204 		return -EINVAL;
205 	/*
206 	 * FLAGS_LOGFLUSH is easy since it asks to write out metadata (not
207 	 * data) but metadata writes are not cached on the client, so can treat
208 	 * it similarly to NOLOGFLUSH
209 	 */
210 	case CIFS_GOING_FLAGS_LOGFLUSH:
211 	case CIFS_GOING_FLAGS_NOLOGFLUSH:
212 		sbi->mnt_cifs_flags |= CIFS_MOUNT_SHUTDOWN;
213 		return 0;
214 	default:
215 		return -EINVAL;
216 	}
217 	return 0;
218 }
219 
220 static int cifs_dump_full_key(struct cifs_tcon *tcon, struct smb3_full_key_debug_info __user *in)
221 {
222 	struct smb3_full_key_debug_info out;
223 	struct cifs_ses *ses;
224 	int rc = 0;
225 	bool found = false;
226 	u8 __user *end;
227 
228 	if (!smb3_encryption_required(tcon)) {
229 		rc = -EOPNOTSUPP;
230 		goto out;
231 	}
232 
233 	/* copy user input into our output buffer */
234 	if (copy_from_user(&out, in, sizeof(out))) {
235 		rc = -EINVAL;
236 		goto out;
237 	}
238 
239 	if (!out.session_id) {
240 		/* if ses id is 0, use current user session */
241 		ses = tcon->ses;
242 	} else {
243 		/* otherwise if a session id is given, look for it in all our sessions */
244 		struct cifs_ses *ses_it = NULL;
245 		struct TCP_Server_Info *server_it = NULL;
246 
247 		spin_lock(&cifs_tcp_ses_lock);
248 		list_for_each_entry(server_it, &cifs_tcp_ses_list, tcp_ses_list) {
249 			list_for_each_entry(ses_it, &server_it->smb_ses_list, smb_ses_list) {
250 				if (ses_it->Suid == out.session_id) {
251 					ses = ses_it;
252 					/*
253 					 * since we are using the session outside the crit
254 					 * section, we need to make sure it won't be released
255 					 * so increment its refcount
256 					 */
257 					cifs_smb_ses_inc_refcount(ses);
258 					found = true;
259 					goto search_end;
260 				}
261 			}
262 		}
263 search_end:
264 		spin_unlock(&cifs_tcp_ses_lock);
265 		if (!found) {
266 			rc = -ENOENT;
267 			goto out;
268 		}
269 	}
270 
271 	switch (ses->server->cipher_type) {
272 	case SMB2_ENCRYPTION_AES128_CCM:
273 	case SMB2_ENCRYPTION_AES128_GCM:
274 		out.session_key_length = CIFS_SESS_KEY_SIZE;
275 		out.server_in_key_length = out.server_out_key_length = SMB3_GCM128_CRYPTKEY_SIZE;
276 		break;
277 	case SMB2_ENCRYPTION_AES256_CCM:
278 	case SMB2_ENCRYPTION_AES256_GCM:
279 		out.session_key_length = CIFS_SESS_KEY_SIZE;
280 		out.server_in_key_length = out.server_out_key_length = SMB3_GCM256_CRYPTKEY_SIZE;
281 		break;
282 	default:
283 		rc = -EOPNOTSUPP;
284 		goto out;
285 	}
286 
287 	/* check if user buffer is big enough to store all the keys */
288 	if (out.in_size < sizeof(out) + out.session_key_length + out.server_in_key_length
289 	    + out.server_out_key_length) {
290 		rc = -ENOBUFS;
291 		goto out;
292 	}
293 
294 	out.session_id = ses->Suid;
295 	out.cipher_type = le16_to_cpu(ses->server->cipher_type);
296 
297 	/* overwrite user input with our output */
298 	if (copy_to_user(in, &out, sizeof(out))) {
299 		rc = -EINVAL;
300 		goto out;
301 	}
302 
303 	/* append all the keys at the end of the user buffer */
304 	end = in->data;
305 	if (copy_to_user(end, ses->auth_key.response, out.session_key_length)) {
306 		rc = -EINVAL;
307 		goto out;
308 	}
309 	end += out.session_key_length;
310 
311 	if (copy_to_user(end, ses->smb3encryptionkey, out.server_in_key_length)) {
312 		rc = -EINVAL;
313 		goto out;
314 	}
315 	end += out.server_in_key_length;
316 
317 	if (copy_to_user(end, ses->smb3decryptionkey, out.server_out_key_length)) {
318 		rc = -EINVAL;
319 		goto out;
320 	}
321 
322 out:
323 	if (found)
324 		cifs_put_smb_ses(ses);
325 	return rc;
326 }
327 
328 long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
329 {
330 	struct inode *inode = file_inode(filep);
331 	struct smb3_key_debug_info pkey_inf;
332 	int rc = -ENOTTY; /* strange error - but the precedent */
333 	unsigned int xid;
334 	struct cifsFileInfo *pSMBFile = filep->private_data;
335 	struct cifs_tcon *tcon;
336 	struct tcon_link *tlink;
337 	struct cifs_sb_info *cifs_sb;
338 	__u64	ExtAttrBits = 0;
339 #ifdef CONFIG_CIFS_POSIX
340 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
341 	__u64   caps;
342 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
343 #endif /* CONFIG_CIFS_POSIX */
344 
345 	xid = get_xid();
346 
347 	cifs_dbg(FYI, "cifs ioctl 0x%x\n", command);
348 	switch (command) {
349 		case FS_IOC_GETFLAGS:
350 			if (pSMBFile == NULL)
351 				break;
352 			tcon = tlink_tcon(pSMBFile->tlink);
353 #ifdef CONFIG_CIFS_POSIX
354 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
355 			caps = le64_to_cpu(tcon->fsUnixInfo.Capability);
356 			if (CIFS_UNIX_EXTATTR_CAP & caps) {
357 				__u64	ExtAttrMask = 0;
358 				rc = CIFSGetExtAttr(xid, tcon,
359 						    pSMBFile->fid.netfid,
360 						    &ExtAttrBits, &ExtAttrMask);
361 				if (rc == 0)
362 					rc = put_user(ExtAttrBits &
363 						FS_FL_USER_VISIBLE,
364 						(int __user *)arg);
365 				if (rc != -EOPNOTSUPP)
366 					break;
367 			}
368 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
369 #endif /* CONFIG_CIFS_POSIX */
370 			rc = 0;
371 			if (CIFS_I(inode)->cifsAttrs & ATTR_COMPRESSED) {
372 				/* add in the compressed bit */
373 				ExtAttrBits = FS_COMPR_FL;
374 				rc = put_user(ExtAttrBits & FS_FL_USER_VISIBLE,
375 					      (int __user *)arg);
376 			}
377 			break;
378 		case FS_IOC_SETFLAGS:
379 			if (pSMBFile == NULL)
380 				break;
381 			tcon = tlink_tcon(pSMBFile->tlink);
382 			/* caps = le64_to_cpu(tcon->fsUnixInfo.Capability); */
383 
384 			if (get_user(ExtAttrBits, (int __user *)arg)) {
385 				rc = -EFAULT;
386 				break;
387 			}
388 
389 			/*
390 			 * if (CIFS_UNIX_EXTATTR_CAP & caps)
391 			 *	rc = CIFSSetExtAttr(xid, tcon,
392 			 *		       pSMBFile->fid.netfid,
393 			 *		       extAttrBits,
394 			 *		       &ExtAttrMask);
395 			 * if (rc != -EOPNOTSUPP)
396 			 *	break;
397 			 */
398 
399 			/* Currently only flag we can set is compressed flag */
400 			if ((ExtAttrBits & FS_COMPR_FL) == 0)
401 				break;
402 
403 			/* Try to set compress flag */
404 			if (tcon->ses->server->ops->set_compression) {
405 				rc = tcon->ses->server->ops->set_compression(
406 							xid, tcon, pSMBFile);
407 				cifs_dbg(FYI, "set compress flag rc %d\n", rc);
408 			}
409 			break;
410 		case CIFS_IOC_COPYCHUNK_FILE:
411 			rc = cifs_ioctl_copychunk(xid, filep, arg);
412 			break;
413 		case CIFS_QUERY_INFO:
414 			rc = cifs_ioctl_query_info(xid, filep, arg);
415 			break;
416 		case CIFS_IOC_SET_INTEGRITY:
417 			if (pSMBFile == NULL)
418 				break;
419 			tcon = tlink_tcon(pSMBFile->tlink);
420 			if (tcon->ses->server->ops->set_integrity)
421 				rc = tcon->ses->server->ops->set_integrity(xid,
422 						tcon, pSMBFile);
423 			else
424 				rc = -EOPNOTSUPP;
425 			break;
426 		case CIFS_IOC_GET_MNT_INFO:
427 			if (pSMBFile == NULL)
428 				break;
429 			tcon = tlink_tcon(pSMBFile->tlink);
430 			rc = smb_mnt_get_fsinfo(xid, tcon, (void __user *)arg);
431 			break;
432 		case CIFS_IOC_GET_TCON_INFO:
433 			cifs_sb = CIFS_SB(inode->i_sb);
434 			tlink = cifs_sb_tlink(cifs_sb);
435 			if (IS_ERR(tlink)) {
436 				rc = PTR_ERR(tlink);
437 				break;
438 			}
439 			tcon = tlink_tcon(tlink);
440 			rc = smb_mnt_get_tcon_info(tcon, (void __user *)arg);
441 			cifs_put_tlink(tlink);
442 			break;
443 		case CIFS_ENUMERATE_SNAPSHOTS:
444 			if (pSMBFile == NULL)
445 				break;
446 			if (arg == 0) {
447 				rc = -EINVAL;
448 				goto cifs_ioc_exit;
449 			}
450 			tcon = tlink_tcon(pSMBFile->tlink);
451 			if (tcon->ses->server->ops->enum_snapshots)
452 				rc = tcon->ses->server->ops->enum_snapshots(xid, tcon,
453 						pSMBFile, (void __user *)arg);
454 			else
455 				rc = -EOPNOTSUPP;
456 			break;
457 		case CIFS_DUMP_KEY:
458 			/*
459 			 * Dump encryption keys. This is an old ioctl that only
460 			 * handles AES-128-{CCM,GCM}.
461 			 */
462 			if (!capable(CAP_SYS_ADMIN)) {
463 				rc = -EACCES;
464 				break;
465 			}
466 
467 			cifs_sb = CIFS_SB(inode->i_sb);
468 			tlink = cifs_sb_tlink(cifs_sb);
469 			if (IS_ERR(tlink)) {
470 				rc = PTR_ERR(tlink);
471 				break;
472 			}
473 			tcon = tlink_tcon(tlink);
474 			if (!smb3_encryption_required(tcon)) {
475 				rc = -EOPNOTSUPP;
476 				cifs_put_tlink(tlink);
477 				break;
478 			}
479 			pkey_inf.cipher_type =
480 				le16_to_cpu(tcon->ses->server->cipher_type);
481 			pkey_inf.Suid = tcon->ses->Suid;
482 			memcpy(pkey_inf.auth_key, tcon->ses->auth_key.response,
483 					16 /* SMB2_NTLMV2_SESSKEY_SIZE */);
484 			memcpy(pkey_inf.smb3decryptionkey,
485 			      tcon->ses->smb3decryptionkey, SMB3_SIGN_KEY_SIZE);
486 			memcpy(pkey_inf.smb3encryptionkey,
487 			      tcon->ses->smb3encryptionkey, SMB3_SIGN_KEY_SIZE);
488 			if (copy_to_user((void __user *)arg, &pkey_inf,
489 					sizeof(struct smb3_key_debug_info)))
490 				rc = -EFAULT;
491 			else
492 				rc = 0;
493 			cifs_put_tlink(tlink);
494 			break;
495 		case CIFS_DUMP_FULL_KEY:
496 			/*
497 			 * Dump encryption keys (handles any key sizes)
498 			 */
499 			if (pSMBFile == NULL)
500 				break;
501 			if (!capable(CAP_SYS_ADMIN)) {
502 				rc = -EACCES;
503 				break;
504 			}
505 			cifs_sb = CIFS_SB(inode->i_sb);
506 			tlink = cifs_sb_tlink(cifs_sb);
507 			if (IS_ERR(tlink)) {
508 				rc = PTR_ERR(tlink);
509 				break;
510 			}
511 
512 			tcon = tlink_tcon(tlink);
513 			rc = cifs_dump_full_key(tcon, (void __user *)arg);
514 			cifs_put_tlink(tlink);
515 			break;
516 		case CIFS_IOC_NOTIFY:
517 			if (!S_ISDIR(inode->i_mode)) {
518 				/* Notify can only be done on directories */
519 				rc = -EOPNOTSUPP;
520 				break;
521 			}
522 			cifs_sb = CIFS_SB(inode->i_sb);
523 			tlink = cifs_sb_tlink(cifs_sb);
524 			if (IS_ERR(tlink)) {
525 				rc = PTR_ERR(tlink);
526 				break;
527 			}
528 			tcon = tlink_tcon(tlink);
529 			if (tcon && tcon->ses->server->ops->notify) {
530 				rc = tcon->ses->server->ops->notify(xid,
531 						filep, (void __user *)arg,
532 						false /* no ret data */);
533 				cifs_dbg(FYI, "ioctl notify rc %d\n", rc);
534 			} else
535 				rc = -EOPNOTSUPP;
536 			cifs_put_tlink(tlink);
537 			break;
538 		case CIFS_IOC_NOTIFY_INFO:
539 			if (!S_ISDIR(inode->i_mode)) {
540 				/* Notify can only be done on directories */
541 				rc = -EOPNOTSUPP;
542 				break;
543 			}
544 			cifs_sb = CIFS_SB(inode->i_sb);
545 			tlink = cifs_sb_tlink(cifs_sb);
546 			if (IS_ERR(tlink)) {
547 				rc = PTR_ERR(tlink);
548 				break;
549 			}
550 			tcon = tlink_tcon(tlink);
551 			if (tcon && tcon->ses->server->ops->notify) {
552 				rc = tcon->ses->server->ops->notify(xid,
553 						filep, (void __user *)arg,
554 						true /* return details */);
555 				cifs_dbg(FYI, "ioctl notify info rc %d\n", rc);
556 			} else
557 				rc = -EOPNOTSUPP;
558 			cifs_put_tlink(tlink);
559 			break;
560 		case CIFS_IOC_SHUTDOWN:
561 			rc = cifs_shutdown(inode->i_sb, arg);
562 			break;
563 		default:
564 			cifs_dbg(FYI, "unsupported ioctl\n");
565 			break;
566 	}
567 cifs_ioc_exit:
568 	free_xid(xid);
569 	return rc;
570 }
571