src/vmcore/suck.c

   1 /* src/vmcore/suck.c - functions to read LE ordered types from a buffer
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: suck.c 8404 2007-08-22 21:34:24Z twisti $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33 #include <dirent.h>
  34 #include <sys/stat.h>
  35 #include <stdlib.h>
  36
  37 #include "vm/types.h"
  38
  39 #include "arch.h"
  40
  41 #include "mm/memory.h"
  42
  43 #include "threads/lock-common.h"
  44
  45 #include "toolbox/list.h"
  46 #include "toolbox/logging.h"
  47 #include "toolbox/util.h"
  48
  49 #include "vm/exceptions.h"
  50 #include "vm/properties.h"
  51 #include "vm/vm.h"
  52
  53 #include "vmcore/loader.h"
  54 #include "vmcore/options.h"
  55 #include "vmcore/suck.h"
  56 #include "vmcore/zip.h"
  57
  58
  59 /* global variables ***********************************************************/
  60
  61 list_t *list_classpath_entries;
  62
  63
  64 /* suck_init *******************************************************************
  65
  66    Initializes the suck subsystem like initializing the classpath
  67    entries list.
  68
  69 *******************************************************************************/
  70
  71 bool suck_init(void)
  72 {
  73         list_classpath_entries = list_create(OFFSET(list_classpath_entry, linkage));
  74
  75         /* everything's ok */
  76
  77         return true;
  78 }
  79
  80
  81 /* scandir_filter **************************************************************
  82
  83    Filters for zip/jar files.
  84
  85 *******************************************************************************/
  86
  87 #if defined(__LINUX__)
  88 static int scandir_filter(const struct dirent *a)
  89 #else
  90 static int scandir_filter(struct dirent *a)
  91 #endif
  92 {
  93         s4 namlen;
  94
  95 #if defined(_DIRENT_HAVE_D_NAMLEN)
  96         namlen = a->d_namlen;
  97 #else
  98         namlen = strlen(a->d_name);
  99 #endif
 100
 101         if ((strncasecmp(a->d_name + namlen - 4, ".zip", 4) == 0) ||
 102                 (strncasecmp(a->d_name + namlen - 4, ".jar", 4) == 0))
 103                 return 1;
 104
 105         return 0;
 106 }
 107
 108
 109 /* suck_add ********************************************************************
 110
 111    Adds a classpath to the global classpath entries list.
 112
 113 *******************************************************************************/
 114
 115 void suck_add(char *classpath)
 116 {
 117         list_classpath_entry *lce;
 118         char                 *start;
 119         char                 *end;
 120         char                 *filename;
 121         s4                    filenamelen;
 122         bool                  is_zip;
 123         char                 *cwd;
 124         s4                    cwdlen;
 125 #if defined(ENABLE_ZLIB)
 126         hashtable            *ht;
 127 #endif
 128
 129         /* parse the classpath string */
 130
 131         for (start = classpath; (*start) != '\0'; ) {
 132
 133                 /* search for ':' delimiter to get the end of the current entry */
 134                 for (end = start; ((*end) != '\0') && ((*end) != ':'); end++);
 135
 136                 if (start != end) {
 137                         is_zip = false;
 138                         filenamelen = end - start;
 139
 140                         if (filenamelen > 4) {
 141                                 if ((strncasecmp(end - 4, ".zip", 4) == 0) ||
 142                                         (strncasecmp(end - 4, ".jar", 4) == 0)) {
 143                                         is_zip = true;
 144                                 }
 145                         }
 146
 147                         /* save classpath entries as absolute pathnames */
 148
 149                         cwd = NULL;
 150                         cwdlen = 0;
 151
 152                         if (*start != '/') {                      /* XXX fix me for win32 */
 153                                 cwd = _Jv_getcwd();
 154                                 cwdlen = strlen(cwd) + strlen("/");
 155                         }
 156
 157                         /* allocate memory for filename and fill it */
 158
 159                         filename = MNEW(char, filenamelen + cwdlen + strlen("/") +
 160                                                         strlen("0"));
 161
 162                         if (cwd) {
 163                                 strcpy(filename, cwd);
 164                                 strcat(filename, "/");
 165                                 strncat(filename, start, filenamelen);
 166
 167                                 /* add cwd length to file length */
 168                                 filenamelen += cwdlen;
 169
 170                         } else {
 171                                 strncpy(filename, start, filenamelen);
 172                                 filename[filenamelen] = '\0';
 173                         }
 174
 175                         lce = NULL;
 176
 177                         if (is_zip) {
 178 #if defined(ENABLE_ZLIB)
 179                                 ht = zip_open(filename);
 180
 181                                 if (ht != NULL) {
 182                                         lce = NEW(list_classpath_entry);
 183
 184                                         lce->type      = CLASSPATH_ARCHIVE;
 185                                         lce->htclasses = ht;
 186                                         lce->path      = filename;
 187                                         lce->pathlen   = filenamelen;
 188
 189                                         /* SUN compatible -verbose:class output */
 190
 191                                         if (opt_verboseclass)
 192                                                 printf("[Opened %s]\n", filename);
 193                                 }
 194
 195 #else
 196                                 vm_abort("suck_add: zip/jar files not supported");
 197 #endif
 198                         }
 199                         else {
 200                                 if (filename[filenamelen - 1] != '/') {/* XXX fixme for win32 */
 201                                         filename[filenamelen] = '/';
 202                                         filename[filenamelen + 1] = '\0';
 203                                         filenamelen++;
 204                                 }
 205
 206                                 lce = NEW(list_classpath_entry);
 207
 208                                 lce->type    = CLASSPATH_PATH;
 209                                 lce->path    = filename;
 210                                 lce->pathlen = filenamelen;
 211                         }
 212
 213                         /* add current classpath entry, if no error */
 214
 215                         if (lce != NULL)
 216                                 list_add_last(list_classpath_entries, lce);
 217                 }
 218
 219                 /* goto next classpath entry, skip ':' delimiter */
 220
 221                 if ((*end) == ':')
 222                         start = end + 1;
 223                 else
 224                         start = end;
 225         }
 226 }
 227
 228
 229 /* suck_add_from_property ******************************************************
 230
 231    Adds a classpath form a property entry to the global classpath
 232    entries list.
 233
 234 *******************************************************************************/
 235
 236 void suck_add_from_property(char *key)
 237 {
 238         char           *value;
 239         char           *start;
 240         char           *end;
 241         char           *path;
 242         s4              pathlen;
 243         struct dirent **namelist;
 244         s4              n;
 245         s4              i;
 246         s4              namlen;
 247         char           *boot_class_path;
 248         char           *p;
 249
 250         /* get the property value */
 251
 252         value = properties_get(key);
 253
 254         if (value == NULL)
 255                 return;
 256
 257         /* get the directory entries of the property */
 258
 259         for (start = value; (*start) != '\0'; ) {
 260
 261                 /* search for ':' delimiter to get the end of the current entry */
 262
 263                 for (end = start; ((*end) != '\0') && ((*end) != ':'); end++);
 264
 265                 /* found an entry */
 266
 267                 if (start != end) {
 268                         /* allocate memory for the path entry */
 269
 270                         pathlen = end - start;
 271                         path = MNEW(char, pathlen + strlen("0"));
 272
 273                         /* copy and terminate the string */
 274
 275                         strncpy(path, start, pathlen);
 276                         path[pathlen] = '\0';
 277
 278                         /* Reset namelist to NULL for the freeing in an error case
 279                            (see below). */
 280
 281                         namelist = NULL;
 282
 283                         /* scan the directory found for zip/jar files */
 284
 285                         n = scandir(path, &namelist, scandir_filter, alphasort);
 286
 287                         /* On error, just continue, this should be ok. */
 288
 289                         if (n > 0) {
 290                                 for (i = 0; i < n; i++) {
 291 #if defined(_DIRENT_HAVE_D_NAMLEN)
 292                                         namlen = namelist[i]->d_namlen;
 293 #else
 294                                         namlen = strlen(namelist[i]->d_name);
 295 #endif
 296
 297                                         /* Allocate memory for bootclasspath. */
 298
 299                                         boot_class_path = properties_get("sun.boot.class.path");
 300
 301                                         p = MNEW(char,
 302                                                          pathlen + strlen("/") + namlen +
 303                                                          strlen(":") +
 304                                                          strlen(boot_class_path) +
 305                                                          strlen("0"));
 306
 307                                         /* Prepend the file found to the bootclasspath. */
 308
 309                                         strcpy(p, path);
 310                                         strcat(p, "/");
 311                                         strcat(p, namelist[i]->d_name);
 312                                         strcat(p, ":");
 313                                         strcat(p, boot_class_path);
 314
 315                                         properties_add("sun.boot.class.path", p);
 316                                         properties_add("java.boot.class.path", p);
 317
 318                                         MFREE(boot_class_path, char, strlen(boot_class_path));
 319
 320                                         /* free the memory allocated by scandir */
 321                                         /* (We use `free` as the memory came from the C library.) */
 322
 323                                         free(namelist[i]);
 324                                 }
 325                         }
 326
 327                         /* On some systems (like Linux) when n == 0, then namelist
 328                            returned from scnadir is NULL, thus we don't have to
 329                            free it.
 330                            (Use `free` as the memory came from the C library.) */
 331
 332                         if (namelist != NULL)
 333                                 free(namelist);
 334
 335                         MFREE(path, char, pathlen + strlen("0"));
 336                 }
 337
 338                 /* goto next entry, skip ':' delimiter */
 339
 340                 if ((*end) == ':')
 341                         start = end + 1;
 342                 else
 343                         start = end;
 344         }
 345 }
 346
 347
 348 /* suck_check_classbuffer_size *************************************************
 349
 350    Assert that at least <len> bytes are left to read <len> is limited
 351    to the range of non-negative s4 values.
 352
 353 *******************************************************************************/
 354
 355 bool suck_check_classbuffer_size(classbuffer *cb, s4 len)
 356 {
 357 #ifdef ENABLE_VERIFIER
 358         if (len < 0 || ((cb->data + cb->size) - cb->pos) < len) {
 359                 exceptions_throw_classformaterror((cb)->class, "Truncated class file");
 360                 return false;
 361         }
 362 #endif /* ENABLE_VERIFIER */
 363
 364         return true;
 365 }
 366
 367
 368 u1 suck_u1(classbuffer *cb)
 369 {
 370         u1 a;
 371
 372         a = SUCK_BE_U1(cb->pos);
 373         cb->pos++;
 374
 375         return a;
 376 }
 377
 378
 379 u2 suck_u2(classbuffer *cb)
 380 {
 381         u2 a;
 382
 383         a = SUCK_BE_U2(cb->pos);
 384         cb->pos += 2;
 385
 386         return a;
 387 }
 388
 389
 390 u4 suck_u4(classbuffer *cb)
 391 {
 392         u4 a;
 393
 394         a = SUCK_BE_U4(cb->pos);
 395         cb->pos += 4;
 396
 397         return a;
 398 }
 399
 400
 401 u8 suck_u8(classbuffer *cb)
 402 {
 403 #if U8_AVAILABLE == 1
 404         u8 a;
 405
 406         a = SUCK_BE_U8(cb->pos);
 407         cb->pos += 8;
 408
 409         return a;
 410 #else
 411         u8 v;
 412
 413         v.high = suck_u4(cb);
 414         v.low = suck_u4(cb);
 415
 416         return v;
 417 #endif
 418 }
 419
 420
 421 float suck_float(classbuffer *cb)
 422 {
 423         float f;
 424
 425 #if WORDS_BIGENDIAN == 0
 426         u1 buffer[4];
 427         u2 i;
 428
 429         for (i = 0; i < 4; i++)
 430                 buffer[3 - i] = suck_u1(cb);
 431
 432         MCOPY((u1 *) (&f), buffer, u1, 4);
 433 #else
 434         suck_nbytes((u1*) (&f), cb, 4);
 435 #endif
 436
 437         assert(sizeof(float) == 4);
 438
 439         return f;
 440 }
 441
 442
 443 double suck_double(classbuffer *cb)
 444 {
 445         double d;
 446
 447 #if WORDS_BIGENDIAN == 0
 448         u1 buffer[8];
 449         u2 i;
 450
 451 # if defined(__ARM__) && defined(__ARMEL__) && !defined(__VFP_FP__)
 452         /*
 453          * On little endian ARM processors when using FPA, word order
 454          * of doubles is still big endian. So take that into account
 455          * here. When using VFP, word order of doubles follows byte
 456          * order. (michi 2005/07/24)
 457          */
 458         for (i = 0; i < 4; i++)
 459                 buffer[3 - i] = suck_u1(cb);
 460         for (i = 0; i < 4; i++)
 461                 buffer[7 - i] = suck_u1(cb);
 462 # else
 463         for (i = 0; i < 8; i++)
 464                 buffer[7 - i] = suck_u1(cb);
 465 # endif /* defined(__ARM__) && ... */
 466
 467         MCOPY((u1 *) (&d), buffer, u1, 8);
 468 #else
 469         suck_nbytes((u1*) (&d), cb, 8);
 470 #endif
 471
 472         assert(sizeof(double) == 8);
 473
 474         return d;
 475 }
 476
 477
 478 /* suck_nbytes *****************************************************************
 479
 480    Transfer block of classfile data into a buffer.
 481
 482 *******************************************************************************/
 483
 484 void suck_nbytes(u1 *buffer, classbuffer *cb, s4 len)
 485 {
 486         MCOPY(buffer, cb->pos, u1, len);
 487         cb->pos += len;
 488 }
 489
 490
 491 /* suck_skip_nbytes ************************************************************
 492
 493    Skip block of classfile data.
 494
 495 *******************************************************************************/
 496
 497 void suck_skip_nbytes(classbuffer *cb, s4 len)
 498 {
 499         cb->pos += len;
 500 }
 501
 502
 503 /* suck_start ******************************************************************
 504
 505    Returns true if classbuffer is already loaded or a file for the
 506    specified class has succussfully been read in. All directories of
 507    the searchpath are used to find the classfile (<classname>.class).
 508    Returns NULL if no classfile is found and writes an error message.
 509
 510 *******************************************************************************/
 511
 512 classbuffer *suck_start(classinfo *c)
 513 {
 514         list_classpath_entry *lce;
 515         char                 *filename;
 516         s4                    filenamelen;
 517         char                 *path;
 518         FILE                 *classfile;
 519         s4                    len;
 520         struct stat           buffer;
 521         classbuffer          *cb;
 522
 523         /* initialize return value */
 524
 525         cb = NULL;
 526
 527         /* get the classname as char string (do it here for the warning at
 528        the end of the function) */
 529
 530         filenamelen = utf_bytes(c->name) + strlen(".class") + strlen("0");
 531         filename = MNEW(char, filenamelen);
 532
 533         utf_copy(filename, c->name);
 534         strcat(filename, ".class");
 535
 536         /* walk through all classpath entries */
 537
 538         for (lce = list_first(list_classpath_entries); lce != NULL && cb == NULL;
 539                  lce = list_next(list_classpath_entries, lce)) {
 540 #if defined(ENABLE_ZLIB)
 541                 if (lce->type == CLASSPATH_ARCHIVE) {
 542
 543                         /* enter a monitor on zip/jar archives */
 544
 545                         LOCK_MONITOR_ENTER(lce);
 546
 547                         /* try to get the file in current archive */
 548
 549                         cb = zip_get(lce, c);
 550
 551                         /* leave the monitor */
 552
 553                         LOCK_MONITOR_EXIT(lce);
 554
 555                 } else {
 556 #endif /* defined(ENABLE_ZLIB) */
 557                         path = MNEW(char, lce->pathlen + filenamelen);
 558                         strcpy(path, lce->path);
 559                         strcat(path, filename);
 560
 561                         classfile = fopen(path, "r");
 562
 563                         if (classfile) {                                   /* file exists */
 564                                 if (!stat(path, &buffer)) {            /* read classfile data */
 565                                         cb = NEW(classbuffer);
 566                                         cb->class = c;
 567                                         cb->size  = buffer.st_size;
 568                                         cb->data  = MNEW(u1, cb->size);
 569                                         cb->pos   = cb->data;
 570                                         cb->path  = lce->path;
 571
 572                                         /* read class data */
 573
 574                                         len = fread(cb->data, 1, cb->size, classfile);
 575
 576                                         if (len != buffer.st_size) {
 577                                                 suck_stop(cb);
 578 /*                                              if (ferror(classfile)) { */
 579 /*                                              } */
 580                                         }
 581
 582                                         /* close the class file */
 583
 584                                         fclose(classfile);
 585                                 }
 586                         }
 587
 588                         MFREE(path, char, lce->pathlen + filenamelen);
 589 #if defined(ENABLE_ZLIB)
 590                 }
 591 #endif
 592         }
 593
 594         if (opt_verbose)
 595                 if (cb == NULL)
 596                         dolog("Warning: Can not open class file '%s'", filename);
 597
 598         MFREE(filename, char, filenamelen);
 599
 600         return cb;
 601 }
 602
 603
 604 /* suck_stop *******************************************************************
 605
 606    Frees memory for buffer with classfile data.
 607
 608    CAUTION: This function may only be called if buffer has been
 609    allocated by suck_start with reading a file.
 610
 611 *******************************************************************************/
 612
 613 void suck_stop(classbuffer *cb)
 614 {
 615         /* free memory */
 616
 617         MFREE(cb->data, u1, cb->size);
 618         FREE(cb, classbuffer);
 619 }
 620
 621
 622 /*
 623  * These are local overrides for various environment variables in Emacs.
 624  * Please do not remove this and leave it at the end of the file, where
 625  * Emacs will automagically detect them.
 626  * ---------------------------------------------------------------------
 627  * Local variables:
 628  * mode: c
 629  * indent-tabs-mode: t
 630  * c-basic-offset: 4
 631  * tab-width: 4
 632  * End:
 633  */