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
convert_dpme(DPME * data,int to_cpu_form)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
convert_bzb(BZB * data,int to_cpu_form)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
convert_block0(Block0 * data,int to_cpu_form)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
reverse2(uint8_t * bytes)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
reverse4(uint8_t * bytes)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