xref: /linux/fs/udf/misc.c (revision cdd5b5a9761fd66d17586e4f4ba6588c70e640ea)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * misc.c
4  *
5  * PURPOSE
6  *	Miscellaneous routines for the OSTA-UDF(tm) filesystem.
7  *
8  * COPYRIGHT
9  *  (C) 1998 Dave Boynton
10  *  (C) 1998-2004 Ben Fennema
11  *  (C) 1999-2000 Stelias Computing Inc
12  *
13  * HISTORY
14  *
15  *  04/19/99 blf  partial support for reading/writing specific EA's
16  */
17 
18 #include "udfdecl.h"
19 
20 #include <linux/fs.h>
21 #include <linux/string.h>
22 #include <linux/crc-itu-t.h>
23 
24 #include "udf_i.h"
25 #include "udf_sb.h"
26 
udf_add_extendedattr(struct inode * inode,uint32_t size,uint32_t type,uint8_t loc)27 struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
28 					   uint32_t type, uint8_t loc)
29 {
30 	uint8_t *ea = NULL, *ad = NULL;
31 	int offset;
32 	uint16_t crclen;
33 	struct udf_inode_info *iinfo = UDF_I(inode);
34 
35 	ea = iinfo->i_data;
36 	if (iinfo->i_lenEAttr) {
37 		ad = iinfo->i_data + iinfo->i_lenEAttr;
38 	} else {
39 		ad = ea;
40 		size += sizeof(struct extendedAttrHeaderDesc);
41 	}
42 
43 	offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
44 		iinfo->i_lenAlloc;
45 
46 	/* TODO - Check for FreeEASpace */
47 
48 	if (loc & 0x01 && offset >= size) {
49 		struct extendedAttrHeaderDesc *eahd;
50 		eahd = (struct extendedAttrHeaderDesc *)ea;
51 
52 		if (iinfo->i_lenAlloc)
53 			memmove(&ad[size], ad, iinfo->i_lenAlloc);
54 
55 		if (iinfo->i_lenEAttr) {
56 			/* check checksum/crc */
57 			if (eahd->descTag.tagIdent !=
58 					cpu_to_le16(TAG_IDENT_EAHD) ||
59 			    le32_to_cpu(eahd->descTag.tagLocation) !=
60 					iinfo->i_location.logicalBlockNum)
61 				return NULL;
62 		} else {
63 			struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
64 
65 			size -= sizeof(struct extendedAttrHeaderDesc);
66 			iinfo->i_lenEAttr +=
67 				sizeof(struct extendedAttrHeaderDesc);
68 			eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
69 			if (sbi->s_udfrev >= 0x0200)
70 				eahd->descTag.descVersion = cpu_to_le16(3);
71 			else
72 				eahd->descTag.descVersion = cpu_to_le16(2);
73 			eahd->descTag.tagSerialNum =
74 					cpu_to_le16(sbi->s_serial_number);
75 			eahd->descTag.tagLocation = cpu_to_le32(
76 					iinfo->i_location.logicalBlockNum);
77 			eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
78 			eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
79 		}
80 
81 		offset = iinfo->i_lenEAttr;
82 		if (type < 2048) {
83 			if (le32_to_cpu(eahd->appAttrLocation) <
84 					iinfo->i_lenEAttr) {
85 				uint32_t aal =
86 					le32_to_cpu(eahd->appAttrLocation);
87 				memmove(&ea[offset - aal + size],
88 					&ea[aal], offset - aal);
89 				offset -= aal;
90 				eahd->appAttrLocation =
91 						cpu_to_le32(aal + size);
92 			}
93 			if (le32_to_cpu(eahd->impAttrLocation) <
94 					iinfo->i_lenEAttr) {
95 				uint32_t ial =
96 					le32_to_cpu(eahd->impAttrLocation);
97 				memmove(&ea[offset - ial + size],
98 					&ea[ial], offset - ial);
99 				offset -= ial;
100 				eahd->impAttrLocation =
101 						cpu_to_le32(ial + size);
102 			}
103 		} else if (type < 65536) {
104 			if (le32_to_cpu(eahd->appAttrLocation) <
105 					iinfo->i_lenEAttr) {
106 				uint32_t aal =
107 					le32_to_cpu(eahd->appAttrLocation);
108 				memmove(&ea[offset - aal + size],
109 					&ea[aal], offset - aal);
110 				offset -= aal;
111 				eahd->appAttrLocation =
112 						cpu_to_le32(aal + size);
113 			}
114 		}
115 		/* rewrite CRC + checksum of eahd */
116 		crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(struct tag);
117 		eahd->descTag.descCRCLength = cpu_to_le16(crclen);
118 		eahd->descTag.descCRC = cpu_to_le16(crc_itu_t(0, (char *)eahd +
119 						sizeof(struct tag), crclen));
120 		eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
121 		iinfo->i_lenEAttr += size;
122 		return (struct genericFormat *)&ea[offset];
123 	}
124 
125 	return NULL;
126 }
127 
udf_get_extendedattr(struct inode * inode,uint32_t type,uint8_t subtype)128 struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
129 					   uint8_t subtype)
130 {
131 	struct genericFormat *gaf;
132 	uint8_t *ea = NULL;
133 	uint32_t offset;
134 	struct udf_inode_info *iinfo = UDF_I(inode);
135 
136 	ea = iinfo->i_data;
137 
138 	if (iinfo->i_lenEAttr) {
139 		struct extendedAttrHeaderDesc *eahd;
140 		eahd = (struct extendedAttrHeaderDesc *)ea;
141 
142 		/* check checksum/crc */
143 		if (eahd->descTag.tagIdent !=
144 				cpu_to_le16(TAG_IDENT_EAHD) ||
145 		    le32_to_cpu(eahd->descTag.tagLocation) !=
146 				iinfo->i_location.logicalBlockNum)
147 			return NULL;
148 
149 		if (type < 2048)
150 			offset = sizeof(struct extendedAttrHeaderDesc);
151 		else if (type < 65536)
152 			offset = le32_to_cpu(eahd->impAttrLocation);
153 		else
154 			offset = le32_to_cpu(eahd->appAttrLocation);
155 
156 		while (offset + sizeof(*gaf) < iinfo->i_lenEAttr) {
157 			uint32_t attrLength;
158 
159 			gaf = (struct genericFormat *)&ea[offset];
160 			attrLength = le32_to_cpu(gaf->attrLength);
161 
162 			/* Detect undersized elements and buffer overflows */
163 			if ((attrLength < sizeof(*gaf)) ||
164 			    (attrLength > (iinfo->i_lenEAttr - offset)))
165 				break;
166 
167 			if (le32_to_cpu(gaf->attrType) == type &&
168 					gaf->attrSubtype == subtype)
169 				return gaf;
170 			else
171 				offset += attrLength;
172 		}
173 	}
174 
175 	return NULL;
176 }
177 
178 /*
179  * udf_read_tagged
180  *
181  * PURPOSE
182  *	Read the first block of a tagged descriptor.
183  *
184  * HISTORY
185  *	July 1, 1997 - Andrew E. Mileski
186  *	Written, tested, and released.
187  */
udf_read_tagged(struct super_block * sb,uint32_t block,uint32_t location,uint16_t * ident)188 struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
189 				    uint32_t location, uint16_t *ident)
190 {
191 	struct tag *tag_p;
192 	struct buffer_head *bh = NULL;
193 	u8 checksum;
194 
195 	/* Read the block */
196 	if (block == 0xFFFFFFFF)
197 		return NULL;
198 
199 	bh = sb_bread(sb, block);
200 	if (!bh) {
201 		udf_err(sb, "read failed, block=%u, location=%u\n",
202 			block, location);
203 		return NULL;
204 	}
205 
206 	tag_p = (struct tag *)(bh->b_data);
207 
208 	*ident = le16_to_cpu(tag_p->tagIdent);
209 
210 	if (location != le32_to_cpu(tag_p->tagLocation)) {
211 		udf_debug("location mismatch block %u, tag %u != %u\n",
212 			  block, le32_to_cpu(tag_p->tagLocation), location);
213 		goto error_out;
214 	}
215 
216 	/* Verify the tag checksum */
217 	checksum = udf_tag_checksum(tag_p);
218 	if (checksum != tag_p->tagChecksum) {
219 		udf_err(sb, "tag checksum failed, block %u: 0x%02x != 0x%02x\n",
220 			block, checksum, tag_p->tagChecksum);
221 		goto error_out;
222 	}
223 
224 	/* Verify the tag version */
225 	if (tag_p->descVersion != cpu_to_le16(0x0002U) &&
226 	    tag_p->descVersion != cpu_to_le16(0x0003U)) {
227 		udf_err(sb, "tag version 0x%04x != 0x0002 || 0x0003, block %u\n",
228 			le16_to_cpu(tag_p->descVersion), block);
229 		goto error_out;
230 	}
231 
232 	/* Verify the descriptor CRC */
233 	if (le16_to_cpu(tag_p->descCRCLength) + sizeof(struct tag) > sb->s_blocksize ||
234 	    le16_to_cpu(tag_p->descCRC) == crc_itu_t(0,
235 					bh->b_data + sizeof(struct tag),
236 					le16_to_cpu(tag_p->descCRCLength)))
237 		return bh;
238 
239 	udf_debug("Crc failure block %u: crc = %u, crclen = %u\n", block,
240 		  le16_to_cpu(tag_p->descCRC),
241 		  le16_to_cpu(tag_p->descCRCLength));
242 error_out:
243 	brelse(bh);
244 	return NULL;
245 }
246 
udf_read_ptagged(struct super_block * sb,struct kernel_lb_addr * loc,uint32_t offset,uint16_t * ident)247 struct buffer_head *udf_read_ptagged(struct super_block *sb,
248 				     struct kernel_lb_addr *loc,
249 				     uint32_t offset, uint16_t *ident)
250 {
251 	return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset),
252 			       loc->logicalBlockNum + offset, ident);
253 }
254 
udf_update_tag(char * data,int length)255 void udf_update_tag(char *data, int length)
256 {
257 	struct tag *tptr = (struct tag *)data;
258 	length -= sizeof(struct tag);
259 
260 	tptr->descCRCLength = cpu_to_le16(length);
261 	tptr->descCRC = cpu_to_le16(crc_itu_t(0, data + sizeof(struct tag), length));
262 	tptr->tagChecksum = udf_tag_checksum(tptr);
263 }
264 
udf_new_tag(char * data,uint16_t ident,uint16_t version,uint16_t snum,uint32_t loc,int length)265 void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
266 		 uint32_t loc, int length)
267 {
268 	struct tag *tptr = (struct tag *)data;
269 	tptr->tagIdent = cpu_to_le16(ident);
270 	tptr->descVersion = cpu_to_le16(version);
271 	tptr->tagSerialNum = cpu_to_le16(snum);
272 	tptr->tagLocation = cpu_to_le32(loc);
273 	udf_update_tag(data, length);
274 }
275 
udf_tag_checksum(const struct tag * t)276 u8 udf_tag_checksum(const struct tag *t)
277 {
278 	u8 *data = (u8 *)t;
279 	u8 checksum = 0;
280 	int i;
281 	for (i = 0; i < sizeof(struct tag); ++i)
282 		if (i != 4) /* position of checksum */
283 			checksum += data[i];
284 	return checksum;
285 }
286