]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/udf/symlink.c
Merge tag 'arc-4.12-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vgupta/arc
[mirror_ubuntu-bionic-kernel.git] / fs / udf / symlink.c
CommitLineData
1da177e4
LT
1/*
2 * symlink.c
3 *
4 * PURPOSE
5 * Symlink handling routines for the OSTA-UDF(tm) filesystem.
6 *
1da177e4
LT
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
28de7948 14 * (C) 1999 Stelias Computing Inc
1da177e4
LT
15 *
16 * HISTORY
17 *
18 * 04/16/99 blf Created.
19 *
20 */
21
22#include "udfdecl.h"
e973606c 23#include <linux/uaccess.h>
1da177e4
LT
24#include <linux/errno.h>
25#include <linux/fs.h>
1da177e4
LT
26#include <linux/time.h>
27#include <linux/mm.h>
28#include <linux/stat.h>
1da177e4 29#include <linux/pagemap.h>
1da177e4
LT
30#include "udf_i.h"
31
0e5cc9a4
JK
32static int udf_pc_to_char(struct super_block *sb, unsigned char *from,
33 int fromlen, unsigned char *to, int tolen)
1da177e4
LT
34{
35 struct pathComponent *pc;
36 int elen = 0;
0e5cc9a4 37 int comp_len;
391e8bbd 38 unsigned char *p = to;
1da177e4 39
0e5cc9a4
JK
40 /* Reserve one byte for terminating \0 */
41 tolen--;
cb00ea35 42 while (elen < fromlen) {
1da177e4 43 pc = (struct pathComponent *)(from + elen);
e237ec37 44 elen += sizeof(struct pathComponent);
cb00ea35
CG
45 switch (pc->componentType) {
46 case 1:
fef2e9f3
JK
47 /*
48 * Symlink points to some place which should be agreed
49 * upon between originator and receiver of the media. Ignore.
50 */
e237ec37
JK
51 if (pc->lengthComponentIdent > 0) {
52 elen += pc->lengthComponentIdent;
fef2e9f3 53 break;
e237ec37 54 }
fef2e9f3
JK
55 /* Fall through */
56 case 2:
0e5cc9a4
JK
57 if (tolen == 0)
58 return -ENAMETOOLONG;
fef2e9f3
JK
59 p = to;
60 *p++ = '/';
0e5cc9a4 61 tolen--;
cb00ea35
CG
62 break;
63 case 3:
0e5cc9a4
JK
64 if (tolen < 3)
65 return -ENAMETOOLONG;
cb00ea35
CG
66 memcpy(p, "../", 3);
67 p += 3;
0e5cc9a4 68 tolen -= 3;
cb00ea35
CG
69 break;
70 case 4:
0e5cc9a4
JK
71 if (tolen < 2)
72 return -ENAMETOOLONG;
cb00ea35
CG
73 memcpy(p, "./", 2);
74 p += 2;
0e5cc9a4 75 tolen -= 2;
cb00ea35
CG
76 /* that would be . - just ignore */
77 break;
78 case 5:
e237ec37
JK
79 elen += pc->lengthComponentIdent;
80 if (elen > fromlen)
81 return -EIO;
0e5cc9a4
JK
82 comp_len = udf_get_filename(sb, pc->componentIdent,
83 pc->lengthComponentIdent,
84 p, tolen);
5ceb8b55
FF
85 if (comp_len < 0)
86 return comp_len;
87
0e5cc9a4
JK
88 p += comp_len;
89 tolen -= comp_len;
90 if (tolen == 0)
91 return -ENAMETOOLONG;
cb00ea35 92 *p++ = '/';
0e5cc9a4 93 tolen--;
cb00ea35 94 break;
1da177e4 95 }
1da177e4 96 }
cb00ea35 97 if (p > to + 1)
1da177e4
LT
98 p[-1] = '\0';
99 else
100 p[0] = '\0';
0e5cc9a4 101 return 0;
1da177e4
LT
102}
103
104static int udf_symlink_filler(struct file *file, struct page *page)
105{
106 struct inode *inode = page->mapping->host;
107 struct buffer_head *bh = NULL;
391e8bbd 108 unsigned char *symlink;
a1d47b26 109 int err;
21fc61c7 110 unsigned char *p = page_address(page);
48d6d8ff 111 struct udf_inode_info *iinfo;
4d0fb621 112 uint32_t pos;
1da177e4 113
a1d47b26
JK
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
48d6d8ff 120 iinfo = UDF_I(inode);
4d0fb621
AIB
121 pos = udf_block_map(inode, 0);
122
123 down_read(&iinfo->i_data_sem);
48d6d8ff
MS
124 if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
125 symlink = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
28de7948 126 } else {
4d0fb621 127 bh = sb_bread(inode->i_sb, pos);
1da177e4 128
a1d47b26
JK
129 if (!bh) {
130 err = -EIO;
131 goto out_unlock_inode;
132 }
1da177e4
LT
133
134 symlink = bh->b_data;
135 }
136
0e5cc9a4 137 err = udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p, PAGE_SIZE);
3bf25cb4 138 brelse(bh);
0e5cc9a4
JK
139 if (err)
140 goto out_unlock_inode;
1da177e4 141
4d0fb621 142 up_read(&iinfo->i_data_sem);
1da177e4 143 SetPageUptodate(page);
1da177e4
LT
144 unlock_page(page);
145 return 0;
28de7948 146
a1d47b26 147out_unlock_inode:
4d0fb621 148 up_read(&iinfo->i_data_sem);
1da177e4 149 SetPageError(page);
a1d47b26 150out_unmap:
1da177e4
LT
151 unlock_page(page);
152 return err;
153}
154
a528d35e
DH
155static int udf_symlink_getattr(const struct path *path, struct kstat *stat,
156 u32 request_mask, unsigned int flags)
ad4d0532 157{
a528d35e 158 struct dentry *dentry = path->dentry;
ad4d0532
JK
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
1da177e4
LT
181/*
182 * symlinks can't do much...
183 */
f5e54d6e 184const struct address_space_operations udf_symlink_aops = {
28de7948 185 .readpage = udf_symlink_filler,
1da177e4 186};
ad4d0532
JK
187
188const struct inode_operations udf_symlink_inode_operations = {
189 .get_link = page_get_link,
190 .getattr = udf_symlink_getattr,
191};