blob: 51dc2fb6e854a724b16b782b6ab514446b8db7f5 [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;
Steve Frenchd6e906f2012-09-18 16:20:31 -0700394 char *from_name = NULL;
395 char *to_name = 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 Frenchd6e906f2012-09-18 16:20:31 -0700398 struct cifs_tcon *tcon;
399 struct TCP_Server_Info *server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 struct cifsInodeInfo *cifsInode;
401
Jeff Layton7ffec372010-09-29 19:51:11 -0400402 tlink = cifs_sb_tlink(cifs_sb);
403 if (IS_ERR(tlink))
404 return PTR_ERR(tlink);
Steve Frenchd6e906f2012-09-18 16:20:31 -0700405 tcon = tlink_tcon(tlink);
Jeff Layton7ffec372010-09-29 19:51:11 -0400406
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400407 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Steve Frenchd6e906f2012-09-18 16:20:31 -0700409 from_name = build_path_from_dentry(old_file);
410 to_name = build_path_from_dentry(direntry);
411 if ((from_name == NULL) || (to_name == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 rc = -ENOMEM;
413 goto cifs_hl_exit;
414 }
415
Steve Frenchd6e906f2012-09-18 16:20:31 -0700416 if (tcon->unix_ext)
417 rc = CIFSUnixCreateHardLink(xid, tcon, from_name, to_name,
Jeff Layton7ffec372010-09-29 19:51:11 -0400418 cifs_sb->local_nls,
419 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700420 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 else {
Steve Frenchd6e906f2012-09-18 16:20:31 -0700422 server = tcon->ses->server;
423 if (!server->ops->create_hardlink)
424 return -ENOSYS;
425 rc = server->ops->create_hardlink(xid, tcon, from_name, to_name,
426 cifs_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000427 if ((rc == -EIO) || (rc == -EINVAL))
428 rc = -EOPNOTSUPP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 }
430
Steve French31ec35d2006-11-16 20:54:20 +0000431 d_drop(direntry); /* force new lookup from server of target */
432
Steve Frenchd6e906f2012-09-18 16:20:31 -0700433 /*
434 * if source file is cached (oplocked) revalidate will not go to server
435 * until the file is closed or oplock broken so update nlinks locally
436 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000437 if (old_file->d_inode) {
Steve French31ec35d2006-11-16 20:54:20 +0000438 cifsInode = CIFS_I(old_file->d_inode);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000439 if (rc == 0) {
Steve Frenchb7ca6922012-08-03 08:43:01 -0500440 spin_lock(&old_file->d_inode->i_lock);
Miklos Szeredi6d6b77f2011-10-28 14:13:28 +0200441 inc_nlink(old_file->d_inode);
Steve Frenchb7ca6922012-08-03 08:43:01 -0500442 spin_unlock(&old_file->d_inode->i_lock);
Steve Frenchd6e906f2012-09-18 16:20:31 -0700443 /*
444 * BB should we make this contingent on superblock flag
445 * NOATIME?
446 */
447 /* old_file->d_inode->i_ctime = CURRENT_TIME; */
448 /*
449 * parent dir timestamps will update from srv within a
450 * second, would it really be worth it to set the parent
451 * dir cifs inode time to zero to force revalidate
452 * (faster) for it too?
453 */
Steve French31ec35d2006-11-16 20:54:20 +0000454 }
Steve Frenchd6e906f2012-09-18 16:20:31 -0700455 /*
456 * if not oplocked will force revalidate to get info on source
457 * file from srv
458 */
Steve French31ec35d2006-11-16 20:54:20 +0000459 cifsInode->time = 0;
460
Steve Frenchd6e906f2012-09-18 16:20:31 -0700461 /*
462 * Will update parent dir timestamps from srv within a second.
463 * Would it really be worth it to set the parent dir (cifs
464 * inode) time field to zero to force revalidate on parent
465 * directory faster ie
466 *
467 * CIFS_I(inode)->time = 0;
468 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
471cifs_hl_exit:
Steve Frenchd6e906f2012-09-18 16:20:31 -0700472 kfree(from_name);
473 kfree(to_name);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400474 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400475 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 return rc;
477}
478
Linus Torvaldscc314ee2005-08-19 18:02:56 -0700479void *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480cifs_follow_link(struct dentry *direntry, struct nameidata *nd)
481{
482 struct inode *inode = direntry->d_inode;
Jeff Layton8b6427a2009-05-19 09:57:03 -0400483 int rc = -ENOMEM;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400484 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 char *full_path = NULL;
Jeff Layton8b6427a2009-05-19 09:57:03 -0400486 char *target_path = NULL;
487 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400488 struct tcon_link *tlink = NULL;
Steve French96daf2b2011-05-27 04:34:02 +0000489 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400491 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492
Jeff Layton7ffec372010-09-29 19:51:11 -0400493 tlink = cifs_sb_tlink(cifs_sb);
494 if (IS_ERR(tlink)) {
495 rc = PTR_ERR(tlink);
496 tlink = NULL;
497 goto out;
498 }
499 tcon = tlink_tcon(tlink);
500
Jeff Layton8b6427a2009-05-19 09:57:03 -0400501 /*
502 * For now, we just handle symlinks with unix extensions enabled.
503 * Eventually we should handle NTFS reparse points, and MacOS
504 * symlink support. For instance...
505 *
506 * rc = CIFSSMBQueryReparseLinkInfo(...)
507 *
508 * For now, just return -EACCES when the server doesn't support posix
509 * extensions. Note that we still allow querying symlinks when posix
510 * extensions are manually disabled. We could disable these as well
511 * but there doesn't seem to be any harm in allowing the client to
512 * read them.
513 */
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400514 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) &&
515 !cap_unix(tcon->ses)) {
Jeff Layton8b6427a2009-05-19 09:57:03 -0400516 rc = -EACCES;
517 goto out;
518 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Jeff Layton8b6427a2009-05-19 09:57:03 -0400520 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 if (!full_path)
Jeff Layton460b9692009-04-30 07:17:56 -0400522 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
Joe Perchesb6b38f72010-04-21 03:50:45 +0000524 cFYI(1, "Full path: %s inode = 0x%p", full_path, inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200526 rc = -EACCES;
527 /*
528 * First try Minshall+French Symlinks, if configured
529 * and fallback to UNIX Extensions Symlinks.
530 */
531 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
532 rc = CIFSQueryMFSymLink(xid, tcon, full_path, &target_path,
533 cifs_sb->local_nls,
534 cifs_sb->mnt_cifs_flags &
535 CIFS_MOUNT_MAP_SPECIAL_CHR);
536
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400537 if ((rc != 0) && cap_unix(tcon->ses))
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200538 rc = CIFSSMBUnixQuerySymLink(xid, tcon, full_path, &target_path,
539 cifs_sb->local_nls);
540
Jeff Layton8b6427a2009-05-19 09:57:03 -0400541 kfree(full_path);
542out:
Jeff Layton460b9692009-04-30 07:17:56 -0400543 if (rc != 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 kfree(target_path);
545 target_path = ERR_PTR(rc);
546 }
547
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400548 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400549 if (tlink)
550 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 nd_set_link(nd, target_path);
Jeff Layton460b9692009-04-30 07:17:56 -0400552 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553}
554
555int
556cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
557{
558 int rc = -EOPNOTSUPP;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400559 unsigned int xid;
Jeff Layton7ffec372010-09-29 19:51:11 -0400560 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
561 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000562 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 char *full_path = NULL;
564 struct inode *newinode = NULL;
565
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400566 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567
Jeff Layton7ffec372010-09-29 19:51:11 -0400568 tlink = cifs_sb_tlink(cifs_sb);
569 if (IS_ERR(tlink)) {
570 rc = PTR_ERR(tlink);
571 goto symlink_exit;
572 }
573 pTcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574
Steve French7f573562005-08-30 11:32:14 -0700575 full_path = build_path_from_dentry(direntry);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000576 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530577 rc = -ENOMEM;
Jeff Layton7ffec372010-09-29 19:51:11 -0400578 goto symlink_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579 }
580
Joe Perchesb6b38f72010-04-21 03:50:45 +0000581 cFYI(1, "Full path: %s", full_path);
582 cFYI(1, "symname is %s", symname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 /* BB what if DFS and this volume is on different share? BB */
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200585 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
586 rc = CIFSCreateMFSymLink(xid, pTcon, full_path, symname,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500587 cifs_sb);
Stefan Metzmacher1b12b9c2010-08-05 21:19:56 +0200588 else if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
590 cifs_sb->local_nls);
591 /* else
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000592 rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
593 cifs_sb_target->local_nls); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594
595 if (rc == 0) {
Steve Frenchc18c8422007-07-18 23:21:09 +0000596 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000598 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 else
600 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +0000601 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602
603 if (rc != 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000604 cFYI(1, "Create symlink ok, getinodeinfo fail rc = %d",
605 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 d_instantiate(direntry, newinode);
608 }
609 }
Jeff Layton7ffec372010-09-29 19:51:11 -0400610symlink_exit:
Jesper Juhlf99d49a2005-11-07 01:01:34 -0800611 kfree(full_path);
Jeff Layton7ffec372010-09-29 19:51:11 -0400612 cifs_put_tlink(tlink);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400613 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 return rc;
615}
616
Linus Torvaldscc314ee2005-08-19 18:02:56 -0700617void cifs_put_link(struct dentry *direntry, struct nameidata *nd, void *cookie)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
619 char *p = nd_get_link(nd);
620 if (!IS_ERR(p))
621 kfree(p);
622}