Loading...
1/*
2 * fs/cifs/link.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21#include <linux/fs.h>
22#include <linux/stat.h>
23#include <linux/slab.h>
24#include <linux/namei.h>
25#include "cifsfs.h"
26#include "cifspdu.h"
27#include "cifsglob.h"
28#include "cifsproto.h"
29#include "cifs_debug.h"
30#include "cifs_fs_sb.h"
31
32#define CIFS_MF_SYMLINK_LEN_OFFSET (4+1)
33#define CIFS_MF_SYMLINK_MD5_OFFSET (CIFS_MF_SYMLINK_LEN_OFFSET+(4+1))
34#define CIFS_MF_SYMLINK_LINK_OFFSET (CIFS_MF_SYMLINK_MD5_OFFSET+(32+1))
35#define CIFS_MF_SYMLINK_LINK_MAXLEN (1024)
36#define CIFS_MF_SYMLINK_FILE_SIZE \
37 (CIFS_MF_SYMLINK_LINK_OFFSET + CIFS_MF_SYMLINK_LINK_MAXLEN)
38
39#define CIFS_MF_SYMLINK_LEN_FORMAT "XSym\n%04u\n"
40#define CIFS_MF_SYMLINK_MD5_FORMAT \
41 "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n"
42#define CIFS_MF_SYMLINK_MD5_ARGS(md5_hash) \
43 md5_hash[0], md5_hash[1], md5_hash[2], md5_hash[3], \
44 md5_hash[4], md5_hash[5], md5_hash[6], md5_hash[7], \
45 md5_hash[8], md5_hash[9], md5_hash[10], md5_hash[11],\
46 md5_hash[12], md5_hash[13], md5_hash[14], md5_hash[15]
47
48static int
49symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
50{
51 int rc;
52 unsigned int size;
53 struct crypto_shash *md5;
54 struct sdesc *sdescmd5;
55
56 md5 = crypto_alloc_shash("md5", 0, 0);
57 if (IS_ERR(md5)) {
58 rc = PTR_ERR(md5);
59 cERROR(1, "%s: Crypto md5 allocation error %d\n", __func__, rc);
60 return rc;
61 }
62 size = sizeof(struct shash_desc) + crypto_shash_descsize(md5);
63 sdescmd5 = kmalloc(size, GFP_KERNEL);
64 if (!sdescmd5) {
65 rc = -ENOMEM;
66 cERROR(1, "%s: Memory allocation failure\n", __func__);
67 goto symlink_hash_err;
68 }
69 sdescmd5->shash.tfm = md5;
70 sdescmd5->shash.flags = 0x0;
71
72 rc = crypto_shash_init(&sdescmd5->shash);
73 if (rc) {
74 cERROR(1, "%s: Could not init md5 shash\n", __func__);
75 goto symlink_hash_err;
76 }
77 rc = crypto_shash_update(&sdescmd5->shash, link_str, link_len);
78 if (rc) {
79 cERROR(1, "%s: Could not update iwth link_str\n", __func__);
80 goto symlink_hash_err;
81 }
82 rc = crypto_shash_final(&sdescmd5->shash, md5_hash);
83 if (rc)
84 cERROR(1, "%s: Could not generate md5 hash\n", __func__);
85
86symlink_hash_err:
87 crypto_free_shash(md5);
88 kfree(sdescmd5);
89
90 return rc;
91}
92
93static int
94CIFSParseMFSymlink(const u8 *buf,
95 unsigned int buf_len,
96 unsigned int *_link_len,
97 char **_link_str)
98{
99 int rc;
100 unsigned int link_len;
101 const char *md5_str1;
102 const char *link_str;
103 u8 md5_hash[16];
104 char md5_str2[34];
105
106 if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
107 return -EINVAL;
108
109 md5_str1 = (const char *)&buf[CIFS_MF_SYMLINK_MD5_OFFSET];
110 link_str = (const char *)&buf[CIFS_MF_SYMLINK_LINK_OFFSET];
111
112 rc = sscanf(buf, CIFS_MF_SYMLINK_LEN_FORMAT, &link_len);
113 if (rc != 1)
114 return -EINVAL;
115
116 rc = symlink_hash(link_len, link_str, md5_hash);
117 if (rc) {
118 cFYI(1, "%s: MD5 hash failure: %d\n", __func__, rc);
119 return rc;
120 }
121
122 snprintf(md5_str2, sizeof(md5_str2),
123 CIFS_MF_SYMLINK_MD5_FORMAT,
124 CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
125
126 if (strncmp(md5_str1, md5_str2, 17) != 0)
127 return -EINVAL;
128
129 if (_link_str) {
130 *_link_str = kstrndup(link_str, link_len, GFP_KERNEL);
131 if (!*_link_str)
132 return -ENOMEM;
133 }
134
135 *_link_len = link_len;
136 return 0;
137}
138
139static int
140CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
141{
142 int rc;
143 unsigned int link_len;
144 unsigned int ofs;
145 u8 md5_hash[16];
146
147 if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
148 return -EINVAL;
149
150 link_len = strlen(link_str);
151
152 if (link_len > CIFS_MF_SYMLINK_LINK_MAXLEN)
153 return -ENAMETOOLONG;
154
155 rc = symlink_hash(link_len, link_str, md5_hash);
156 if (rc) {
157 cFYI(1, "%s: MD5 hash failure: %d\n", __func__, rc);
158 return rc;
159 }
160
161 snprintf(buf, buf_len,
162 CIFS_MF_SYMLINK_LEN_FORMAT CIFS_MF_SYMLINK_MD5_FORMAT,
163 link_len,
164 CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
165
166 ofs = CIFS_MF_SYMLINK_LINK_OFFSET;
167 memcpy(buf + ofs, link_str, link_len);
168
169 ofs += link_len;
170 if (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
171 buf[ofs] = '\n';
172 ofs++;
173 }
174
175 while (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
176 buf[ofs] = ' ';
177 ofs++;
178 }
179
180 return 0;
181}
182
183static int
184CIFSCreateMFSymLink(const int xid, struct cifs_tcon *tcon,
185 const char *fromName, const char *toName,
186 struct cifs_sb_info *cifs_sb)
187{
188 int rc;
189 int oplock = 0;
190 int remap;
191 int create_options = CREATE_NOT_DIR;
192 __u16 netfid = 0;
193 u8 *buf;
194 unsigned int bytes_written = 0;
195 struct cifs_io_parms io_parms;
196 struct nls_table *nls_codepage;
197
198 nls_codepage = cifs_sb->local_nls;
199 remap = cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR;
200
201 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
202 if (!buf)
203 return -ENOMEM;
204
205 rc = CIFSFormatMFSymlink(buf, CIFS_MF_SYMLINK_FILE_SIZE, toName);
206 if (rc != 0) {
207 kfree(buf);
208 return rc;
209 }
210
211 if (backup_cred(cifs_sb))
212 create_options |= CREATE_OPEN_BACKUP_INTENT;
213
214 rc = CIFSSMBOpen(xid, tcon, fromName, FILE_CREATE, GENERIC_WRITE,
215 create_options, &netfid, &oplock, NULL,
216 nls_codepage, remap);
217 if (rc != 0) {
218 kfree(buf);
219 return rc;
220 }
221
222 io_parms.netfid = netfid;
223 io_parms.pid = current->tgid;
224 io_parms.tcon = tcon;
225 io_parms.offset = 0;
226 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
227
228 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, buf, NULL, 0);
229 CIFSSMBClose(xid, tcon, netfid);
230 kfree(buf);
231 if (rc != 0)
232 return rc;
233
234 if (bytes_written != CIFS_MF_SYMLINK_FILE_SIZE)
235 return -EIO;
236
237 return 0;
238}
239
240static int
241CIFSQueryMFSymLink(const int xid, struct cifs_tcon *tcon,
242 const unsigned char *searchName, char **symlinkinfo,
243 const struct nls_table *nls_codepage, int remap)
244{
245 int rc;
246 int oplock = 0;
247 __u16 netfid = 0;
248 u8 *buf;
249 char *pbuf;
250 unsigned int bytes_read = 0;
251 int buf_type = CIFS_NO_BUFFER;
252 unsigned int link_len = 0;
253 struct cifs_io_parms io_parms;
254 FILE_ALL_INFO file_info;
255
256 rc = CIFSSMBOpen(xid, tcon, searchName, FILE_OPEN, GENERIC_READ,
257 CREATE_NOT_DIR, &netfid, &oplock, &file_info,
258 nls_codepage, remap);
259 if (rc != 0)
260 return rc;
261
262 if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
263 CIFSSMBClose(xid, tcon, netfid);
264 /* it's not a symlink */
265 return -EINVAL;
266 }
267
268 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
269 if (!buf)
270 return -ENOMEM;
271 pbuf = buf;
272 io_parms.netfid = netfid;
273 io_parms.pid = current->tgid;
274 io_parms.tcon = tcon;
275 io_parms.offset = 0;
276 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
277
278 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
279 CIFSSMBClose(xid, tcon, netfid);
280 if (rc != 0) {
281 kfree(buf);
282 return rc;
283 }
284
285 rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, symlinkinfo);
286 kfree(buf);
287 if (rc != 0)
288 return rc;
289
290 return 0;
291}
292
293bool
294CIFSCouldBeMFSymlink(const struct cifs_fattr *fattr)
295{
296 if (!(fattr->cf_mode & S_IFREG))
297 /* it's not a symlink */
298 return false;
299
300 if (fattr->cf_eof != CIFS_MF_SYMLINK_FILE_SIZE)
301 /* it's not a symlink */
302 return false;
303
304 return true;
305}
306
307int
308CIFSCheckMFSymlink(struct cifs_fattr *fattr,
309 const unsigned char *path,
310 struct cifs_sb_info *cifs_sb, int xid)
311{
312 int rc;
313 int oplock = 0;
314 __u16 netfid = 0;
315 struct tcon_link *tlink;
316 struct cifs_tcon *pTcon;
317 struct cifs_io_parms io_parms;
318 u8 *buf;
319 char *pbuf;
320 unsigned int bytes_read = 0;
321 int buf_type = CIFS_NO_BUFFER;
322 unsigned int link_len = 0;
323 FILE_ALL_INFO file_info;
324
325 if (!CIFSCouldBeMFSymlink(fattr))
326 /* it's not a symlink */
327 return 0;
328
329 tlink = cifs_sb_tlink(cifs_sb);
330 if (IS_ERR(tlink))
331 return PTR_ERR(tlink);
332 pTcon = tlink_tcon(tlink);
333
334 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
335 CREATE_NOT_DIR, &netfid, &oplock, &file_info,
336 cifs_sb->local_nls,
337 cifs_sb->mnt_cifs_flags &
338 CIFS_MOUNT_MAP_SPECIAL_CHR);
339 if (rc != 0)
340 goto out;
341
342 if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
343 CIFSSMBClose(xid, pTcon, netfid);
344 /* it's not a symlink */
345 goto out;
346 }
347
348 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
349 if (!buf) {
350 rc = -ENOMEM;
351 goto out;
352 }
353 pbuf = buf;
354 io_parms.netfid = netfid;
355 io_parms.pid = current->tgid;
356 io_parms.tcon = pTcon;
357 io_parms.offset = 0;
358 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
359
360 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
361 CIFSSMBClose(xid, pTcon, netfid);
362 if (rc != 0) {
363 kfree(buf);
364 goto out;
365 }
366
367 rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, NULL);
368 kfree(buf);
369 if (rc == -EINVAL) {
370 /* it's not a symlink */
371 rc = 0;
372 goto out;
373 }
374
375 if (rc != 0)
376 goto out;
377
378 /* it is a symlink */
379 fattr->cf_eof = link_len;
380 fattr->cf_mode &= ~S_IFMT;
381 fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
382 fattr->cf_dtype = DT_LNK;
383out:
384 cifs_put_tlink(tlink);
385 return rc;
386}
387
388int
389cifs_hardlink(struct dentry *old_file, struct inode *inode,
390 struct dentry *direntry)
391{
392 int rc = -EACCES;
393 int xid;
394 char *fromName = NULL;
395 char *toName = NULL;
396 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
397 struct tcon_link *tlink;
398 struct cifs_tcon *pTcon;
399 struct cifsInodeInfo *cifsInode;
400
401 tlink = cifs_sb_tlink(cifs_sb);
402 if (IS_ERR(tlink))
403 return PTR_ERR(tlink);
404 pTcon = tlink_tcon(tlink);
405
406 xid = GetXid();
407
408 fromName = build_path_from_dentry(old_file);
409 toName = build_path_from_dentry(direntry);
410 if ((fromName == NULL) || (toName == NULL)) {
411 rc = -ENOMEM;
412 goto cifs_hl_exit;
413 }
414
415 if (pTcon->unix_ext)
416 rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
417 cifs_sb->local_nls,
418 cifs_sb->mnt_cifs_flags &
419 CIFS_MOUNT_MAP_SPECIAL_CHR);
420 else {
421 rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
422 cifs_sb->local_nls,
423 cifs_sb->mnt_cifs_flags &
424 CIFS_MOUNT_MAP_SPECIAL_CHR);
425 if ((rc == -EIO) || (rc == -EINVAL))
426 rc = -EOPNOTSUPP;
427 }
428
429 d_drop(direntry); /* force new lookup from server of target */
430
431 /* if source file is cached (oplocked) revalidate will not go to server
432 until the file is closed or oplock broken so update nlinks locally */
433 if (old_file->d_inode) {
434 cifsInode = CIFS_I(old_file->d_inode);
435 if (rc == 0) {
436 inc_nlink(old_file->d_inode);
437/* BB should we make this contingent on superblock flag NOATIME? */
438/* old_file->d_inode->i_ctime = CURRENT_TIME;*/
439 /* parent dir timestamps will update from srv
440 within a second, would it really be worth it
441 to set the parent dir cifs inode time to zero
442 to force revalidate (faster) for it too? */
443 }
444 /* if not oplocked will force revalidate to get info
445 on source file from srv */
446 cifsInode->time = 0;
447
448 /* Will update parent dir timestamps from srv within a second.
449 Would it really be worth it to set the parent dir (cifs
450 inode) time field to zero to force revalidate on parent
451 directory faster ie
452 CIFS_I(inode)->time = 0; */
453 }
454
455cifs_hl_exit:
456 kfree(fromName);
457 kfree(toName);
458 FreeXid(xid);
459 cifs_put_tlink(tlink);
460 return rc;
461}
462
463void *
464cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
465{
466 struct inode *inode = direntry->d_inode;
467 int rc = -ENOMEM;
468 int xid;
469 char *full_path = NULL;
470 char *target_path = NULL;
471 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
472 struct tcon_link *tlink = NULL;
473 struct cifs_tcon *tcon;
474
475 xid = GetXid();
476
477 tlink = cifs_sb_tlink(cifs_sb);
478 if (IS_ERR(tlink)) {
479 rc = PTR_ERR(tlink);
480 tlink = NULL;
481 goto out;
482 }
483 tcon = tlink_tcon(tlink);
484
485 /*
486 * For now, we just handle symlinks with unix extensions enabled.
487 * Eventually we should handle NTFS reparse points, and MacOS
488 * symlink support. For instance...
489 *
490 * rc = CIFSSMBQueryReparseLinkInfo(...)
491 *
492 * For now, just return -EACCES when the server doesn't support posix
493 * extensions. Note that we still allow querying symlinks when posix
494 * extensions are manually disabled. We could disable these as well
495 * but there doesn't seem to be any harm in allowing the client to
496 * read them.
497 */
498 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
499 && !(tcon->ses->capabilities & CAP_UNIX)) {
500 rc = -EACCES;
501 goto out;
502 }
503
504 full_path = build_path_from_dentry(direntry);
505 if (!full_path)
506 goto out;
507
508 cFYI(1, "Full path: %s inode = 0x%p", full_path, inode);
509
510 rc = -EACCES;
511 /*
512 * First try Minshall+French Symlinks, if configured
513 * and fallback to UNIX Extensions Symlinks.
514 */
515 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
516 rc = CIFSQueryMFSymLink(xid, tcon, full_path, &target_path,
517 cifs_sb->local_nls,
518 cifs_sb->mnt_cifs_flags &
519 CIFS_MOUNT_MAP_SPECIAL_CHR);
520
521 if ((rc != 0) && (tcon->ses->capabilities & CAP_UNIX))
522 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
523 cifs_sb->local_nls);
524
525 kfree(full_path);
526out:
527 if (rc != 0) {
528 kfree(target_path);
529 target_path = ERR_PTR(rc);
530 }
531
532 FreeXid(xid);
533 if (tlink)
534 cifs_put_tlink(tlink);
535 nd_set_link(nd, target_path);
536 return NULL;
537}
538
539int
540cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
541{
542 int rc = -EOPNOTSUPP;
543 int xid;
544 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
545 struct tcon_link *tlink;
546 struct cifs_tcon *pTcon;
547 char *full_path = NULL;
548 struct inode *newinode = NULL;
549
550 xid = GetXid();
551
552 tlink = cifs_sb_tlink(cifs_sb);
553 if (IS_ERR(tlink)) {
554 rc = PTR_ERR(tlink);
555 goto symlink_exit;
556 }
557 pTcon = tlink_tcon(tlink);
558
559 full_path = build_path_from_dentry(direntry);
560 if (full_path == NULL) {
561 rc = -ENOMEM;
562 goto symlink_exit;
563 }
564
565 cFYI(1, "Full path: %s", full_path);
566 cFYI(1, "symname is %s", symname);
567
568 /* BB what if DFS and this volume is on different share? BB */
569 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
570 rc = CIFSCreateMFSymLink(xid, pTcon, full_path, symname,
571 cifs_sb);
572 else if (pTcon->unix_ext)
573 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
574 cifs_sb->local_nls);
575 /* else
576 rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
577 cifs_sb_target->local_nls); */
578
579 if (rc == 0) {
580 if (pTcon->unix_ext)
581 rc = cifs_get_inode_info_unix(&newinode, full_path,
582 inode->i_sb, xid);
583 else
584 rc = cifs_get_inode_info(&newinode, full_path, NULL,
585 inode->i_sb, xid, NULL);
586
587 if (rc != 0) {
588 cFYI(1, "Create symlink ok, getinodeinfo fail rc = %d",
589 rc);
590 } else {
591 d_instantiate(direntry, newinode);
592 }
593 }
594symlink_exit:
595 kfree(full_path);
596 cifs_put_tlink(tlink);
597 FreeXid(xid);
598 return rc;
599}
600
601void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
602{
603 char *p = nd_get_link(nd);
604 if (!IS_ERR(p))
605 kfree(p);
606}
1/*
2 * fs/cifs/link.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2008
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21#include <linux/fs.h>
22#include <linux/stat.h>
23#include <linux/slab.h>
24#include <linux/namei.h>
25#include "cifsfs.h"
26#include "cifspdu.h"
27#include "cifsglob.h"
28#include "cifsproto.h"
29#include "cifs_debug.h"
30#include "cifs_fs_sb.h"
31#include "cifs_unicode.h"
32#include "smb2proto.h"
33
34/*
35 * M-F Symlink Functions - Begin
36 */
37
38#define CIFS_MF_SYMLINK_LEN_OFFSET (4+1)
39#define CIFS_MF_SYMLINK_MD5_OFFSET (CIFS_MF_SYMLINK_LEN_OFFSET+(4+1))
40#define CIFS_MF_SYMLINK_LINK_OFFSET (CIFS_MF_SYMLINK_MD5_OFFSET+(32+1))
41#define CIFS_MF_SYMLINK_LINK_MAXLEN (1024)
42#define CIFS_MF_SYMLINK_FILE_SIZE \
43 (CIFS_MF_SYMLINK_LINK_OFFSET + CIFS_MF_SYMLINK_LINK_MAXLEN)
44
45#define CIFS_MF_SYMLINK_LEN_FORMAT "XSym\n%04u\n"
46#define CIFS_MF_SYMLINK_MD5_FORMAT "%16phN\n"
47#define CIFS_MF_SYMLINK_MD5_ARGS(md5_hash) md5_hash
48
49static int
50symlink_hash(unsigned int link_len, const char *link_str, u8 *md5_hash)
51{
52 int rc;
53 struct crypto_shash *md5 = NULL;
54 struct sdesc *sdescmd5 = NULL;
55
56 rc = cifs_alloc_hash("md5", &md5, &sdescmd5);
57 if (rc)
58 goto symlink_hash_err;
59
60 rc = crypto_shash_init(&sdescmd5->shash);
61 if (rc) {
62 cifs_dbg(VFS, "%s: Could not init md5 shash\n", __func__);
63 goto symlink_hash_err;
64 }
65 rc = crypto_shash_update(&sdescmd5->shash, link_str, link_len);
66 if (rc) {
67 cifs_dbg(VFS, "%s: Could not update with link_str\n", __func__);
68 goto symlink_hash_err;
69 }
70 rc = crypto_shash_final(&sdescmd5->shash, md5_hash);
71 if (rc)
72 cifs_dbg(VFS, "%s: Could not generate md5 hash\n", __func__);
73
74symlink_hash_err:
75 cifs_free_hash(&md5, &sdescmd5);
76 return rc;
77}
78
79static int
80parse_mf_symlink(const u8 *buf, unsigned int buf_len, unsigned int *_link_len,
81 char **_link_str)
82{
83 int rc;
84 unsigned int link_len;
85 const char *md5_str1;
86 const char *link_str;
87 u8 md5_hash[16];
88 char md5_str2[34];
89
90 if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
91 return -EINVAL;
92
93 md5_str1 = (const char *)&buf[CIFS_MF_SYMLINK_MD5_OFFSET];
94 link_str = (const char *)&buf[CIFS_MF_SYMLINK_LINK_OFFSET];
95
96 rc = sscanf(buf, CIFS_MF_SYMLINK_LEN_FORMAT, &link_len);
97 if (rc != 1)
98 return -EINVAL;
99
100 rc = symlink_hash(link_len, link_str, md5_hash);
101 if (rc) {
102 cifs_dbg(FYI, "%s: MD5 hash failure: %d\n", __func__, rc);
103 return rc;
104 }
105
106 scnprintf(md5_str2, sizeof(md5_str2),
107 CIFS_MF_SYMLINK_MD5_FORMAT,
108 CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
109
110 if (strncmp(md5_str1, md5_str2, 17) != 0)
111 return -EINVAL;
112
113 if (_link_str) {
114 *_link_str = kstrndup(link_str, link_len, GFP_KERNEL);
115 if (!*_link_str)
116 return -ENOMEM;
117 }
118
119 *_link_len = link_len;
120 return 0;
121}
122
123static int
124format_mf_symlink(u8 *buf, unsigned int buf_len, const char *link_str)
125{
126 int rc;
127 unsigned int link_len;
128 unsigned int ofs;
129 u8 md5_hash[16];
130
131 if (buf_len != CIFS_MF_SYMLINK_FILE_SIZE)
132 return -EINVAL;
133
134 link_len = strlen(link_str);
135
136 if (link_len > CIFS_MF_SYMLINK_LINK_MAXLEN)
137 return -ENAMETOOLONG;
138
139 rc = symlink_hash(link_len, link_str, md5_hash);
140 if (rc) {
141 cifs_dbg(FYI, "%s: MD5 hash failure: %d\n", __func__, rc);
142 return rc;
143 }
144
145 scnprintf(buf, buf_len,
146 CIFS_MF_SYMLINK_LEN_FORMAT CIFS_MF_SYMLINK_MD5_FORMAT,
147 link_len,
148 CIFS_MF_SYMLINK_MD5_ARGS(md5_hash));
149
150 ofs = CIFS_MF_SYMLINK_LINK_OFFSET;
151 memcpy(buf + ofs, link_str, link_len);
152
153 ofs += link_len;
154 if (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
155 buf[ofs] = '\n';
156 ofs++;
157 }
158
159 while (ofs < CIFS_MF_SYMLINK_FILE_SIZE) {
160 buf[ofs] = ' ';
161 ofs++;
162 }
163
164 return 0;
165}
166
167bool
168couldbe_mf_symlink(const struct cifs_fattr *fattr)
169{
170 if (!S_ISREG(fattr->cf_mode))
171 /* it's not a symlink */
172 return false;
173
174 if (fattr->cf_eof != CIFS_MF_SYMLINK_FILE_SIZE)
175 /* it's not a symlink */
176 return false;
177
178 return true;
179}
180
181static int
182create_mf_symlink(const unsigned int xid, struct cifs_tcon *tcon,
183 struct cifs_sb_info *cifs_sb, const char *fromName,
184 const char *toName)
185{
186 int rc;
187 u8 *buf;
188 unsigned int bytes_written = 0;
189
190 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
191 if (!buf)
192 return -ENOMEM;
193
194 rc = format_mf_symlink(buf, CIFS_MF_SYMLINK_FILE_SIZE, toName);
195 if (rc)
196 goto out;
197
198 if (tcon->ses->server->ops->create_mf_symlink)
199 rc = tcon->ses->server->ops->create_mf_symlink(xid, tcon,
200 cifs_sb, fromName, buf, &bytes_written);
201 else
202 rc = -EOPNOTSUPP;
203
204 if (rc)
205 goto out;
206
207 if (bytes_written != CIFS_MF_SYMLINK_FILE_SIZE)
208 rc = -EIO;
209out:
210 kfree(buf);
211 return rc;
212}
213
214static int
215query_mf_symlink(const unsigned int xid, struct cifs_tcon *tcon,
216 struct cifs_sb_info *cifs_sb, const unsigned char *path,
217 char **symlinkinfo)
218{
219 int rc;
220 u8 *buf = NULL;
221 unsigned int link_len = 0;
222 unsigned int bytes_read = 0;
223
224 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
225 if (!buf)
226 return -ENOMEM;
227
228 if (tcon->ses->server->ops->query_mf_symlink)
229 rc = tcon->ses->server->ops->query_mf_symlink(xid, tcon,
230 cifs_sb, path, buf, &bytes_read);
231 else
232 rc = -ENOSYS;
233
234 if (rc)
235 goto out;
236
237 if (bytes_read == 0) { /* not a symlink */
238 rc = -EINVAL;
239 goto out;
240 }
241
242 rc = parse_mf_symlink(buf, bytes_read, &link_len, symlinkinfo);
243out:
244 kfree(buf);
245 return rc;
246}
247
248int
249check_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
250 struct cifs_sb_info *cifs_sb, struct cifs_fattr *fattr,
251 const unsigned char *path)
252{
253 int rc;
254 u8 *buf = NULL;
255 unsigned int link_len = 0;
256 unsigned int bytes_read = 0;
257
258 if (!couldbe_mf_symlink(fattr))
259 /* it's not a symlink */
260 return 0;
261
262 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
263 if (!buf)
264 return -ENOMEM;
265
266 if (tcon->ses->server->ops->query_mf_symlink)
267 rc = tcon->ses->server->ops->query_mf_symlink(xid, tcon,
268 cifs_sb, path, buf, &bytes_read);
269 else
270 rc = -ENOSYS;
271
272 if (rc)
273 goto out;
274
275 if (bytes_read == 0) /* not a symlink */
276 goto out;
277
278 rc = parse_mf_symlink(buf, bytes_read, &link_len, NULL);
279 if (rc == -EINVAL) {
280 /* it's not a symlink */
281 rc = 0;
282 goto out;
283 }
284
285 if (rc != 0)
286 goto out;
287
288 /* it is a symlink */
289 fattr->cf_eof = link_len;
290 fattr->cf_mode &= ~S_IFMT;
291 fattr->cf_mode |= S_IFLNK | S_IRWXU | S_IRWXG | S_IRWXO;
292 fattr->cf_dtype = DT_LNK;
293out:
294 kfree(buf);
295 return rc;
296}
297
298/*
299 * SMB 1.0 Protocol specific functions
300 */
301
302int
303cifs_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
304 struct cifs_sb_info *cifs_sb, const unsigned char *path,
305 char *pbuf, unsigned int *pbytes_read)
306{
307 int rc;
308 int oplock = 0;
309 struct cifs_fid fid;
310 struct cifs_open_parms oparms;
311 struct cifs_io_parms io_parms = {0};
312 int buf_type = CIFS_NO_BUFFER;
313 FILE_ALL_INFO file_info;
314
315 oparms.tcon = tcon;
316 oparms.cifs_sb = cifs_sb;
317 oparms.desired_access = GENERIC_READ;
318 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
319 oparms.disposition = FILE_OPEN;
320 oparms.path = path;
321 oparms.fid = &fid;
322 oparms.reconnect = false;
323
324 rc = CIFS_open(xid, &oparms, &oplock, &file_info);
325 if (rc)
326 return rc;
327
328 if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
329 rc = -ENOENT;
330 /* it's not a symlink */
331 goto out;
332 }
333
334 io_parms.netfid = fid.netfid;
335 io_parms.pid = current->tgid;
336 io_parms.tcon = tcon;
337 io_parms.offset = 0;
338 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
339
340 rc = CIFSSMBRead(xid, &io_parms, pbytes_read, &pbuf, &buf_type);
341out:
342 CIFSSMBClose(xid, tcon, fid.netfid);
343 return rc;
344}
345
346int
347cifs_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
348 struct cifs_sb_info *cifs_sb, const unsigned char *path,
349 char *pbuf, unsigned int *pbytes_written)
350{
351 int rc;
352 int oplock = 0;
353 struct cifs_fid fid;
354 struct cifs_open_parms oparms;
355 struct cifs_io_parms io_parms = {0};
356
357 oparms.tcon = tcon;
358 oparms.cifs_sb = cifs_sb;
359 oparms.desired_access = GENERIC_WRITE;
360 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
361 oparms.disposition = FILE_CREATE;
362 oparms.path = path;
363 oparms.fid = &fid;
364 oparms.reconnect = false;
365
366 rc = CIFS_open(xid, &oparms, &oplock, NULL);
367 if (rc)
368 return rc;
369
370 io_parms.netfid = fid.netfid;
371 io_parms.pid = current->tgid;
372 io_parms.tcon = tcon;
373 io_parms.offset = 0;
374 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
375
376 rc = CIFSSMBWrite(xid, &io_parms, pbytes_written, pbuf);
377 CIFSSMBClose(xid, tcon, fid.netfid);
378 return rc;
379}
380
381/*
382 * SMB 2.1/SMB3 Protocol specific functions
383 */
384int
385smb3_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
386 struct cifs_sb_info *cifs_sb, const unsigned char *path,
387 char *pbuf, unsigned int *pbytes_read)
388{
389 int rc;
390 struct cifs_fid fid;
391 struct cifs_open_parms oparms;
392 struct cifs_io_parms io_parms = {0};
393 int buf_type = CIFS_NO_BUFFER;
394 __le16 *utf16_path;
395 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
396 struct smb2_file_all_info *pfile_info = NULL;
397
398 oparms.tcon = tcon;
399 oparms.cifs_sb = cifs_sb;
400 oparms.desired_access = GENERIC_READ;
401 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
402 oparms.disposition = FILE_OPEN;
403 oparms.fid = &fid;
404 oparms.reconnect = false;
405
406 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
407 if (utf16_path == NULL)
408 return -ENOMEM;
409
410 pfile_info = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
411 GFP_KERNEL);
412
413 if (pfile_info == NULL) {
414 kfree(utf16_path);
415 return -ENOMEM;
416 }
417
418 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, pfile_info, NULL,
419 NULL, NULL);
420 if (rc)
421 goto qmf_out_open_fail;
422
423 if (pfile_info->EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
424 /* it's not a symlink */
425 rc = -ENOENT; /* Is there a better rc to return? */
426 goto qmf_out;
427 }
428
429 io_parms.netfid = fid.netfid;
430 io_parms.pid = current->tgid;
431 io_parms.tcon = tcon;
432 io_parms.offset = 0;
433 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
434 io_parms.persistent_fid = fid.persistent_fid;
435 io_parms.volatile_fid = fid.volatile_fid;
436 rc = SMB2_read(xid, &io_parms, pbytes_read, &pbuf, &buf_type);
437qmf_out:
438 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
439qmf_out_open_fail:
440 kfree(utf16_path);
441 kfree(pfile_info);
442 return rc;
443}
444
445int
446smb3_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
447 struct cifs_sb_info *cifs_sb, const unsigned char *path,
448 char *pbuf, unsigned int *pbytes_written)
449{
450 int rc;
451 struct cifs_fid fid;
452 struct cifs_open_parms oparms;
453 struct cifs_io_parms io_parms = {0};
454 __le16 *utf16_path;
455 __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
456 struct kvec iov[2];
457
458 cifs_dbg(FYI, "%s: path: %s\n", __func__, path);
459
460 utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
461 if (!utf16_path)
462 return -ENOMEM;
463
464 oparms.tcon = tcon;
465 oparms.cifs_sb = cifs_sb;
466 oparms.desired_access = GENERIC_WRITE;
467 oparms.create_options = cifs_create_options(cifs_sb, CREATE_NOT_DIR);
468 oparms.disposition = FILE_CREATE;
469 oparms.fid = &fid;
470 oparms.reconnect = false;
471
472 rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL,
473 NULL, NULL);
474 if (rc) {
475 kfree(utf16_path);
476 return rc;
477 }
478
479 io_parms.netfid = fid.netfid;
480 io_parms.pid = current->tgid;
481 io_parms.tcon = tcon;
482 io_parms.offset = 0;
483 io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
484 io_parms.persistent_fid = fid.persistent_fid;
485 io_parms.volatile_fid = fid.volatile_fid;
486
487 /* iov[0] is reserved for smb header */
488 iov[1].iov_base = pbuf;
489 iov[1].iov_len = CIFS_MF_SYMLINK_FILE_SIZE;
490
491 rc = SMB2_write(xid, &io_parms, pbytes_written, iov, 1);
492
493 /* Make sure we wrote all of the symlink data */
494 if ((rc == 0) && (*pbytes_written != CIFS_MF_SYMLINK_FILE_SIZE))
495 rc = -EIO;
496
497 SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
498
499 kfree(utf16_path);
500 return rc;
501}
502
503/*
504 * M-F Symlink Functions - End
505 */
506
507int
508cifs_hardlink(struct dentry *old_file, struct inode *inode,
509 struct dentry *direntry)
510{
511 int rc = -EACCES;
512 unsigned int xid;
513 char *from_name = NULL;
514 char *to_name = NULL;
515 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
516 struct tcon_link *tlink;
517 struct cifs_tcon *tcon;
518 struct TCP_Server_Info *server;
519 struct cifsInodeInfo *cifsInode;
520
521 tlink = cifs_sb_tlink(cifs_sb);
522 if (IS_ERR(tlink))
523 return PTR_ERR(tlink);
524 tcon = tlink_tcon(tlink);
525
526 xid = get_xid();
527
528 from_name = build_path_from_dentry(old_file);
529 to_name = build_path_from_dentry(direntry);
530 if ((from_name == NULL) || (to_name == NULL)) {
531 rc = -ENOMEM;
532 goto cifs_hl_exit;
533 }
534
535 if (tcon->unix_ext)
536 rc = CIFSUnixCreateHardLink(xid, tcon, from_name, to_name,
537 cifs_sb->local_nls,
538 cifs_remap(cifs_sb));
539 else {
540 server = tcon->ses->server;
541 if (!server->ops->create_hardlink) {
542 rc = -ENOSYS;
543 goto cifs_hl_exit;
544 }
545 rc = server->ops->create_hardlink(xid, tcon, from_name, to_name,
546 cifs_sb);
547 if ((rc == -EIO) || (rc == -EINVAL))
548 rc = -EOPNOTSUPP;
549 }
550
551 d_drop(direntry); /* force new lookup from server of target */
552
553 /*
554 * if source file is cached (oplocked) revalidate will not go to server
555 * until the file is closed or oplock broken so update nlinks locally
556 */
557 if (d_really_is_positive(old_file)) {
558 cifsInode = CIFS_I(d_inode(old_file));
559 if (rc == 0) {
560 spin_lock(&d_inode(old_file)->i_lock);
561 inc_nlink(d_inode(old_file));
562 spin_unlock(&d_inode(old_file)->i_lock);
563
564 /*
565 * parent dir timestamps will update from srv within a
566 * second, would it really be worth it to set the parent
567 * dir cifs inode time to zero to force revalidate
568 * (faster) for it too?
569 */
570 }
571 /*
572 * if not oplocked will force revalidate to get info on source
573 * file from srv. Note Samba server prior to 4.2 has bug -
574 * not updating src file ctime on hardlinks but Windows servers
575 * handle it properly
576 */
577 cifsInode->time = 0;
578
579 /*
580 * Will update parent dir timestamps from srv within a second.
581 * Would it really be worth it to set the parent dir (cifs
582 * inode) time field to zero to force revalidate on parent
583 * directory faster ie
584 *
585 * CIFS_I(inode)->time = 0;
586 */
587 }
588
589cifs_hl_exit:
590 kfree(from_name);
591 kfree(to_name);
592 free_xid(xid);
593 cifs_put_tlink(tlink);
594 return rc;
595}
596
597const char *
598cifs_get_link(struct dentry *direntry, struct inode *inode,
599 struct delayed_call *done)
600{
601 int rc = -ENOMEM;
602 unsigned int xid;
603 char *full_path = NULL;
604 char *target_path = NULL;
605 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
606 struct tcon_link *tlink = NULL;
607 struct cifs_tcon *tcon;
608 struct TCP_Server_Info *server;
609
610 if (!direntry)
611 return ERR_PTR(-ECHILD);
612
613 xid = get_xid();
614
615 tlink = cifs_sb_tlink(cifs_sb);
616 if (IS_ERR(tlink)) {
617 free_xid(xid);
618 return ERR_CAST(tlink);
619 }
620 tcon = tlink_tcon(tlink);
621 server = tcon->ses->server;
622
623 full_path = build_path_from_dentry(direntry);
624 if (!full_path) {
625 free_xid(xid);
626 cifs_put_tlink(tlink);
627 return ERR_PTR(-ENOMEM);
628 }
629
630 cifs_dbg(FYI, "Full path: %s inode = 0x%p\n", full_path, inode);
631
632 rc = -EACCES;
633 /*
634 * First try Minshall+French Symlinks, if configured
635 * and fallback to UNIX Extensions Symlinks.
636 */
637 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
638 rc = query_mf_symlink(xid, tcon, cifs_sb, full_path,
639 &target_path);
640
641 if (rc != 0 && server->ops->query_symlink) {
642 struct cifsInodeInfo *cifsi = CIFS_I(inode);
643 bool reparse_point = false;
644
645 if (cifsi->cifsAttrs & ATTR_REPARSE)
646 reparse_point = true;
647
648 rc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path,
649 &target_path, reparse_point);
650 }
651
652 kfree(full_path);
653 free_xid(xid);
654 cifs_put_tlink(tlink);
655 if (rc != 0) {
656 kfree(target_path);
657 return ERR_PTR(rc);
658 }
659 set_delayed_call(done, kfree_link, target_path);
660 return target_path;
661}
662
663int
664cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
665{
666 int rc = -EOPNOTSUPP;
667 unsigned int xid;
668 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
669 struct tcon_link *tlink;
670 struct cifs_tcon *pTcon;
671 char *full_path = NULL;
672 struct inode *newinode = NULL;
673
674 xid = get_xid();
675
676 tlink = cifs_sb_tlink(cifs_sb);
677 if (IS_ERR(tlink)) {
678 rc = PTR_ERR(tlink);
679 goto symlink_exit;
680 }
681 pTcon = tlink_tcon(tlink);
682
683 full_path = build_path_from_dentry(direntry);
684 if (full_path == NULL) {
685 rc = -ENOMEM;
686 goto symlink_exit;
687 }
688
689 cifs_dbg(FYI, "Full path: %s\n", full_path);
690 cifs_dbg(FYI, "symname is %s\n", symname);
691
692 /* BB what if DFS and this volume is on different share? BB */
693 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
694 rc = create_mf_symlink(xid, pTcon, cifs_sb, full_path, symname);
695 else if (pTcon->unix_ext)
696 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
697 cifs_sb->local_nls,
698 cifs_remap(cifs_sb));
699 /* else
700 rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
701 cifs_sb_target->local_nls); */
702
703 if (rc == 0) {
704 if (pTcon->posix_extensions)
705 rc = smb311_posix_get_inode_info(&newinode, full_path, inode->i_sb, xid);
706 else if (pTcon->unix_ext)
707 rc = cifs_get_inode_info_unix(&newinode, full_path,
708 inode->i_sb, xid);
709 else
710 rc = cifs_get_inode_info(&newinode, full_path, NULL,
711 inode->i_sb, xid, NULL);
712
713 if (rc != 0) {
714 cifs_dbg(FYI, "Create symlink ok, getinodeinfo fail rc = %d\n",
715 rc);
716 } else {
717 d_instantiate(direntry, newinode);
718 }
719 }
720symlink_exit:
721 kfree(full_path);
722 cifs_put_tlink(tlink);
723 free_xid(xid);
724 return rc;
725}