wine.c

   1 static char RCSId[] = "$Id: wine.c,v 1.1 1993/06/29 15:55:18 root Exp $";
   2 static char Copyright[] = "Copyright  Robert J. Amstadt, 1993";
   3
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <fcntl.h>
   9 #include <unistd.h>
  10 #include <linux/unistd.h>
  11 #include <linux/head.h>
  12 #include <linux/ldt.h>
  13 #include <linux/segment.h>
  14 #include <errno.h>
  15 #include "neexe.h"
  16 #include "segmem.h"
  17 #include "prototypes.h"
  18 #include "dlls.h"
  19
  20 extern int CallToInit16(unsigned long csip, unsigned long sssp,
  21                         unsigned short ds);
  22 extern void CallTo32();
  23
  24 unsigned short WIN_StackSize;
  25 unsigned short WIN_HeapSize;
  26
  27 char **Argv;
  28 int Argc;
  29 struct mz_header_s *CurrentMZHeader;
  30 struct ne_header_s *CurrentNEHeader;
  31 int CurrentNEFile;
  32
  33 /**********************************************************************
  34  *                                      DebugPrintString
  35  */
  36 int
  37 DebugPrintString(char *str)
  38 {
  39     printf("%s", str);
  40     return 0;
  41 }
  42
  43 /**********************************************************************
  44  *                                      myerror
  45  */
  46 void
  47 myerror(const char *s)
  48 {
  49     char buffer[200];
  50
  51     sprintf(buffer, "%s", Argv[0]);
  52     if (s == NULL)
  53         perror(buffer);
  54     else
  55         fprintf(stderr, "%s: %s\n", buffer, s);
  56
  57     exit(1);
  58 }
  59 \f
  60 /**********************************************************************
  61  *                                      main
  62  */
  63 main(int argc, char **argv)
  64 {
  65     struct stat finfo;
  66     struct mz_header_s *mz_header;
  67     struct ne_header_s *ne_header;
  68     struct ne_segment_table_entry_s *seg_table;
  69     unsigned int status;
  70     unsigned int read_size;
  71     struct segment_descriptor_s *selector_table;
  72     int fd;
  73     int segment;
  74     int cs_reg, ds_reg, ss_reg, ip_reg, sp_reg;
  75     int rv;
  76
  77     Argc = argc;
  78     Argv = argv;
  79
  80     if (argc < 2)
  81     {
  82         fprintf(stderr, "usage: %s FILENAME\n", argv[0]);
  83         exit(1);
  84     }
  85
  86     /*
  87      * Open file for reading.
  88      */
  89     fd = open(argv[1], O_RDONLY);
  90     if (fd < 0)
  91     {
  92         myerror(NULL);
  93     }
  94
  95     /*
  96      * Allocate memory to hold entire executable.
  97      */
  98     if (fstat(fd, &finfo) < 0)
  99         myerror(NULL);
 100
 101     /*
 102      * Establish header pointers.
 103      */
 104     mz_header = (struct mz_header_s *) malloc(sizeof(struct mz_header_s));;
 105     status = lseek(fd, 0, SEEK_SET);
 106     if (read(fd, mz_header, sizeof(struct mz_header_s)) !=
 107         sizeof(struct mz_header_s))
 108     {
 109         myerror("Unable to read MZ header from file");
 110     }
 111     if (mz_header->must_be_0x40 != 0x40)
 112         myerror("This is not a Windows program");
 113
 114     ne_header = (struct ne_header_s *) malloc(sizeof(struct ne_header_s));
 115     status = lseek(fd, mz_header->ne_offset, SEEK_SET);
 116     if (read(fd, ne_header, sizeof(struct ne_header_s))
 117         != sizeof(struct ne_header_s))
 118     {
 119         myerror("Unable to read NE header from file");
 120     }
 121     if (ne_header->header_type[0] != 'N' || ne_header->header_type[1] != 'E')
 122         myerror("This is not a Windows program");
 123
 124     CurrentMZHeader = mz_header;
 125     CurrentNEHeader = ne_header;
 126     CurrentNEFile   = fd;
 127
 128     WIN_StackSize = ne_header->stack_length;
 129     WIN_HeapSize = ne_header->local_heap_length;
 130
 131     /*
 132      * Create segment selectors.
 133      */
 134     status = lseek(fd, mz_header->ne_offset + ne_header->segment_tab_offset,
 135                    SEEK_SET);
 136     read_size  = ne_header->n_segment_tab *
 137                  sizeof(struct ne_segment_table_entry_s);
 138     seg_table = (struct ne_segment_table_entry_s *) malloc(read_size);
 139     if (read(fd, seg_table, read_size) != read_size)
 140         myerror("Unable to read segment table header from file");
 141     selector_table = CreateSelectors(fd, seg_table, ne_header);
 142
 143     /*
 144      * Fixup references.
 145      */
 146     for (segment = 0; segment < ne_header->n_segment_tab; segment++)
 147     {
 148         if (FixupSegment(fd, mz_header, ne_header, seg_table,
 149                          selector_table, segment) < 0)
 150         {
 151             myerror("fixup failed.");
 152         }
 153     }
 154
 155     /*
 156      * Fixup stack and jump to start.
 157      */
 158     ds_reg = selector_table[ne_header->auto_data_seg-1].selector;
 159     cs_reg = selector_table[ne_header->cs-1].selector;
 160     ip_reg = ne_header->ip;
 161     ss_reg = selector_table[ne_header->ss-1].selector;
 162     sp_reg = ne_header->sp;
 163
 164     rv = CallToInit16(cs_reg << 16 | ip_reg, ss_reg << 16 | sp_reg, ds_reg);
 165     printf ("rv = %x\n", rv);
 166 }
 167
 168 \f
 169 /**********************************************************************
 170  *                                      GetImportedName
 171  */
 172 char *
 173 GetImportedName(int fd, struct mz_header_s *mz_header,
 174                 struct ne_header_s *ne_header, int name_offset, char *buffer)
 175 {
 176     char *p;
 177     int length;
 178     int status;
 179     int i;
 180
 181     status = lseek(fd, mz_header->ne_offset + ne_header->iname_tab_offset +
 182                    name_offset, SEEK_SET);
 183     length = 0;
 184     read(fd, &length, 1);  /* Get the length byte */
 185     read(fd, buffer, length);
 186     buffer[length] = 0;
 187     return buffer;
 188 }
 189
 190 /**********************************************************************
 191  *                                      GetModuleName
 192  */
 193 char *
 194 GetModuleName(int fd, struct mz_header_s *mz_header,
 195               struct ne_header_s *ne_header, int index, char *buffer)
 196 {
 197     char *p;
 198     int length;
 199     int name_offset, status;
 200     int i;
 201
 202     status = lseek(fd, mz_header->ne_offset + ne_header->moduleref_tab_offset +
 203                    2*(index - 1), SEEK_SET);
 204     name_offset = 0;
 205     read(fd, &name_offset, 2);
 206     status = lseek(fd, mz_header->ne_offset + ne_header->iname_tab_offset +
 207                    name_offset, SEEK_SET);
 208     length = 0;
 209     read(fd, &length, 1);  /* Get the length byte */
 210     read(fd, buffer, length);
 211     buffer[length] = 0;
 212     return buffer;
 213 }
 214
 215 \f
 216 /**********************************************************************
 217  *                                      FixupSegment
 218  */
 219 int
 220 FixupSegment(int fd, struct mz_header_s * mz_header,
 221              struct ne_header_s *ne_header,
 222              struct ne_segment_table_entry_s *seg_table,
 223              struct segment_descriptor_s *selector_table,
 224              int segment_num)
 225 {
 226     struct relocation_entry_s *rep, *rep1;
 227     struct ne_segment_table_entry_s *seg;
 228     struct segment_descriptor_s *sel;
 229     struct dll_table_entry_s *dll_table;
 230     unsigned short *sp;
 231     unsigned int selector, address;
 232     unsigned int next_addr;
 233     int ordinal;
 234     int status;
 235     char dll_name[257];
 236     char func_name[257];
 237     int i, n_entries;
 238
 239     seg = &seg_table[segment_num];
 240     sel = &selector_table[segment_num];
 241
 242     if (seg->seg_data_offset == 0)
 243         return 0;
 244
 245     /*
 246      * Go through the relocation table on entry at a time.
 247      */
 248     i = seg->seg_data_length;
 249     if (i == 0)
 250         i = 0x10000;
 251
 252     status = lseek(fd, seg->seg_data_offset *
 253                        (1 << ne_header->align_shift_count) + i, SEEK_SET);
 254     n_entries = 0;
 255     read(fd, &n_entries, sizeof(short int));
 256     rep = (struct relocation_entry_s *)
 257           malloc(n_entries * sizeof(struct relocation_entry_s));
 258
 259     if (read(fd,rep, n_entries * sizeof(struct relocation_entry_s)) !=
 260         n_entries * sizeof(struct relocation_entry_s))
 261     {
 262         myerror("Unable to read relocation information");
 263     }
 264
 265     rep1 = rep;
 266
 267     for (i = 0; i < n_entries; i++, rep++)
 268     {
 269         /*
 270          * Get the target address corresponding to this entry.
 271          */
 272         switch (rep->relocation_type)
 273         {
 274           case NE_RELTYPE_ORDINAL:
 275             if (GetModuleName(fd, mz_header, ne_header, rep->target1,
 276                               dll_name) == NULL)
 277             {
 278                 return -1;
 279             }
 280
 281             dll_table = FindDLLTable(dll_name);
 282             if (dll_table == NULL)
 283             {
 284                 char s[80];
 285
 286                 sprintf(s, "Bad DLL name '%s'", dll_name);
 287                 myerror(s);
 288                 return -1;
 289             }
 290
 291             ordinal = rep->target2;
 292             selector = dll_table[ordinal].selector;
 293             address  = (unsigned int) dll_table[ordinal].address;
 294 #ifdef DEBUG_FIXUP
 295             printf("%d: %s.%d: %04.4x:%04.4x\n", i + 1, dll_name, ordinal,
 296                    selector, address);
 297 #endif
 298             break;
 299
 300           case NE_RELTYPE_NAME:
 301             if (GetModuleName(fd, mz_header, ne_header, rep->target1, dll_name)
 302                 == NULL)
 303             {
 304                 return -1;
 305             }
 306             dll_table = FindDLLTable(dll_name);
 307             if (dll_table == NULL)
 308             {
 309                 char s[80];
 310
 311                 sprintf(s, "Bad DLL name '%s'", dll_name);
 312                 myerror(s);
 313                 return -1;
 314             }
 315
 316             if (GetImportedName(fd, mz_header, ne_header,
 317                                 rep->target2, func_name) == NULL)
 318             {
 319                 return -1;
 320             }
 321             ordinal = FindOrdinalFromName(dll_table, func_name);
 322             selector = dll_table[ordinal].selector;
 323             address  = (unsigned int) dll_table[ordinal].address;
 324 #ifdef DEBUG_FIXUP
 325             printf("%d: %s %s.%d: %04.4x:%04.4x\n", i + 1, func_name,
 326                    dll_name, ordinal, selector, address);
 327 #endif
 328             break;
 329
 330           case NE_RELTYPE_INTERNAL:
 331             if (rep->target1 == 0x00ff)
 332             {
 333                 address  = GetEntryPointFromOrdinal(fd, mz_header, ne_header,
 334                                                     rep->target2);
 335                 selector = (address >> 16) & 0xffff;
 336                 address &= 0xffff;
 337             }
 338             else
 339             {
 340                 selector = selector_table[rep->target1-1].selector;
 341                 address  = rep->target2;
 342             }
 343
 344 #ifdef DEBUG_FIXUP
 345             printf("%d: %04.4x:%04.4x\n", i + 1, selector, address);
 346 #endif
 347             break;
 348
 349           case 7:
 350             /* Relocation type 7:
 351              *
 352              *    These appear to be used as fixups for the Windows
 353              * floating point emulator.  Let's just ignore them and
 354              * try to use the hardware floating point.  Linux should
 355              * successfully emulate the coprocessor if it doesn't
 356              * exist.
 357              */
 358 #ifdef DEBUG_FIXUP
 359             printf("%d: ADDR TYPE %d,  TYPE %d,  OFFSET %04.4x,  ",
 360                    i + 1, rep->address_type, rep->relocation_type,
 361                    rep->offset);
 362             printf("TARGET %04.4x %04.4x\n", rep->target1, rep->target2);
 363 #endif
 364             continue;
 365
 366           default:
 367 #ifdef DEBUG_FIXUP
 368             printf("%d: ADDR TYPE %d,  TYPE %d,  OFFSET %04.4x,  ",
 369                    i + 1, rep->address_type, rep->relocation_type,
 370                    rep->offset);
 371             printf("TARGET %04.4x %04.4x\n", rep->target1, rep->target2);
 372 #endif
 373             free(rep1);
 374             return -1;
 375         }
 376
 377         /*
 378          * Stuff the right size result in.
 379          */
 380         sp = (unsigned short *) ((char *) sel->base_addr + rep->offset);
 381         switch (rep->address_type)
 382         {
 383           case NE_RADDR_OFFSET16:
 384             do {
 385                 next_addr = *sp;
 386                 *sp = (unsigned short) address;
 387                 sp = (unsigned short *) ((char *) sel->base_addr + next_addr);
 388             }
 389             while (next_addr != 0xffff);
 390
 391             break;
 392
 393           case NE_RADDR_POINTER32:
 394             do {
 395                 next_addr = *sp;
 396                 *sp     = (unsigned short) address;
 397                 *(sp+1) = (unsigned short) selector;
 398                 sp = (unsigned short *) ((char *) sel->base_addr + next_addr);
 399             }
 400             while (next_addr != 0xffff);
 401
 402             break;
 403
 404           case NE_RADDR_SELECTOR:
 405             do {
 406                 next_addr = *sp;
 407                 *sp     = (unsigned short) selector;
 408                 sp = (unsigned short *) ((char *) sel->base_addr + next_addr);
 409             }
 410             while (next_addr != 0xffff);
 411
 412             break;
 413
 414           default:
 415 #ifdef DEBUG_FIXUP
 416             printf("%d: ADDR TYPE %d,  TYPE %d,  OFFSET %04.4x,  ",
 417                    i + 1, rep->address_type, rep->relocation_type,
 418                    rep->offset);
 419             printf("TARGET %04.4x %04.4x\n", rep->target1, rep->target2);
 420 #endif
 421             free(rep1);
 422             return -1;
 423         }
 424     }
 425
 426     free(rep1);
 427     return 0;
 428 }