~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/link.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 49 static int
 50 symlink_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 
 74 symlink_hash_err:
 75         cifs_free_hash(&md5, &sdescmd5);
 76         return rc;
 77 }
 78 
 79 static int
 80 parse_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 
123 static int
124 format_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 
167 bool
168 couldbe_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 
181 static int
182 create_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;
209 out:
210         kfree(buf);
211         return rc;
212 }
213 
214 static int
215 query_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);
243 out:
244         kfree(buf);
245         return rc;
246 }
247 
248 int
249 check_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;
293 out:
294         kfree(buf);
295         return rc;
296 }
297 
298 /*
299  * SMB 1.0 Protocol specific functions
300  */
301 
302 int
303 cifs_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;
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 = 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);
341 out:
342         CIFSSMBClose(xid, tcon, fid.netfid);
343         return rc;
344 }
345 
346 int
347 cifs_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;
356         int create_options = CREATE_NOT_DIR;
357 
358         if (backup_cred(cifs_sb))
359                 create_options |= CREATE_OPEN_BACKUP_INTENT;
360 
361         oparms.tcon = tcon;
362         oparms.cifs_sb = cifs_sb;
363         oparms.desired_access = GENERIC_WRITE;
364         oparms.create_options = create_options;
365         oparms.disposition = FILE_CREATE;
366         oparms.path = path;
367         oparms.fid = &fid;
368         oparms.reconnect = false;
369 
370         rc = CIFS_open(xid, &oparms, &oplock, NULL);
371         if (rc)
372                 return rc;
373 
374         io_parms.netfid = fid.netfid;
375         io_parms.pid = current->tgid;
376         io_parms.tcon = tcon;
377         io_parms.offset = 0;
378         io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
379 
380         rc = CIFSSMBWrite(xid, &io_parms, pbytes_written, pbuf);
381         CIFSSMBClose(xid, tcon, fid.netfid);
382         return rc;
383 }
384 
385 /*
386  * SMB 2.1/SMB3 Protocol specific functions
387  */
388 int
389 smb3_query_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
390                       struct cifs_sb_info *cifs_sb, const unsigned char *path,
391                       char *pbuf, unsigned int *pbytes_read)
392 {
393         int rc;
394         struct cifs_fid fid;
395         struct cifs_open_parms oparms;
396         struct cifs_io_parms io_parms;
397         int buf_type = CIFS_NO_BUFFER;
398         __le16 *utf16_path;
399         __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
400         struct smb2_file_all_info *pfile_info = NULL;
401 
402         oparms.tcon = tcon;
403         oparms.cifs_sb = cifs_sb;
404         oparms.desired_access = GENERIC_READ;
405         oparms.create_options = CREATE_NOT_DIR;
406         if (backup_cred(cifs_sb))
407                 oparms.create_options |= CREATE_OPEN_BACKUP_INTENT;
408         oparms.disposition = FILE_OPEN;
409         oparms.fid = &fid;
410         oparms.reconnect = false;
411 
412         utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
413         if (utf16_path == NULL)
414                 return -ENOMEM;
415 
416         pfile_info = kzalloc(sizeof(struct smb2_file_all_info) + PATH_MAX * 2,
417                              GFP_KERNEL);
418 
419         if (pfile_info == NULL) {
420                 kfree(utf16_path);
421                 return  -ENOMEM;
422         }
423 
424         rc = SMB2_open(xid, &oparms, utf16_path, &oplock, pfile_info, NULL,
425                        NULL);
426         if (rc)
427                 goto qmf_out_open_fail;
428 
429         if (pfile_info->EndOfFile != cpu_to_le64(CIFS_MF_SYMLINK_FILE_SIZE)) {
430                 /* it's not a symlink */
431                 rc = -ENOENT; /* Is there a better rc to return? */
432                 goto qmf_out;
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         rc = SMB2_read(xid, &io_parms, pbytes_read, &pbuf, &buf_type);
443 qmf_out:
444         SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
445 qmf_out_open_fail:
446         kfree(utf16_path);
447         kfree(pfile_info);
448         return rc;
449 }
450 
451 int
452 smb3_create_mf_symlink(unsigned int xid, struct cifs_tcon *tcon,
453                        struct cifs_sb_info *cifs_sb, const unsigned char *path,
454                        char *pbuf, unsigned int *pbytes_written)
455 {
456         int rc;
457         struct cifs_fid fid;
458         struct cifs_open_parms oparms;
459         struct cifs_io_parms io_parms;
460         int create_options = CREATE_NOT_DIR;
461         __le16 *utf16_path;
462         __u8 oplock = SMB2_OPLOCK_LEVEL_NONE;
463         struct kvec iov[2];
464 
465         if (backup_cred(cifs_sb))
466                 create_options |= CREATE_OPEN_BACKUP_INTENT;
467 
468         cifs_dbg(FYI, "%s: path: %s\n", __func__, path);
469 
470         utf16_path = cifs_convert_path_to_utf16(path, cifs_sb);
471         if (!utf16_path)
472                 return -ENOMEM;
473 
474         oparms.tcon = tcon;
475         oparms.cifs_sb = cifs_sb;
476         oparms.desired_access = GENERIC_WRITE;
477         oparms.create_options = create_options;
478         oparms.disposition = FILE_CREATE;
479         oparms.fid = &fid;
480         oparms.reconnect = false;
481 
482         rc = SMB2_open(xid, &oparms, utf16_path, &oplock, NULL, NULL,
483                        NULL);
484         if (rc) {
485                 kfree(utf16_path);
486                 return rc;
487         }
488 
489         io_parms.netfid = fid.netfid;
490         io_parms.pid = current->tgid;
491         io_parms.tcon = tcon;
492         io_parms.offset = 0;
493         io_parms.length = CIFS_MF_SYMLINK_FILE_SIZE;
494         io_parms.persistent_fid = fid.persistent_fid;
495         io_parms.volatile_fid = fid.volatile_fid;
496 
497         /* iov[0] is reserved for smb header */
498         iov[1].iov_base = pbuf;
499         iov[1].iov_len = CIFS_MF_SYMLINK_FILE_SIZE;
500 
501         rc = SMB2_write(xid, &io_parms, pbytes_written, iov, 1);
502 
503         /* Make sure we wrote all of the symlink data */
504         if ((rc == 0) && (*pbytes_written != CIFS_MF_SYMLINK_FILE_SIZE))
505                 rc = -EIO;
506 
507         SMB2_close(xid, tcon, fid.persistent_fid, fid.volatile_fid);
508 
509         kfree(utf16_path);
510         return rc;
511 }
512 
513 /*
514  * M-F Symlink Functions - End
515  */
516 
517 int
518 cifs_hardlink(struct dentry *old_file, struct inode *inode,
519               struct dentry *direntry)
520 {
521         int rc = -EACCES;
522         unsigned int xid;
523         char *from_name = NULL;
524         char *to_name = NULL;
525         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
526         struct tcon_link *tlink;
527         struct cifs_tcon *tcon;
528         struct TCP_Server_Info *server;
529         struct cifsInodeInfo *cifsInode;
530 
531         tlink = cifs_sb_tlink(cifs_sb);
532         if (IS_ERR(tlink))
533                 return PTR_ERR(tlink);
534         tcon = tlink_tcon(tlink);
535 
536         xid = get_xid();
537 
538         from_name = build_path_from_dentry(old_file);
539         to_name = build_path_from_dentry(direntry);
540         if ((from_name == NULL) || (to_name == NULL)) {
541                 rc = -ENOMEM;
542                 goto cifs_hl_exit;
543         }
544 
545         if (tcon->unix_ext)
546                 rc = CIFSUnixCreateHardLink(xid, tcon, from_name, to_name,
547                                             cifs_sb->local_nls,
548                                             cifs_remap(cifs_sb));
549         else {
550                 server = tcon->ses->server;
551                 if (!server->ops->create_hardlink) {
552                         rc = -ENOSYS;
553                         goto cifs_hl_exit;
554                 }
555                 rc = server->ops->create_hardlink(xid, tcon, from_name, to_name,
556                                                   cifs_sb);
557                 if ((rc == -EIO) || (rc == -EINVAL))
558                         rc = -EOPNOTSUPP;
559         }
560 
561         d_drop(direntry);       /* force new lookup from server of target */
562 
563         /*
564          * if source file is cached (oplocked) revalidate will not go to server
565          * until the file is closed or oplock broken so update nlinks locally
566          */
567         if (d_really_is_positive(old_file)) {
568                 cifsInode = CIFS_I(d_inode(old_file));
569                 if (rc == 0) {
570                         spin_lock(&d_inode(old_file)->i_lock);
571                         inc_nlink(d_inode(old_file));
572                         spin_unlock(&d_inode(old_file)->i_lock);
573 
574                         /*
575                          * parent dir timestamps will update from srv within a
576                          * second, would it really be worth it to set the parent
577                          * dir cifs inode time to zero to force revalidate
578                          * (faster) for it too?
579                          */
580                 }
581                 /*
582                  * if not oplocked will force revalidate to get info on source
583                  * file from srv.  Note Samba server prior to 4.2 has bug -
584                  * not updating src file ctime on hardlinks but Windows servers
585                  * handle it properly
586                  */
587                 cifsInode->time = 0;
588 
589                 /*
590                  * Will update parent dir timestamps from srv within a second.
591                  * Would it really be worth it to set the parent dir (cifs
592                  * inode) time field to zero to force revalidate on parent
593                  * directory faster ie
594                  *
595                  * CIFS_I(inode)->time = 0;
596                  */
597         }
598 
599 cifs_hl_exit:
600         kfree(from_name);
601         kfree(to_name);
602         free_xid(xid);
603         cifs_put_tlink(tlink);
604         return rc;
605 }
606 
607 const char *
608 cifs_get_link(struct dentry *direntry, struct inode *inode,
609               struct delayed_call *done)
610 {
611         int rc = -ENOMEM;
612         unsigned int xid;
613         char *full_path = NULL;
614         char *target_path = NULL;
615         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
616         struct tcon_link *tlink = NULL;
617         struct cifs_tcon *tcon;
618         struct TCP_Server_Info *server;
619 
620         if (!direntry)
621                 return ERR_PTR(-ECHILD);
622 
623         xid = get_xid();
624 
625         tlink = cifs_sb_tlink(cifs_sb);
626         if (IS_ERR(tlink)) {
627                 free_xid(xid);
628                 return ERR_CAST(tlink);
629         }
630         tcon = tlink_tcon(tlink);
631         server = tcon->ses->server;
632 
633         full_path = build_path_from_dentry(direntry);
634         if (!full_path) {
635                 free_xid(xid);
636                 cifs_put_tlink(tlink);
637                 return ERR_PTR(-ENOMEM);
638         }
639 
640         cifs_dbg(FYI, "Full path: %s inode = 0x%p\n", full_path, inode);
641 
642         rc = -EACCES;
643         /*
644          * First try Minshall+French Symlinks, if configured
645          * and fallback to UNIX Extensions Symlinks.
646          */
647         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
648                 rc = query_mf_symlink(xid, tcon, cifs_sb, full_path,
649                                       &target_path);
650 
651         if (rc != 0 && server->ops->query_symlink) {
652                 struct cifsInodeInfo *cifsi = CIFS_I(inode);
653                 bool reparse_point = false;
654 
655                 if (cifsi->cifsAttrs & ATTR_REPARSE)
656                         reparse_point = true;
657 
658                 rc = server->ops->query_symlink(xid, tcon, cifs_sb, full_path,
659                                                 &target_path, reparse_point);
660         }
661 
662         kfree(full_path);
663         free_xid(xid);
664         cifs_put_tlink(tlink);
665         if (rc != 0) {
666                 kfree(target_path);
667                 return ERR_PTR(rc);
668         }
669         set_delayed_call(done, kfree_link, target_path);
670         return target_path;
671 }
672 
673 int
674 cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
675 {
676         int rc = -EOPNOTSUPP;
677         unsigned int xid;
678         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
679         struct tcon_link *tlink;
680         struct cifs_tcon *pTcon;
681         char *full_path = NULL;
682         struct inode *newinode = NULL;
683 
684         xid = get_xid();
685 
686         tlink = cifs_sb_tlink(cifs_sb);
687         if (IS_ERR(tlink)) {
688                 rc = PTR_ERR(tlink);
689                 goto symlink_exit;
690         }
691         pTcon = tlink_tcon(tlink);
692 
693         full_path = build_path_from_dentry(direntry);
694         if (full_path == NULL) {
695                 rc = -ENOMEM;
696                 goto symlink_exit;
697         }
698 
699         cifs_dbg(FYI, "Full path: %s\n", full_path);
700         cifs_dbg(FYI, "symname is %s\n", symname);
701 
702         /* BB what if DFS and this volume is on different share? BB */
703         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
704                 rc = create_mf_symlink(xid, pTcon, cifs_sb, full_path, symname);
705         else if (pTcon->unix_ext)
706                 rc = CIFSUnixCreateSymLink(xid, pTcon, full_path, symname,
707                                            cifs_sb->local_nls,
708                                            cifs_remap(cifs_sb));
709         /* else
710            rc = CIFSCreateReparseSymLink(xid, pTcon, fromName, toName,
711                                         cifs_sb_target->local_nls); */
712 
713         if (rc == 0) {
714                 if (pTcon->unix_ext)
715                         rc = cifs_get_inode_info_unix(&newinode, full_path,
716                                                       inode->i_sb, xid);
717                 else
718                         rc = cifs_get_inode_info(&newinode, full_path, NULL,
719                                                  inode->i_sb, xid, NULL);
720 
721                 if (rc != 0) {
722                         cifs_dbg(FYI, "Create symlink ok, getinodeinfo fail rc = %d\n",
723                                  rc);
724                 } else {
725                         d_instantiate(direntry, newinode);
726                 }
727         }
728 symlink_exit:
729         kfree(full_path);
730         cifs_put_tlink(tlink);
731         free_xid(xid);
732         return rc;
733 }
734 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp