1 /* $NetBSD: gzboot.c,v 1.16 2020/02/12 19:55:32 thorpej Exp $ */ 2 3 /* 4 * Copyright (c) 2002 Wasabi Systems, Inc. 5 * All rights reserved. 6 * 7 * Written by Jason R. Thorpe for Wasabi Systems, Inc. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed for the NetBSD Project by 20 * Wasabi Systems, Inc. 21 * 4. The name of Wasabi Systems, Inc. may not be used to endorse 22 * or promote products derived from this software without specific prior 23 * written permission. 24 * 25 * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``AS IS'' AND 26 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 27 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 28 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL WASABI SYSTEMS, INC 29 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 * POSSIBILITY OF SUCH DAMAGE. 36 */ 37 38 /* 39 * The Gzip header parser and libz interface glue are derived from 40 * sys/lib/libsa/cread.c, which carries the following notice: 41 * 42 * Copyright (c) 1996 43 * Matthias Drochner. All rights reserved. 44 * 45 * Redistribution and use in source and binary forms, with or without 46 * modification, are permitted provided that the following conditions 47 * are met: 48 * 1. Redistributions of source code must retain the above copyright 49 * notice, this list of conditions and the following disclaimer. 50 * 2. Redistributions in binary form must reproduce the above copyright 51 * notice, this list of conditions and the following disclaimer in the 52 * documentation and/or other materials provided with the distribution. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 55 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 56 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 57 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 58 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 59 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 60 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 61 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 62 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 63 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 64 */ 65 66 #include <sys/param.h> 67 #include <lib/libsa/stand.h> 68 #include <lib/libkern/libkern.h> 69 #include <lib/libz/libz.h> 70 71 #include "board.h" 72 #include "gzboot.h" 73 74 /* zlib glue defns */ 75 76 #define EOF (-1) /* needed by compression code */ 77 78 #define Z_BUFSIZE 1024 79 80 static const int gz_magic[2] = { 0x1f, 0x8b }; /* gzip magic header */ 81 82 /* gzip flag byte */ 83 #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ 84 #define HEAD_CRC 0x02 /* bit 1 set: header CRC present */ 85 #define EXTRA_FIELD 0x04 /* bit 2 set: extra field present */ 86 #define ORIG_NAME 0x08 /* bit 3 set: original file name present */ 87 #define COMMENT 0x10 /* bit 4 set: file comment present */ 88 #define RESERVED 0xe0 /* bits 5..7: reserved */ 89 90 struct state { 91 z_stream stream; 92 int z_err; /* error code for last stream operation */ 93 int z_eof; /* set of end of input file */ 94 const unsigned char *srcbuf;/* source buffer */ 95 size_t srcoff; /* source buffer offset */ 96 size_t srcsize;/* size of source buffer */ 97 unsigned char *inbuf; /* input buffer */ 98 uint32_t crc; /* crc32 of uncompressed data */ 99 int spinny; /* twiddle every N reads */ 100 }; 101 102 static uint32_t get_u8(struct state *); 103 static uint32_t get_u32(struct state *); 104 static int check_header(struct state *); 105 106 /* XXX - find a suitable header for these: */ 107 void zmemcpy(unsigned char *, unsigned char *, unsigned int); 108 109 /* end zlib glue defns */ 110 111 void main(void); 112 void gzcopy(void *, const void *, size_t); 113 114 #ifdef GZSRCADDR 115 #define compressed_image (void *)GZSRCADDR 116 #else 117 #define compressed_image md_root_image 118 #endif 119 120 void 121 main(void) 122 { 123 extern char bootprog_name[], bootprog_rev[]; 124 void (*loadaddr)(void) = (void *) md_root_loadaddr; 125 126 cons_init(); 127 128 printf("\n"); 129 printf(">> %s, Revision %s\n", bootprog_name, bootprog_rev); 130 131 board_init(); 132 133 printf(">> Load address: 0x%x\n", md_root_loadaddr); 134 135 /* 136 * If md_root_size is 0, then it means that we are simply 137 * decompressing from an image which was concatenated onto 138 * the end of the gzboot binary. 139 */ 140 #ifdef GZSRCADDR 141 printf(">> Image address: %p\n", compressed_image); 142 #endif 143 if (md_root_size != 0) 144 printf(">> Image size: %u\n", md_root_size); 145 146 printf("Uncompressing image..."); 147 gzcopy((void *) loadaddr, compressed_image, md_root_size); 148 printf("done.\n"); 149 150 printf("Jumping to image @ 0x%x...\n", md_root_loadaddr); 151 152 board_fini(); 153 154 (*loadaddr)(); 155 156 _rtt(); 157 } 158 159 void abort(void); 160 void 161 abort(void) 162 { 163 164 for (;;) ; 165 } 166 167 __dead void 168 _rtt(void) 169 { 170 171 for (;;) ; 172 } 173 174 /* internal utility routines */ 175 176 static ssize_t 177 readbuf(struct state *s, void *buf, size_t len) 178 { 179 180 if (s->srcsize != 0 && len > (s->srcsize - s->srcoff)) 181 len = s->srcsize - s->srcoff; 182 183 if ((s->spinny++ & 7) == 0) 184 twiddle(); 185 memcpy(buf, s->srcbuf + s->srcoff, len); 186 s->srcoff += len; 187 188 return (len); 189 } 190 191 static ssize_t 192 readgz(struct state *s, void *buf, size_t len) 193 { 194 unsigned char *start = buf; /* start for CRC computation */ 195 196 if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) 197 return (-1); 198 if (s->z_err == Z_STREAM_END) 199 return (0); /* EOF */ 200 201 s->stream.next_out = buf; 202 s->stream.avail_out = len; 203 204 while (s->stream.avail_out != 0) { 205 if (s->stream.avail_in == 0 && s->z_eof == 0) { 206 ssize_t got; 207 got = readbuf(s, s->inbuf, Z_BUFSIZE); 208 if (got <= 0) 209 s->z_eof = 1; 210 s->stream.avail_in = got; 211 s->stream.next_in = s->inbuf; 212 } 213 214 s->z_err = inflate(&s->stream, Z_NO_FLUSH); 215 216 if (s->z_err == Z_STREAM_END) { 217 /* Check CRC and original size */ 218 s->crc = crc32(s->crc, start, (unsigned int) 219 (s->stream.next_out - start)); 220 start = s->stream.next_out; 221 222 if (get_u32(s) != s->crc) { 223 printf("FATAL: CRC checksum mismatch\n"); 224 s->z_err = Z_DATA_ERROR; 225 } 226 if (get_u32(s) != s->stream.total_out) { 227 printf("FATAL: total output mismatch\n"); 228 s->z_err = Z_DATA_ERROR; 229 } 230 s->z_eof = 1; 231 } 232 if (s->z_err != Z_OK && s->z_err != Z_STREAM_END) { 233 printf("FATAL: error %d from zlib\n", 234 s->z_err); 235 return (-1); 236 } 237 if (s->z_err != Z_OK || s->z_eof) 238 break; 239 } 240 241 s->crc = crc32(s->crc, start, 242 (unsigned int)(s->stream.next_out - start)); 243 244 return ((ssize_t) (len - s->stream.avail_out)); 245 } 246 247 /* util routines for zlib */ 248 249 void 250 zmemcpy(unsigned char *dst, unsigned char *src, unsigned int len) 251 { 252 253 memcpy(dst, src, len); 254 } 255 256 /* gzip utility routines */ 257 258 static uint32_t 259 get_u8(struct state *s) 260 { 261 262 if (s->z_eof) 263 return (EOF); 264 265 if (s->stream.avail_in == 0) { 266 ssize_t got; 267 268 got = readbuf(s, s->inbuf, Z_BUFSIZE); 269 if (got <= 0) { 270 s->z_eof = 1; 271 return (EOF); 272 } 273 s->stream.avail_in = got; 274 s->stream.next_in = s->inbuf; 275 } 276 s->stream.avail_in--; 277 return (*(s->stream.next_in)++); 278 } 279 280 static uint32_t 281 get_u32(struct state *s) 282 { 283 uint32_t x, c; 284 285 x = get_u8(s); 286 x |= get_u8(s) << 8; 287 x |= get_u8(s) << 16; 288 c = get_u8(s); 289 if (c == EOF) 290 s->z_err = Z_DATA_ERROR; 291 x |= c << 24; 292 return (x); 293 } 294 295 static int 296 check_header(struct state *s) 297 { 298 int method; /* method byte */ 299 int flags; /* flags byte */ 300 unsigned int len; 301 int c; 302 303 /* Check the gzip magic header */ 304 for (len = 0; len < 2; len++) { 305 c = get_u8(s); 306 if (c == gz_magic[len]) 307 continue; 308 printf("FATAL: not a Gzip'd image\n"); 309 return (1); 310 } 311 312 method = get_u8(s); 313 flags = get_u8(s); 314 if (method != Z_DEFLATED || (flags & RESERVED) != 0) { 315 printf("FATAL: invalid Gzip header\n"); 316 return (1); 317 } 318 319 /* Discard time, xflags, and OS code: */ 320 for (len = 0; len < 6; len++) 321 (void) get_u8(s); 322 323 if (flags & EXTRA_FIELD) { 324 /* skip the extra field */ 325 len = get_u8(s); 326 len |= get_u8(s) << 8; 327 /* len is garbage if EOF, but the loop below will quit anyway */ 328 while (len-- && get_u8(s) != EOF) 329 /* loop */; 330 } 331 if (flags & ORIG_NAME) { 332 /* skip the original file name */ 333 while ((c = get_u8(s)) != 0 && c != EOF) 334 /* loop */; 335 } 336 if (flags & COMMENT) { 337 /* skip the file comment */ 338 while ((c = get_u8(s)) != 0 && c != EOF) 339 /* loop */; 340 } 341 if (flags & HEAD_CRC) { 342 /* skip header CRC */ 343 for (len = 0; len < 2; len++) 344 (void) get_u8(s); 345 } 346 347 if (s->z_eof) { 348 printf("FATAL: end of image encountered parsing Gzip header\n"); 349 return (1); 350 } 351 352 /* OK! */ 353 return (0); 354 } 355 356 /* the actual gzcopy routine */ 357 358 void 359 gzcopy(void *dst, const void *src, size_t srclen) 360 { 361 struct state state; 362 unsigned char *cp = dst; 363 ssize_t len; 364 365 memset(&state, 0, sizeof(state)); 366 367 state.z_err = Z_OK; 368 state.srcbuf = src; 369 state.srcsize = srclen; 370 371 if (inflateInit2(&state.stream, -15) != Z_OK) { 372 printf("FATAL: inflateInit2 failed\n"); 373 _rtt(); 374 } 375 376 state.stream.next_in = state.inbuf = alloc(Z_BUFSIZE); 377 if (state.inbuf == NULL) { 378 inflateEnd(&state.stream); 379 printf("FATAL: unable to allocate Z buffer\n"); 380 _rtt(); 381 } 382 383 /* Skip the Gzip header. */ 384 if (check_header(&state)) { 385 inflateEnd(&state.stream); 386 dealloc(state.inbuf, Z_BUFSIZE); 387 _rtt(); 388 } 389 390 /* Uncompress the image! */ 391 while ((len = readgz(&state, cp, Z_BUFSIZE)) > 0) 392 cp += len; 393 if (len == -1) 394 _rtt(); 395 396 /* All done! */ 397 inflateEnd(&state.stream); 398 dealloc(state.inbuf, Z_BUFSIZE); 399 } 400
Indexes created Sat Sep 20 22:09:52 GMT 2025