blob: e6ce3b1128756be4496494b2623fab27fa0d165f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/link.c
3 *
Steve French366781c2008-01-25 10:12:41 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090023#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#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"
Stefan Metzmacherc69c1b62010-07-31 09:14:16 +020031
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
Steve French93c100c2011-01-25 19:28:43 +000049symlink_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);
Shirish Pargaonkaree2c9252011-01-27 09:58:04 -060057 if (IS_ERR(md5)) {
Jeff Laytonffeb4142011-01-29 07:03:02 -050058 rc = PTR_ERR(md5);
Jeff Laytonac3aa2f2012-07-23 13:14:28 -040059 cERROR(1, "%s: Crypto md5 allocation error %d", __func__, rc);
Jeff Laytonffeb4142011-01-29 07:03:02 -050060 return rc;
Steve French93c100c2011-01-25 19:28:43 +000061 }
62 size = sizeof(struct shash_desc) + crypto_shash_descsize(md5);
63 sdescmd5 = kmalloc(size, GFP_KERNEL);
64 if (!sdescmd5) {
65 rc = -ENOMEM;
Jeff Laytonac3aa2f2012-07-23 13:14:28 -040066 cERROR(1, "%s: Memory allocation failure", __func__);
Steve French93c100c2011-01-25 19:28:43 +000067 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) {
Jeff Laytonac3aa2f2012-07-23 13:14:28 -040074 cERROR(1, "%s: Could not init md5 shash", __func__);
Steve French93c100c2011-01-25 19:28:43 +000075 goto symlink_hash_err;
76 }
Shirish Pargaonkar14cae322011-06-20 16:14:03 -050077 rc = crypto_shash_update(&sdescmd5->shash, link_str, link_len);
78 if (rc) {
Jeff Laytonac3aa2f2012-07-23 13:14:28 -040079 cERROR(1, "%s: Could not update iwth link_str", __func__);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -050080 goto symlink_hash_err;
81 }
Steve French93c100c2011-01-25 19:28:43 +000082 rc = crypto_shash_final(&sdescmd5->shash, md5_hash);
Shirish Pargaonkar14cae322011-06-20 16:14:03 -050083 if (rc)
Jeff Laytonac3aa2f2012-07-23 13:14:28 -040084 cERROR(1, "%s: Could not generate md5 hash", __func__);
Steve French93c100c2011-01-25 19:28:43 +000085
86symlink_hash_err:
87 crypto_free_shash(md5);
88 kfree(sdescmd5);
89
90 return rc;
91}
92
93static int
Stefan Metzmacherc69c1b62010-07-31 09:14:16 +020094CIFSParseMFSymlink(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;
Stefan Metzmacherc69c1b62010-07-31 09:14:16 +0200103 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
Steve French93c100c2011-01-25 19:28:43 +0000116 rc = symlink_hash(link_len, link_str, md5_hash);
117 if (rc) {
Jeff Laytonac3aa2f2012-07-23 13:14:28 -0400118 cFYI(1, "%s: MD5 hash failure: %d", __func__, rc);
Steve French93c100c2011-01-25 19:28:43 +0000119 return rc;
120 }
Stefan Metzmacherc69c1b62010-07-31 09:14:16 +0200121
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}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Stefan Metzmacher0fd43ae2010-08-05 21:13:44 +0200139static int
Stefan Metzmacher18bddd12010-08-03 11:24:22 +0200140CIFSFormatMFSymlink(u8 *buf, unsigned int buf_len, const char *link_str)
141{
Steve French93c100c2011-01-25 19:28:43 +0000142 int rc;
Stefan Metzmacher18bddd12010-08-03 11:24:22 +0200143 unsigned int link_len;
144 unsigned int ofs;
Stefan Metzmacher18bddd12010-08-03 11:24:22 +0200145 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
Steve French93c100c2011-01-25 19:28:43 +0000155 rc = symlink_hash(link_len, link_str, md5_hash);
156 if (rc) {
Jeff Laytonac3aa2f2012-07-23 13:14:28 -0400157 cFYI(1, "%s: MD5 hash failure: %d", __func__, rc);
Steve French93c100c2011-01-25 19:28:43 +0000158 return rc;
159 }
Stefan Metzmacher18bddd12010-08-03 11:24:22 +0200160
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
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200183static int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400184CIFSCreateMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200185 const char *fromName, const char *toName,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500186 struct cifs_sb_info *cifs_sb)
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200187{
188 int rc;
189 int oplock = 0;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500190 int remap;
191 int create_options = CREATE_NOT_DIR;
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200192 __u16 netfid = 0;
193 u8 *buf;
194 unsigned int bytes_written = 0;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400195 struct cifs_io_parms io_parms;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500196 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;
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200200
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
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500211 if (backup_cred(cifs_sb))
212 create_options |= CREATE_OPEN_BACKUP_INTENT;
213
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200214 rc = CIFSSMBOpen(xid, tcon, fromName, FILE_CREATE, GENERIC_WRITE,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500215 create_options, &netfid, &oplock, NULL,
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200216 nls_codepage, remap);
217 if (rc != 0) {
218 kfree(buf);
219 return rc;
220 }
221
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +0400222 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);
Stefan Metzmacher8713d012010-08-05 21:15:22 +0200229 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
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400241CIFSQueryMFSymLink(const unsigned int xid, struct cifs_tcon *tcon,
Stefan Metzmacher0fd43ae2010-08-05 21:13:44 +0200242 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;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000253 struct cifs_io_parms io_parms;
Stefan Metzmacher0fd43ae2010-08-05 21:13:44 +0200254 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
Steve French5443d132011-03-13 05:08:25 +0000262 if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
Stefan Metzmacher0fd43ae2010-08-05 21:13:44 +0200263 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;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000272 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;
Stefan Metzmacher0fd43ae2010-08-05 21:13:44 +0200277
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000278 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
Stefan Metzmacher0fd43ae2010-08-05 21:13:44 +0200279 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
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200293bool
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,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400310 struct cifs_sb_info *cifs_sb, unsigned int xid)
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200311{
312 int rc;
313 int oplock = 0;
314 __u16 netfid = 0;
Jeff Layton7ffec372010-09-29 19:51:11 -0400315 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000316 struct cifs_tcon *pTcon;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000317 struct cifs_io_parms io_parms;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200318 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
Jeff Layton7ffec372010-09-29 19:51:11 -0400329 tlink = cifs_sb_tlink(cifs_sb);
330 if (IS_ERR(tlink))
331 return PTR_ERR(tlink);
332 pTcon = tlink_tcon(tlink);
333
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200334 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)
Jeff Layton7ffec372010-09-29 19:51:11 -0400340 goto out;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200341
Steve French5443d132011-03-13 05:08:25 +0000342 if (file_info.EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200343 CIFSSMBClose(xid, pTcon, netfid);
344 /* it's not a symlink */
Jeff Layton7ffec372010-09-29 19:51:11 -0400345 goto out;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200346 }
347
348 buf = kmalloc(CIFS_MF_SYMLINK_FILE_SIZE, GFP_KERNEL);
Jeff Layton7ffec372010-09-29 19:51:11 -0400349 if (!buf) {
350 rc = -ENOMEM;
351 goto out;
352 }
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200353 pbuf = buf;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000354 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;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200359
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +0000360 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf, &buf_type);
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200361 CIFSSMBClose(xid, pTcon, netfid);
362 if (rc != 0) {
363 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400364 goto out;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200365 }
366
367 rc = CIFSParseMFSymlink(buf, bytes_read, &link_len, NULL);
368 kfree(buf);
Jeff Layton7ffec372010-09-29 19:51:11 -0400369 if (rc == -EINVAL) {
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200370 /* it's not a symlink */
Jeff Layton7ffec372010-09-29 19:51:11 -0400371 rc = 0;
372 goto out;
373 }
374
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200375 if (rc != 0)
Jeff Layton7ffec372010-09-29 19:51:11 -0400376 goto out;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200377
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;
Jeff Layton7ffec372010-09-29 19:51:11 -0400383out:
384 cifs_put_tlink(tlink);
385 return rc;
Stefan Metzmacher8bfb50a2010-07-31 09:15:10 +0200386}
387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388int
389cifs_hardlink(struct dentry *old_file, struct inode *inode,
390 struct dentry *direntry)
391{
392 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400393 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 char *fromName = NULL;
395 char *toName = NULL;
Jeff Layton7ffec372010-09-29 19:51:11 -0400396 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
397 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000398 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 struct cifsInodeInfo *cifsInode;
400
Jeff Layton7ffec372010-09-29 19:51:11 -0400401 tlink = cifs_sb_tlink(cifs_sb);
402 if (IS_ERR(tlink))
403 return PTR_ERR(tlink);
404 pTcon = tlink_tcon(tlink);
405
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400406 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407
Steve French7f573562005-08-30 11:32:14 -0700408 fromName = build_path_from_dentry(old_file);
409 toName = build_path_from_dentry(direntry);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000410 if ((fromName == NULL) || (toName == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 rc = -ENOMEM;
412 goto cifs_hl_exit;
413 }
414
Steve Frenchc18c8422007-07-18 23:21:09 +0000415 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 rc = CIFSUnixCreateHardLink(xid, pTcon, fromName, toName,
Jeff Layton7ffec372010-09-29 19:51:11 -0400417 cifs_sb->local_nls,
418 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700419 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 else {
421 rc = CIFSCreateHardLink(xid, pTcon, fromName, toName,
Jeff Layton7ffec372010-09-29 19:51:11 -0400422 cifs_sb->local_nls,
423 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700424 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000425 if ((rc == -EIO) || (rc == -EINVAL))
426 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 }
428
Steve French31ec35d2006-11-16 20:54:20 +0000429 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 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000433 if (old_file->d_inode) {
Steve French31ec35d2006-11-16 20:54:20 +0000434 cifsInode = CIFS_I(old_file->d_inode);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000435 if (rc == 0) {
Steve Frenchb7ca6922012-08-03 08:43:01 -0500436 spin_lock(&old_file->d_inode->i_lock);
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200437 inc_nlink(old_file->d_inode);
Steve Frenchb7ca6922012-08-03 08:43:01 -0500438 spin_unlock(&old_file->d_inode->i_lock);
Steve French1b2b2122007-02-17 04:30:54 +0000439/* BB should we make this contingent on superblock flag NOATIME? */
440/* old_file->d_inode->i_ctime = CURRENT_TIME;*/
Steve French31ec35d2006-11-16 20:54:20 +0000441 /* parent dir timestamps will update from srv
442 within a second, would it really be worth it
443 to set the parent dir cifs inode time to zero
444 to force revalidate (faster) for it too? */
445 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000446 /* if not oplocked will force revalidate to get info
Steve French31ec35d2006-11-16 20:54:20 +0000447 on source file from srv */
448 cifsInode->time = 0;
449
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000450 /* Will update parent dir timestamps from srv within a second.
Steve French31ec35d2006-11-16 20:54:20 +0000451 Would it really be worth it to set the parent dir (cifs
452 inode) time field to zero to force revalidate on parent
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000453 directory faster ie
Steve French31ec35d2006-11-16 20:54:20 +0000454 CIFS_I(inode)->time = 0; */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457cifs_hl_exit:
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800458 kfree(fromName);
459 kfree(toName);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400460 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400461 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 return rc;
463}
464
Linus Torvaldscc314ee2005-08-19 18:02:56 -0700465void *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
467{
468 struct inode *inode = direntry->d_inode;
Jeff Layton8b6427a2009-05-19 09:57:03 -0400469 int rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400470 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 char *full_path = NULL;
Jeff Layton8b6427a2009-05-19 09:57:03 -0400472 char *target_path = NULL;
473 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400474 struct tcon_link *tlink = NULL;
Steve French96daf2b2011-05-27 04:34:02 +0000475 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400477 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Jeff Layton7ffec372010-09-29 19:51:11 -0400479 tlink = cifs_sb_tlink(cifs_sb);
480 if (IS_ERR(tlink)) {
481 rc = PTR_ERR(tlink);
482 tlink = NULL;
483 goto out;
484 }
485 tcon = tlink_tcon(tlink);
486
Jeff Layton8b6427a2009-05-19 09:57:03 -0400487 /*
488 * For now, we just handle symlinks with unix extensions enabled.
489 * Eventually we should handle NTFS reparse points, and MacOS
490 * symlink support. For instance...
491 *
492 * rc = CIFSSMBQueryReparseLinkInfo(...)
493 *
494 * For now, just return -EACCES when the server doesn't support posix
495 * extensions. Note that we still allow querying symlinks when posix
496 * extensions are manually disabled. We could disable these as well
497 * but there doesn't seem to be any harm in allowing the client to
498 * read them.
499 */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400500 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
501 !cap_unix(tcon->ses)) {
Jeff Layton8b6427a2009-05-19 09:57:03 -0400502 rc = -EACCES;
503 goto out;
504 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Jeff Layton8b6427a2009-05-19 09:57:03 -0400506 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 if (!full_path)
Jeff Layton460b9692009-04-30 07:17:56 -0400508 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Joe Perchesb6b38f72010-04-21 03:50:45 +0000510 cFYI(1, "Full path: %s inode = 0x%p", full_path, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200512 rc = -EACCES;
513 /*
514 * First try Minshall+French Symlinks, if configured
515 * and fallback to UNIX Extensions Symlinks.
516 */
517 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
518 rc = CIFSQueryMFSymLink(xid, tcon, full_path, &target_path,
519 cifs_sb->local_nls,
520 cifs_sb->mnt_cifs_flags &
521 CIFS_MOUNT_MAP_SPECIAL_CHR);
522
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400523 if ((rc != 0) && cap_unix(tcon->ses))
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200524 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
525 cifs_sb->local_nls);
526
Jeff Layton8b6427a2009-05-19 09:57:03 -0400527 kfree(full_path);
528out:
Jeff Layton460b9692009-04-30 07:17:56 -0400529 if (rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 kfree(target_path);
531 target_path = ERR_PTR(rc);
532 }
533
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400534 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400535 if (tlink)
536 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 nd_set_link(nd, target_path);
Jeff Layton460b9692009-04-30 07:17:56 -0400538 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539}
540
541int
542cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
543{
544 int rc = -EOPNOTSUPP;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400545 unsigned int xid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400546 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
547 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000548 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 char *full_path = NULL;
550 struct inode *newinode = NULL;
551
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400552 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
Jeff Layton7ffec372010-09-29 19:51:11 -0400554 tlink = cifs_sb_tlink(cifs_sb);
555 if (IS_ERR(tlink)) {
556 rc = PTR_ERR(tlink);
557 goto symlink_exit;
558 }
559 pTcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560
Steve French7f573562005-08-30 11:32:14 -0700561 full_path = build_path_from_dentry(direntry);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000562 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530563 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -0400564 goto symlink_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 }
566
Joe Perchesb6b38f72010-04-21 03:50:45 +0000567 cFYI(1, "Full path: %s", full_path);
568 cFYI(1, "symname is %s", symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 /* BB what if DFS and this volume is on different share? BB */
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200571 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
572 rc = CIFSCreateMFSymLink(xid, pTcon, full_path, symname,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500573 cifs_sb);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200574 else if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
576 cifs_sb->local_nls);
577 /* else
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000578 rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
579 cifs_sb_target->local_nls); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 if (rc == 0) {
Steve Frenchc18c8422007-07-18 23:21:09 +0000582 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000584 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 else
586 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +0000587 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
589 if (rc != 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000590 cFYI(1, "Create symlink ok, getinodeinfo fail rc = %d",
591 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 d_instantiate(direntry, newinode);
594 }
595 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400596symlink_exit:
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800597 kfree(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -0400598 cifs_put_tlink(tlink);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400599 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 return rc;
601}
602
Linus Torvaldscc314ee2005-08-19 18:02:56 -0700603void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
605 char *p = nd_get_link(nd);
606 if (!IS_ERR(p))
607 kfree(p);
608}