1
2
3
4
5
6
7
8
9#include <linux/slab.h>
10#include <linux/pagemap.h>
11#include <linux/smp_lock.h>
12
13#include "isofs.h"
14#include "rock.h"
15
16
17
18
19
20
21
22
23
24
25#define SIG(A,B) ((A) | ((B) << 8))
26
27struct rock_state {
28 void *buffer;
29 unsigned char *chr;
30 int len;
31 int cont_size;
32 int cont_extent;
33 int cont_offset;
34 struct inode *inode;
35};
36
37
38
39
40
41
42static int check_sp(struct rock_ridge *rr, struct inode *inode)
43{
44 if (rr->u.SP.magic[0] != 0xbe)
45 return -1;
46 if (rr->u.SP.magic[1] != 0xef)
47 return -1;
48 ISOFS_SB(inode->i_sb)->s_rock_offset = rr->u.SP.skip;
49 return 0;
50}
51
52static void setup_rock_ridge(struct iso_directory_record *de,
53 struct inode *inode, struct rock_state *rs)
54{
55 rs->len = sizeof(struct iso_directory_record) + de->name_len[0];
56 if (rs->len & 1)
57 (rs->len)++;
58 rs->chr = (unsigned char *)de + rs->len;
59 rs->len = *((unsigned char *)de) - rs->len;
60 if (rs->len < 0)
61 rs->len = 0;
62
63 if (ISOFS_SB(inode->i_sb)->s_rock_offset != -1) {
64 rs->len -= ISOFS_SB(inode->i_sb)->s_rock_offset;
65 rs->chr += ISOFS_SB(inode->i_sb)->s_rock_offset;
66 if (rs->len < 0)
67 rs->len = 0;
68 }
69}
70
71static void init_rock_state(struct rock_state *rs, struct inode *inode)
72{
73 memset(rs, 0, sizeof(*rs));
74 rs->inode = inode;
75}
76
77
78
79
80
81static int rock_continue(struct rock_state *rs)
82{
83 int ret = 1;
84 int blocksize = 1 << rs->inode->i_blkbits;
85 const int min_de_size = offsetof(struct rock_ridge, u);
86
87 kfree(rs->buffer);
88 rs->buffer = NULL;
89
90 if ((unsigned)rs->cont_offset > blocksize - min_de_size ||
91 (unsigned)rs->cont_size > blocksize ||
92 (unsigned)(rs->cont_offset + rs->cont_size) > blocksize) {
93 printk(KERN_NOTICE "rock: corrupted directory entry. "
94 "extent=%d, offset=%d, size=%d\n",
95 rs->cont_extent, rs->cont_offset, rs->cont_size);
96 ret = -EIO;
97 goto out;
98 }
99
100 if (rs->cont_extent) {
101 struct buffer_head *bh;
102
103 rs->buffer = kmalloc(rs->cont_size, GFP_KERNEL);
104 if (!rs->buffer) {
105 ret = -ENOMEM;
106 goto out;
107 }
108 ret = -EIO;
109 bh = sb_bread(rs->inode->i_sb, rs->cont_extent);
110 if (bh) {
111 memcpy(rs->buffer, bh->b_data + rs->cont_offset,
112 rs->cont_size);
113 put_bh(bh);
114 rs->chr = rs->buffer;
115 rs->len = rs->cont_size;
116 rs->cont_extent = 0;
117 rs->cont_size = 0;
118 rs->cont_offset = 0;
119 return 0;
120 }
121 printk("Unable to read rock-ridge attributes\n");
122 }
123out:
124 kfree(rs->buffer);
125 rs->buffer = NULL;
126 return ret;
127}
128
129
130
131
132
133static int rock_check_overflow(struct rock_state *rs, int sig)
134{
135 int len;
136
137 switch (sig) {
138 case SIG('S', 'P'):
139 len = sizeof(struct SU_SP_s);
140 break;
141 case SIG('C', 'E'):
142 len = sizeof(struct SU_CE_s);
143 break;
144 case SIG('E', 'R'):
145 len = sizeof(struct SU_ER_s);
146 break;
147 case SIG('R', 'R'):
148 len = sizeof(struct RR_RR_s);
149 break;
150 case SIG('P', 'X'):
151 len = sizeof(struct RR_PX_s);
152 break;
153 case SIG('P', 'N'):
154 len = sizeof(struct RR_PN_s);
155 break;
156 case SIG('S', 'L'):
157 len = sizeof(struct RR_SL_s);
158 break;
159 case SIG('N', 'M'):
160 len = sizeof(struct RR_NM_s);
161 break;
162 case SIG('C', 'L'):
163 len = sizeof(struct RR_CL_s);
164 break;
165 case SIG('P', 'L'):
166 len = sizeof(struct RR_PL_s);
167 break;
168 case SIG('T', 'F'):
169 len = sizeof(struct RR_TF_s);
170 break;
171 case SIG('Z', 'F'):
172 len = sizeof(struct RR_ZF_s);
173 break;
174 default:
175 len = 0;
176 break;
177 }
178 len += offsetof(struct rock_ridge, u);
179 if (len > rs->len) {
180 printk(KERN_NOTICE "rock: directory entry would overflow "
181 "storage\n");
182 printk(KERN_NOTICE "rock: sig=0x%02x, size=%d, remaining=%d\n",
183 sig, len, rs->len);
184 return -EIO;
185 }
186 return 0;
187}
188
189
190
191
192int get_rock_ridge_filename(struct iso_directory_record *de,
193 char *retname, struct inode *inode)
194{
195 struct rock_state rs;
196 struct rock_ridge *rr;
197 int sig;
198 int retnamlen = 0;
199 int truncate = 0;
200 int ret = 0;
201
202 if (!ISOFS_SB(inode->i_sb)->s_rock)
203 return 0;
204 *retname = 0;
205
206 init_rock_state(&rs, inode);
207 setup_rock_ridge(de, inode, &rs);
208repeat:
209
210 while (rs.len > 2) {
211 rr = (struct rock_ridge *)rs.chr;
212
213
214
215
216
217 if (rr->len < 3)
218 goto out;
219 sig = isonum_721(rs.chr);
220 if (rock_check_overflow(&rs, sig))
221 goto eio;
222 rs.chr += rr->len;
223 rs.len -= rr->len;
224
225
226
227
228 if (rs.len < 0)
229 goto out;
230
231 switch (sig) {
232 case SIG('R', 'R'):
233 if ((rr->u.RR.flags[0] & RR_NM) == 0)
234 goto out;
235 break;
236 case SIG('S', 'P'):
237 if (check_sp(rr, inode))
238 goto out;
239 break;
240 case SIG('C', 'E'):
241 rs.cont_extent = isonum_733(rr->u.CE.extent);
242 rs.cont_offset = isonum_733(rr->u.CE.offset);
243 rs.cont_size = isonum_733(rr->u.CE.size);
244 break;
245 case SIG('N', 'M'):
246 if (truncate)
247 break;
248 if (rr->len < 5)
249 break;
250
251
252
253
254
255
256
257 if (rr->u.NM.flags & 6)
258 break;
259
260 if (rr->u.NM.flags & ~1) {
261 printk("Unsupported NM flag settings (%d)\n",
262 rr->u.NM.flags);
263 break;
264 }
265 if ((strlen(retname) + rr->len - 5) >= 254) {
266 truncate = 1;
267 break;
268 }
269 strncat(retname, rr->u.NM.name, rr->len - 5);
270 retnamlen += rr->len - 5;
271 break;
272 case SIG('R', 'E'):
273 kfree(rs.buffer);
274 return -1;
275 default:
276 break;
277 }
278 }
279 ret = rock_continue(&rs);
280 if (ret == 0)
281 goto repeat;
282 if (ret == 1)
283 return retnamlen;
284out:
285 kfree(rs.buffer);
286 return ret;
287eio:
288 ret = -EIO;
289 goto out;
290}
291
292static int
293parse_rock_ridge_inode_internal(struct iso_directory_record *de,
294 struct inode *inode, int regard_xa)
295{
296 int symlink_len = 0;
297 int cnt, sig;
298 struct inode *reloc;
299 struct rock_ridge *rr;
300 int rootflag;
301 struct rock_state rs;
302 int ret = 0;
303
304 if (!ISOFS_SB(inode->i_sb)->s_rock)
305 return 0;
306
307 init_rock_state(&rs, inode);
308 setup_rock_ridge(de, inode, &rs);
309 if (regard_xa) {
310 rs.chr += 14;
311 rs.len -= 14;
312 if (rs.len < 0)
313 rs.len = 0;
314 }
315
316repeat:
317 while (rs.len > 2) {
318 rr = (struct rock_ridge *)rs.chr;
319
320
321
322
323
324 if (rr->len < 3)
325 goto out;
326 sig = isonum_721(rs.chr);
327 if (rock_check_overflow(&rs, sig))
328 goto eio;
329 rs.chr += rr->len;
330 rs.len -= rr->len;
331
332
333
334
335 if (rs.len < 0)
336 goto out;
337
338 switch (sig) {
339#ifndef CONFIG_ZISOFS
340 case SIG('R', 'R'):
341 if ((rr->u.RR.flags[0] &
342 (RR_PX | RR_TF | RR_SL | RR_CL)) == 0)
343 goto out;
344 break;
345#endif
346 case SIG('S', 'P'):
347 if (check_sp(rr, inode))
348 goto out;
349 break;
350 case SIG('C', 'E'):
351 rs.cont_extent = isonum_733(rr->u.CE.extent);
352 rs.cont_offset = isonum_733(rr->u.CE.offset);
353 rs.cont_size = isonum_733(rr->u.CE.size);
354 break;
355 case SIG('E', 'R'):
356 ISOFS_SB(inode->i_sb)->s_rock = 1;
357 printk(KERN_DEBUG "ISO 9660 Extensions: ");
358 {
359 int p;
360 for (p = 0; p < rr->u.ER.len_id; p++)
361 printk("%c", rr->u.ER.data[p]);
362 }
363 printk("\n");
364 break;
365 case SIG('P', 'X'):
366 inode->i_mode = isonum_733(rr->u.PX.mode);
367 inode->i_nlink = isonum_733(rr->u.PX.n_links);
368 inode->i_uid = isonum_733(rr->u.PX.uid);
369 inode->i_gid = isonum_733(rr->u.PX.gid);
370 break;
371 case SIG('P', 'N'):
372 {
373 int high, low;
374 high = isonum_733(rr->u.PN.dev_high);
375 low = isonum_733(rr->u.PN.dev_low);
376
377
378
379
380
381
382
383
384
385
386 if ((low & ~0xff) && high == 0) {
387 inode->i_rdev =
388 MKDEV(low >> 8, low & 0xff);
389 } else {
390 inode->i_rdev =
391 MKDEV(high, low);
392 }
393 }
394 break;
395 case SIG('T', 'F'):
396
397
398
399
400
401
402 cnt = 0;
403 if (rr->u.TF.flags & TF_CREATE) {
404 inode->i_ctime.tv_sec =
405 iso_date(rr->u.TF.times[cnt++].time,
406 0);
407 inode->i_ctime.tv_nsec = 0;
408 }
409 if (rr->u.TF.flags & TF_MODIFY) {
410 inode->i_mtime.tv_sec =
411 iso_date(rr->u.TF.times[cnt++].time,
412 0);
413 inode->i_mtime.tv_nsec = 0;
414 }
415 if (rr->u.TF.flags & TF_ACCESS) {
416 inode->i_atime.tv_sec =
417 iso_date(rr->u.TF.times[cnt++].time,
418 0);
419 inode->i_atime.tv_nsec = 0;
420 }
421 if (rr->u.TF.flags & TF_ATTRIBUTES) {
422 inode->i_ctime.tv_sec =
423 iso_date(rr->u.TF.times[cnt++].time,
424 0);
425 inode->i_ctime.tv_nsec = 0;
426 }
427 break;
428 case SIG('S', 'L'):
429 {
430 int slen;
431 struct SL_component *slp;
432 struct SL_component *oldslp;
433 slen = rr->len - 5;
434 slp = &rr->u.SL.link;
435 inode->i_size = symlink_len;
436 while (slen > 1) {
437 rootflag = 0;
438 switch (slp->flags & ~1) {
439 case 0:
440 inode->i_size +=
441 slp->len;
442 break;
443 case 2:
444 inode->i_size += 1;
445 break;
446 case 4:
447 inode->i_size += 2;
448 break;
449 case 8:
450 rootflag = 1;
451 inode->i_size += 1;
452 break;
453 default:
454 printk("Symlink component flag "
455 "not implemented\n");
456 }
457 slen -= slp->len + 2;
458 oldslp = slp;
459 slp = (struct SL_component *)
460 (((char *)slp) + slp->len + 2);
461
462 if (slen < 2) {
463 if (((rr->u.SL.
464 flags & 1) != 0)
465 &&
466 ((oldslp->
467 flags & 1) == 0))
468 inode->i_size +=
469 1;
470 break;
471 }
472
473
474
475
476
477 if (!rootflag
478 && (oldslp->flags & 1) == 0)
479 inode->i_size += 1;
480 }
481 }
482 symlink_len = inode->i_size;
483 break;
484 case SIG('R', 'E'):
485 printk(KERN_WARNING "Attempt to read inode for "
486 "relocated directory\n");
487 goto out;
488 case SIG('C', 'L'):
489 ISOFS_I(inode)->i_first_extent =
490 isonum_733(rr->u.CL.location);
491 reloc =
492 isofs_iget(inode->i_sb,
493 ISOFS_I(inode)->i_first_extent,
494 0);
495 if (IS_ERR(reloc)) {
496 ret = PTR_ERR(reloc);
497 goto out;
498 }
499 inode->i_mode = reloc->i_mode;
500 inode->i_nlink = reloc->i_nlink;
501 inode->i_uid = reloc->i_uid;
502 inode->i_gid = reloc->i_gid;
503 inode->i_rdev = reloc->i_rdev;
504 inode->i_size = reloc->i_size;
505 inode->i_blocks = reloc->i_blocks;
506 inode->i_atime = reloc->i_atime;
507 inode->i_ctime = reloc->i_ctime;
508 inode->i_mtime = reloc->i_mtime;
509 iput(reloc);
510 break;
511#ifdef CONFIG_ZISOFS
512 case SIG('Z', 'F'): {
513 int algo;
514
515 if (ISOFS_SB(inode->i_sb)->s_nocompress)
516 break;
517 algo = isonum_721(rr->u.ZF.algorithm);
518 if (algo == SIG('p', 'z')) {
519 int block_shift =
520 isonum_711(&rr->u.ZF.parms[1]);
521 if (block_shift < PAGE_CACHE_SHIFT
522 || block_shift > 17) {
523 printk(KERN_WARNING "isofs: "
524 "Can't handle ZF block "
525 "size of 2^%d\n",
526 block_shift);
527 } else {
528
529
530
531
532 ISOFS_I(inode)->i_file_format =
533 isofs_file_compressed;
534
535
536
537
538
539 ISOFS_I(inode)->i_format_parm[0] =
540 isonum_711(&rr->u.ZF.parms[0]);
541 ISOFS_I(inode)->i_format_parm[1] =
542 isonum_711(&rr->u.ZF.parms[1]);
543 inode->i_size =
544 isonum_733(rr->u.ZF.
545 real_size);
546 }
547 } else {
548 printk(KERN_WARNING
549 "isofs: Unknown ZF compression "
550 "algorithm: %c%c\n",
551 rr->u.ZF.algorithm[0],
552 rr->u.ZF.algorithm[1]);
553 }
554 break;
555 }
556#endif
557 default:
558 break;
559 }
560 }
561 ret = rock_continue(&rs);
562 if (ret == 0)
563 goto repeat;
564 if (ret == 1)
565 ret = 0;
566out:
567 kfree(rs.buffer);
568 return ret;
569eio:
570 ret = -EIO;
571 goto out;
572}
573
574static char *get_symlink_chunk(char *rpnt, struct rock_ridge *rr, char *plimit)
575{
576 int slen;
577 int rootflag;
578 struct SL_component *oldslp;
579 struct SL_component *slp;
580 slen = rr->len - 5;
581 slp = &rr->u.SL.link;
582 while (slen > 1) {
583 rootflag = 0;
584 switch (slp->flags & ~1) {
585 case 0:
586 if (slp->len > plimit - rpnt)
587 return NULL;
588 memcpy(rpnt, slp->text, slp->len);
589 rpnt += slp->len;
590 break;
591 case 2:
592 if (rpnt >= plimit)
593 return NULL;
594 *rpnt++ = '.';
595 break;
596 case 4:
597 if (2 > plimit - rpnt)
598 return NULL;
599 *rpnt++ = '.';
600 *rpnt++ = '.';
601 break;
602 case 8:
603 if (rpnt >= plimit)
604 return NULL;
605 rootflag = 1;
606 *rpnt++ = '/';
607 break;
608 default:
609 printk("Symlink component flag not implemented (%d)\n",
610 slp->flags);
611 }
612 slen -= slp->len + 2;
613 oldslp = slp;
614 slp = (struct SL_component *)((char *)slp + slp->len + 2);
615
616 if (slen < 2) {
617
618
619
620
621 if ((!rootflag) && (rr->u.SL.flags & 1) &&
622 !(oldslp->flags & 1)) {
623 if (rpnt >= plimit)
624 return NULL;
625 *rpnt++ = '/';
626 }
627 break;
628 }
629
630
631
632
633 if (!rootflag && !(oldslp->flags & 1)) {
634 if (rpnt >= plimit)
635 return NULL;
636 *rpnt++ = '/';
637 }
638 }
639 return rpnt;
640}
641
642int parse_rock_ridge_inode(struct iso_directory_record *de, struct inode *inode)
643{
644 int result = parse_rock_ridge_inode_internal(de, inode, 0);
645
646
647
648
649
650 if ((ISOFS_SB(inode->i_sb)->s_rock_offset == -1)
651 && (ISOFS_SB(inode->i_sb)->s_rock == 2)) {
652 result = parse_rock_ridge_inode_internal(de, inode, 14);
653 }
654 return result;
655}
656
657
658
659
660
661static int rock_ridge_symlink_readpage(struct file *file, struct page *page)
662{
663 struct inode *inode = page->mapping->host;
664 struct iso_inode_info *ei = ISOFS_I(inode);
665 char *link = kmap(page);
666 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
667 struct buffer_head *bh;
668 char *rpnt = link;
669 unsigned char *pnt;
670 struct iso_directory_record *raw_de;
671 unsigned long block, offset;
672 int sig;
673 struct rock_ridge *rr;
674 struct rock_state rs;
675 int ret;
676
677 if (!ISOFS_SB(inode->i_sb)->s_rock)
678 goto error;
679
680 init_rock_state(&rs, inode);
681 block = ei->i_iget5_block;
682 lock_kernel();
683 bh = sb_bread(inode->i_sb, block);
684 if (!bh)
685 goto out_noread;
686
687 offset = ei->i_iget5_offset;
688 pnt = (unsigned char *)bh->b_data + offset;
689
690 raw_de = (struct iso_directory_record *)pnt;
691
692
693
694
695 if (offset + *pnt > bufsize)
696 goto out_bad_span;
697
698
699
700
701
702
703 setup_rock_ridge(raw_de, inode, &rs);
704
705repeat:
706 while (rs.len > 2) {
707 rr = (struct rock_ridge *)rs.chr;
708 if (rr->len < 3)
709 goto out;
710 sig = isonum_721(rs.chr);
711 if (rock_check_overflow(&rs, sig))
712 goto out;
713 rs.chr += rr->len;
714 rs.len -= rr->len;
715 if (rs.len < 0)
716 goto out;
717
718 switch (sig) {
719 case SIG('R', 'R'):
720 if ((rr->u.RR.flags[0] & RR_SL) == 0)
721 goto out;
722 break;
723 case SIG('S', 'P'):
724 if (check_sp(rr, inode))
725 goto out;
726 break;
727 case SIG('S', 'L'):
728 rpnt = get_symlink_chunk(rpnt, rr,
729 link + (PAGE_SIZE - 1));
730 if (rpnt == NULL)
731 goto out;
732 break;
733 case SIG('C', 'E'):
734
735 rs.cont_extent = isonum_733(rr->u.CE.extent);
736 rs.cont_offset = isonum_733(rr->u.CE.offset);
737 rs.cont_size = isonum_733(rr->u.CE.size);
738 default:
739 break;
740 }
741 }
742 ret = rock_continue(&rs);
743 if (ret == 0)
744 goto repeat;
745 if (ret < 0)
746 goto fail;
747
748 if (rpnt == link)
749 goto fail;
750 brelse(bh);
751 *rpnt = '\0';
752 unlock_kernel();
753 SetPageUptodate(page);
754 kunmap(page);
755 unlock_page(page);
756 return 0;
757
758
759out:
760 kfree(rs.buffer);
761 goto fail;
762out_noread:
763 printk("unable to read i-node block");
764 goto fail;
765out_bad_span:
766 printk("symlink spans iso9660 blocks\n");
767fail:
768 brelse(bh);
769 unlock_kernel();
770error:
771 SetPageError(page);
772 kunmap(page);
773 unlock_page(page);
774 return -EIO;
775}
776
777const struct address_space_operations isofs_symlink_aops = {
778 .readpage = rock_ridge_symlink_readpage
779};
780