1 // SPDX-License-Identifier: LGPL-2.1
2 /*
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French ([email protected])
6 *
7 */
8 #include <linux/fs.h>
9 #include <linux/stat.h>
10 #include <linux/slab.h>
11 #include <linux/namei.h>
12 #include "cifsfs.h"
13 #include "cifspdu.h"
14 #include "cifsglob.h"
15 #include "cifsproto.h"
16 #include "cifs_debug.h"
17 #include "cifs_fs_sb.h"
18 #include "cifs_unicode.h"
19 #include "smb2proto.h"
20 #include "cifs_ioctl.h"
21 #include "fs_context.h"
22
23 /*
24 * M-F Symlink Functions - Begin
25 */
26
27 #define CIFS_MF_SYMLINK_LEN_OFFSET (4+1)
28 #define CIFS_MF_SYMLINK_MD5_OFFSET (CIFS_MF_SYMLINK_LEN_OFFSET+(4+1))
29 #define CIFS_MF_SYMLINK_LINK_OFFSET (CIFS_MF_SYMLINK_MD5_OFFSET+(32+1))
30 #define CIFS_MF_SYMLINK_LINK_MAXLEN (1024)
31 #define CIFS_MF_SYMLINK_FILE_SIZE \
32 (CIFS_MF_SYMLINK_LINK_OFFSET + CIFS_MF_SYMLINK_LINK_MAXLEN)
33
34 #define CIFS_MF_SYMLINK_LEN_FORMAT "XSym\n%04u\n"
35 #define CIFS_MF_SYMLINK_MD5_FORMAT "%16phN\n"
36 #define CIFS_MF_SYMLINK_MD5_ARGS(md5_hash) md5_hash
37
38 static int
symlink_hash(unsigned int link_len,const char * link_str,u8 * md5_hash)39 symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
40 {
41 int rc;
42 struct shash_desc *md5 = NULL;
43
44 rc = cifs_alloc_hash("md5", &md5);
45 if (rc)
46 return rc;
47
48 rc = crypto_shash_digest(md5, link_str, link_len, md5_hash);
49 if (rc)
50 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
51 cifs_free_hash(&md5);
52 return rc;
53 }
54
55 static int
parse_mf_symlink(const u8 * buf,unsigned int buf_len,unsigned int * _link_len,char ** _link_str)56 parse_mf_symlink(const u8 *buf, unsigned int buf_len, unsigned int *_link_len,
57 char **_link_str)
58 {
59 int rc;
60 unsigned int link_len;
61 const char *md5_str1;
62 const char *link_str;
63 u8 md5_hash[16];
64 char md5_str2[34];
65
66 if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
67 return -EINVAL;
68
69 md5_str1 = (const char *)&buf[CIFS_MF_SYMLINK_MD5_OFFSET];
70 link_str = (const char *)&buf[CIFS_MF_SYMLINK_LINK_OFFSET];
71
72 rc = sscanf(buf, CIFS_MF_SYMLINK_LEN_FORMAT, &link_len);
73 if (rc != 1)
74 return -EINVAL;
75
76 if (link_len > CIFS_MF_SYMLINK_LINK_MAXLEN)
77 return -EINVAL;
78
79 rc = symlink_hash(link_len, link_str, md5_hash);
80 if (rc) {
81 cifs_dbg(FYI, "%s: MD5 hash failure: %d\n", __func__, rc);
82 return rc;
83 }
84
85 scnprintf(md5_str2, sizeof(md5_str2),
86 CIFS_MF_SYMLINK_MD5_FORMAT,
87 CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
88
89 if (strncmp(md5_str1, md5_str2, 17) != 0)
90 return -EINVAL;
91
92 if (_link_str) {
93 *_link_str = kstrndup(link_str, link_len, GFP_KERNEL);
94 if (!*_link_str)
95 return -ENOMEM;
96 }
97
98 *_link_len = link_len;
99 return 0;
100 }
101
102 static int
format_mf_symlink(u8 * buf,unsigned int buf_len,const char * link_str)103 format_mf_symlink(u8 *buf, unsigned int buf_len, const char *link_str)
104 {
105 int rc;
106 unsigned int link_len;
107 unsigned int ofs;
108 u8 md5_hash[16];
109
110 if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
111 return -EINVAL;
112
113 link_len = strlen(link_str);
114
115 if (link_len > CIFS_MF_SYMLINK_LINK_MAXLEN)
116 return -ENAMETOOLONG;
117
118 rc = symlink_hash(link_len, link_str, md5_hash);
119 if (rc) {
120 cifs_dbg(FYI, "%s: MD5 hash failure: %d\n", __func__, rc);
121 return rc;
122 }
123
124 scnprintf(buf, buf_len,
125 CIFS_MF_SYMLINK_LEN_FORMAT CIFS_MF_SYMLINK_MD5_FORMAT,
126 link_len,
127 CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
128
129 ofs = CIFS_MF_SYMLINK_LINK_OFFSET;
130 memcpy(buf + ofs, link_str, link_len);
131
132 ofs += link_len;
133 if (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
134 buf[ofs] = '\n';
135 ofs++;
136 }
137
138 while (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
139 buf[ofs] = ' ';
140 ofs++;
141 }
142
143 return 0;
144 }
145
146 bool
couldbe_mf_symlink(const struct cifs_fattr * fattr)147 couldbe_mf_symlink(const struct cifs_fattr *fattr)
148 {
149 if (!S_ISREG(fattr->cf_mode))
150 /* it's not a symlink */
151 return false;
152
153 if (fattr->cf_eof != CIFS_MF_SYMLINK_FILE_SIZE)
154 /* it's not a symlink */
155 return false;
156
157 return true;
158 }
159
160 static int
create_mf_symlink(const unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const char * fromName,const char * toName)161 create_mf_symlink(const unsigned int xid, struct cifs_tcon *tcon,
162 struct cifs_sb_info *cifs_sb, const char *fromName,
163 const char *toName)
164 {
165 int rc;
166 u8 *buf;
167 unsigned int bytes_written = 0;
168
169 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
170 if (!buf)
171 return -ENOMEM;
172
173 rc = format_mf_symlink(buf, CIFS_MF_SYMLINK_FILE_SIZE, toName);
174 if (rc)
175 goto out;
176
177 if (tcon->ses->server->ops->create_mf_symlink)
178 rc = tcon->ses->server->ops->create_mf_symlink(xid, tcon,
179 cifs_sb, fromName, buf, &bytes_written);
180 else
181 rc = -EOPNOTSUPP;
182
183 if (rc)
184 goto out;
185
186 if (bytes_written != CIFS_MF_SYMLINK_FILE_SIZE)
187 rc = -EIO;
188 out:
189 kfree(buf);
190 return rc;
191 }
192
193 int
check_mf_symlink(unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,struct cifs_fattr * fattr,const unsigned char * path)194 check_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
195 struct cifs_sb_info *cifs_sb, struct cifs_fattr *fattr,
196 const unsigned char *path)
197 {
198 int rc;
199 u8 *buf = NULL;
200 unsigned int link_len = 0;
201 unsigned int bytes_read = 0;
202 char *symlink = NULL;
203
204 if (!couldbe_mf_symlink(fattr))
205 /* it's not a symlink */
206 return 0;
207
208 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
209 if (!buf)
210 return -ENOMEM;
211
212 if (tcon->ses->server->ops->query_mf_symlink)
213 rc = tcon->ses->server->ops->query_mf_symlink(xid, tcon,
214 cifs_sb, path, buf, &bytes_read);
215 else
216 rc = -ENOSYS;
217
218 if (rc)
219 goto out;
220
221 if (bytes_read == 0) /* not a symlink */
222 goto out;
223
224 rc = parse_mf_symlink(buf, bytes_read, &link_len, &symlink);
225 if (rc == -EINVAL) {
226 /* it's not a symlink */
227 rc = 0;
228 goto out;
229 }
230
231 if (rc != 0)
232 goto out;
233
234 /* it is a symlink */
235 fattr->cf_eof = link_len;
236 fattr->cf_mode &= ~S_IFMT;
237 fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
238 fattr->cf_dtype = DT_LNK;
239 fattr->cf_symlink_target = symlink;
240 out:
241 kfree(buf);
242 return rc;
243 }
244
245 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
246 /*
247 * SMB 1.0 Protocol specific functions
248 */
249
250 int
cifs_query_mf_symlink(unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const unsigned char * path,char * pbuf,unsigned int * pbytes_read)251 cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
252 struct cifs_sb_info *cifs_sb, const unsigned char *path,
253 char *pbuf, unsigned int *pbytes_read)
254 {
255 int rc;
256 int oplock = 0;
257 struct cifs_fid fid;
258 struct cifs_open_parms oparms;
259 struct cifs_io_parms io_parms = {0};
260 int buf_type = CIFS_NO_BUFFER;
261 FILE_ALL_INFO file_info;
262
263 oparms = (struct cifs_open_parms) {
264 .tcon = tcon,
265 .cifs_sb = cifs_sb,
266 .desired_access = GENERIC_READ,
267 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
268 .disposition = FILE_OPEN,
269 .path = path,
270 .fid = &fid,
271 };
272
273 rc = CIFS_open(xid, &oparms, &oplock, &file_info);
274 if (rc)
275 return rc;
276
277 if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
278 rc = -ENOENT;
279 /* it's not a symlink */
280 goto out;
281 }
282
283 io_parms.netfid = fid.netfid;
284 io_parms.pid = current->tgid;
285 io_parms.tcon = tcon;
286 io_parms.offset = 0;
287 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
288
289 rc = CIFSSMBRead(xid, &io_parms, pbytes_read, &pbuf, &buf_type);
290 out:
291 CIFSSMBClose(xid, tcon, fid.netfid);
292 return rc;
293 }
294
295 int
cifs_create_mf_symlink(unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const unsigned char * path,char * pbuf,unsigned int * pbytes_written)296 cifs_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
297 struct cifs_sb_info *cifs_sb, const unsigned char *path,
298 char *pbuf, unsigned int *pbytes_written)
299 {
300 int rc;
301 int oplock = 0;
302 struct cifs_fid fid;
303 struct cifs_open_parms oparms;
304 struct cifs_io_parms io_parms = {0};
305
306 oparms = (struct cifs_open_parms) {
307 .tcon = tcon,
308 .cifs_sb = cifs_sb,
309 .desired_access = GENERIC_WRITE,
310 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
311 .disposition = FILE_CREATE,
312 .path = path,
313 .fid = &fid,
314 };
315
316 rc = CIFS_open(xid, &oparms, &oplock, NULL);
317 if (rc)
318 return rc;
319
320 io_parms.netfid = fid.netfid;
321 io_parms.pid = current->tgid;
322 io_parms.tcon = tcon;
323 io_parms.offset = 0;
324 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
325
326 rc = CIFSSMBWrite(xid, &io_parms, pbytes_written, pbuf);
327 CIFSSMBClose(xid, tcon, fid.netfid);
328 return rc;
329 }
330 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
331
332 /*
333 * SMB 2.1/SMB3 Protocol specific functions
334 */
335 int
smb3_query_mf_symlink(unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const unsigned char * path,char * pbuf,unsigned int * pbytes_read)336 smb3_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
337 struct cifs_sb_info *cifs_sb, const unsigned char *path,
338 char *pbuf, unsigned int *pbytes_read)
339 {
340 int rc;
341 struct cifs_fid fid;
342 struct cifs_open_parms oparms;
343 struct cifs_io_parms io_parms = {0};
344 int buf_type = CIFS_NO_BUFFER;
345 __le16 *utf16_path;
346 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
347 struct smb2_file_all_info *pfile_info = NULL;
348
349 oparms = (struct cifs_open_parms) {
350 .tcon = tcon,
351 .cifs_sb = cifs_sb,
352 .path = path,
353 .desired_access = GENERIC_READ,
354 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
355 .disposition = FILE_OPEN,
356 .fid = &fid,
357 };
358
359 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
360 if (utf16_path == NULL)
361 return -ENOMEM;
362
363 pfile_info = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
364 GFP_KERNEL);
365
366 if (pfile_info == NULL) {
367 kfree(utf16_path);
368 return -ENOMEM;
369 }
370
371 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, pfile_info, NULL,
372 NULL, NULL);
373 if (rc)
374 goto qmf_out_open_fail;
375
376 if (pfile_info->EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
377 /* it's not a symlink */
378 rc = -ENOENT; /* Is there a better rc to return? */
379 goto qmf_out;
380 }
381
382 io_parms.netfid = fid.netfid;
383 io_parms.pid = current->tgid;
384 io_parms.tcon = tcon;
385 io_parms.offset = 0;
386 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
387 io_parms.persistent_fid = fid.persistent_fid;
388 io_parms.volatile_fid = fid.volatile_fid;
389 rc = SMB2_read(xid, &io_parms, pbytes_read, &pbuf, &buf_type);
390 qmf_out:
391 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
392 qmf_out_open_fail:
393 kfree(utf16_path);
394 kfree(pfile_info);
395 return rc;
396 }
397
398 int
smb3_create_mf_symlink(unsigned int xid,struct cifs_tcon * tcon,struct cifs_sb_info * cifs_sb,const unsigned char * path,char * pbuf,unsigned int * pbytes_written)399 smb3_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
400 struct cifs_sb_info *cifs_sb, const unsigned char *path,
401 char *pbuf, unsigned int *pbytes_written)
402 {
403 int rc;
404 struct cifs_fid fid;
405 struct cifs_open_parms oparms;
406 struct cifs_io_parms io_parms = {0};
407 __le16 *utf16_path;
408 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
409 struct kvec iov[2];
410
411 cifs_dbg(FYI, "%s: path: %s\n", __func__, path);
412
413 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
414 if (!utf16_path)
415 return -ENOMEM;
416
417 oparms = (struct cifs_open_parms) {
418 .tcon = tcon,
419 .cifs_sb = cifs_sb,
420 .path = path,
421 .desired_access = GENERIC_WRITE,
422 .create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR),
423 .disposition = FILE_CREATE,
424 .fid = &fid,
425 .mode = 0644,
426 };
427
428 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL,
429 NULL, NULL);
430 if (rc) {
431 kfree(utf16_path);
432 return rc;
433 }
434
435 io_parms.netfid = fid.netfid;
436 io_parms.pid = current->tgid;
437 io_parms.tcon = tcon;
438 io_parms.offset = 0;
439 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
440 io_parms.persistent_fid = fid.persistent_fid;
441 io_parms.volatile_fid = fid.volatile_fid;
442
443 /* iov[0] is reserved for smb header */
444 iov[1].iov_base = pbuf;
445 iov[1].iov_len = CIFS_MF_SYMLINK_FILE_SIZE;
446
447 rc = SMB2_write(xid, &io_parms, pbytes_written, iov, 1);
448
449 /* Make sure we wrote all of the symlink data */
450 if ((rc == 0) && (*pbytes_written != CIFS_MF_SYMLINK_FILE_SIZE))
451 rc = -EIO;
452
453 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
454
455 kfree(utf16_path);
456 return rc;
457 }
458
459 /*
460 * M-F Symlink Functions - End
461 */
462
463 int
cifs_hardlink(struct dentry * old_file,struct inode * inode,struct dentry * direntry)464 cifs_hardlink(struct dentry *old_file, struct inode *inode,
465 struct dentry *direntry)
466 {
467 int rc = -EACCES;
468 unsigned int xid;
469 const char *from_name, *to_name;
470 void *page1, *page2;
471 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
472 struct tcon_link *tlink;
473 struct cifs_tcon *tcon;
474 struct TCP_Server_Info *server;
475 struct cifsInodeInfo *cifsInode;
476
477 if (unlikely(cifs_forced_shutdown(cifs_sb)))
478 return -EIO;
479
480 tlink = cifs_sb_tlink(cifs_sb);
481 if (IS_ERR(tlink))
482 return PTR_ERR(tlink);
483 tcon = tlink_tcon(tlink);
484
485 xid = get_xid();
486 page1 = alloc_dentry_path();
487 page2 = alloc_dentry_path();
488
489 from_name = build_path_from_dentry(old_file, page1);
490 if (IS_ERR(from_name)) {
491 rc = PTR_ERR(from_name);
492 goto cifs_hl_exit;
493 }
494 to_name = build_path_from_dentry(direntry, page2);
495 if (IS_ERR(to_name)) {
496 rc = PTR_ERR(to_name);
497 goto cifs_hl_exit;
498 }
499
500 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
501 if (tcon->unix_ext)
502 rc = CIFSUnixCreateHardLink(xid, tcon, from_name, to_name,
503 cifs_sb->local_nls,
504 cifs_remap(cifs_sb));
505 else {
506 #else
507 {
508 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
509 server = tcon->ses->server;
510 if (!server->ops->create_hardlink) {
511 rc = -ENOSYS;
512 goto cifs_hl_exit;
513 }
514 rc = server->ops->create_hardlink(xid, tcon, old_file,
515 from_name, to_name, cifs_sb);
516 if ((rc == -EIO) || (rc == -EINVAL))
517 rc = -EOPNOTSUPP;
518 }
519
520 d_drop(direntry); /* force new lookup from server of target */
521
522 /*
523 * if source file is cached (oplocked) revalidate will not go to server
524 * until the file is closed or oplock broken so update nlinks locally
525 */
526 if (d_really_is_positive(old_file)) {
527 cifsInode = CIFS_I(d_inode(old_file));
528 if (rc == 0) {
529 spin_lock(&d_inode(old_file)->i_lock);
530 inc_nlink(d_inode(old_file));
531 spin_unlock(&d_inode(old_file)->i_lock);
532
533 /*
534 * parent dir timestamps will update from srv within a
535 * second, would it really be worth it to set the parent
536 * dir cifs inode time to zero to force revalidate
537 * (faster) for it too?
538 */
539 }
540 /*
541 * if not oplocked will force revalidate to get info on source
542 * file from srv. Note Samba server prior to 4.2 has bug -
543 * not updating src file ctime on hardlinks but Windows servers
544 * handle it properly
545 */
546 cifsInode->time = 0;
547
548 /*
549 * Will update parent dir timestamps from srv within a second.
550 * Would it really be worth it to set the parent dir (cifs
551 * inode) time field to zero to force revalidate on parent
552 * directory faster ie
553 *
554 * CIFS_I(inode)->time = 0;
555 */
556 }
557
558 cifs_hl_exit:
559 free_dentry_path(page1);
560 free_dentry_path(page2);
561 free_xid(xid);
562 cifs_put_tlink(tlink);
563 return rc;
564 }
565
566 int
567 cifs_symlink(struct mnt_idmap *idmap, struct inode *inode,
568 struct dentry *direntry, const char *symname)
569 {
570 int rc = -EOPNOTSUPP;
571 unsigned int xid;
572 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
573 struct TCP_Server_Info *server;
574 struct tcon_link *tlink;
575 struct cifs_tcon *pTcon;
576 const char *full_path;
577 void *page;
578 struct inode *newinode = NULL;
579
580 if (unlikely(cifs_forced_shutdown(cifs_sb)))
581 return -EIO;
582
583 page = alloc_dentry_path();
584 if (!page)
585 return -ENOMEM;
586
587 xid = get_xid();
588
589 tlink = cifs_sb_tlink(cifs_sb);
590 if (IS_ERR(tlink)) {
591 rc = PTR_ERR(tlink);
592 /* BB could be clearer if skipped put_tlink on error here, but harmless */
593 goto symlink_exit;
594 }
595 pTcon = tlink_tcon(tlink);
596 server = cifs_pick_channel(pTcon->ses);
597
598 full_path = build_path_from_dentry(direntry, page);
599 if (IS_ERR(full_path)) {
600 rc = PTR_ERR(full_path);
601 goto symlink_exit;
602 }
603
604 cifs_dbg(FYI, "Full path: %s\n", full_path);
605 cifs_dbg(FYI, "symname is %s\n", symname);
606
607 /* BB what if DFS and this volume is on different share? BB */
608 rc = -EOPNOTSUPP;
609 switch (get_cifs_symlink_type(cifs_sb)) {
610 case CIFS_SYMLINK_TYPE_DEFAULT:
611 /* should not happen, get_cifs_symlink_type() resolves the default */
612 break;
613
614 case CIFS_SYMLINK_TYPE_NONE:
615 break;
616
617 case CIFS_SYMLINK_TYPE_UNIX:
618 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
619 if (pTcon->unix_ext) {
620 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path,
621 symname,
622 cifs_sb->local_nls,
623 cifs_remap(cifs_sb));
624 }
625 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
626 break;
627
628 case CIFS_SYMLINK_TYPE_MFSYMLINKS:
629 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
630 rc = create_mf_symlink(xid, pTcon, cifs_sb,
631 full_path, symname);
632 }
633 break;
634
635 case CIFS_SYMLINK_TYPE_SFU:
636 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
637 rc = __cifs_sfu_make_node(xid, inode, direntry, pTcon,
638 full_path, S_IFLNK,
639 0, symname);
640 }
641 break;
642
643 case CIFS_SYMLINK_TYPE_NATIVE:
644 case CIFS_SYMLINK_TYPE_NFS:
645 case CIFS_SYMLINK_TYPE_WSL:
646 if (server->ops->create_reparse_symlink) {
647 rc = server->ops->create_reparse_symlink(xid, inode,
648 direntry,
649 pTcon,
650 full_path,
651 symname);
652 goto symlink_exit;
653 }
654 break;
655 }
656
657 if (rc == 0) {
658 if (pTcon->posix_extensions) {
659 rc = smb311_posix_get_inode_info(&newinode, full_path,
660 NULL, inode->i_sb, xid);
661 } else if (pTcon->unix_ext) {
662 rc = cifs_get_inode_info_unix(&newinode, full_path,
663 inode->i_sb, xid);
664 } else {
665 rc = cifs_get_inode_info(&newinode, full_path, NULL,
666 inode->i_sb, xid, NULL);
667 }
668
669 if (rc != 0) {
670 cifs_dbg(FYI, "Create symlink ok, getinodeinfo fail rc = %d\n",
671 rc);
672 } else {
673 d_instantiate(direntry, newinode);
674 }
675 }
676 symlink_exit:
677 free_dentry_path(page);
678 cifs_put_tlink(tlink);
679 free_xid(xid);
680 return rc;
681 }
682