Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 1 | // Copyright (c) 2010 The Chromium OS Authors. All rights reserved. |
| 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
| 5 | #include <errno.h> |
| 6 | #include <fcntl.h> |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 7 | #include <limits.h> |
Tom Wai-Hong Tam | ee2bc91 | 2011-02-17 12:58:58 +0800 | [diff] [blame] | 8 | #include <lzma.h> |
Bill Richardson | 0c3ba24 | 2013-03-29 11:09:30 -0700 | [diff] [blame] | 9 | #include <stdint.h> |
| 10 | #include <stdlib.h> |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 11 | #include <stdio.h> |
| 12 | #include <string.h> |
| 13 | #include <sys/mman.h> |
| 14 | #include <sys/stat.h> |
| 15 | #include <sys/types.h> |
| 16 | #include <unistd.h> |
| 17 | |
| 18 | #include "bmpblk_util.h" |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 19 | #include "eficompress.h" |
Bill Richardson | 0c3ba24 | 2013-03-29 11:09:30 -0700 | [diff] [blame] | 20 | #include "vboot_api.h" |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 21 | |
| 22 | // Returns pointer to buffer containing entire file, sets length. |
| 23 | static void *read_entire_file(const char *filename, size_t *length) { |
| 24 | int fd; |
| 25 | struct stat sbuf; |
| 26 | void *ptr; |
| 27 | |
| 28 | *length = 0; // just in case |
| 29 | |
| 30 | if (0 != stat(filename, &sbuf)) { |
| 31 | fprintf(stderr, "Unable to stat %s: %s\n", filename, strerror(errno)); |
| 32 | return 0; |
| 33 | } |
| 34 | |
| 35 | if (!sbuf.st_size) { |
| 36 | fprintf(stderr, "File %s is empty\n", filename); |
| 37 | return 0; |
| 38 | } |
| 39 | |
| 40 | fd = open(filename, O_RDONLY); |
| 41 | if (fd < 0) { |
| 42 | fprintf(stderr, "Unable to open %s: %s\n", filename, strerror(errno)); |
| 43 | return 0; |
| 44 | } |
| 45 | |
| 46 | ptr = mmap(0, sbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); |
| 47 | if (MAP_FAILED == ptr) { |
| 48 | fprintf(stderr, "Unable to mmap %s: %s\n", filename, strerror(errno)); |
| 49 | close(fd); |
| 50 | return 0; |
| 51 | } |
| 52 | |
| 53 | *length = sbuf.st_size; |
| 54 | |
| 55 | close(fd); |
| 56 | |
| 57 | return ptr; |
| 58 | } |
| 59 | |
| 60 | |
| 61 | // Reclaims buffer from read_entire_file(). |
| 62 | static void discard_file(void *ptr, size_t length) { |
| 63 | munmap(ptr, length); |
| 64 | } |
| 65 | |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 66 | ////////////////////////////////////////////////////////////////////////////// |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 67 | |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 68 | static int require_dir(const char *dirname) { |
| 69 | struct stat sbuf; |
| 70 | |
| 71 | if (0 == stat(dirname, &sbuf)) { |
| 72 | // Something's there. Is it a directory? |
| 73 | if (S_ISDIR(sbuf.st_mode)) { |
| 74 | return 0; |
| 75 | } |
| 76 | fprintf(stderr, "%s already exists and is not a directory\n", dirname); |
| 77 | return 1; |
| 78 | } |
| 79 | |
| 80 | // dirname doesn't exist. Try to create it. |
| 81 | if (ENOENT == errno) { |
| 82 | if (0 != mkdir(dirname, 0777)) { |
| 83 | fprintf(stderr, "Unable to create directory %s: %s\n", |
| 84 | dirname, strerror(errno)); |
| 85 | return 1; |
| 86 | } |
| 87 | return 0; |
| 88 | } |
| 89 | |
| 90 | fprintf(stderr, "Unable to stat %s: %s\n", dirname, strerror(errno)); |
| 91 | return 1; |
| 92 | } |
| 93 | |
| 94 | |
| 95 | |
| 96 | static void *do_efi_decompress(ImageInfo *img) { |
| 97 | void *ibuf; |
| 98 | void *sbuf; |
| 99 | void *obuf; |
| 100 | uint32_t isize; |
| 101 | uint32_t ssize; |
| 102 | uint32_t osize; |
| 103 | EFI_STATUS r; |
| 104 | |
Tom Wai-Hong Tam | ee2bc91 | 2011-02-17 12:58:58 +0800 | [diff] [blame] | 105 | ibuf = (void*)(img + 1); |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 106 | isize = img->compressed_size; |
| 107 | |
| 108 | r = EfiGetInfo(ibuf, isize, &osize, &ssize); |
| 109 | if (EFI_SUCCESS != r) { |
| 110 | fprintf(stderr, "EfiGetInfo() failed with code %d\n", |
| 111 | r); |
| 112 | return 0; |
| 113 | } |
| 114 | |
| 115 | sbuf = malloc(ssize); |
| 116 | if (!sbuf) { |
| 117 | fprintf(stderr, "Can't allocate %d bytes: %s\n", |
| 118 | ssize, |
| 119 | strerror(errno)); |
| 120 | return 0; |
| 121 | } |
| 122 | |
| 123 | obuf = malloc(osize); |
| 124 | if (!obuf) { |
| 125 | fprintf(stderr, "Can't allocate %d bytes: %s\n", |
| 126 | osize, |
| 127 | strerror(errno)); |
| 128 | free(sbuf); |
| 129 | return 0; |
| 130 | } |
| 131 | |
| 132 | r = EfiDecompress(ibuf, isize, obuf, osize, sbuf, ssize); |
| 133 | if (r != EFI_SUCCESS) { |
| 134 | fprintf(stderr, "EfiDecompress failed with code %d\n", r); |
| 135 | free(obuf); |
| 136 | free(sbuf); |
| 137 | return 0; |
| 138 | } |
| 139 | |
| 140 | free(sbuf); |
| 141 | return obuf; |
| 142 | } |
| 143 | |
| 144 | |
Tom Wai-Hong Tam | ee2bc91 | 2011-02-17 12:58:58 +0800 | [diff] [blame] | 145 | |
| 146 | static void *do_lzma_decompress(ImageInfo *img) { |
| 147 | void *ibuf; |
| 148 | void *obuf; |
| 149 | uint32_t isize; |
| 150 | uint32_t osize; |
| 151 | lzma_stream stream = LZMA_STREAM_INIT; |
| 152 | lzma_ret result; |
| 153 | |
| 154 | ibuf = (void*)(img + 1); |
| 155 | isize = img->compressed_size; |
| 156 | osize = img->original_size; |
| 157 | obuf = malloc(osize); |
| 158 | if (!obuf) { |
| 159 | fprintf(stderr, "Can't allocate %d bytes: %s\n", |
| 160 | osize, |
| 161 | strerror(errno)); |
| 162 | return 0; |
| 163 | } |
| 164 | |
| 165 | result = lzma_auto_decoder(&stream, -1, 0); |
| 166 | if (result != LZMA_OK) { |
| 167 | fprintf(stderr, "Unable to initialize auto decoder (error: %d)!\n", |
| 168 | result); |
| 169 | free(obuf); |
| 170 | return 0; |
| 171 | } |
| 172 | |
| 173 | stream.next_in = ibuf; |
| 174 | stream.avail_in = isize; |
| 175 | stream.next_out = obuf; |
| 176 | stream.avail_out = osize; |
| 177 | result = lzma_code(&stream, LZMA_FINISH); |
| 178 | if (result != LZMA_STREAM_END) { |
| 179 | fprintf(stderr, "Unalbe to decode data (error: %d)!\n", result); |
| 180 | free(obuf); |
| 181 | return 0; |
| 182 | } |
| 183 | lzma_end(&stream); |
| 184 | return obuf; |
| 185 | } |
| 186 | |
| 187 | |
| 188 | |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 189 | // Show what's inside. If todir is NULL, just print. Otherwise unpack. |
| 190 | int dump_bmpblock(const char *infile, int show_as_yaml, |
| 191 | const char *todir, int overwrite) { |
| 192 | void *ptr, *data_ptr; |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 193 | size_t length = 0; |
| 194 | BmpBlockHeader *hdr; |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 195 | ImageInfo *img; |
| 196 | ScreenLayout *scr; |
| 197 | int loc_num; |
| 198 | int screen_num; |
| 199 | int i; |
| 200 | int offset; |
| 201 | int free_data; |
| 202 | char image_name[80]; |
| 203 | char full_path_name[PATH_MAX]; |
| 204 | int yfd, bfd; |
| 205 | FILE *yfp = stdout; |
| 206 | FILE *bfp = stdout; |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 207 | |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 208 | ptr = (void *)read_entire_file(infile, &length); |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 209 | if (!ptr) |
| 210 | return 1; |
| 211 | |
| 212 | if (length < sizeof(BmpBlockHeader)) { |
| 213 | fprintf(stderr, "File %s is too small to be a BMPBLOCK\n", infile); |
| 214 | discard_file(ptr, length); |
| 215 | return 1; |
| 216 | } |
| 217 | |
| 218 | if (0 != memcmp(ptr, BMPBLOCK_SIGNATURE, BMPBLOCK_SIGNATURE_SIZE)) { |
| 219 | fprintf(stderr, "File %s is not a BMPBLOCK\n", infile); |
| 220 | discard_file(ptr, length); |
| 221 | return 1; |
| 222 | } |
| 223 | |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 224 | if (todir) { |
| 225 | // Unpacking everything. Create the output directory if needed. |
| 226 | if (0 != require_dir(todir)) { |
| 227 | discard_file(ptr, length); |
| 228 | return 1; |
| 229 | } |
| 230 | |
| 231 | // Open yaml output. |
| 232 | show_as_yaml = 1; |
| 233 | |
| 234 | sprintf(full_path_name, "%s/%s", todir, "config.yaml"); |
| 235 | yfd = open(full_path_name, |
| 236 | O_WRONLY | O_CREAT | O_TRUNC | (overwrite ? 0 : O_EXCL), |
| 237 | 0666); |
| 238 | if (yfd < 0) { |
| 239 | fprintf(stderr, "Unable to open %s: %s\n", full_path_name, |
| 240 | strerror(errno)); |
| 241 | discard_file(ptr, length); |
| 242 | return 1; |
| 243 | } |
| 244 | |
| 245 | yfp = fdopen(yfd, "wb"); |
| 246 | if (!yfp) { |
| 247 | fprintf(stderr, "Unable to fdopen %s: %s\n", full_path_name, |
| 248 | strerror(errno)); |
| 249 | close(yfd); |
| 250 | discard_file(ptr, length); |
| 251 | return 1; |
| 252 | } |
| 253 | } |
| 254 | |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 255 | hdr = (BmpBlockHeader *)ptr; |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 256 | |
| 257 | if (!show_as_yaml) { |
| 258 | printf("%s:\n", infile); |
| 259 | printf(" version %d.%d\n", hdr->major_version, hdr->minor_version); |
| 260 | printf(" %d screens\n", hdr->number_of_screenlayouts); |
| 261 | printf(" %d localizations\n", hdr->number_of_localizations); |
| 262 | printf(" %d discrete images\n", hdr->number_of_imageinfos); |
| 263 | discard_file(ptr, length); |
| 264 | return 0; |
| 265 | } |
| 266 | |
| 267 | // Write out yaml |
| 268 | fprintf(yfp, "bmpblock: %d.%d\n", hdr->major_version, hdr->minor_version); |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 269 | offset = sizeof(BmpBlockHeader) + |
| 270 | (sizeof(ScreenLayout) * |
| 271 | hdr->number_of_localizations * |
| 272 | hdr->number_of_screenlayouts); |
Bill Richardson | a7209ee | 2011-02-17 14:30:14 -0800 | [diff] [blame] | 273 | // FIXME(chromium-os:12134): The bmbblock structure allows each image to be |
| 274 | // compressed differently, but we haven't provided a way for the yaml file to |
| 275 | // specify that. Additionally, we allow the yaml file to specify a default |
| 276 | // compression scheme for all images, but only if that line appears in the |
| 277 | // yaml file before any images. Accordingly, we'll just check the first image |
| 278 | // to see if it has any compression, and if it does, we'll write that out as |
| 279 | // the default. When this bug is fixed, we should just write each image's |
| 280 | // compression setting separately. |
| 281 | img = (ImageInfo *)(ptr + offset); |
| 282 | if (img->compression) |
| 283 | fprintf(yfp, "compression: %d\n", img->compression); |
| 284 | fprintf(yfp, "images:\n"); |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 285 | for(i=0; i<hdr->number_of_imageinfos; i++) { |
| 286 | img = (ImageInfo *)(ptr + offset); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 287 | if (img->compressed_size) { |
| 288 | sprintf(image_name, "img_%08x.bmp", offset); |
| 289 | if (img->tag == TAG_HWID) { |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 290 | fprintf(yfp, " %s: %s # %dx%d %d/%d tag=%d fmt=%d\n", |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 291 | RENDER_HWID, image_name, |
| 292 | img->width, img->height, |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 293 | img->compressed_size, img->original_size, |
| 294 | img->tag, img->format); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 295 | } else if (img->tag == TAG_HWID_RTOL) { |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 296 | fprintf(yfp, " %s: %s # %dx%d %d/%d tag=%d fmt=%d\n", |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 297 | RENDER_HWID_RTOL, image_name, |
| 298 | img->width, img->height, |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 299 | img->compressed_size, img->original_size, |
| 300 | img->tag, img->format); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 301 | } else { |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 302 | fprintf(yfp, " img_%08x: %s # %dx%d %d/%d tag=%d fmt=%d\n", |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 303 | offset, image_name, |
| 304 | img->width, img->height, |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 305 | img->compressed_size, img->original_size, |
| 306 | img->tag, img->format); |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 307 | } |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 308 | if (todir) { |
| 309 | sprintf(full_path_name, "%s/%s", todir, image_name); |
| 310 | bfd = open(full_path_name, |
| 311 | O_WRONLY | O_CREAT | O_TRUNC | (overwrite ? 0 : O_EXCL), |
| 312 | 0666); |
| 313 | if (bfd < 0) { |
| 314 | fprintf(stderr, "Unable to open %s: %s\n", full_path_name, |
| 315 | strerror(errno)); |
| 316 | fclose(yfp); |
| 317 | discard_file(ptr, length); |
| 318 | return 1; |
| 319 | } |
| 320 | bfp = fdopen(bfd, "wb"); |
| 321 | if (!bfp) { |
| 322 | fprintf(stderr, "Unable to fdopen %s: %s\n", full_path_name, |
| 323 | strerror(errno)); |
| 324 | close(bfd); |
| 325 | fclose(yfp); |
| 326 | discard_file(ptr, length); |
| 327 | return 1; |
| 328 | } |
| 329 | switch(img->compression) { |
| 330 | case COMPRESS_NONE: |
| 331 | data_ptr = ptr + offset + sizeof(ImageInfo); |
| 332 | free_data = 0; |
| 333 | break; |
| 334 | case COMPRESS_EFIv1: |
| 335 | data_ptr = do_efi_decompress(img); |
| 336 | if (!data_ptr) { |
| 337 | fclose(bfp); |
| 338 | fclose(yfp); |
| 339 | discard_file(ptr, length); |
| 340 | return 1; |
| 341 | } |
| 342 | free_data = 1; |
| 343 | break; |
| 344 | case COMPRESS_LZMA1: |
| 345 | data_ptr = do_lzma_decompress(img); |
| 346 | if (!data_ptr) { |
| 347 | fclose(bfp); |
| 348 | fclose(yfp); |
| 349 | discard_file(ptr, length); |
| 350 | return 1; |
| 351 | } |
| 352 | free_data = 1; |
| 353 | break; |
| 354 | default: |
| 355 | fprintf(stderr, "Unsupported compression method encountered.\n"); |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 356 | fclose(bfp); |
| 357 | fclose(yfp); |
| 358 | discard_file(ptr, length); |
| 359 | return 1; |
| 360 | } |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 361 | if (1 != fwrite(data_ptr, img->original_size, 1, bfp)) { |
| 362 | fprintf(stderr, "Unable to write %s: %s\n", full_path_name, |
| 363 | strerror(errno)); |
Tom Wai-Hong Tam | ee2bc91 | 2011-02-17 12:58:58 +0800 | [diff] [blame] | 364 | fclose(bfp); |
| 365 | fclose(yfp); |
| 366 | discard_file(ptr, length); |
| 367 | return 1; |
| 368 | } |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 369 | fclose(bfp); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 370 | if (free_data) |
| 371 | free(data_ptr); |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 372 | } |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 373 | } |
| 374 | offset += sizeof(ImageInfo); |
| 375 | offset += img->compressed_size; |
| 376 | // 4-byte aligned |
| 377 | if ((offset & 3) > 0) |
| 378 | offset = (offset & ~3) + 4; |
| 379 | } |
| 380 | fprintf(yfp, "screens:\n"); |
| 381 | for(loc_num = 0; |
| 382 | loc_num < hdr->number_of_localizations; |
| 383 | loc_num++) { |
| 384 | for(screen_num = 0; |
| 385 | screen_num < hdr->number_of_screenlayouts; |
| 386 | screen_num++) { |
| 387 | fprintf(yfp, " scr_%d_%d:\n", loc_num, screen_num); |
| 388 | i = loc_num * hdr->number_of_screenlayouts + screen_num; |
| 389 | offset = sizeof(BmpBlockHeader) + i * sizeof(ScreenLayout); |
| 390 | scr = (ScreenLayout *)(ptr + offset); |
| 391 | for(i=0; i<MAX_IMAGE_IN_LAYOUT; i++) { |
| 392 | if (scr->images[i].image_info_offset) { |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 393 | ImageInfo *iptr = |
| 394 | (ImageInfo *)(ptr + scr->images[i].image_info_offset); |
| 395 | if (iptr->tag == TAG_HWID) { |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 396 | fprintf(yfp, " - [%d, %d, %s] # tag=%d fmt=%d c=%d %d/%d\n", |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 397 | scr->images[i].x, scr->images[i].y, |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 398 | RENDER_HWID, iptr->tag, iptr->format, iptr->compression, |
| 399 | iptr->compressed_size, iptr->original_size); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 400 | } else if (iptr->tag == TAG_HWID_RTOL) { |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 401 | fprintf(yfp, " - [%d, %d, %s] # tag=%d fmt=%d c=%d %d/%d\n", |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 402 | scr->images[i].x, scr->images[i].y, |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 403 | RENDER_HWID_RTOL, iptr->tag, |
| 404 | iptr->format, iptr->compression, |
| 405 | iptr->compressed_size, iptr->original_size); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 406 | } else { |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 407 | fprintf(yfp, " - [%d, %d, img_%08x]" |
| 408 | " # tag=%d fmt=%d c=%d %d/%d\n", |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 409 | scr->images[i].x, scr->images[i].y, |
Bill Richardson | 0a9977e | 2011-08-22 16:03:59 -0700 | [diff] [blame] | 410 | scr->images[i].image_info_offset, |
| 411 | iptr->tag, iptr->format, iptr->compression, |
| 412 | iptr->compressed_size, iptr->original_size); |
Bill Richardson | 54e9582 | 2011-05-05 15:12:10 -0700 | [diff] [blame] | 413 | } |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 414 | } |
| 415 | } |
| 416 | } |
| 417 | } |
| 418 | fprintf(yfp, "localizations:\n"); |
| 419 | for(loc_num = 0; |
| 420 | loc_num < hdr->number_of_localizations; |
| 421 | loc_num++) { |
| 422 | fprintf(yfp, " - ["); |
| 423 | for(screen_num = 0; |
| 424 | screen_num < hdr->number_of_screenlayouts; |
| 425 | screen_num++) { |
| 426 | fprintf(yfp, " scr_%d_%d", loc_num, screen_num); |
| 427 | if (screen_num != hdr->number_of_screenlayouts - 1) |
| 428 | fprintf(yfp, ","); |
| 429 | } |
| 430 | fprintf(yfp, " ]\n"); |
| 431 | } |
| 432 | |
Bill Richardson | 8ba3d79 | 2011-05-18 18:25:31 -0700 | [diff] [blame] | 433 | if (hdr->locale_string_offset) { |
| 434 | char *loc_ptr = (char *)ptr + hdr->locale_string_offset; |
| 435 | char c; |
| 436 | fprintf(yfp, "locale_index:\n"); |
| 437 | while ((c = *loc_ptr) != '\0') { |
| 438 | fprintf(yfp, " - "); |
| 439 | do { |
| 440 | fputc(c, yfp); |
| 441 | loc_ptr++; |
| 442 | } while((c = *loc_ptr) != '\0'); |
| 443 | loc_ptr++; |
| 444 | fputc('\n', yfp); |
| 445 | } |
| 446 | } |
| 447 | |
Bill Richardson | 61362d6 | 2011-02-14 10:28:03 -0800 | [diff] [blame] | 448 | if (todir) |
| 449 | fclose(yfp); |
Bill Richardson | 794d4d4 | 2011-02-10 19:13:10 -0800 | [diff] [blame] | 450 | |
| 451 | discard_file(ptr, length); |
| 452 | |
| 453 | return 0; |
| 454 | } |
| 455 | |