/* *  linux/fs/isofs/rock.c * *  (C) 1992, 1993  Eric Youngdale * *  Rock Ridge Extensions to iso9660 */#include <linux/stat.h>#include <linux/sched.h>#include <linux/iso_fs.h>#include <linux/string.h>#include <linux/mm.h>#include <linux/slab.h>#include <linux/pagemap.h>#include <linux/smp_lock.h>#include "rock.h"/* These functions are designed to read the system areas of a directory record * and extract relevant information.  There are different functions provided * depending upon what information we need at the time.  One function fills * out an inode structure, a second one extracts a filename, a third one * returns a symbolic link name, and a fourth one returns the extent number * for the file. */#define SIG(A,B) ((A) | ((B) << 8)) /* isonum_721() *//* This is a way of ensuring that we have something in the system   use fields that is compatible with Rock Ridge */#define CHECK_SP(FAIL)	       			\      if(rr->u.SP.magic[0] != 0xbe) FAIL;	\      if(rr->u.SP.magic[1] != 0xef) FAIL;       \      inode->i_sb->u.isofs_sb.s_rock_offset=rr->u.SP.skip;/* We define a series of macros because each function must do exactly the   same thing in certain places.  We use the macros to ensure that everything   is done correctly */#define CONTINUE_DECLS \  int cont_extent = 0, cont_offset = 0, cont_size = 0;   \  void * buffer = 0#define CHECK_CE	       			\      {cont_extent = isonum_733(rr->u.CE.extent); \      cont_offset = isonum_733(rr->u.CE.offset); \      cont_size = isonum_733(rr->u.CE.size);}#define SETUP_ROCK_RIDGE(DE,CHR,LEN)	      		      	\  {LEN= sizeof(struct iso_directory_record) + DE->name_len[0];	\  if(LEN & 1) LEN++;						\  CHR = ((unsigned char *) DE) + LEN;				\  LEN = *((unsigned char *) DE) - LEN;                          \  if (inode->i_sb->u.isofs_sb.s_rock_offset!=-1)                \  {                                                             \     LEN-=inode->i_sb->u.isofs_sb.s_rock_offset;                \     CHR+=inode->i_sb->u.isofs_sb.s_rock_offset;                \     if (LEN<0) LEN=0;                                          \  }                                                             \}                                     #define MAYBE_CONTINUE(LABEL,DEV) \  {if (buffer) kfree(buffer); \  if (cont_extent){ \    int block, offset, offset1; \    struct buffer_head * pbh; \    buffer = kmalloc(cont_size,GFP_KERNEL); \    if (!buffer) goto out; \    block = cont_extent; \    offset = cont_offset; \    offset1 = 0; \    pbh = sb_bread(DEV->i_sb, block); \    if(pbh){       \      memcpy(buffer + offset1, pbh->b_data + offset, cont_size - offset1); \      brelse(pbh); \      chr = (unsigned char *) buffer; \      len = cont_size; \      cont_extent = 0; \      cont_size = 0; \      cont_offset = 0; \      goto LABEL; \    }    \    printk("Unable to read rock-ridge attributes\n");    \  }}/* This is the inner layer of the get filename routine, and is called   for each system area and continuation record related to the file */int find_rock_ridge_relocation(struct iso_directory_record * de, 			       struct inode * inode) {  int flag;  int len;  int retval;  unsigned char * chr;  CONTINUE_DECLS;  flag = 0;    /* If this is a '..' then we are looking for the parent, otherwise we     are looking for the child */    if (de->name[0]==1 && de->name_len[0]==1) flag = 1;  /* Return value if we do not find appropriate record. */  retval = isonum_733 (de->extent);    if (!inode->i_sb->u.isofs_sb.s_rock) return retval;  SETUP_ROCK_RIDGE(de, chr, len); repeat:  {    int rrflag, sig;    struct rock_ridge * rr;        while (len > 1){ /* There may be one byte for padding somewhere */      rr = (struct rock_ridge *) chr;      if (rr->len == 0) goto out; /* Something got screwed up here */      sig = isonum_721(chr);      chr += rr->len;       len -= rr->len;      switch(sig){      case SIG('R','R'):	rrflag = rr->u.RR.flags[0];	if (flag && !(rrflag & RR_PL)) goto out;	if (!flag && !(rrflag & RR_CL)) goto out;	break;      case SIG('S','P'):	CHECK_SP(goto out);	break;      case SIG('C','L'):	if (flag == 0) {	  retval = isonum_733(rr->u.CL.location);	  goto out;	}	break;      case SIG('P','L'):	if (flag != 0) {	  retval = isonum_733(rr->u.PL.location);	  goto out;	}	break;      case SIG('C','E'):	CHECK_CE; /* This tells is if there is a continuation record */	break;      default:	break;      }    }  }  MAYBE_CONTINUE(repeat, inode);  return retval; out:  if(buffer) kfree(buffer);  return retval;}/* return length of name field; 0: not found, -1: to be ignored */int get_rock_ridge_filename(struct iso_directory_record * de,			    char * retname, struct inode * inode){  int len;  unsigned char * chr;  CONTINUE_DECLS;  int retnamlen = 0, truncate=0;   if (!inode->i_sb->u.isofs_sb.s_rock) return 0;  *retname = 0;  SETUP_ROCK_RIDGE(de, chr, len); repeat:  {    struct rock_ridge * rr;    int sig;        while (len > 1){ /* There may be one byte for padding somewhere */      rr = (struct rock_ridge *) chr;      if (rr->len == 0) goto out; /* Something got screwed up here */      sig = isonum_721(chr);      chr += rr->len;       len -= rr->len;      switch(sig){      case SIG('R','R'):	if((rr->u.RR.flags[0] & RR_NM) == 0) goto out;	break;      case SIG('S','P'):	CHECK_SP(goto out);	break;      case SIG('C','E'):	CHECK_CE;	break;      case SIG('N','M'):	if (truncate) break;        /*	 * If the flags are 2 or 4, this indicates '.' or '..'.	 * We don't want to do anything with this, because it	 * screws up the code that calls us.  We don't really	 * care anyways, since we can just use the non-RR	 * name.	 */	if (rr->u.NM.flags & 6) {	  break;	}	if (rr->u.NM.flags & ~1) {	  printk("Unsupported NM flag settings (%d)\n",rr->u.NM.flags);	  break;	}	if((strlen(retname) + rr->len - 5) >= 254) {	  truncate = 1;	  break;	}	strncat(retname, rr->u.NM.name, rr->len - 5);	retnamlen += rr->len - 5;	break;      case SIG('R','E'):	if (buffer) kfree(buffer);	return -1;      default:	break;      }    }  }  MAYBE_CONTINUE(repeat,inode);  return retnamlen; /* If 0, this file did not have a NM field */ out:  if(buffer) kfree(buffer);  return 0;}int parse_rock_ridge_inode_internal(struct iso_directory_record * de,			            struct inode * inode,int regard_xa){  int len;  unsigned char * chr;  int symlink_len = 0;  CONTINUE_DECLS;  if (!inode->i_sb->u.isofs_sb.s_rock) return 0;  SETUP_ROCK_RIDGE(de, chr, len);  if (regard_xa)   {     chr+=14;     len-=14;     if (len<0) len=0;   };    repeat:  {    int cnt, sig;    struct inode * reloc;    struct rock_ridge * rr;    int rootflag;        while (len > 1){ /* There may be one byte for padding somewhere */      rr = (struct rock_ridge *) chr;      if (rr->len == 0) goto out; /* Something got screwed up here */      sig = isonum_721(chr);      chr += rr->len;       len -= rr->len;            switch(sig){#ifndef CONFIG_ZISOFS		/* No flag for SF or ZF */      case SIG('R','R'):	if((rr->u.RR.flags[0] &  	    (RR_PX | RR_TF | RR_SL | RR_CL)) == 0) goto out;	break;#endif      case SIG('S','P'):	CHECK_SP(goto out);	break;      case SIG('C','E'):	CHECK_CE;	break;      case SIG('E','R'):	inode->i_sb->u.isofs_sb.s_rock = 1;	printk(KERN_DEBUG "ISO 9660 Extensions: ");	{ int p;	  for(p=0;p<rr->u.ER.len_id;p++) printk("%c",rr->u.ER.data[p]);	}	  printk("\n");	break;      case SIG('P','X'):	inode->i_mode  = isonum_733(rr->u.PX.mode);	inode->i_nlink = isonum_733(rr->u.PX.n_links);	inode->i_uid   = isonum_733(rr->u.PX.uid);	inode->i_gid   = isonum_733(rr->u.PX.gid);	break;      case SIG('P','N'):	{ int high, low;	  high = isonum_733(rr->u.PN.dev_high);	  low = isonum_733(rr->u.PN.dev_low);	  /*	   * The Rock Ridge standard specifies that if sizeof(dev_t) <= 4,	   * then the high field is unused, and the device number is completely	   * stored in the low field.  Some writers may ignore this subtlety,	   * and as a result we test to see if the entire device number is	   * stored in the low field, and use that.