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

TOMOYO Linux Cross Reference
Linux/fs/udf/symlink.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ 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  * symlink.c
  3  *
  4  * PURPOSE
  5  *      Symlink handling routines for the OSTA-UDF(tm) filesystem.
  6  *
  7  * COPYRIGHT
  8  *      This file is distributed under the terms of the GNU General Public
  9  *      License (GPL). Copies of the GPL can be obtained from:
 10  *              ftp://prep.ai.mit.edu/pub/gnu/GPL
 11  *      Each contributing author retains all rights to their own work.
 12  *
 13  *  (C) 1998-2001 Ben Fennema
 14  *  (C) 1999 Stelias Computing Inc
 15  *
 16  * HISTORY
 17  *
 18  *  04/16/99 blf  Created.
 19  *
 20  */
 21 
 22 #include "udfdecl.h"
 23 #include <linux/uaccess.h>
 24 #include <linux/errno.h>
 25 #include <linux/fs.h>
 26 #include <linux/time.h>
 27 #include <linux/mm.h>
 28 #include <linux/stat.h>
 29 #include <linux/pagemap.h>
 30 #include "udf_i.h"
 31 
 32 static int udf_pc_to_char(struct super_block *sb, unsigned char *from,
 33                           int fromlen, unsigned char *to, int tolen)
 34 {
 35         struct pathComponent *pc;
 36         int elen = 0;
 37         int comp_len;
 38         unsigned char *p = to;
 39 
 40         /* Reserve one byte for terminating \0 */
 41         tolen--;
 42         while (elen < fromlen) {
 43                 pc = (struct pathComponent *)(from + elen);
 44                 elen += sizeof(struct pathComponent);
 45                 switch (pc->componentType) {
 46                 case 1:
 47                         /*
 48                          * Symlink points to some place which should be agreed
 49                          * upon between originator and receiver of the media. Ignore.
 50                          */
 51                         if (pc->lengthComponentIdent > 0) {
 52                                 elen += pc->lengthComponentIdent;
 53                                 break;
 54                         }
 55                         /* Fall through */
 56                 case 2:
 57                         if (tolen == 0)
 58                                 return -ENAMETOOLONG;
 59                         p = to;
 60                         *p++ = '/';
 61                         tolen--;
 62                         break;
 63                 case 3:
 64                         if (tolen < 3)
 65                                 return -ENAMETOOLONG;
 66                         memcpy(p, "../", 3);
 67                         p += 3;
 68                         tolen -= 3;
 69                         break;
 70                 case 4:
 71                         if (tolen < 2)
 72                                 return -ENAMETOOLONG;
 73                         memcpy(p, "./", 2);
 74                         p += 2;
 75                         tolen -= 2;
 76                         /* that would be . - just ignore */
 77                         break;
 78                 case 5:
 79                         elen += pc->lengthComponentIdent;
 80                         if (elen > fromlen)
 81                                 return -EIO;
 82                         comp_len = udf_get_filename(sb, pc->componentIdent,
 83                                                     pc->lengthComponentIdent,
 84                                                     p, tolen);
 85                         if (comp_len < 0)
 86                                 return comp_len;
 87 
 88                         p += comp_len;
 89                         tolen -= comp_len;
 90                         if (tolen == 0)
 91                                 return -ENAMETOOLONG;
 92                         *p++ = '/';
 93                         tolen--;
 94                         break;
 95                 }
 96         }
 97         if (p > to + 1)
 98                 p[-1] = '\0';
 99         else
100                 p[0] = '\0';
101         return 0;
102 }
103 
104 static int udf_symlink_filler(struct file *file, struct page *page)
105 {
106         struct inode *inode = page->mapping->host;
107         struct buffer_head *bh = NULL;
108         unsigned char *symlink;
109         int err;
110         unsigned char *p = page_address(page);
111         struct udf_inode_info *iinfo;
112         uint32_t pos;
113 
114         /* We don't support symlinks longer than one block */
115         if (inode->i_size > inode->i_sb->s_blocksize) {
116                 err = -ENAMETOOLONG;
117                 goto out_unmap;
118         }
119 
120         iinfo = UDF_I(inode);
121         pos = udf_block_map(inode, 0);
122 
123         down_read(&iinfo->i_data_sem);
124         if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
125                 symlink = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
126         } else {
127                 bh = sb_bread(inode->i_sb, pos);
128 
129                 if (!bh) {
130                         err = -EIO;
131                         goto out_unlock_inode;
132                 }
133 
134                 symlink = bh->b_data;
135         }
136 
137         err = udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p, PAGE_SIZE);
138         brelse(bh);
139         if (err)
140                 goto out_unlock_inode;
141 
142         up_read(&iinfo->i_data_sem);
143         SetPageUptodate(page);
144         unlock_page(page);
145         return 0;
146 
147 out_unlock_inode:
148         up_read(&iinfo->i_data_sem);
149         SetPageError(page);
150 out_unmap:
151         unlock_page(page);
152         return err;
153 }
154 
155 static int udf_symlink_getattr(const struct path *path, struct kstat *stat,
156                                 u32 request_mask, unsigned int flags)
157 {
158         struct dentry *dentry = path->dentry;
159         struct inode *inode = d_backing_inode(dentry);
160         struct page *page;
161 
162         generic_fillattr(inode, stat);
163         page = read_mapping_page(inode->i_mapping, 0, NULL);
164         if (IS_ERR(page))
165                 return PTR_ERR(page);
166         /*
167          * UDF uses non-trivial encoding of symlinks so i_size does not match
168          * number of characters reported by readlink(2) which apparently some
169          * applications expect. Also POSIX says that "The value returned in the
170          * st_size field shall be the length of the contents of the symbolic
171          * link, and shall not count a trailing null if one is present." So
172          * let's report the length of string returned by readlink(2) for
173          * st_size.
174          */
175         stat->size = strlen(page_address(page));
176         put_page(page);
177 
178         return 0;
179 }
180 
181 /*
182  * symlinks can't do much...
183  */
184 const struct address_space_operations udf_symlink_aops = {
185         .readpage               = udf_symlink_filler,
186 };
187 
188 const struct inode_operations udf_symlink_inode_operations = {
189         .get_link       = page_get_link,
190         .getattr        = udf_symlink_getattr,
191 };
192 

~ [ 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