src/unexnext.c

   1 /* Dump Emacs in macho format.
   2    Copyright (C) 1990, 1993 Free Software Foundation, Inc.
   3    Written by Bradley Taylor (btaylor@next.com).
   4
   5 This file is part of GNU Emacs.
   6
   7 GNU Emacs is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU Emacs is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU Emacs; see the file COPYING.  If not, write to
  19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #undef __STRICT_BSD__
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <stdarg.h>
  28 #include <mach/mach.h>
  29 #include <mach-o/loader.h>
  30 #include <sys/file.h>
  31 #include <sys/stat.h>
  32 #include <libc.h>
  33
  34
  35 int malloc_cookie;
  36
  37 /*
  38  * Kludge: we don't expect any program data beyond VM_HIGHDATA
  39  * What is really needed is a way to find out from malloc() which
  40  * pages it vm_allocated and write only those out into the data segment.
  41  *
  42  * This kludge may break when we stop using fixed virtual address
  43  * shared libraries. Actually, emacs will probably continue working, but be
  44  * much larger on disk than it needs to be (because non-malloced data will
  45  * be in the file).
  46  */
  47 static const unsigned VM_HIGHDATA = 0x2000000;
  48
  49 typedef struct region_t {
  50         vm_address_t address;
  51         vm_size_t size;
  52         vm_prot_t protection;
  53         vm_prot_t max_protection;
  54         vm_inherit_t inheritance;
  55         boolean_t shared;
  56         port_t object_name;
  57         vm_offset_t offset;
  58 } region_t;
  59
  60
  61 static void
  62 grow(
  63      struct load_command ***the_commands,
  64      unsigned *the_commands_len
  65      )
  66 {
  67         if (*the_commands == NULL) {
  68                 *the_commands_len = 1;
  69                 *the_commands = malloc(sizeof(*the_commands));
  70         } else {
  71                 (*the_commands_len)++;
  72                 *the_commands = realloc(*the_commands,
  73                                         (*the_commands_len *
  74                                          sizeof(**the_commands)));
  75         }
  76 }
  77
  78
  79 static void
  80 save_command(
  81              struct load_command *command,
  82              struct load_command ***the_commands,
  83              unsigned *the_commands_len
  84              )
  85 {
  86         struct load_command **tmp;
  87
  88         grow(the_commands, the_commands_len);
  89         tmp = &(*the_commands)[*the_commands_len - 1];
  90         *tmp = malloc(command->cmdsize);
  91         bcopy(command, *tmp, command->cmdsize);
  92 }
  93
  94 static void
  95 fatal_unexec(char *format, ...)
  96 {
  97         va_list ap;
  98
  99         va_start(ap, format);
 100         fprintf(stderr, "unexec: ");
 101         vfprintf(stderr, format, ap);
 102         fprintf(stderr, "\n");
 103         va_end(ap);
 104 }
 105
 106 static int
 107 read_macho(
 108            int fd,
 109            struct mach_header *the_header,
 110            struct load_command ***the_commands,
 111            unsigned *the_commands_len
 112            )
 113 {
 114         struct load_command command;
 115         struct load_command *buf;
 116         int i;
 117         int size;
 118
 119         if (read(fd, the_header, sizeof(*the_header)) != sizeof(*the_header)) {
 120                 fatal_unexec("cannot read macho header");
 121                 return (0);
 122         }
 123         for (i = 0; i < the_header->ncmds; i++) {
 124                 if (read(fd, &command, sizeof(struct load_command)) !=
 125                     sizeof(struct load_command)) {
 126                         fatal_unexec("cannot read macho load command header");
 127                         return (0);
 128                 }
 129                 size = command.cmdsize - sizeof(struct load_command);
 130                 if (size < 0) {
 131                         fatal_unexec("bogus load command size");
 132                         return (0);
 133                 }
 134                 buf = malloc(command.cmdsize);
 135                 buf->cmd = command.cmd;
 136                 buf->cmdsize = command.cmdsize;
 137                 if (read(fd, ((char *)buf +
 138                               sizeof(struct load_command)),
 139                          size) != size) {
 140                         fatal_unexec("cannot read load command data");
 141                         return (0);
 142                 }
 143                 save_command(buf, the_commands, the_commands_len);
 144         }
 145         return (1);
 146 }
 147
 148 static int
 149 filldatagap(
 150             vm_address_t start_address,
 151             vm_size_t *size,
 152             vm_address_t end_address
 153             )
 154 {
 155         vm_address_t address;
 156         vm_size_t gapsize;
 157
 158         address = (start_address + *size);
 159         gapsize = end_address - address;
 160         *size += gapsize;
 161         if (vm_allocate(task_self(), &address, gapsize,
 162                         FALSE) != KERN_SUCCESS) {
 163                 fatal_unexec("cannot vm_allocate");
 164                 return (0);
 165         }
 166         return (1);
 167 }
 168
 169 static int
 170 get_data_region(
 171                 vm_address_t *address,
 172                 vm_size_t *size
 173                 )
 174 {
 175         region_t region;
 176         kern_return_t ret;
 177         struct section *sect;
 178
 179         sect = (struct section *) getsectbyname(SEG_DATA, SECT_DATA);
 180         region.address = 0;
 181         *address = 0;
 182         for (;;) {
 183                 ret = vm_region(task_self(),
 184                                 &region.address,
 185                                 &region.size,
 186                                 &region.protection,
 187                                 &region.max_protection,
 188                                 &region.inheritance,
 189                                 &region.shared,
 190                                 &region.object_name,
 191                                 &region.offset);
 192                 if (ret != KERN_SUCCESS || region.address >= VM_HIGHDATA) {
 193                         break;
 194                 }
 195                 if (*address != 0) {
 196                         if (region.address > *address + *size) {
 197                                 if (!filldatagap(*address, size,
 198                                                  region.address)) {
 199                                         return (0);
 200                                 }
 201                         }
 202                         *size += region.size;
 203                 } else {
 204                         if (region.address == sect->addr) {
 205                                 *address = region.address;
 206                                 *size = region.size;
 207                         }
 208                 }
 209                 region.address += region.size;
 210         }
 211         return (1);
 212 }
 213
 214 static char *
 215 my_malloc(
 216           vm_size_t size
 217           )
 218 {
 219         vm_address_t address;
 220
 221         if (vm_allocate(task_self(), &address, size, TRUE) != KERN_SUCCESS) {
 222                 return (NULL);
 223         }
 224         return ((char *)address);
 225 }
 226
 227 static void
 228 my_free(
 229         char *buf,
 230         vm_size_t size
 231         )
 232 {
 233         vm_deallocate(task_self(), (vm_address_t)buf, size);
 234 }
 235
 236 static int
 237 unexec_doit(
 238             int infd,
 239             int outfd
 240             )
 241 {
 242         int i;
 243         struct load_command **the_commands = NULL;
 244         unsigned the_commands_len;
 245         struct mach_header the_header;
 246         int fgrowth;
 247         int fdatastart;
 248         int fdatasize;
 249         int size;
 250         struct stat st;
 251         char *buf;
 252         vm_address_t data_address;
 253         vm_size_t data_size;
 254
 255         struct segment_command *segment;
 256
 257         if (!read_macho(infd, &the_header, &the_commands, &the_commands_len)) {
 258                 return (0);
 259         }
 260
 261
 262         malloc_cookie = malloc_freezedry ();
 263         if (!get_data_region(&data_address, &data_size)) {
 264                 return (0);
 265         }
 266
 267
 268         /*
 269          * DO NOT USE MALLOC IN THIS SECTION
 270          */
 271         {
 272                 /*
 273                  * Fix offsets
 274                  */
 275                 for (i = 0; i < the_commands_len; i++) {
 276                         switch (the_commands[i]->cmd) {
 277                         case LC_SEGMENT:
 278                                 segment = ((struct segment_command *)
 279                                            the_commands[i]);
 280                                 if (strcmp(segment->segname, SEG_DATA) == 0) {
 281                                         fdatastart = segment->fileoff;
 282                                         fdatasize = segment->filesize;
 283                                         fgrowth = (data_size -
 284                                                    segment->filesize);
 285                                         segment->vmsize = data_size;
 286                                         segment->filesize = data_size;
 287                                 }
 288                                 break;
 289                         case LC_SYMTAB:
 290                                 ((struct symtab_command *)
 291                                  the_commands[i])->symoff += fgrowth;
 292                                 ((struct symtab_command *)
 293                                  the_commands[i])->stroff += fgrowth;
 294                                 break;
 295                         case LC_SYMSEG:
 296                                 ((struct symseg_command *)
 297                                  the_commands[i])->offset += fgrowth;
 298                                 break;
 299                         default:
 300                                 break;
 301                         }
 302                 }
 303
 304                 /*
 305                  * Write header
 306                  */
 307                 if (write(outfd, &the_header,
 308                           sizeof(the_header)) != sizeof(the_header)) {
 309                         fatal_unexec("cannot write output file");
 310                         return (0);
 311                 }
 312
 313                 /*
 314                  * Write commands
 315                  */
 316                 for (i = 0; i < the_commands_len; i++) {
 317                         if (write(outfd, the_commands[i],
 318                                   the_commands[i]->cmdsize) !=
 319                             the_commands[i]->cmdsize) {
 320                                 fatal_unexec("cannot write output file");
 321                                 return (0);
 322                         }
 323                 }
 324
 325                 /*
 326                  * Write original text
 327                  */
 328                 if (lseek(infd, the_header.sizeofcmds + sizeof(the_header),
 329                           L_SET) < 0) {
 330                         fatal_unexec("cannot seek input file");
 331                         return (0);
 332                 }
 333                 size = fdatastart - (sizeof(the_header) +
 334                                      the_header.sizeofcmds);
 335                 buf = my_malloc(size);
 336                 if (read(infd, buf, size) != size) {
 337                         my_free(buf, size);
 338                         fatal_unexec("cannot read input file");
 339                 }
 340                 if (write(outfd, buf, size) != size) {
 341                         my_free(buf, size);
 342                         fatal_unexec("cannot write output file");
 343                         return (0);
 344                 }
 345                 my_free(buf, size);
 346
 347
 348                 /*
 349                  * Write new data
 350                  */
 351                 if (write(outfd, (char *)data_address,
 352                           data_size) != data_size) {
 353                         fatal_unexec("cannot write output file");
 354                         return (0);
 355                 }
 356
 357         }
 358
 359         /*
 360          * OKAY TO USE MALLOC NOW
 361          */
 362
 363         /*
 364          * Write rest of file
 365          */
 366         fstat(infd, &st);
 367         if (lseek(infd, fdatasize, L_INCR) < 0) {
 368                 fatal_unexec("cannot seek input file");
 369                 return (0);
 370         }
 371         size = st.st_size - lseek(infd, 0, L_INCR);
 372
 373         buf = malloc(size);
 374         if (read(infd, buf, size) != size) {
 375                 free(buf);
 376                 fatal_unexec("cannot read input file");
 377                 return (0);
 378         }
 379         if (write(outfd, buf, size) != size) {
 380                 free(buf);
 381                 fatal_unexec("cannot write output file");
 382                 return (0);
 383         }
 384         free(buf);
 385         return (1);
 386 }
 387
 388 void
 389 unexec(
 390        char *outfile,
 391        char *infile
 392        )
 393 {
 394         int infd;
 395         int outfd;
 396         char tmpbuf[L_tmpnam];
 397         char *tmpfile;
 398
 399         infd = open(infile, O_RDONLY, 0);
 400         if (infd < 0) {
 401                 fatal_unexec("cannot open input file `%s'", infile);
 402                 exit(1);
 403         }
 404
 405         tmpnam(tmpbuf);
 406         tmpfile = rindex(tmpbuf, '/');
 407         if (tmpfile == NULL) {
 408                 tmpfile = tmpbuf;
 409         } else {
 410                 tmpfile++;
 411         }
 412         outfd = open(tmpfile, O_WRONLY|O_TRUNC|O_CREAT, 0755);
 413         if (outfd < 0) {
 414                 close(infd);
 415                 fatal_unexec("cannot open tmp file `%s'", tmpfile);
 416                 exit(1);
 417         }
 418         if (!unexec_doit(infd, outfd)) {
 419                 close(infd);
 420                 close(outfd);
 421                 unlink(tmpfile);
 422                 exit(1);
 423         }
 424         close(infd);
 425         close(outfd);
 426         if (rename(tmpfile, outfile) < 0) {
 427                 unlink(tmpfile);
 428                 fatal_unexec("cannot rename `%s' to `%s'", tmpfile, outfile);
 429                 exit(1);
 430         }
 431 }