1 // 2 // convert.c - Little-endian conversion 3 // 4 // Written by Eryk Vershen 5 // 6 // See comments in convert.h 7 // 8 9 /* 10 * Copyright 1996,1997,1998 by Apple Computer, Inc. 11 * All Rights Reserved 12 * 13 * Permission to use, copy, modify, and distribute this software and 14 * its documentation for any purpose and without fee is hereby granted, 15 * provided that the above copyright notice appears in all copies and 16 * that both the copyright notice and this permission notice appear in 17 * supporting documentation. 18 * 19 * APPLE COMPUTER DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE 20 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 21 * FOR A PARTICULAR PURPOSE. 22 * 23 * IN NO EVENT SHALL APPLE COMPUTER BE LIABLE FOR ANY SPECIAL, INDIRECT, OR 24 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 25 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT, 26 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION 27 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 28 */ 29 30 #ifdef __linux__ 31 #include <endian.h> 32 #elif __NetBSD__ 33 #include <machine/endian.h> 34 #else 35 #define LITTLE_ENDIAN 1234 36 #define BIG_ENDIAN 4321 37 #define BYTE_ORDER 4321 38 //#define BYTE_ORDER 1234 39 #endif 40 41 #include "convert.h" 42 43 44 // 45 // Defines 46 // 47 48 49 // 50 // Types 51 // 52 53 54 // 55 // Global Constants 56 // 57 58 59 // 60 // Global Variables 61 // 62 63 64 // 65 // Forward declarations 66 // 67 void reverse2(uint8_t *bytes); 68 void reverse4(uint8_t *bytes); 69 70 71 // 72 // Routines 73 // 74 int 75 convert_dpme(DPME *data, int to_cpu_form) 76 { 77 #if BYTE_ORDER == LITTLE_ENDIAN 78 // Since we will toss the block if the signature doesn't match 79 // we don't need to check the signature down here. 80 reverse2((uint8_t *)&data->dpme_signature); 81 reverse2((uint8_t *)&data->dpme_reserved_1); 82 reverse4((uint8_t *)&data->dpme_map_entries); 83 reverse4((uint8_t *)&data->dpme_pblock_start); 84 reverse4((uint8_t *)&data->dpme_pblocks); 85 reverse4((uint8_t *)&data->dpme_lblock_start); 86 reverse4((uint8_t *)&data->dpme_lblocks); 87 reverse4((uint8_t *)&data->dpme_flags); 88 reverse4((uint8_t *)&data->dpme_boot_block); 89 reverse4((uint8_t *)&data->dpme_boot_bytes); 90 reverse4((uint8_t *)&data->dpme_load_addr); 91 reverse4((uint8_t *)&data->dpme_load_addr_2); 92 reverse4((uint8_t *)&data->dpme_goto_addr); 93 reverse4((uint8_t *)&data->dpme_goto_addr_2); 94 reverse4((uint8_t *)&data->dpme_checksum); 95 convert_bzb((BZB *)data->dpme_bzb, to_cpu_form); 96 #endif 97 return 0; 98 } 99 100 101 #if BYTE_ORDER == LITTLE_ENDIAN 102 int 103 convert_bzb(BZB *data, int to_cpu_form) 104 { 105 // Since the data here varies according to the type of partition we 106 // do not want to convert willy-nilly. We use the flag to determine 107 // whether to check for the signature before or after we flip the bytes. 108 if (to_cpu_form) { 109 reverse4((uint8_t *)&data->bzb_magic); 110 if (data->bzb_magic != BZBMAGIC) { 111 reverse4((uint8_t *)&data->bzb_magic); 112 if (data->bzb_magic != BZBMAGIC) { 113 return 0; 114 } 115 } 116 } else { 117 if (data->bzb_magic != BZBMAGIC) { 118 return 0; 119 } 120 reverse4((uint8_t *)&data->bzb_magic); 121 } 122 reverse2((uint8_t *)&data->bzb_inode); 123 reverse4((uint8_t *)&data->bzb_flags); 124 reverse4((uint8_t *)&data->bzb_tmade); 125 reverse4((uint8_t *)&data->bzb_tmount); 126 reverse4((uint8_t *)&data->bzb_tumount); 127 return 0; 128 } 129 #endif 130 131 132 int 133 convert_block0(Block0 *data, int to_cpu_form) 134 { 135 #if BYTE_ORDER == LITTLE_ENDIAN 136 DDMap *m; 137 uint16_t count; 138 int i; 139 140 // Since this data is optional we do not want to convert willy-nilly. 141 // We use the flag to determine whether to check for the signature 142 // before or after we flip the bytes and to determine which form of 143 // the count to use. 144 if (to_cpu_form) { 145 reverse2((uint8_t *)&data->sbSig); 146 if (data->sbSig != BLOCK0_SIGNATURE) { 147 reverse2((uint8_t *)&data->sbSig); 148 if (data->sbSig != BLOCK0_SIGNATURE) { 149 return 0; 150 } 151 } 152 } else { 153 if (data->sbSig != BLOCK0_SIGNATURE) { 154 return 0; 155 } 156 reverse2((uint8_t *)&data->sbSig); 157 } 158 reverse2((uint8_t *)&data->sbBlkSize); 159 reverse4((uint8_t *)&data->sbBlkCount); 160 reverse2((uint8_t *)&data->sbDevType); 161 reverse2((uint8_t *)&data->sbDevId); 162 reverse4((uint8_t *)&data->sbData); 163 if (to_cpu_form) { 164 reverse2((uint8_t *)&data->sbDrvrCount); 165 count = data->sbDrvrCount; 166 } else { 167 count = data->sbDrvrCount; 168 reverse2((uint8_t *)&data->sbDrvrCount); 169 } 170 171 if (count > 0) { 172 m = (DDMap *) data->sbMap; 173 for (i = 0; i < count; i++) { 174 reverse4((uint8_t *)&m[i].ddBlock); 175 reverse2((uint8_t *)&m[i].ddSize); 176 reverse2((uint8_t *)&m[i].ddType); 177 } 178 } 179 #endif 180 return 0; 181 } 182 183 184 void 185 reverse2(uint8_t *bytes) 186 { 187 uint8_t t; 188 189 t = *bytes; 190 *bytes = bytes[1]; 191 bytes[1] = t; 192 } 193 194 195 void 196 reverse4(uint8_t *bytes) 197 { 198 uint8_t t; 199 200 t = *bytes; 201 *bytes = bytes[3]; 202 bytes[3] = t; 203 t = bytes[1]; 204 bytes[1] = bytes[2]; 205 bytes[2] = t; 206 } 207
Indexes created Wed Jul 22 00:25:13 UTC 2026