1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2024 Paulo Alcantara <pc@manguebit.com>
4 */
5
6 #include <linux/fs.h>
7 #include <linux/stat.h>
8 #include <linux/slab.h>
9 #include "cifsglob.h"
10 #include "smb2proto.h"
11 #include "cifsproto.h"
12 #include "cifs_unicode.h"
13 #include "cifs_debug.h"
14 #include "fs_context.h"
15 #include "reparse.h"
16
17 static int mknod_nfs(unsigned int xid, struct inode *inode,
18 struct dentry *dentry, struct cifs_tcon *tcon,
19 const char *full_path, umode_t mode, dev_t dev,
20 const char *symname);
21
22 static int mknod_wsl(unsigned int xid, struct inode *inode,
23 struct dentry *dentry, struct cifs_tcon *tcon,
24 const char *full_path, umode_t mode, dev_t dev,
25 const char *symname);
26
27 static int create_native_symlink(const unsigned int xid, struct inode *inode,
28 struct dentry *dentry, struct cifs_tcon *tcon,
29 const char *full_path, const char *symname);
30
31 static int detect_directory_symlink_target(struct cifs_sb_info *cifs_sb,
32 const unsigned int xid,
33 const char *full_path,
34 const char *symname,
35 bool *directory);
36
create_reparse_symlink(const unsigned int xid,struct inode * inode,struct dentry * dentry,struct cifs_tcon * tcon,const char * full_path,const char * symname)37 int create_reparse_symlink(const unsigned int xid, struct inode *inode,
38 struct dentry *dentry, struct cifs_tcon *tcon,
39 const char *full_path, const char *symname)
40 {
41 switch (cifs_symlink_type(CIFS_SB(inode->i_sb))) {
42 case CIFS_SYMLINK_TYPE_NATIVE:
43 return create_native_symlink(xid, inode, dentry, tcon, full_path, symname);
44 case CIFS_SYMLINK_TYPE_NFS:
45 return mknod_nfs(xid, inode, dentry, tcon, full_path, S_IFLNK, 0, symname);
46 case CIFS_SYMLINK_TYPE_WSL:
47 return mknod_wsl(xid, inode, dentry, tcon, full_path, S_IFLNK, 0, symname);
48 default:
49 return -EOPNOTSUPP;
50 }
51 }
52
create_native_symlink(const unsigned int xid,struct inode * inode,struct dentry * dentry,struct cifs_tcon * tcon,const char * full_path,const char * symname)53 static int create_native_symlink(const unsigned int xid, struct inode *inode,
54 struct dentry *dentry, struct cifs_tcon *tcon,
55 const char *full_path, const char *symname)
56 {
57 struct reparse_symlink_data_buffer *buf = NULL;
58 struct cifs_sb_info *cifs_sb = CIFS_SB(inode);
59 const char *symroot = cifs_sb->ctx->symlinkroot;
60 struct cifs_open_info_data data = {};
61 char sep = CIFS_DIR_SEP(cifs_sb);
62 char *symlink_target = NULL;
63 u16 len, plen, poff, slen;
64 unsigned int sbflags;
65 __le16 *path = NULL;
66 struct inode *new;
67 char *sym = NULL;
68 struct kvec iov;
69 bool directory;
70 int path_len;
71 int rc = 0;
72
73 if (strlen(symname) > REPARSE_SYM_PATH_MAX)
74 return -ENAMETOOLONG;
75
76 symlink_target = kstrdup(symname, GFP_KERNEL);
77 if (!symlink_target) {
78 rc = -ENOMEM;
79 goto out;
80 }
81
82 data = (struct cifs_open_info_data) {
83 .reparse_point = true,
84 .reparse = { .tag = IO_REPARSE_TAG_SYMLINK, },
85 .symlink_target = symlink_target,
86 };
87
88 sbflags = cifs_sb_flags(cifs_sb);
89 if (!(sbflags & CIFS_MOUNT_POSIX_PATHS) && symroot && symname[0] == '/') {
90 /*
91 * This is a request to create an absolute symlink on the server
92 * which does not support POSIX paths, and expects symlink in
93 * NT-style path. So convert absolute Linux symlink target path
94 * to the absolute NT-style path. Root of the NT-style path for
95 * symlinks is specified in "symlinkroot" mount option. This will
96 * ensure compatibility of this symlink stored in absolute form
97 * on the SMB server.
98 */
99 if (!strstarts(symname, symroot)) {
100 /*
101 * If the absolute Linux symlink target path is not
102 * inside "symlinkroot" location then there is no way
103 * to convert such Linux symlink to NT-style path.
104 */
105 cifs_dbg(VFS,
106 "absolute symlink '%s' cannot be converted to NT format "
107 "because it is outside of symlinkroot='%s'\n",
108 symname, symroot);
109 rc = -EINVAL;
110 goto out;
111 }
112 len = strlen(symroot);
113 if (symroot[len - 1] != '/')
114 len++;
115 if (symname[len] >= 'a' && symname[len] <= 'z' &&
116 (symname[len+1] == '/' || symname[len+1] == '\0')) {
117 /*
118 * Symlink points to Linux target /symlinkroot/x/path/...
119 * where 'x' is the lowercase local Windows drive.
120 * NT-style path for 'x' has common form \??\X:\path\...
121 * with uppercase local Windows drive.
122 */
123 int common_path_len = strlen(symname+len+1)+1;
124 sym = kzalloc(6+common_path_len, GFP_KERNEL);
125 if (!sym) {
126 rc = -ENOMEM;
127 goto out;
128 }
129 memcpy(sym, "\\??\\", 4);
130 sym[4] = symname[len] - ('a'-'A');
131 sym[5] = ':';
132 memcpy(sym+6, symname+len+1, common_path_len);
133 } else {
134 /* Unhandled absolute symlink. Report an error. */
135 cifs_dbg(
136 VFS,
137 "absolute symlink '%s' cannot be converted to NT format "
138 "because it points to unknown target\n",
139 symname);
140 rc = -EINVAL;
141 goto out;
142 }
143 } else {
144 /*
145 * This is request to either create an absolute symlink on
146 * server which expects POSIX paths or it is an request to
147 * create a relative symlink from the current directory.
148 * These paths have same format as relative SMB symlinks,
149 * so no conversion is needed. So just take symname as-is.
150 */
151 sym = kstrdup(symname, GFP_KERNEL);
152 if (!sym) {
153 rc = -ENOMEM;
154 goto out;
155 }
156 }
157
158 if (sep == '\\')
159 convert_delimiter(sym, sep);
160
161 /*
162 * For absolute NT symlinks it is required to pass also leading
163 * backslash and to not mangle NT object prefix "\\??\\" and not to
164 * mangle colon in drive letter. But cifs_convert_path_to_utf16()
165 * removes leading backslash and replaces '?' and ':'. So temporary
166 * mask these characters in NT object prefix by '_' and then change
167 * them back.
168 */
169 if (!(sbflags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/')
170 sym[0] = sym[1] = sym[2] = sym[5] = '_';
171
172 /*
173 * On a POSIX paths mount the symlink target is stored verbatim, so
174 * convert it with cifs_strndup_to_utf16(). cifs_convert_path_to_utf16()
175 * must not be used here: it strips a leading path separator (it is
176 * meant for share-relative SMB paths), which would corrupt an absolute
177 * POSIX symlink target such as "/foo/bar". Using NO_MAP_UNI_RSVD also
178 * matches the readback path in smb2_parse_native_symlink().
179 */
180 if (sbflags & CIFS_MOUNT_POSIX_PATHS)
181 path = cifs_strndup_to_utf16(sym, strlen(sym), &path_len,
182 cifs_sb->local_nls,
183 NO_MAP_UNI_RSVD);
184 else
185 path = cifs_convert_path_to_utf16(sym, cifs_sb);
186
187 if (!path) {
188 rc = -ENOMEM;
189 goto out;
190 }
191
192 if (!(sbflags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/') {
193 sym[0] = '\\';
194 sym[1] = sym[2] = '?';
195 sym[5] = ':';
196 path[0] = cpu_to_le16('\\');
197 path[1] = path[2] = cpu_to_le16('?');
198 path[5] = cpu_to_le16(':');
199 }
200
201 /*
202 * SMB distinguish between symlink to directory and symlink to file.
203 * They cannot be exchanged (symlink of file type which points to
204 * directory cannot be resolved and vice-versa). Try to detect if
205 * the symlink target could be a directory or not. When detection
206 * fails then treat symlink as a file (non-directory) symlink.
207 */
208 directory = false;
209 rc = detect_directory_symlink_target(cifs_sb, xid, full_path, symname, &directory);
210 if (rc < 0)
211 goto out;
212
213 slen = 2 * UniStrnlen((wchar_t *)path, REPARSE_SYM_PATH_MAX);
214 poff = 0;
215 plen = slen;
216 if (!(sbflags & CIFS_MOUNT_POSIX_PATHS) && symname[0] == '/') {
217 /*
218 * For absolute NT symlinks skip leading "\\??\\" in PrintName as
219 * PrintName is user visible location in DOS/Win32 format (not in NT format).
220 */
221 poff = 4;
222 plen -= 2 * poff;
223 }
224 len = sizeof(*buf) + plen + slen;
225 buf = kzalloc(len, GFP_KERNEL);
226 if (!buf) {
227 rc = -ENOMEM;
228 goto out;
229 }
230
231 buf->ReparseTag = cpu_to_le32(IO_REPARSE_TAG_SYMLINK);
232 buf->ReparseDataLength = cpu_to_le16(len - sizeof(struct reparse_data_buffer));
233
234 buf->SubstituteNameOffset = cpu_to_le16(plen);
235 buf->SubstituteNameLength = cpu_to_le16(slen);
236 memcpy(&buf->PathBuffer[plen], path, slen);
237
238 buf->PrintNameOffset = 0;
239 buf->PrintNameLength = cpu_to_le16(plen);
240 memcpy(buf->PathBuffer, path+poff, plen);
241
242 buf->Flags = cpu_to_le32(*symname != '/' ? SYMLINK_FLAG_RELATIVE : 0);
243
244 iov.iov_base = buf;
245 iov.iov_len = len;
246 new = tcon->ses->server->ops->create_reparse_inode(
247 &data, inode->i_sb, xid,
248 tcon, full_path, directory,
249 &iov, NULL);
250 if (!IS_ERR(new))
251 d_instantiate(dentry, new);
252 else
253 rc = PTR_ERR(new);
254 out:
255 kfree(sym);
256 kfree(path);
257 cifs_free_open_info(&data);
258 kfree(buf);
259 return rc;
260 }
261
detect_directory_symlink_target(struct cifs_sb_info * cifs_sb,const unsigned int xid,const char * full_path,const char * symname,bool * directory)262 static int detect_directory_symlink_target(struct cifs_sb_info *cifs_sb,
263 const unsigned int xid,
264 const char *full_path,
265 const char *symname,
266 bool *directory)
267 {
268 char sep = CIFS_DIR_SEP(cifs_sb);
269 struct cifs_open_parms oparms;
270 struct tcon_link *tlink;
271 struct cifs_tcon *tcon;
272 const char *basename;
273 struct cifs_fid fid;
274 char *resolved_path;
275 int full_path_len;
276 int basename_len;
277 int symname_len;
278 char *path_sep;
279 __u32 oplock;
280 int open_rc;
281
282 /*
283 * First do some simple check. If the original Linux symlink target ends
284 * with slash, or last path component is dot or dot-dot then it is for
285 * sure symlink to the directory.
286 */
287 basename = kbasename(symname);
288 basename_len = strlen(basename);
289 if (basename_len == 0 || /* symname ends with slash */
290 (basename_len == 1 && basename[0] == '.') || /* last component is "." */
291 (basename_len == 2 && basename[0] == '.' && basename[1] == '.')) { /* or ".." */
292 *directory = true;
293 return 0;
294 }
295
296 /*
297 * For absolute symlinks it is not possible to determine
298 * if it should point to directory or file.
299 */
300 if (symname[0] == '/') {
301 cifs_dbg(FYI,
302 "%s: cannot determinate if the symlink target path '%s' "
303 "is directory or not, creating '%s' as file symlink\n",
304 __func__, symname, full_path);
305 return 0;
306 }
307
308 /*
309 * If it was not detected as directory yet and the symlink is relative
310 * then try to resolve the path on the SMB server, check if the path
311 * exists and determinate if it is a directory or not.
312 */
313
314 full_path_len = strlen(full_path);
315 symname_len = strlen(symname);
316
317 tlink = cifs_sb_tlink(cifs_sb);
318 if (IS_ERR(tlink))
319 return PTR_ERR(tlink);
320
321 resolved_path = kzalloc(full_path_len + symname_len + 1, GFP_KERNEL);
322 if (!resolved_path) {
323 cifs_put_tlink(tlink);
324 return -ENOMEM;
325 }
326
327 /*
328 * Compose the resolved SMB symlink path from the SMB full path
329 * and Linux target symlink path.
330 */
331 memcpy(resolved_path, full_path, full_path_len+1);
332 path_sep = strrchr(resolved_path, sep);
333 if (path_sep)
334 path_sep++;
335 else
336 path_sep = resolved_path;
337 memcpy(path_sep, symname, symname_len+1);
338 if (sep == '\\')
339 convert_delimiter(path_sep, sep);
340
341 tcon = tlink_tcon(tlink);
342 oparms = CIFS_OPARMS(cifs_sb, tcon, resolved_path,
343 FILE_READ_ATTRIBUTES, FILE_OPEN, 0, ACL_NO_MODE);
344 oparms.fid = &fid;
345
346 /* Try to open as a directory (NOT_FILE) */
347 oplock = 0;
348 oparms.create_options = cifs_create_options(cifs_sb,
349 CREATE_NOT_FILE | OPEN_REPARSE_POINT);
350 open_rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
351 if (open_rc == 0) {
352 /* Successful open means that the target path is definitely a directory. */
353 *directory = true;
354 tcon->ses->server->ops->close(xid, tcon, &fid);
355 } else if (open_rc == -ENOTDIR) {
356 /* -ENOTDIR means that the target path is definitely a file. */
357 *directory = false;
358 } else if (open_rc == -ENOENT) {
359 /* -ENOENT means that the target path does not exist. */
360 cifs_dbg(FYI,
361 "%s: symlink target path '%s' does not exist, "
362 "creating '%s' as file symlink\n",
363 __func__, symname, full_path);
364 } else {
365 /* Try to open as a file (NOT_DIR) */
366 oplock = 0;
367 oparms.create_options = cifs_create_options(cifs_sb,
368 CREATE_NOT_DIR | OPEN_REPARSE_POINT);
369 open_rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
370 if (open_rc == 0) {
371 /* Successful open means that the target path is definitely a file. */
372 *directory = false;
373 tcon->ses->server->ops->close(xid, tcon, &fid);
374 } else if (open_rc == -EISDIR) {
375 /* -EISDIR means that the target path is definitely a directory. */
376 *directory = true;
377 } else {
378 /*
379 * This code branch is called when we do not have a permission to
380 * open the resolved_path or some other client/process denied
381 * opening the resolved_path.
382 *
383 * TODO: Try to use ops->query_dir_first on the parent directory
384 * of resolved_path, search for basename of resolved_path and
385 * check if the ATTR_DIRECTORY is set in fi.Attributes. In some
386 * case this could work also when opening of the path is denied.
387 */
388 cifs_dbg(FYI,
389 "%s: cannot determinate if the symlink target path '%s' "
390 "is directory or not, creating '%s' as file symlink\n",
391 __func__, symname, full_path);
392 }
393 }
394
395 kfree(resolved_path);
396 cifs_put_tlink(tlink);
397 return 0;
398 }
399
create_native_socket(const unsigned int xid,struct inode * inode,struct dentry * dentry,struct cifs_tcon * tcon,const char * full_path)400 static int create_native_socket(const unsigned int xid, struct inode *inode,
401 struct dentry *dentry, struct cifs_tcon *tcon,
402 const char *full_path)
403 {
404 struct reparse_data_buffer buf = {
405 .ReparseTag = cpu_to_le32(IO_REPARSE_TAG_AF_UNIX),
406 .ReparseDataLength = cpu_to_le16(0),
407 };
408 struct cifs_open_info_data data = {
409 .reparse_point = true,
410 .reparse = { .tag = IO_REPARSE_TAG_AF_UNIX, .buf = &buf, },
411 };
412 struct kvec iov = {
413 .iov_base = &buf,
414 .iov_len = sizeof(buf),
415 };
416 struct inode *new;
417 int rc = 0;
418
419 new = tcon->ses->server->ops->create_reparse_inode(
420 &data, inode->i_sb, xid,
421 tcon, full_path, false, &iov, NULL);
422 if (!IS_ERR(new))
423 d_instantiate(dentry, new);
424 else
425 rc = PTR_ERR(new);
426 cifs_free_open_info(&data);
427 return rc;
428 }
429
nfs_set_reparse_buf(struct reparse_nfs_data_buffer * buf,mode_t mode,dev_t dev,__le16 * symname_utf16,int symname_utf16_len,struct kvec * iov)430 static int nfs_set_reparse_buf(struct reparse_nfs_data_buffer *buf,
431 mode_t mode, dev_t dev,
432 __le16 *symname_utf16,
433 int symname_utf16_len,
434 struct kvec *iov)
435 {
436 u64 type;
437 u16 len, dlen;
438
439 len = sizeof(*buf);
440
441 switch ((type = reparse_mode_nfs_type(mode))) {
442 case NFS_SPECFILE_BLK:
443 case NFS_SPECFILE_CHR:
444 dlen = 2 * sizeof(__le32);
445 ((__le32 *)buf->DataBuffer)[0] = cpu_to_le32(MAJOR(dev));
446 ((__le32 *)buf->DataBuffer)[1] = cpu_to_le32(MINOR(dev));
447 break;
448 case NFS_SPECFILE_LNK:
449 dlen = symname_utf16_len;
450 memcpy(buf->DataBuffer, symname_utf16, symname_utf16_len);
451 break;
452 case NFS_SPECFILE_FIFO:
453 case NFS_SPECFILE_SOCK:
454 dlen = 0;
455 break;
456 default:
457 return -EOPNOTSUPP;
458 }
459
460 buf->ReparseTag = cpu_to_le32(IO_REPARSE_TAG_NFS);
461 buf->Reserved = 0;
462 buf->InodeType = cpu_to_le64(type);
463 buf->ReparseDataLength = cpu_to_le16(len + dlen -
464 sizeof(struct reparse_data_buffer));
465 iov->iov_base = buf;
466 iov->iov_len = len + dlen;
467 return 0;
468 }
469
mknod_nfs(unsigned int xid,struct inode * inode,struct dentry * dentry,struct cifs_tcon * tcon,const char * full_path,umode_t mode,dev_t dev,const char * symname)470 static int mknod_nfs(unsigned int xid, struct inode *inode,
471 struct dentry *dentry, struct cifs_tcon *tcon,
472 const char *full_path, umode_t mode, dev_t dev,
473 const char *symname)
474 {
475 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
476 struct cifs_open_info_data data;
477 struct reparse_nfs_data_buffer *p = NULL;
478 __le16 *symname_utf16 = NULL;
479 int symname_utf16_len = 0;
480 struct inode *new;
481 struct kvec iov;
482 __u8 buf[sizeof(*p) + sizeof(__le64)];
483 int rc;
484
485 if (S_ISLNK(mode)) {
486 symname_utf16 = cifs_strndup_to_utf16(symname, strlen(symname),
487 &symname_utf16_len,
488 cifs_sb->local_nls,
489 NO_MAP_UNI_RSVD);
490 if (!symname_utf16) {
491 rc = -ENOMEM;
492 goto out;
493 }
494 symname_utf16_len -= 2; /* symlink is without trailing wide-nul */
495 p = kzalloc(sizeof(*p) + symname_utf16_len, GFP_KERNEL);
496 if (!p) {
497 rc = -ENOMEM;
498 goto out;
499 }
500 } else {
501 p = (struct reparse_nfs_data_buffer *)buf;
502 }
503 rc = nfs_set_reparse_buf(p, mode, dev, symname_utf16, symname_utf16_len, &iov);
504 if (rc)
505 goto out;
506
507 data = (struct cifs_open_info_data) {
508 .reparse_point = true,
509 .reparse = { .tag = IO_REPARSE_TAG_NFS, .buf = (struct reparse_data_buffer *)p, },
510 .symlink_target = kstrdup(symname, GFP_KERNEL),
511 };
512
513 new = tcon->ses->server->ops->create_reparse_inode(
514 &data, inode->i_sb, xid,
515 tcon, full_path, false, &iov, NULL);
516 if (!IS_ERR(new))
517 d_instantiate(dentry, new);
518 else
519 rc = PTR_ERR(new);
520 cifs_free_open_info(&data);
521 out:
522 if (S_ISLNK(mode)) {
523 kfree(symname_utf16);
524 kfree(p);
525 }
526 return rc;
527 }
528
wsl_set_reparse_buf(struct reparse_data_buffer ** buf,mode_t mode,const char * symname,struct cifs_sb_info * cifs_sb,struct kvec * iov)529 static int wsl_set_reparse_buf(struct reparse_data_buffer **buf,
530 mode_t mode, const char *symname,
531 struct cifs_sb_info *cifs_sb,
532 struct kvec *iov)
533 {
534 struct reparse_wsl_symlink_data_buffer *symlink_buf;
535 __le16 *symname_utf16;
536 int symname_utf16_len;
537 int symname_utf8_maxlen;
538 int symname_utf8_len;
539 size_t buf_len;
540 u32 tag;
541
542 switch ((tag = reparse_mode_wsl_tag(mode))) {
543 case IO_REPARSE_TAG_LX_BLK:
544 case IO_REPARSE_TAG_LX_CHR:
545 case IO_REPARSE_TAG_LX_FIFO:
546 case IO_REPARSE_TAG_AF_UNIX:
547 buf_len = sizeof(struct reparse_data_buffer);
548 *buf = kzalloc(buf_len, GFP_KERNEL);
549 if (!*buf)
550 return -ENOMEM;
551 break;
552 case IO_REPARSE_TAG_LX_SYMLINK:
553 symname_utf16 = cifs_strndup_to_utf16(symname, strlen(symname),
554 &symname_utf16_len,
555 cifs_sb->local_nls,
556 NO_MAP_UNI_RSVD);
557 if (!symname_utf16)
558 return -ENOMEM;
559 symname_utf8_maxlen = symname_utf16_len/2*3;
560 symlink_buf = kzalloc(sizeof(struct reparse_wsl_symlink_data_buffer) +
561 symname_utf8_maxlen, GFP_KERNEL);
562 if (!symlink_buf) {
563 kfree(symname_utf16);
564 return -ENOMEM;
565 }
566 /* Version field must be set to 2 (MS-FSCC 2.1.2.7) */
567 symlink_buf->Version = cpu_to_le32(2);
568 /* Target for Version 2 is in UTF-8 but without trailing null-term byte */
569 symname_utf8_len = utf16s_to_utf8s((wchar_t *)symname_utf16, symname_utf16_len/2,
570 UTF16_LITTLE_ENDIAN,
571 symlink_buf->Target,
572 symname_utf8_maxlen);
573 *buf = (struct reparse_data_buffer *)symlink_buf;
574 buf_len = sizeof(struct reparse_wsl_symlink_data_buffer) + symname_utf8_len;
575 kfree(symname_utf16);
576 break;
577 default:
578 return -EOPNOTSUPP;
579 }
580
581 (*buf)->ReparseTag = cpu_to_le32(tag);
582 (*buf)->Reserved = 0;
583 (*buf)->ReparseDataLength = cpu_to_le16(buf_len - sizeof(struct reparse_data_buffer));
584 iov->iov_base = *buf;
585 iov->iov_len = buf_len;
586 return 0;
587 }
588
ea_create_context(u32 dlen,size_t * cc_len)589 static struct smb2_create_ea_ctx *ea_create_context(u32 dlen, size_t *cc_len)
590 {
591 struct smb2_create_ea_ctx *cc;
592
593 *cc_len = round_up(sizeof(*cc) + dlen, 8);
594 cc = kzalloc(*cc_len, GFP_KERNEL);
595 if (!cc)
596 return ERR_PTR(-ENOMEM);
597
598 cc->ctx.NameOffset = cpu_to_le16(offsetof(struct smb2_create_ea_ctx,
599 name));
600 cc->ctx.NameLength = cpu_to_le16(4);
601 memcpy(cc->name, SMB2_CREATE_EA_BUFFER, strlen(SMB2_CREATE_EA_BUFFER));
602 cc->ctx.DataOffset = cpu_to_le16(offsetof(struct smb2_create_ea_ctx, ea));
603 cc->ctx.DataLength = cpu_to_le32(dlen);
604 return cc;
605 }
606
607 struct wsl_xattr {
608 const char *name;
609 __le64 value;
610 u16 size;
611 u32 next;
612 };
613
wsl_set_xattrs(struct inode * inode,umode_t _mode,dev_t _dev,struct kvec * iov)614 static int wsl_set_xattrs(struct inode *inode, umode_t _mode,
615 dev_t _dev, struct kvec *iov)
616 {
617 struct smb2_file_full_ea_info *ea;
618 struct smb2_create_ea_ctx *cc;
619 struct smb3_fs_context *ctx = CIFS_SB(inode->i_sb)->ctx;
620 __le64 uid = cpu_to_le64(from_kuid(current_user_ns(), ctx->linux_uid));
621 __le64 gid = cpu_to_le64(from_kgid(current_user_ns(), ctx->linux_gid));
622 __le64 dev = cpu_to_le64(((u64)MINOR(_dev) << 32) | MAJOR(_dev));
623 __le64 mode = cpu_to_le64(_mode);
624 struct wsl_xattr xattrs[] = {
625 { .name = SMB2_WSL_XATTR_UID, .value = uid, .size = SMB2_WSL_XATTR_UID_SIZE, },
626 { .name = SMB2_WSL_XATTR_GID, .value = gid, .size = SMB2_WSL_XATTR_GID_SIZE, },
627 { .name = SMB2_WSL_XATTR_MODE, .value = mode, .size = SMB2_WSL_XATTR_MODE_SIZE, },
628 { .name = SMB2_WSL_XATTR_DEV, .value = dev, .size = SMB2_WSL_XATTR_DEV_SIZE, },
629 };
630 size_t cc_len;
631 u32 dlen = 0, next = 0;
632 int i, num_xattrs;
633 u8 name_size = SMB2_WSL_XATTR_NAME_LEN + 1;
634
635 memset(iov, 0, sizeof(*iov));
636
637 /* Exclude $LXDEV xattr for non-device files */
638 if (!S_ISBLK(_mode) && !S_ISCHR(_mode))
639 num_xattrs = ARRAY_SIZE(xattrs) - 1;
640 else
641 num_xattrs = ARRAY_SIZE(xattrs);
642
643 for (i = 0; i < num_xattrs; i++) {
644 xattrs[i].next = ALIGN(sizeof(*ea) + name_size +
645 xattrs[i].size, 4);
646 dlen += xattrs[i].next;
647 }
648
649 cc = ea_create_context(dlen, &cc_len);
650 if (IS_ERR(cc))
651 return PTR_ERR(cc);
652
653 ea = &cc->ea;
654 for (i = 0; i < num_xattrs; i++) {
655 ea = (void *)((u8 *)ea + next);
656 next = xattrs[i].next;
657 ea->next_entry_offset = cpu_to_le32(next);
658
659 ea->ea_name_length = name_size - 1;
660 ea->ea_value_length = cpu_to_le16(xattrs[i].size);
661 memcpy(ea->ea_data, xattrs[i].name, name_size);
662 memcpy(&ea->ea_data[name_size],
663 &xattrs[i].value, xattrs[i].size);
664 }
665 ea->next_entry_offset = 0;
666
667 iov->iov_base = cc;
668 iov->iov_len = cc_len;
669 return 0;
670 }
671
mknod_wsl(unsigned int xid,struct inode * inode,struct dentry * dentry,struct cifs_tcon * tcon,const char * full_path,umode_t mode,dev_t dev,const char * symname)672 static int mknod_wsl(unsigned int xid, struct inode *inode,
673 struct dentry *dentry, struct cifs_tcon *tcon,
674 const char *full_path, umode_t mode, dev_t dev,
675 const char *symname)
676 {
677 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
678 struct cifs_open_info_data data;
679 struct reparse_data_buffer *buf;
680 struct smb2_create_ea_ctx *cc;
681 struct inode *new;
682 unsigned int len;
683 struct kvec reparse_iov, xattr_iov;
684 int rc;
685
686 rc = wsl_set_reparse_buf(&buf, mode, symname, cifs_sb, &reparse_iov);
687 if (rc)
688 return rc;
689
690 rc = wsl_set_xattrs(inode, mode, dev, &xattr_iov);
691 if (rc) {
692 kfree(buf);
693 return rc;
694 }
695
696 data = (struct cifs_open_info_data) {
697 .reparse_point = true,
698 .reparse = { .tag = le32_to_cpu(buf->ReparseTag), .buf = buf, },
699 .symlink_target = kstrdup(symname, GFP_KERNEL),
700 };
701
702 cc = xattr_iov.iov_base;
703 len = le32_to_cpu(cc->ctx.DataLength);
704 memcpy(data.wsl.eas, &cc->ea, len);
705 data.wsl.eas_len = len;
706
707 new = tcon->ses->server->ops->create_reparse_inode(
708 &data, inode->i_sb,
709 xid, tcon, full_path, false,
710 &reparse_iov, &xattr_iov);
711 if (!IS_ERR(new))
712 d_instantiate(dentry, new);
713 else
714 rc = PTR_ERR(new);
715 cifs_free_open_info(&data);
716 kfree(xattr_iov.iov_base);
717 kfree(buf);
718 return rc;
719 }
720
mknod_reparse(unsigned int xid,struct inode * inode,struct dentry * dentry,struct cifs_tcon * tcon,const char * full_path,umode_t mode,dev_t dev)721 int mknod_reparse(unsigned int xid, struct inode *inode,
722 struct dentry *dentry, struct cifs_tcon *tcon,
723 const char *full_path, umode_t mode, dev_t dev)
724 {
725 struct smb3_fs_context *ctx = CIFS_SB(inode->i_sb)->ctx;
726
727 if (S_ISSOCK(mode) && !ctx->nonativesocket && ctx->reparse_type != CIFS_REPARSE_TYPE_NONE)
728 return create_native_socket(xid, inode, dentry, tcon, full_path);
729
730 switch (ctx->reparse_type) {
731 case CIFS_REPARSE_TYPE_NFS:
732 return mknod_nfs(xid, inode, dentry, tcon, full_path, mode, dev, NULL);
733 case CIFS_REPARSE_TYPE_WSL:
734 return mknod_wsl(xid, inode, dentry, tcon, full_path, mode, dev, NULL);
735 default:
736 return -EOPNOTSUPP;
737 }
738 }
739
740 /* See MS-FSCC 2.1.2.6 for the 'NFS' style reparse tags */
parse_reparse_nfs(struct reparse_nfs_data_buffer * buf,struct cifs_sb_info * cifs_sb,struct cifs_open_info_data * data)741 static int parse_reparse_nfs(struct reparse_nfs_data_buffer *buf,
742 struct cifs_sb_info *cifs_sb,
743 struct cifs_open_info_data *data)
744 {
745 unsigned int len;
746 u64 type;
747
748 len = le16_to_cpu(buf->ReparseDataLength);
749 if (len < sizeof(buf->InodeType)) {
750 cifs_dbg(VFS, "srv returned malformed nfs buffer\n");
751 return smb_EIO2(smb_eio_trace_reparse_nfs_too_short,
752 len, sizeof(buf->InodeType));
753 }
754
755 len -= sizeof(buf->InodeType);
756
757 switch ((type = le64_to_cpu(buf->InodeType))) {
758 case NFS_SPECFILE_LNK:
759 if (len == 0 || (len % 2)) {
760 cifs_dbg(VFS, "srv returned malformed nfs symlink buffer\n");
761 return smb_EIO1(smb_eio_trace_reparse_nfs_symbuf, len);
762 }
763 /*
764 * Check that buffer does not contain UTF-16 null codepoint
765 * because Linux cannot process symlink with null byte.
766 */
767 if (UniStrnlen((wchar_t *)buf->DataBuffer, len/2) != len/2) {
768 cifs_dbg(VFS, "srv returned null byte in nfs symlink target location\n");
769 return smb_EIO1(smb_eio_trace_reparse_nfs_nul, len);
770 }
771 data->symlink_target = cifs_strndup_from_utf16(buf->DataBuffer,
772 len, true,
773 cifs_sb->local_nls);
774 if (!data->symlink_target)
775 return -ENOMEM;
776 cifs_dbg(FYI, "%s: target path: %s\n",
777 __func__, data->symlink_target);
778 break;
779 case NFS_SPECFILE_CHR:
780 case NFS_SPECFILE_BLK:
781 /* DataBuffer for block and char devices contains two 32-bit numbers */
782 if (len != 8) {
783 cifs_dbg(VFS, "srv returned malformed nfs buffer for type: 0x%llx\n", type);
784 return smb_EIO1(smb_eio_trace_reparse_nfs_dev, len);
785 }
786 break;
787 case NFS_SPECFILE_FIFO:
788 case NFS_SPECFILE_SOCK:
789 /* DataBuffer for fifos and sockets is empty */
790 if (len != 0) {
791 cifs_dbg(VFS, "srv returned malformed nfs buffer for type: 0x%llx\n", type);
792 return smb_EIO1(smb_eio_trace_reparse_nfs_sockfifo, len);
793 }
794 break;
795 default:
796 cifs_dbg(VFS, "%s: unhandled inode type: 0x%llx\n",
797 __func__, type);
798 return -EOPNOTSUPP;
799 }
800 return 0;
801 }
802
smb2_parse_native_symlink(char ** target,const char * buf,unsigned int len,bool relative,const char * full_path,struct cifs_sb_info * cifs_sb)803 int smb2_parse_native_symlink(char **target, const char *buf, unsigned int len,
804 bool relative,
805 const char *full_path,
806 struct cifs_sb_info *cifs_sb)
807 {
808 const char *symroot = cifs_sb->ctx->symlinkroot;
809 char sep = CIFS_DIR_SEP(cifs_sb);
810 char *linux_target = NULL;
811 char *smb_target = NULL;
812 int symlinkroot_len;
813 int abs_path_len;
814 char *abs_path;
815 int levels;
816 int rc, ulen;
817 int i;
818
819 /* Check that length it valid */
820 if (!len || (len % 2)) {
821 cifs_dbg(VFS, "srv returned malformed symlink buffer\n");
822 rc = smb_EIO1(smb_eio_trace_reparse_native_nul, len);
823 goto out;
824 }
825
826 /*
827 * Check that buffer does not contain UTF-16 null codepoint
828 * because Linux cannot process symlink with null byte.
829 */
830 ulen = UniStrnlen((wchar_t *)buf, len/2);
831 if (ulen != len/2) {
832 cifs_dbg(VFS, "srv returned null byte in native symlink target location\n");
833 rc = smb_EIO2(smb_eio_trace_reparse_native_nul, ulen, len);
834 goto out;
835 }
836
837 smb_target = cifs_strndup_from_utf16(buf, len, true, cifs_sb->local_nls);
838 if (!smb_target) {
839 rc = -ENOMEM;
840 goto out;
841 }
842
843 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_POSIX_PATHS) &&
844 symroot && !relative) {
845 /*
846 * This is an absolute symlink from the server which does not
847 * support POSIX paths, so the symlink is in NT-style path.
848 * So convert it to absolute Linux symlink target path. Root of
849 * the NT-style path for symlinks is specified in "symlinkroot"
850 * mount option.
851 *
852 * Root of the DOS and Win32 paths is at NT path \??\
853 * It means that DOS/Win32 path C:\folder\file.txt is
854 * NT path \??\C:\folder\file.txt
855 *
856 * NT systems have some well-known object symlinks in their NT
857 * hierarchy, which is needed to take into account when resolving
858 * other symlinks. Most commonly used symlink paths are:
859 * \?? -> \GLOBAL??
860 * \DosDevices -> \??
861 * \GLOBAL??\GLOBALROOT -> \
862 * \GLOBAL??\Global -> \GLOBAL??
863 * \GLOBAL??\NUL -> \Device\Null
864 * \GLOBAL??\UNC -> \Device\Mup
865 * \GLOBAL??\PhysicalDrive0 -> \Device\Harddisk0\DR0 (for each harddisk)
866 * \GLOBAL??\A: -> \Device\Floppy0 (if A: is the first floppy)
867 * \GLOBAL??\C: -> \Device\HarddiskVolume1 (if C: is the first harddisk)
868 * \GLOBAL??\D: -> \Device\CdRom0 (if D: is first cdrom)
869 * \SystemRoot -> \Device\Harddisk0\Partition1\WINDOWS (or where is NT system installed)
870 * \Volume{...} -> \Device\HarddiskVolume1 (where ... is system generated guid)
871 *
872 * In most common cases, absolute NT symlinks points to path on
873 * DOS/Win32 drive letter, system-specific Volume or on UNC share.
874 * Here are few examples of commonly used absolute NT symlinks
875 * created by mklink.exe tool:
876 * \??\C:\folder\file.txt
877 * \??\\C:\folder\file.txt
878 * \??\UNC\server\share\file.txt
879 * \??\\UNC\server\share\file.txt
880 * \??\Volume{b75e2c83-0000-0000-0000-602f00000000}\folder\file.txt
881 *
882 * It means that the most common path prefix \??\ is also NT path
883 * symlink (to \GLOBAL??). It is less common that second path
884 * separator is double backslash, but it is valid.
885 *
886 * Volume guid is randomly generated by the target system and so
887 * only the target system knows the mapping between guid and the
888 * hardisk number. Over SMB it is not possible to resolve this
889 * mapping, therefore symlinks pointing to target location of
890 * volume guids are totally unusable over SMB.
891 *
892 * For now parse only symlink paths available for DOS and Win32.
893 * Those are paths with \??\ prefix or paths which points to \??\
894 * via other NT symlink (\DosDevices\, \GLOBAL??\, ...).
895 */
896 abs_path = smb_target;
897 globalroot:
898 if (strstarts(abs_path, "\\??\\"))
899 abs_path += sizeof("\\??\\")-1;
900 else if (strstarts(abs_path, "\\DosDevices\\"))
901 abs_path += sizeof("\\DosDevices\\")-1;
902 else if (strstarts(abs_path, "\\GLOBAL??\\"))
903 abs_path += sizeof("\\GLOBAL??\\")-1;
904 else
905 goto out_unhandled_target;
906
907 /* Sometimes path separator after \?? is double backslash */
908 if (abs_path[0] == '\\')
909 abs_path++;
910
911 while (strstarts(abs_path, "Global\\"))
912 abs_path += sizeof("Global\\")-1;
913
914 if (strstarts(abs_path, "GLOBALROOT\\")) {
915 /* Label globalroot requires path with leading '\\', so do not trim '\\' */
916 abs_path += sizeof("GLOBALROOT")-1;
917 goto globalroot;
918 }
919
920 /* For now parse only paths to drive letters */
921 if (((abs_path[0] >= 'A' && abs_path[0] <= 'Z') ||
922 (abs_path[0] >= 'a' && abs_path[0] <= 'z')) &&
923 abs_path[1] == ':' &&
924 (abs_path[2] == '\\' || abs_path[2] == '\0')) {
925 /* Convert drive letter to lowercase and drop colon */
926 char drive_letter = abs_path[0];
927 if (drive_letter >= 'A' && drive_letter <= 'Z')
928 drive_letter += 'a'-'A';
929 abs_path++;
930 abs_path[0] = drive_letter;
931 } else {
932 goto out_unhandled_target;
933 }
934
935 abs_path_len = strlen(abs_path)+1;
936 symlinkroot_len = strlen(symroot);
937 if (symroot[symlinkroot_len - 1] == '/')
938 symlinkroot_len--;
939 linux_target = kmalloc(symlinkroot_len + 1 + abs_path_len, GFP_KERNEL);
940 if (!linux_target) {
941 rc = -ENOMEM;
942 goto out;
943 }
944 memcpy(linux_target, symroot, symlinkroot_len);
945 linux_target[symlinkroot_len] = '/';
946 memcpy(linux_target + symlinkroot_len + 1, abs_path, abs_path_len);
947 } else if (smb_target[0] == sep && relative) {
948 /*
949 * This is a relative SMB symlink from the top of the share,
950 * which is the top level directory of the Linux mount point.
951 * Linux does not support such relative symlinks, so convert
952 * it to the relative symlink from the current directory.
953 * full_path is the SMB path to the symlink (from which is
954 * extracted current directory) and smb_target is the SMB path
955 * where symlink points, therefore full_path must always be on
956 * the SMB share.
957 */
958 int smb_target_len = strlen(smb_target)+1;
959 levels = 0;
960 for (i = 1; full_path[i]; i++) { /* i=1 to skip leading sep */
961 if (full_path[i] == sep)
962 levels++;
963 }
964 linux_target = kmalloc(levels*3 + smb_target_len, GFP_KERNEL);
965 if (!linux_target) {
966 rc = -ENOMEM;
967 goto out;
968 }
969 for (i = 0; i < levels; i++) {
970 linux_target[i*3 + 0] = '.';
971 linux_target[i*3 + 1] = '.';
972 linux_target[i*3 + 2] = sep;
973 }
974 memcpy(linux_target + levels*3, smb_target+1, smb_target_len); /* +1 to skip leading sep */
975 } else {
976 /*
977 * This is either an absolute symlink in POSIX-style format
978 * or relative SMB symlink from the current directory.
979 * These paths have same format as Linux symlinks, so no
980 * conversion is needed.
981 */
982 out_unhandled_target:
983 linux_target = smb_target;
984 smb_target = NULL;
985 }
986
987 if (sep == '\\')
988 convert_delimiter(linux_target, '/');
989
990 rc = 0;
991 *target = linux_target;
992
993 cifs_dbg(FYI, "%s: symlink target: %s\n", __func__, *target);
994
995 out:
996 if (rc != 0)
997 kfree(linux_target);
998 kfree(smb_target);
999 return rc;
1000 }
1001
parse_reparse_native_symlink(struct reparse_symlink_data_buffer * sym,u32 plen,struct cifs_sb_info * cifs_sb,const char * full_path,struct cifs_open_info_data * data)1002 static int parse_reparse_native_symlink(struct reparse_symlink_data_buffer *sym,
1003 u32 plen,
1004 struct cifs_sb_info *cifs_sb,
1005 const char *full_path,
1006 struct cifs_open_info_data *data)
1007 {
1008 unsigned int len;
1009 unsigned int offs;
1010
1011 /* We handle Symbolic Link reparse tag here. See: MS-FSCC 2.1.2.4 */
1012
1013 offs = le16_to_cpu(sym->SubstituteNameOffset);
1014 len = le16_to_cpu(sym->SubstituteNameLength);
1015 if (offs + 20 > plen || offs + len + 20 > plen) {
1016 cifs_dbg(VFS, "srv returned malformed symlink buffer\n");
1017 return smb_EIO2(smb_eio_trace_reparse_native_sym_len,
1018 offs << 16 | len, plen);
1019 }
1020
1021 return smb2_parse_native_symlink(&data->symlink_target,
1022 sym->PathBuffer + offs,
1023 len,
1024 le32_to_cpu(sym->Flags) & SYMLINK_FLAG_RELATIVE,
1025 full_path,
1026 cifs_sb);
1027 }
1028
parse_reparse_wsl_symlink(struct reparse_wsl_symlink_data_buffer * buf,struct cifs_sb_info * cifs_sb,struct cifs_open_info_data * data)1029 static int parse_reparse_wsl_symlink(struct reparse_wsl_symlink_data_buffer *buf,
1030 struct cifs_sb_info *cifs_sb,
1031 struct cifs_open_info_data *data)
1032 {
1033 int len = le16_to_cpu(buf->ReparseDataLength);
1034 int data_offset = offsetof(typeof(*buf), Target) - offsetof(typeof(*buf), Version);
1035 int symname_utf8_len;
1036 __le16 *symname_utf16;
1037 int symname_utf16_len;
1038
1039 if (len <= data_offset) {
1040 cifs_dbg(VFS, "srv returned malformed wsl symlink buffer\n");
1041 return smb_EIO2(smb_eio_trace_reparse_wsl_symbuf,
1042 len, data_offset);
1043 }
1044
1045 /* MS-FSCC 2.1.2.7 defines layout of the Target field only for Version 2. */
1046 u32 version = le32_to_cpu(buf->Version);
1047
1048 if (version != 2) {
1049 cifs_dbg(VFS, "srv returned unsupported wsl symlink version %u\n", version);
1050 return smb_EIO1(smb_eio_trace_reparse_wsl_ver, version);
1051 }
1052
1053 /* Target for Version 2 is in UTF-8 but without trailing null-term byte */
1054 symname_utf8_len = len - data_offset;
1055 /*
1056 * Check that buffer does not contain null byte
1057 * because Linux cannot process symlink with null byte.
1058 */
1059 size_t ulen = strnlen(buf->Target, symname_utf8_len);
1060
1061 if (ulen != symname_utf8_len) {
1062 cifs_dbg(VFS, "srv returned null byte in wsl symlink target location\n");
1063 return smb_EIO2(smb_eio_trace_reparse_wsl_ver,
1064 ulen, symname_utf8_len);
1065 }
1066 symname_utf16 = kzalloc(symname_utf8_len * 2, GFP_KERNEL);
1067 if (!symname_utf16)
1068 return -ENOMEM;
1069 symname_utf16_len = utf8s_to_utf16s(buf->Target, symname_utf8_len,
1070 UTF16_LITTLE_ENDIAN,
1071 (wchar_t *) symname_utf16, symname_utf8_len * 2);
1072 if (symname_utf16_len < 0) {
1073 kfree(symname_utf16);
1074 return symname_utf16_len;
1075 }
1076 symname_utf16_len *= 2; /* utf8s_to_utf16s() returns number of u16 items, not byte length */
1077
1078 data->symlink_target = cifs_strndup_from_utf16((u8 *)symname_utf16,
1079 symname_utf16_len, true,
1080 cifs_sb->local_nls);
1081 kfree(symname_utf16);
1082 if (!data->symlink_target)
1083 return -ENOMEM;
1084
1085 return 0;
1086 }
1087
parse_reparse_point(struct reparse_data_buffer * buf,u32 plen,struct cifs_sb_info * cifs_sb,const char * full_path,struct cifs_open_info_data * data)1088 int parse_reparse_point(struct reparse_data_buffer *buf,
1089 u32 plen, struct cifs_sb_info *cifs_sb,
1090 const char *full_path,
1091 struct cifs_open_info_data *data)
1092 {
1093 data->reparse.buf = buf;
1094
1095 /* See MS-FSCC 2.1.2 */
1096 switch (le32_to_cpu(buf->ReparseTag)) {
1097 case IO_REPARSE_TAG_NFS:
1098 return parse_reparse_nfs((struct reparse_nfs_data_buffer *)buf,
1099 cifs_sb, data);
1100 case IO_REPARSE_TAG_SYMLINK:
1101 return parse_reparse_native_symlink(
1102 (struct reparse_symlink_data_buffer *)buf,
1103 plen, cifs_sb, full_path, data);
1104 case IO_REPARSE_TAG_LX_SYMLINK:
1105 return parse_reparse_wsl_symlink(
1106 (struct reparse_wsl_symlink_data_buffer *)buf,
1107 cifs_sb, data);
1108 case IO_REPARSE_TAG_AF_UNIX:
1109 case IO_REPARSE_TAG_LX_FIFO:
1110 case IO_REPARSE_TAG_LX_CHR:
1111 case IO_REPARSE_TAG_LX_BLK: {
1112 u16 dlen = le16_to_cpu(buf->ReparseDataLength);
1113
1114 if (dlen != 0) {
1115 u32 rtag = le32_to_cpu(buf->ReparseTag);
1116 cifs_dbg(VFS, "srv returned malformed buffer for reparse point: 0x%08x\n",
1117 rtag);
1118 return smb_EIO2(smb_eio_trace_reparse_data_len, dlen, rtag);
1119 }
1120 return 0;
1121 }
1122 default:
1123 return -EOPNOTSUPP;
1124 }
1125 }
1126
smb2_get_reparse_point_buffer(const struct kvec * rsp_iov,u32 * plen)1127 struct reparse_data_buffer *smb2_get_reparse_point_buffer(const struct kvec *rsp_iov,
1128 u32 *plen)
1129 {
1130 struct smb2_ioctl_rsp *io = rsp_iov->iov_base;
1131 *plen = le32_to_cpu(io->OutputCount);
1132 return (struct reparse_data_buffer *)((u8 *)io +
1133 le32_to_cpu(io->OutputOffset));
1134 }
1135
wsl_to_fattr(struct cifs_open_info_data * data,struct cifs_sb_info * cifs_sb,u32 tag,struct cifs_fattr * fattr)1136 static bool wsl_to_fattr(struct cifs_open_info_data *data,
1137 struct cifs_sb_info *cifs_sb,
1138 u32 tag, struct cifs_fattr *fattr)
1139 {
1140 struct smb2_file_full_ea_info *ea;
1141 bool have_xattr_dev = false;
1142 u32 next = 0;
1143
1144 switch (tag) {
1145 case IO_REPARSE_TAG_LX_SYMLINK:
1146 fattr->cf_mode |= S_IFLNK;
1147 break;
1148 case IO_REPARSE_TAG_LX_FIFO:
1149 fattr->cf_mode |= S_IFIFO;
1150 break;
1151 case IO_REPARSE_TAG_AF_UNIX:
1152 fattr->cf_mode |= S_IFSOCK;
1153 break;
1154 case IO_REPARSE_TAG_LX_CHR:
1155 fattr->cf_mode |= S_IFCHR;
1156 break;
1157 case IO_REPARSE_TAG_LX_BLK:
1158 fattr->cf_mode |= S_IFBLK;
1159 break;
1160 }
1161
1162 if (!data->wsl.eas_len)
1163 goto out;
1164
1165 ea = (struct smb2_file_full_ea_info *)data->wsl.eas;
1166 do {
1167 const char *name;
1168 void *v;
1169 u8 nlen;
1170
1171 ea = (void *)((u8 *)ea + next);
1172 next = le32_to_cpu(ea->next_entry_offset);
1173 if (!le16_to_cpu(ea->ea_value_length))
1174 continue;
1175
1176 name = ea->ea_data;
1177 nlen = ea->ea_name_length;
1178 v = (void *)((u8 *)ea->ea_data + ea->ea_name_length + 1);
1179
1180 if (!strncmp(name, SMB2_WSL_XATTR_UID, nlen))
1181 fattr->cf_uid = wsl_make_kuid(cifs_sb, v);
1182 else if (!strncmp(name, SMB2_WSL_XATTR_GID, nlen))
1183 fattr->cf_gid = wsl_make_kgid(cifs_sb, v);
1184 else if (!strncmp(name, SMB2_WSL_XATTR_MODE, nlen)) {
1185 /* File type in reparse point tag and in xattr mode must match. */
1186 if (S_DT(fattr->cf_mode) != S_DT(le32_to_cpu(*(__le32 *)v)))
1187 return false;
1188 fattr->cf_mode = (umode_t)le32_to_cpu(*(__le32 *)v);
1189 } else if (!strncmp(name, SMB2_WSL_XATTR_DEV, nlen)) {
1190 fattr->cf_rdev = reparse_mkdev(v);
1191 have_xattr_dev = true;
1192 }
1193 } while (next);
1194 out:
1195
1196 /* Major and minor numbers for char and block devices are mandatory. */
1197 if (!have_xattr_dev && (tag == IO_REPARSE_TAG_LX_CHR || tag == IO_REPARSE_TAG_LX_BLK))
1198 return false;
1199
1200 return true;
1201 }
1202
posix_reparse_to_fattr(struct cifs_sb_info * cifs_sb,struct cifs_fattr * fattr,struct cifs_open_info_data * data)1203 static bool posix_reparse_to_fattr(struct cifs_sb_info *cifs_sb,
1204 struct cifs_fattr *fattr,
1205 struct cifs_open_info_data *data)
1206 {
1207 struct reparse_nfs_data_buffer *buf = (struct reparse_nfs_data_buffer *)data->reparse.buf;
1208
1209 if (buf == NULL)
1210 return true;
1211
1212 if (le16_to_cpu(buf->ReparseDataLength) < sizeof(buf->InodeType)) {
1213 WARN_ON_ONCE(1);
1214 return false;
1215 }
1216
1217 switch (le64_to_cpu(buf->InodeType)) {
1218 case NFS_SPECFILE_CHR:
1219 if (le16_to_cpu(buf->ReparseDataLength) != sizeof(buf->InodeType) + 8) {
1220 WARN_ON_ONCE(1);
1221 return false;
1222 }
1223 fattr->cf_mode |= S_IFCHR;
1224 fattr->cf_rdev = reparse_mkdev(buf->DataBuffer);
1225 break;
1226 case NFS_SPECFILE_BLK:
1227 if (le16_to_cpu(buf->ReparseDataLength) != sizeof(buf->InodeType) + 8) {
1228 WARN_ON_ONCE(1);
1229 return false;
1230 }
1231 fattr->cf_mode |= S_IFBLK;
1232 fattr->cf_rdev = reparse_mkdev(buf->DataBuffer);
1233 break;
1234 case NFS_SPECFILE_FIFO:
1235 fattr->cf_mode |= S_IFIFO;
1236 break;
1237 case NFS_SPECFILE_SOCK:
1238 fattr->cf_mode |= S_IFSOCK;
1239 break;
1240 case NFS_SPECFILE_LNK:
1241 fattr->cf_mode |= S_IFLNK;
1242 break;
1243 default:
1244 WARN_ON_ONCE(1);
1245 return false;
1246 }
1247 return true;
1248 }
1249
cifs_reparse_point_to_fattr(struct cifs_sb_info * cifs_sb,struct cifs_fattr * fattr,struct cifs_open_info_data * data)1250 bool cifs_reparse_point_to_fattr(struct cifs_sb_info *cifs_sb,
1251 struct cifs_fattr *fattr,
1252 struct cifs_open_info_data *data)
1253 {
1254 u32 tag = data->reparse.tag;
1255 bool ok;
1256
1257 switch (tag) {
1258 case IO_REPARSE_TAG_LX_SYMLINK:
1259 case IO_REPARSE_TAG_LX_FIFO:
1260 case IO_REPARSE_TAG_AF_UNIX:
1261 case IO_REPARSE_TAG_LX_CHR:
1262 case IO_REPARSE_TAG_LX_BLK:
1263 ok = wsl_to_fattr(data, cifs_sb, tag, fattr);
1264 if (!ok)
1265 return false;
1266 break;
1267 case IO_REPARSE_TAG_NFS:
1268 ok = posix_reparse_to_fattr(cifs_sb, fattr, data);
1269 if (!ok)
1270 return false;
1271 break;
1272 case 0: /* SMB1 symlink */
1273 case IO_REPARSE_TAG_SYMLINK:
1274 fattr->cf_mode |= S_IFLNK;
1275 break;
1276 default:
1277 if (!(fattr->cf_cifsattrs & ATTR_DIRECTORY))
1278 return false;
1279 if (!IS_REPARSE_TAG_NAME_SURROGATE(tag) &&
1280 tag != IO_REPARSE_TAG_INTERNAL)
1281 return false;
1282 /* See cifs_create_junction_fattr() */
1283 fattr->cf_mode = S_IFDIR | 0711;
1284 break;
1285 }
1286
1287 fattr->cf_dtype = S_DT(fattr->cf_mode);
1288 return true;
1289 }
1290