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 8399 2007-08-22 18:24:23Z 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                                         MFREE(boot_class_path, u1, strlen(boot_class_path));
 316
 317 #if defined(ENABLE_JAVASE)
 318                                         properties_add("sun.boot.class.path", p);
 319                                         properties_add("java.boot.class.path", p);
 320 #endif
 321
 322                                         /* free the memory allocated by scandir */
 323                                         /* (We use `free` as the memory came from the C library.) */
 324
 325                                         free(namelist[i]);
 326                                 }
 327                         }
 328
 329                         /* On some systems (like Linux) when n == 0, then namelist
 330                            returned from scnadir is NULL, thus we don't have to
 331                            free it.
 332                            (Use `free` as the memory came from the C library.) */
 333
 334                         if (namelist != NULL)
 335                                 free(namelist);
 336
 337                         MFREE(path, char, pathlen + strlen("0"));
 338                 }
 339
 340                 /* goto next entry, skip ':' delimiter */
 341
 342                 if ((*end) == ':')
 343                         start = end + 1;
 344                 else
 345                         start = end;
 346         }
 347 }
 348
 349
 350 /* suck_check_classbuffer_size *************************************************
 351
 352    Assert that at least <len> bytes are left to read <len> is limited
 353    to the range of non-negative s4 values.
 354
 355 *******************************************************************************/
 356
 357 bool suck_check_classbuffer_size(classbuffer *cb, s4 len)
 358 {
 359 #ifdef ENABLE_VERIFIER
 360         if (len < 0 || ((cb->data + cb->size) - cb->pos) < len) {
 361                 exceptions_throw_classformaterror((cb)->class, "Truncated class file");
 362                 return false;
 363         }
 364 #endif /* ENABLE_VERIFIER */
 365
 366         return true;
 367 }
 368
 369
 370 u1 suck_u1(classbuffer *cb)
 371 {
 372         u1 a;
 373
 374         a = SUCK_BE_U1(cb->pos);
 375         cb->pos++;
 376
 377         return a;
 378 }
 379
 380
 381 u2 suck_u2(classbuffer *cb)
 382 {
 383         u2 a;
 384
 385         a = SUCK_BE_U2(cb->pos);
 386         cb->pos += 2;
 387
 388         return a;
 389 }
 390
 391
 392 u4 suck_u4(classbuffer *cb)
 393 {
 394         u4 a;
 395
 396         a = SUCK_BE_U4(cb->pos);
 397         cb->pos += 4;
 398
 399         return a;
 400 }
 401
 402
 403 u8 suck_u8(classbuffer *cb)
 404 {
 405 #if U8_AVAILABLE == 1
 406         u8 a;
 407
 408         a = SUCK_BE_U8(cb->pos);
 409         cb->pos += 8;
 410
 411         return a;
 412 #else
 413         u8 v;
 414
 415         v.high = suck_u4(cb);
 416         v.low = suck_u4(cb);
 417
 418         return v;
 419 #endif
 420 }
 421
 422
 423 float suck_float(classbuffer *cb)
 424 {
 425         float f;
 426
 427 #if WORDS_BIGENDIAN == 0
 428         u1 buffer[4];
 429         u2 i;
 430
 431         for (i = 0; i < 4; i++)
 432                 buffer[3 - i] = suck_u1(cb);
 433
 434         MCOPY((u1 *) (&f), buffer, u1, 4);
 435 #else
 436         suck_nbytes((u1*) (&f), cb, 4);
 437 #endif
 438
 439         assert(sizeof(float) == 4);
 440
 441         return f;
 442 }
 443
 444
 445 double suck_double(classbuffer *cb)
 446 {
 447         double d;
 448
 449 #if WORDS_BIGENDIAN == 0
 450         u1 buffer[8];
 451         u2 i;
 452
 453 # if defined(__ARM__) && defined(__ARMEL__) && !defined(__VFP_FP__)
 454         /*
 455          * On little endian ARM processors when using FPA, word order
 456          * of doubles is still big endian. So take that into account
 457          * here. When using VFP, word order of doubles follows byte
 458          * order. (michi 2005/07/24)
 459          */
 460         for (i = 0; i < 4; i++)
 461                 buffer[3 - i] = suck_u1(cb);
 462         for (i = 0; i < 4; i++)
 463                 buffer[7 - i] = suck_u1(cb);
 464 # else
 465         for (i = 0; i < 8; i++)
 466                 buffer[7 - i] = suck_u1(cb);
 467 # endif /* defined(__ARM__) && ... */
 468
 469         MCOPY((u1 *) (&d), buffer, u1, 8);
 470 #else
 471         suck_nbytes((u1*) (&d), cb, 8);
 472 #endif
 473
 474         assert(sizeof(double) == 8);
 475
 476         return d;
 477 }
 478
 479
 480 /* suck_nbytes *****************************************************************
 481
 482    Transfer block of classfile data into a buffer.
 483
 484 *******************************************************************************/
 485
 486 void suck_nbytes(u1 *buffer, classbuffer *cb, s4 len)
 487 {
 488         MCOPY(buffer, cb->pos, u1, len);
 489         cb->pos += len;
 490 }
 491
 492
 493 /* suck_skip_nbytes ************************************************************
 494
 495    Skip block of classfile data.
 496
 497 *******************************************************************************/
 498
 499 void suck_skip_nbytes(classbuffer *cb, s4 len)
 500 {
 501         cb->pos += len;
 502 }
 503
 504
 505 /* suck_start ******************************************************************
 506
 507    Returns true if classbuffer is already loaded or a file for the
 508    specified class has succussfully been read in. All directories of
 509    the searchpath are used to find the classfile (<classname>.class).
 510    Returns NULL if no classfile is found and writes an error message.
 511
 512 *******************************************************************************/
 513
 514 classbuffer *suck_start(classinfo *c)
 515 {
 516         list_classpath_entry *lce;
 517         char                 *filename;
 518         s4                    filenamelen;
 519         char                 *path;
 520         FILE                 *classfile;
 521         s4                    len;
 522         struct stat           buffer;
 523         classbuffer          *cb;
 524
 525         /* initialize return value */
 526
 527         cb = NULL;
 528
 529         /* get the classname as char string (do it here for the warning at
 530        the end of the function) */
 531
 532         filenamelen = utf_bytes(c->name) + strlen(".class") + strlen("0");
 533         filename = MNEW(char, filenamelen);
 534
 535         utf_copy(filename, c->name);
 536         strcat(filename, ".class");
 537
 538         /* walk through all classpath entries */
 539
 540         for (lce = list_first(list_classpath_entries); lce != NULL && cb == NULL;
 541                  lce = list_next(list_classpath_entries, lce)) {
 542 #if defined(ENABLE_ZLIB)
 543                 if (lce->type == CLASSPATH_ARCHIVE) {
 544
 545                         /* enter a monitor on zip/jar archives */
 546
 547                         LOCK_MONITOR_ENTER(lce);
 548
 549                         /* try to get the file in current archive */
 550
 551                         cb = zip_get(lce, c);
 552
 553                         /* leave the monitor */
 554
 555                         LOCK_MONITOR_EXIT(lce);
 556
 557                 } else {
 558 #endif /* defined(ENABLE_ZLIB) */
 559                         path = MNEW(char, lce->pathlen + filenamelen);
 560                         strcpy(path, lce->path);
 561                         strcat(path, filename);
 562
 563                         classfile = fopen(path, "r");
 564
 565                         if (classfile) {                                   /* file exists */
 566                                 if (!stat(path, &buffer)) {            /* read classfile data */
 567                                         cb = NEW(classbuffer);
 568                                         cb->class = c;
 569                                         cb->size  = buffer.st_size;
 570                                         cb->data  = MNEW(u1, cb->size);
 571                                         cb->pos   = cb->data;
 572                                         cb->path  = lce->path;
 573
 574                                         /* read class data */
 575
 576                                         len = fread(cb->data, 1, cb->size, classfile);
 577
 578                                         if (len != buffer.st_size) {
 579                                                 suck_stop(cb);
 580 /*                                              if (ferror(classfile)) { */
 581 /*                                              } */
 582                                         }
 583
 584                                         /* close the class file */
 585
 586                                         fclose(classfile);
 587                                 }
 588                         }
 589
 590                         MFREE(path, char, lce->pathlen + filenamelen);
 591 #if defined(ENABLE_ZLIB)
 592                 }
 593 #endif
 594         }
 595
 596         if (opt_verbose)
 597                 if (cb == NULL)
 598                         dolog("Warning: Can not open class file '%s'", filename);
 599
 600         MFREE(filename, char, filenamelen);
 601
 602         return cb;
 603 }
 604
 605
 606 /* suck_stop *******************************************************************
 607
 608    Frees memory for buffer with classfile data.
 609
 610    CAUTION: This function may only be called if buffer has been
 611    allocated by suck_start with reading a file.
 612
 613 *******************************************************************************/
 614
 615 void suck_stop(classbuffer *cb)
 616 {
 617         /* free memory */
 618
 619         MFREE(cb->data, u1, cb->size);
 620         FREE(cb, classbuffer);
 621 }
 622
 623
 624 /*
 625  * These are local overrides for various environment variables in Emacs.
 626  * Please do not remove this and leave it at the end of the file, where
 627  * Emacs will automagically detect them.
 628  * ---------------------------------------------------------------------
 629  * Local variables:
 630  * mode: c
 631  * indent-tabs-mode: t
 632  * c-basic-offset: 4
 633  * tab-width: 4
 634  * End:
 635  */