1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * ISO 9660 System Use Sharing Protocol extension filesystem specifications 24 * Copyright (c) 1991,2000,2001 by Sun Microsystems, Inc. 25 * All rights reserved. 26 */ 27 28 #include <sys/types.h> 29 #include <sys/t_lock.h> 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/sysmacros.h> 33 #include <sys/kmem.h> 34 #include <sys/signal.h> 35 #include <sys/user.h> 36 #include <sys/proc.h> 37 #include <sys/disp.h> 38 #include <sys/buf.h> 39 #include <sys/pathname.h> 40 #include <sys/vfs.h> 41 #include <sys/vnode.h> 42 #include <sys/file.h> 43 #include <sys/uio.h> 44 #include <sys/conf.h> 45 46 #include <vm/page.h> 47 48 #include <sys/fs/hsfs_spec.h> 49 #include <sys/fs/hsfs_isospec.h> 50 #include <sys/fs/hsfs_node.h> 51 #include <sys/fs/hsfs_impl.h> 52 #include <sys/fs/hsfs_susp.h> 53 #include <sys/fs/hsfs_rrip.h> 54 55 #include <sys/statvfs.h> 56 #include <sys/mount.h> 57 #include <sys/swap.h> 58 #include <sys/errno.h> 59 #include <sys/debug.h> 60 #include "fs/fs_subr.h" 61 #include <sys/cmn_err.h> 62 63 64 65 /* 66 * Common Signatures for all SUSP 67 */ 68 ext_signature_t susp_signature_table[ ] = { 69 { SUSP_SP, share_protocol }, /* must be first in table */ 70 { SUSP_CE, share_continue }, /* must be second in table */ 71 { SUSP_PD, share_padding }, 72 { SUSP_ER, share_ext_ref }, 73 { SUSP_ST, share_stop }, 74 { NULL, NULL } 75 }; 76 77 /* 78 * These are global pointers referring to the above table, so the 79 * positions must not change as marked on the right above. 80 */ 81 ext_signature_t *susp_sp = &susp_signature_table[0]; 82 ext_signature_t *susp_ce = &susp_signature_table[1]; 83 84 85 /* 86 * ext name version implemented signature table 87 * 88 * the SUSP must be the first entry in the table. 89 * the RRIP must be the second entry in the table. We need to be able 90 * to check the RRIP bit being set, so we must know it's position. 91 * RRIP_BIT is set to 2 in rrip.h 92 */ 93 extension_name_t extension_name_table[] = { 94 { "SUSP_1991A", SUSP_VERSION, susp_signature_table }, /* #1 */ 95 { RRIP_ER_EXT_ID, RRIP_EXT_VERSION, rrip_signature_table }, 96 { NULL, 0, (ext_signature_t *)NULL } 97 }; 98 99 extension_name_t *susp_ext_name = extension_name_table; 100 101 /* 102 * share_protocol() 103 * 104 * sig_handler() for SUSP signature "SP" 105 * 106 * This function looks for the "SP" signature field, which means that 107 * the SUSP is supported on the current CD-ROM. It looks for the word 108 * 0xBEEF in the signature. If that exists, the SUSP is implemented. 109 * The function will then set the implemented bit in the "SUSP" entry 110 * of the extention_name_table[]. If the bytes don't match, then we 111 * return a big fat NULL and treat this as an ISO 9660 CD-ROM. 112 */ 113 uchar_t * 114 share_protocol(sig_args_t *sig_args_p) 115 { 116 uchar_t *sp_ptr = sig_args_p->SUF_ptr; 117 118 /* Let's check the check bytes */ 119 if (!CHECK_BYTES_OK(sp_ptr)) 120 return ((uchar_t *)NULL); 121 122 /* 123 * Ah, we have the go ahead, so let's set the implemented bit 124 * of the SUSP in the extension_name_table[] 125 */ 126 127 if (SUSP_VERSION < SUF_VER(sp_ptr)) { 128 cmn_err(CE_NOTE, 129 "System Use Sharing Protocol ver. %d:not supported\n", 130 (int)SUF_VER(sp_ptr)); 131 return ((uchar_t *)NULL); 132 } 133 134 SET_SUSP_BIT(sig_args_p->fsp); 135 136 sig_args_p->fsp->hsfs_sua_off = SP_SUA_OFFSET(sp_ptr); 137 138 return (sp_ptr + SUF_LEN(sp_ptr)); 139 } 140 141 /* 142 * share_ext_ref() 143 * 144 * sig_handler() for SUSP signature "ER" 145 * 146 * This function looks for the "ER" signature field, which lists an 147 * extension that is implemented on the current CD-ROM. The function 148 * will then search through the extention_name_table[], looking for the 149 * extension reference in this SUF. 150 * 151 * If the correct extension reference is found, and the version number 152 * in the "ER" SUF is less than or equal to the version specified in 153 * the extension_name_table, the implemented bit will be set to 1. 154 * 155 * If the version number in the "ER" field is greater than that in the 156 * extension_name_table or no reference can be matched, the reference 157 * will be skipped the function will return the next field. 158 */ 159 uchar_t * 160 share_ext_ref(sig_args_t *sig_args_p) 161 { 162 uchar_t *er_ptr = sig_args_p->SUF_ptr; 163 extension_name_t *extnp; 164 int index; 165 166 /* 167 * Find appropriate extension and signature table 168 */ 169 for (extnp = extension_name_table, index = 0; 170 extnp->extension_name != (char *)NULL; 171 extnp++, index++) { 172 if (strncmp(extnp->extension_name, 173 (char *)ER_ext_id(er_ptr), 174 ER_ID_LEN(er_ptr)) == 0) { 175 SET_IMPL_BIT(sig_args_p->fsp, index); 176 } 177 } 178 179 return (er_ptr + SUF_LEN(er_ptr)); 180 } 181 182 /* 183 * share_continue() 184 * 185 * sig_handler() for SUSP signature "CE" 186 * 187 * This function looks for the "CE" signature field. This means that 188 * the SUA is continued in another block on the CD-ROM. Because it is 189 * not a requirement that this "CE" field come at the end of the SUA, 190 * this function will only set up a structure containing the 191 * information needed to read the next SUA, somewhere on the disk. 192 * 193 * The end of the SUA is signaled by 2 NULL bytes, where the next 194 * signature would have been. 195 * 196 * This one will be tough to implement. 197 */ 198 uchar_t * 199 share_continue(sig_args_t *sig_args_p) 200 { 201 uchar_t *ce_ptr = sig_args_p->SUF_ptr; 202 203 sig_args_p->cont_info_p->cont_lbn = CE_BLK_LOC(ce_ptr); 204 sig_args_p->cont_info_p->cont_offset = CE_OFFSET(ce_ptr); 205 sig_args_p->cont_info_p->cont_len = CE_CONT_LEN(ce_ptr); 206 207 return (ce_ptr + SUF_LEN(ce_ptr)); 208 } 209 210 211 /* 212 * share_padding() 213 * 214 * sig_handler() for SUSP signature "PD" 215 * 216 * All this function is needed for is bypassing a certain number of 217 * bytes. So, we just advance past this field and we're set. 218 */ 219 uchar_t * 220 share_padding(sig_args_t *sig_args_p) 221 { 222 uchar_t *pd_ptr = sig_args_p->SUF_ptr; 223 224 return (pd_ptr + SUF_LEN(pd_ptr)); 225 } 226 227 228 229 /* 230 * share_stop() 231 * 232 * sig_handler() for SUSP signature "ST" 233 * 234 * All this is used for is signaling the end of an SUA. 235 * It fills the flag variable with the 236 */ 237 uchar_t * 238 share_stop(sig_args_t *sig_args_p) 239 { 240 uchar_t *st_ptr = sig_args_p->SUF_ptr; 241 242 sig_args_p->flags = END_OF_SUA; /* stop parsing the SUA NOW!!!! */ 243 244 return (st_ptr + SUF_LEN(st_ptr)); 245 }