libhfs_iso/data.c

   1 /*
   2  * This file has been modified for the cdrkit suite.
   3  *
   4  * The behaviour and appearence of the program code below can differ to a major
   5  * extent from the version distributed by the original author(s).
   6  *
   7  * For details, see Changelog file distributed with the cdrkit package. If you
   8  * received this file from another source then ask the distributing person for
   9  * a log of modifications.
  10  *
  11  */
  12
  13 /* @(#)data.c   1.5 02/02/10 joerg */
  14 /*
  15  * hfsutils - tools for reading and writing Macintosh HFS volumes
  16  * Copyright (C) 1996, 1997 Robert Leslie
  17  *
  18  * This program is free software; you can redistribute it and/or modify
  19  * it under the terms of the GNU General Public License as published by
  20  * the Free Software Foundation; either version 2 of the License, or
  21  * (at your option) any later version.
  22  *
  23  * This program is distributed in the hope that it will be useful,
  24  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  25  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26  * GNU General Public License for more details.
  27  *
  28  * You should have received a copy of the GNU General Public License
  29  * along with this program; if not, write to the Free Software
  30  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  31  */
  32
  33 #include <mconfig.h>
  34 #include <strdefs.h>
  35 #include <timedefs.h>
  36
  37 #include "internal.h"
  38 #include "data.h"
  39 #include "btree.h"
  40
  41 #ifdef APPLE_HYB
  42 /*
  43  *      Depending on the version, AppleDouble/Single stores dates
  44  *      relative to 1st Jan 1904 (v1) or 1st Jan 2000 (v2)
  45  *
  46  *      DUTDIFF is the difference between 1st Jan 2000 and
  47  *      1st Jan 1970 (Unix epoch)).
  48  */
  49
  50 #define DUTDIFF 946684800L
  51 #endif /* APPLE_HYB */
  52 #define MUTDIFF 2082844800L
  53 #define TZNONE  0x0FFFFFFFL     /* A timezone diff that cannot occur */
  54
  55 static  void    calctzdiff(void);
  56
  57 static
  58 unsigned long tzdiff = TZNONE;
  59
  60 static
  61 unsigned char hfs_charorder[256] = {
  62   0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  63   0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
  64   0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  65   0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  66
  67   0x20, 0x22, 0x23, 0x28, 0x29, 0x2a, 0x2b, 0x2c,
  68   0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36,
  69   0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e,
  70   0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
  71
  72   0x47, 0x48, 0x58, 0x5a, 0x5e, 0x60, 0x67, 0x69,
  73   0x6b, 0x6d, 0x73, 0x75, 0x77, 0x79, 0x7b, 0x7f,
  74   0x8d, 0x8f, 0x91, 0x93, 0x96, 0x98, 0x9f, 0xa1,
  75   0xa3, 0xa5, 0xa8, 0xaa, 0xab, 0xac, 0xad, 0xae,
  76
  77   0x54, 0x48, 0x58, 0x5a, 0x5e, 0x60, 0x67, 0x69,
  78   0x6b, 0x6d, 0x73, 0x75, 0x77, 0x79, 0x7b, 0x7f,
  79   0x8d, 0x8f, 0x91, 0x93, 0x96, 0x98, 0x9f, 0xa1,
  80   0xa3, 0xa5, 0xa8, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
  81
  82   0x4c, 0x50, 0x5c, 0x62, 0x7d, 0x81, 0x9a, 0x55,
  83   0x4a, 0x56, 0x4c, 0x4e, 0x50, 0x5c, 0x62, 0x64,
  84   0x65, 0x66, 0x6f, 0x70, 0x71, 0x72, 0x7d, 0x89,
  85   0x8a, 0x8b, 0x81, 0x83, 0x9c, 0x9d, 0x9e, 0x9a,
  86
  87   0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0x95,
  88   0xbb, 0xbc, 0xbd, 0xbe, 0xbf, 0xc0, 0x52, 0x85,
  89   0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8,
  90   0xc9, 0xca, 0xcb, 0x57, 0x8c, 0xcc, 0x52, 0x85,
  91
  92   0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0x26,
  93   0x27, 0xd4, 0x20, 0x4a, 0x4e, 0x83, 0x87, 0x87,
  94   0xd5, 0xd6, 0x24, 0x25, 0x2d, 0x2e, 0xd7, 0xd8,
  95   0xa7, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,
  96
  97   0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,
  98   0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  99   0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
 100   0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
 101 };
 102
 103 /*
 104  * NAME:        data->getb()
 105  * DESCRIPTION: marshal 1 byte into local host format
 106  */
 107 char d_getb(unsigned char *ptr)
 108 {
 109   return (char) ptr[0];
 110 }
 111
 112 /*
 113  * NAME:        data->getw()
 114  * DESCRIPTION: marshal 2 bytes into local host format
 115  */
 116 short d_getw(unsigned char *ptr)
 117 {
 118   return (short)
 119     ((ptr[0] << 8) |
 120      (ptr[1] << 0));
 121 }
 122
 123 /*
 124  * NAME:        data->getl()
 125  * DESCRIPTION: marshal 4 bytes into local host format
 126  */
 127 long d_getl(unsigned char *ptr)
 128 {
 129   return (long)
 130     ((ptr[0] << 24) |
 131      (ptr[1] << 16) |
 132      (ptr[2] <<  8) |
 133      (ptr[3] <<  0));
 134 }
 135
 136 /*
 137  * NAME:        data->putb()
 138  * DESCRIPTION: marshal 1 byte out to Macintosh (big-endian) format
 139  */
 140 #ifdef  PROTOTYPES
 141 void d_putb(unsigned char *ptr, char data)
 142 #else
 143 void d_putb(unsigned char *ptr, char data)
 144 #endif
 145 {
 146   ptr[0] = (unsigned char) data;
 147 }
 148
 149 /*
 150  * NAME:        data->putw()
 151  * DESCRIPTION: marshal 2 bytes out to Macintosh (big-endian) format
 152  */
 153 #ifdef  PROTOTYPES
 154 void d_putw(unsigned char *ptr, short data)
 155 #else
 156 void d_putw(unsigned char *ptr, short data)
 157 #endif
 158 {
 159   ptr[0] = ((unsigned) data & 0xff00) >> 8;
 160   ptr[1] = ((unsigned) data & 0x00ff) >> 0;
 161 }
 162
 163 /*
 164  * NAME:        data->putl()
 165  * DESCRIPTION: marshal 4 bytes out to Macintosh (big-endian) format
 166  */
 167 void d_putl(unsigned char *ptr, long data)
 168 {
 169   ptr[0] = ((unsigned long) data & 0xff000000) >> 24;
 170   ptr[1] = ((unsigned long) data & 0x00ff0000) >> 16;
 171   ptr[2] = ((unsigned long) data & 0x0000ff00) >>  8;
 172   ptr[3] = ((unsigned long) data & 0x000000ff) >>  0;
 173 }
 174
 175 /*
 176  * NAME:        data->fetchb()
 177  * DESCRIPTION: incrementally retrieve a byte of data
 178  */
 179 void d_fetchb(unsigned char **ptr, char *dest)
 180 {
 181   *dest = d_getb(*ptr);
 182   *ptr += 1;
 183 }
 184
 185 /*
 186  * NAME:        data->fetchw()
 187  * DESCRIPTION: incrementally retrieve a word of data
 188  */
 189 void d_fetchw(unsigned char **ptr, short *dest)
 190 {
 191   *dest = d_getw(*ptr);
 192   *ptr += 2;
 193 }
 194
 195 /*
 196  * NAME:        data->fetchl()
 197  * DESCRIPTION: incrementally retrieve a long word of data
 198  */
 199 void d_fetchl(unsigned char **ptr, long *dest)
 200 {
 201   *dest = d_getl(*ptr);
 202   *ptr += 4;
 203 }
 204
 205 /*
 206  * NAME:        data->fetchs()
 207  * DESCRIPTION: incrementally retrieve a string
 208  */
 209 void d_fetchs(unsigned char **ptr, char *dest, int size)
 210 {
 211   int len;
 212   char blen;
 213
 214   d_fetchb(ptr, &blen);
 215   len = blen;
 216
 217   if (len > 0 && len < size)
 218     memcpy(dest, *ptr, len);
 219   else
 220     len = 0;
 221
 222   dest[len] = 0;
 223
 224   *ptr += size - 1;
 225 }
 226
 227 /*
 228  * NAME:        data->storeb()
 229  * DESCRIPTION: incrementally store a byte of data
 230  */
 231 #ifdef  PROTOTYPES
 232 void d_storeb(unsigned char **ptr, char data)
 233 #else
 234 void d_storeb(unsigned char **ptr, char data)
 235 #endif
 236 {
 237   d_putb(*ptr, data);
 238   *ptr += 1;
 239 }
 240
 241 /*
 242  * NAME:        data->storew()
 243  * DESCRIPTION: incrementally store a word of data
 244  */
 245 #ifdef  PROTOTYPES
 246 void d_storew(unsigned char **ptr, short data)
 247 #else
 248 void d_storew(unsigned char **ptr, short data)
 249 #endif
 250 {
 251   d_putw(*ptr, data);
 252   *ptr += 2;
 253 }
 254
 255 /*
 256  * NAME:        data->storel()
 257  * DESCRIPTION: incrementally store a long word of data
 258  */
 259 void d_storel(unsigned char **ptr, long data)
 260 {
 261   d_putl(*ptr, data);
 262   *ptr += 4;
 263 }
 264
 265 /*
 266  * NAME:        data->stores()
 267  * DESCRIPTION: incrementally store a string
 268  */
 269 void d_stores(unsigned char **ptr, char *src, int size)
 270 {
 271   int len;
 272
 273   len = strlen(src);
 274   if (len > --size)
 275     len = 0;
 276
 277   d_storeb(ptr, (unsigned char) len);
 278
 279   memcpy(*ptr, src, len);
 280   memset(*ptr + len, 0, size - len);
 281
 282   *ptr += size;
 283 }
 284
 285 /*
 286  * NAME:        calctzdiff()
 287  * DESCRIPTION: calculate the timezone difference between local time and UTC
 288  */
 289 static void calctzdiff()
 290 {
 291   time_t t;
 292   int isdst;
 293   struct tm tm, *tmp;
 294
 295   time(&t);
 296   isdst = localtime(&t)->tm_isdst;
 297
 298   tmp = gmtime(&t);
 299   if (tmp)
 300     {
 301       tm = *tmp;
 302       tm.tm_isdst = isdst;
 303
 304       tzdiff = t - mktime(&tm);
 305     }
 306   else
 307     tzdiff = 0;
 308 }
 309
 310 /*
 311  * NAME:        data->tomtime()
 312  * DESCRIPTION: convert UNIX time to Macintosh time
 313  */
 314 unsigned long d_tomtime(unsigned long secs)
 315 {
 316   time_t utime = secs;
 317
 318   if (tzdiff == TZNONE)
 319     calctzdiff();
 320
 321   return utime + tzdiff + MUTDIFF;
 322 }
 323
 324 /*
 325  * NAME:        data->toutime()
 326  * DESCRIPTION: convert Macintosh time to UNIX time
 327  */
 328 unsigned long d_toutime(unsigned long secs)
 329 {
 330   time_t utime = secs;
 331
 332   if (tzdiff == TZNONE)
 333     calctzdiff();
 334
 335   return utime - MUTDIFF - tzdiff;
 336 }
 337
 338 #ifdef APPLE_HYB
 339 /*
 340  * NAME:        data->dtoutime()
 341  * DESCRIPTION: convert Apple Double v2 time to UNIX time
 342  */
 343 unsigned long d_dtoutime(long secs)
 344 {
 345   time_t utime = secs;
 346
 347   if (tzdiff == TZNONE)
 348     calctzdiff();
 349
 350   return utime + DUTDIFF - tzdiff;
 351 }
 352 #endif /* APPLE_HYB */
 353
 354 /*
 355  * NAME:        data->relstring()
 356  * DESCRIPTION: compare two strings as per MacOS for HFS
 357  */
 358 int d_relstring(char *str1, char *str2)
 359 {
 360   int diff;
 361
 362   while (*str1 && *str2)
 363     {
 364       diff = hfs_charorder[(unsigned char) *str1] -
 365              hfs_charorder[(unsigned char) *str2];
 366
 367       if (diff)
 368         return diff;
 369
 370       ++str1, ++str2;
 371     }
 372
 373   if (! *str1 && *str2)
 374     return -1;
 375   else if (*str1 && ! *str2)
 376     return 1;
 377
 378   return 0;
 379 }