installshield_main.c

   1 /*
   2   InstallShield Z file format
   3   Copyright 2015 <hacker@iam.tj>
   4   Licenced on the terms of then GNU General Public Licence version 3
   5
   6   Read and extract InstallShield .Z archive files
   7  */
   8
   9 #include <stdio.h>
  10 #include <sys/types.h>
  11 #include <sys/stat.h>
  12 #include <inttypes.h>
  13 #include <fcntl.h>
  14 #include <stdlib.h>
  15 #include <unistd.h>
  16 #include <errno.h>
  17 #include <string.h>
  18
  19 #include "installshield_z.h"
  20
  21 static const size_t BUFFER_SIZE = 0x4000;
  22 static bool debug = 0;
  23 static bool extract = 0;
  24
  25 void
  26 usage(const char *name)
  27 {
  28         printf("usage: %s %s\n\n", name,
  29                 " FILENAME\n"
  30                 " [-x|--extract]"
  31         );
  32 }
  33
  34 int
  35 headers_decode(int z_fd)
  36 {
  37         int result = -1;
  38         struct archive_header *header = NULL;
  39         off_t offset = 0;
  40         ssize_t qty = 0;
  41
  42         if (z_fd != -1 && (header = calloc(BUFFER_SIZE, 1))) {
  43                 offset = lseek(z_fd, offset, SEEK_SET);
  44                 if ((qty = read(z_fd, header, Z_FILE_HEADER_BYTES))< Z_FILE_HEADER_BYTES)
  45                         fprintf(stderr, "Warning: Tried to read %ld header bytes but only got %ld. Will do my best\n", Z_FILE_HEADER_BYTES, qty);
  46                 printf("Magic               %08x\n", header->magic);
  47                 printf("CRC32               %08x\n", header->__crc32);
  48                 printf("File size           %08x\n", header->file_bytes);
  49                 printf("Payload size        %08x\n", header->payload_bytes);
  50                 printf("Directories offset  %08x\n", header->directories_offset);
  51                 printf("Directories size    %08x\n", header->directories_bytes);
  52                 printf("Directories entries     %04x\n", header->directories_entries);
  53                 printf("Files offset        %08x\n", header->files_offset);
  54                 printf("Files size          %08x\n", header->files_bytes);
  55                 printf("Files entries           %04x\n", header->files_entries);
  56
  57                 offset = lseek(z_fd, header->directories_offset, SEEK_SET);
  58                 struct dirent_prefix *dirent, *p;
  59
  60                 if (offset == header->directories_offset && ((dirent = p = calloc(header->directories_bytes, 1)))) {
  61
  62                         if ((qty = read(z_fd, dirent, header->directories_bytes)) != header->directories_bytes)
  63                                 fprintf(stderr, "Warning: Tried to read %d directory bytes but only got %ld. Will do my best\n", header->directories_bytes, qty);
  64
  65                         printf("Directory entries: %d ( %08x bytes @ 0x%08x)\n", header->directories_entries, header->directories_bytes, header->directories_offset);
  66
  67                         struct ll_dirents dirents[header->directories_entries];
  68                         for (int i = 0; i < header->directories_entries; ++i) {
  69                                 printf(" Entry %4d Size %x @ %08x    \"%s\"\n", i, p->entry_bytes, header->directories_offset + (uint32_t)((void *)p - (void *)dirent), p->name);
  70                                 dirents[i].entry = p;
  71                                 p = (void *)p + p->entry_bytes;
  72                         }
  73
  74                         offset = lseek(z_fd, header->files_offset, SEEK_SET);
  75                         struct fileent_prefix *fileent, *q;
  76                         if (offset == header->files_offset && ((fileent = q = calloc(header->files_bytes, 1)))) {
  77                                 if ((qty = read(z_fd, fileent, header->files_bytes)) != header->files_bytes)
  78                                         fprintf(stderr, "Warning: Tried to read %d file entry bytes but only got %ld. Will do my best\n", header->files_bytes, qty);
  79
  80                                 printf("File entries: %d ( %08x bytes @ 0x%08x)\n", header->files_entries, header->files_bytes, header->files_offset);
  81
  82                                 for (int i = 0; i < header->files_entries; ++i) {
  83                                         printf(" Entry %4d Size %06x @ %08x payload size %06x @ %08x", i, q->entry_bytes, header->files_offset +(uint32_t)((void *)q - (void *)fileent), q->payload_bytes, q->payload_offset);
  84
  85                                         if (debug) {
  86                                                 printf(" next @ %08x", q->payload_offset + q->payload_bytes);
  87                                                 for (int r = 0; r < 0x1E; ++r)
  88                                                 printf(" %02x", *(unsigned char *)(r + (void *)q));
  89                                         }
  90
  91                                         printf(" \"%s\\%s\"\n", dirents[q->dir_index].entry->name, q->name);
  92
  93                                         char *dir_name = strdup(dirents[q->dir_index].entry->name);
  94                                         for (char *p = dir_name; *p; ++p)
  95                                                 if (*p == '\\') *p = '/';
  96                                         printf("Parsing '%s' (%d bytes)\n", dir_name, strlen(dir_name));
  97
  98                                         int dir_fd = AT_FDCWD;
  99                                         int dir_fd_last = dir_fd;
 100                                         if (extract) {
 101                                                 if (!dirents[q->dir_index].created) {
 102                                                         char *component = dir_name;
 103                                                         bool last_component = false;
 104                                                         for (char *sep = dir_name;; ++sep) {
 105                                                                 if (*sep == '/' || *sep == 0) {
 106                                                                         if (*sep == 0)
 107                                                                                 last_component = true;
 108                                                                         char temp = *sep;
 109                                                                         *sep = 0;
 110                                                                         if (strlen(component) > 0) {
 111                                                                                 if (debug) printf("Component: '%s' %d bytes @ %p\n", component, strlen(component), component);
 112                                                                                 int ret = mkdirat(dir_fd, component, 0755);
 113                                                                                 if (ret == 0 || (ret == -1 && errno == EEXIST)) {
 114                                                                                         if (debug)
 115                                                                                                 printf("Directory '%s' %s\n", component, ret == 0 ? "created" : "already exists");
 116                                                                                         dir_fd_last = dir_fd;
 117                                                                                         dir_fd = openat(dir_fd_last, component, O_DIRECTORY);
 118                                                                                         close(dir_fd_last);
 119                                                                                         if (dir_fd == -1) {
 120                                                                                                 fprintf(stderr, "Error %d: cannot open directory '%s': ", errno, component);
 121                                                                                                 perror(NULL);
 122                                                                                                 *sep = temp;
 123                                                                                                 break; // cannot continue if unable to open a path component
 124                                                                                         } else if (last_component == true) {
 125                                                                                                 dirents[q->dir_index].created = true;
 126                                                                                         }
 127                                                                                 } else {
 128                                                                                         fprintf(stderr, "Error %d: cannot create directory '%s': ", errno, component);
 129                                                                                         perror(NULL);
 130                                                                                         *sep = temp;
 131                                                                                         break; // leave the for() loop immediately
 132                                                                                 }
 133                                                                         } // strlen()
 134                                                                         *sep = temp;
 135                                                                         component = sep + 1;
 136                                                                         if (last_component) break;
 137                                                                 } // separator
 138                                                         } // for()
 139                                                         if (dir_fd < 0)
 140                                                                 dir_fd = AT_FDCWD;
 141                                                 } // .created == false
 142                                         }
 143                                         if ((dir_fd = openat(AT_FDCWD, dir_name, O_DIRECTORY)) != -1) {
 144
 145                                                 unsigned int z_filename_len = strlen(q->name) + 4;
 146                                                 char z_filename[z_filename_len];
 147                                                 strncpy(z_filename, q->name, z_filename_len);
 148                                                 strncat(z_filename, ".z", 2);
 149
 150                                                 if (debug)
 151                                                         printf(" Creating payload file '%s/%s'\n", dir_name,  z_filename);
 152
 153                                                 if ((offset = lseek(z_fd, q->payload_offset, SEEK_SET)) == q->payload_offset) {
 154                                                         void *buffer;
 155                                                         if ((buffer = calloc(q->payload_bytes, 1)) != 0) {
 156                                                                 int pay_fd;
 157                                                                 if ((pay_fd = openat(dir_fd, z_filename, O_WRONLY | O_CREAT | O_TRUNC, 0644))) {
 158                                                                         ssize_t z_qty, pay_qty;
 159                                                                         if ((z_qty = read(z_fd, buffer, q->payload_bytes)) == q->payload_bytes) {
 160                                                                                 if ((pay_qty = write(pay_fd, buffer, q->payload_bytes)) != q->payload_bytes)
 161                                                                                         fprintf(stderr, "Error: whilst writing payload expected %d bytes but wrote %ld\n", q->payload_bytes, pay_qty);
 162                                                                         } else
 163                                                                                 fprintf(stderr, "Error: whilst reading payload expected %d bytes but read %ld\n", q->payload_bytes, z_qty);
 164                                                                         close(pay_fd);
 165                                                                 }
 166                                                                 free(buffer);
 167                                                         }
 168                                                 } else {
 169                                                         fprintf(stderr, "Error %d: failed to create %s\n", errno, z_filename);
 170                                                 }
 171                                                 close(dir_fd);
 172                                         } else {
 173                                                 fprintf(stderr, "Error %d: cannot open directory at (%d) '%s': ", errno, dir_fd, dir_name);
 174                                                 perror(NULL);
 175                                         }
 176                                         free(dir_name);
 177                                         q = (void *)q + q->entry_bytes;
 178                                 }
 179                                 free(fileent);
 180                         }
 181                         free(dirent);
 182                 } else
 183                         fprintf(stderr, "Error: %s\n", "failed to seek or couldn't allocate memory for directories");
 184
 185                 free(header);
 186                 result = 0;
 187         }
 188         return result;
 189 }
 190
 191 int
 192 main(int argc, char **argv, char **env)
 193 {
 194         int result = -1;
 195         int fd = 0;
 196
 197         if (argc < 2 ) {
 198                 usage(argv[0]);
 199                 return 0;
 200         }
 201
 202         for (char **e = env; *e; ++e) {
 203                 if (strncmp("DEBUG", *e, 5) == 0)
 204                         debug = true;
 205         }
 206         for (char **a = argv; *a; ++a) {
 207                 if (debug) printf("Arg: %s\n", *a);
 208                 if (strncmp("-x", *a, 2) == 0 || strncmp("--extract", *a, 9) == 0)
 209                         extract = true;
 210         }
 211
 212         if ((fd = open(argv[1], O_RDONLY)) != -1) {
 213                 result = headers_decode(fd);
 214                 close(fd);
 215         } else {
 216                 fprintf(stderr, "Error: could not open %s\n", argv[0]);
 217                 return errno;
 218         }
 219
 220
 221         return result;
 222 }
 223