uisimulator/common/io.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Daniel Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <stdarg.h>
  26 #include <sys/stat.h>
  27 #include <time.h>
  28 #ifdef __FreeBSD__
  29 #include <sys/param.h>
  30 #include <sys/mount.h>
  31 #elif defined(__APPLE__)
  32 #include <sys/param.h>
  33 #include <sys/mount.h>
  34 #elif !defined(WIN32)
  35 #include <sys/vfs.h>
  36 #endif
  37
  38 #ifdef WIN32
  39 #include <windows.h>
  40 #endif
  41
  42 #ifndef _MSC_VER
  43 #include <dirent.h>
  44 #include <unistd.h>
  45 #else
  46 #include "dir-win32.h"
  47 #endif
  48
  49 #define MAX_PATH 260
  50 #define MAX_OPEN_FILES 11
  51
  52 #include <fcntl.h>
  53 #include <SDL.h>
  54 #include <SDL_thread.h>
  55 #include "thread.h"
  56 #include "kernel.h"
  57 #include "debug.h"
  58 #include "config.h"
  59 #include "ata.h" /* for IF_MV2 et al. */
  60 #include "thread-sdl.h"
  61
  62
  63 /* Windows (and potentially other OSes) distinguish binary and text files.
  64  * Define a dummy for the others. */
  65 #ifndef O_BINARY
  66 #define O_BINARY 0
  67 #endif
  68
  69 /* Unicode compatibility for win32 */
  70 #if defined __MINGW32__
  71 /* Rockbox unicode functions */
  72 extern const unsigned char* utf8decode(const unsigned char *utf8,
  73                                        unsigned short *ucs);
  74 extern unsigned char* utf8encode(unsigned long ucs, unsigned char *utf8);
  75
  76 /* Static buffers for the conversion results. This isn't thread safe,
  77  * but it's sufficient for rockbox. */
  78 static unsigned char convbuf1[3*MAX_PATH];
  79 static unsigned char convbuf2[3*MAX_PATH];
  80
  81 static wchar_t* utf8_to_ucs2(const unsigned char *utf8, void *buffer)
  82 {
  83     wchar_t *ucs = buffer;
  84
  85     while (*utf8)
  86         utf8 = utf8decode(utf8, ucs++);
  87
  88     *ucs = 0;
  89     return buffer;
  90 }
  91 static unsigned char *ucs2_to_utf8(const wchar_t *ucs, unsigned char *buffer)
  92 {
  93     unsigned char *utf8 = buffer;
  94
  95     while (*ucs)
  96         utf8 = utf8encode(*ucs++, utf8);
  97
  98     *utf8 = 0;
  99     return buffer;
 100 }
 101
 102 #define UTF8_TO_OS(a)  utf8_to_ucs2(a,convbuf1)
 103 #define OS_TO_UTF8(a)  ucs2_to_utf8(a,convbuf1)
 104 #define DIR_T       _WDIR
 105 #define DIRENT_T    struct _wdirent
 106 #define STAT_T      struct _stat
 107 extern int _wmkdir(const wchar_t*);
 108 extern int _wrmdir(const wchar_t*);
 109 #define MKDIR(a,b)  (_wmkdir)(UTF8_TO_OS(a))
 110 #define RMDIR(a)    (_wrmdir)(UTF8_TO_OS(a))
 111 #define OPENDIR(a)  (_wopendir)(UTF8_TO_OS(a))
 112 #define READDIR(a)  (_wreaddir)(a)
 113 #define CLOSEDIR(a) (_wclosedir)(a)
 114 #define STAT(a,b)   (_wstat)(UTF8_TO_OS(a),b)
 115 #define OPEN(a,b,c) (_wopen)(UTF8_TO_OS(a),b,c)
 116 #define CLOSE(a)    (close)(a)
 117 #define REMOVE(a)   (_wremove)(UTF8_TO_OS(a))
 118 #define RENAME(a,b) (_wrename)(UTF8_TO_OS(a),utf8_to_ucs2(b,convbuf2))
 119
 120 #else  /* !__MINGW32__ */
 121
 122 #define UTF8_TO_OS(a) (a)
 123 #define OS_TO_UTF8(a) (a)
 124 #define DIR_T       DIR
 125 #define DIRENT_T    struct dirent
 126 #define STAT_T      struct stat
 127 #define MKDIR(a,b)  (mkdir)(a,b)
 128 #define RMDIR(a)    (rmdir)(a)
 129 #define OPENDIR(a)  (opendir)(a)
 130 #define READDIR(a)  (readdir)(a)
 131 #define CLOSEDIR(a) (closedir)(a)
 132 #define STAT(a,b)   (stat)(a,b)
 133 #define OPEN(a,b,c) (open)(a,b,c)
 134 #define CLOSE(x)    (close)(x)
 135 #define REMOVE(a)   (remove)(a)
 136 #define RENAME(a,b) (rename)(a,b)
 137
 138 #endif /* !__MINGW32__ */
 139
 140
 141 #ifdef HAVE_DIRCACHE
 142 void dircache_remove(const char *name);
 143 void dircache_rename(const char *oldname, const char *newname);
 144 #endif
 145
 146
 147 #define SIMULATOR_DEFAULT_ROOT "simdisk"
 148 extern const char *sim_root_dir;
 149
 150 static int num_openfiles = 0;
 151
 152 struct sim_dirent {
 153     unsigned char d_name[MAX_PATH];
 154     int attribute;
 155     long size;
 156     long startcluster;
 157     unsigned short wrtdate; /*  Last write date */
 158     unsigned short wrttime; /*  Last write time */
 159 };
 160
 161 struct dirstruct {
 162     void *dir; /* actually a DIR* dir */
 163     char *name;
 164 } SIM_DIR;
 165
 166 struct mydir {
 167     DIR_T *dir;
 168     char *name;
 169 };
 170
 171 typedef struct mydir MYDIR;
 172
 173 #if 1 /* maybe this needs disabling for MSVC... */
 174 static unsigned int rockbox2sim(int opt)
 175 {
 176     int newopt = O_BINARY;
 177
 178     if(opt & 1)
 179         newopt |= O_WRONLY;
 180     if(opt & 2)
 181         newopt |= O_RDWR;
 182     if(opt & 4)
 183         newopt |= O_CREAT;
 184     if(opt & 8)
 185         newopt |= O_APPEND;
 186     if(opt & 0x10)
 187         newopt |= O_TRUNC;
 188
 189     return newopt;
 190 }
 191 #endif
 192
 193 /** Simulator I/O engine routines **/
 194 #define IO_YIELD_THRESHOLD 512
 195
 196 enum
 197 {
 198     IO_READ,
 199     IO_WRITE,
 200 };
 201
 202 struct sim_io
 203 {
 204     struct mutex sim_mutex; /* Rockbox mutex */
 205     int cmd; /* The command to perform */
 206     int ready; /* I/O ready flag - 1= ready */
 207     int fd; /* The file to read/write */
 208     void *buf; /* The buffer to read/write */
 209     size_t count; /* Number of bytes to read/write */
 210     size_t accum; /* Acculated bytes transferred */
 211 };
 212
 213 static struct sim_io io;
 214
 215 int ata_init(void)
 216 {
 217     /* Initialize the rockbox kernel objects on a rockbox thread */
 218     mutex_init(&io.sim_mutex);
 219     io.accum = 0;
 220     return 1;
 221 }
 222
 223 int ata_spinup_time(void)
 224 {
 225     return HZ;
 226 }
 227
 228 static ssize_t io_trigger_and_wait(int cmd)
 229 {
 230     void *mythread = NULL;
 231     ssize_t result;
 232
 233     if (io.count > IO_YIELD_THRESHOLD ||
 234         (io.accum += io.count) >= IO_YIELD_THRESHOLD)
 235     {
 236         /* Allow other rockbox threads to run */
 237         io.accum = 0;
 238         mythread = thread_sdl_thread_unlock();
 239     }
 240
 241     switch (cmd)
 242     {
 243     case IO_READ:
 244         result = read(io.fd, io.buf, io.count);
 245         break;
 246     case IO_WRITE:
 247         result = write(io.fd, io.buf, io.count);
 248         break;
 249     }
 250
 251     /* Regain our status as current */
 252     if (mythread != NULL)
 253     {
 254         thread_sdl_thread_lock(mythread);
 255     }
 256
 257     return result;
 258 }
 259
 260 #ifndef __PCTOOL__
 261 static const char *get_sim_pathname(const char *name)
 262 {
 263     static char buffer[MAX_PATH]; /* sufficiently big */
 264
 265     if(name[0] == '/')
 266     {
 267         snprintf(buffer, sizeof(buffer), "%s%s",
 268             sim_root_dir != NULL ? sim_root_dir : SIMULATOR_DEFAULT_ROOT, name);
 269         return buffer;
 270     }
 271     fprintf(stderr, "WARNING, bad file name lacks slash: %s\n", name);
 272     return name;
 273 }
 274 #else
 275 #define get_sim_pathname(name) name
 276 #endif
 277
 278 MYDIR *sim_opendir(const char *name)
 279 {
 280     DIR_T *dir;
 281
 282     dir = (DIR_T *) OPENDIR(get_sim_pathname(name));
 283
 284     if (dir)
 285     {
 286         MYDIR *my = (MYDIR *)malloc(sizeof(MYDIR));
 287         my->dir = dir;
 288         my->name = (char *)malloc(strlen(name)+1);
 289         strcpy(my->name, name);
 290
 291         return my;
 292     }
 293     /* failed open, return NULL */
 294     return (MYDIR *)0;
 295 }
 296
 297 struct sim_dirent *sim_readdir(MYDIR *dir)
 298 {
 299     char buffer[MAX_PATH]; /* sufficiently big */
 300     static struct sim_dirent secret;
 301     STAT_T s;
 302     DIRENT_T *x11 = READDIR(dir->dir);
 303     struct tm* tm;
 304
 305     if(!x11)
 306         return (struct sim_dirent *)0;
 307
 308     strcpy((char *)secret.d_name, OS_TO_UTF8(x11->d_name));
 309
 310     /* build file name */
 311     snprintf(buffer, sizeof(buffer), "%s/%s",
 312         get_sim_pathname(dir->name), secret.d_name);
 313     STAT(buffer, &s); /* get info */
 314
 315 #define ATTR_DIRECTORY 0x10
 316
 317     secret.attribute = S_ISDIR(s.st_mode)?ATTR_DIRECTORY:0;
 318     secret.size = s.st_size;
 319
 320     tm = localtime(&(s.st_mtime));
 321     secret.wrtdate = ((tm->tm_year - 80) << 9) |
 322                         ((tm->tm_mon + 1) << 5) |
 323                         tm->tm_mday;
 324     secret.wrttime = (tm->tm_hour << 11) |
 325                         (tm->tm_min << 5) |
 326                         (tm->tm_sec >> 1);
 327     return &secret;
 328 }
 329
 330 void sim_closedir(MYDIR *dir)
 331 {
 332     free(dir->name);
 333     CLOSEDIR(dir->dir);
 334
 335     free(dir);
 336 }
 337
 338 int sim_open(const char *name, int o)
 339 {
 340     int opts = rockbox2sim(o);
 341     int ret;
 342
 343     if (num_openfiles >= MAX_OPEN_FILES)
 344         return -2;
 345
 346     ret = OPEN(get_sim_pathname(name), opts, 0666);
 347     if (ret >= 0)
 348         num_openfiles++;
 349     return ret;
 350 }
 351
 352 int sim_close(int fd)
 353 {
 354     int ret;
 355     ret = CLOSE(fd);
 356     if (ret == 0)
 357         num_openfiles--;
 358     return ret;
 359 }
 360
 361 int sim_creat(const char *name)
 362 {
 363     return OPEN(get_sim_pathname(name), O_BINARY | O_WRONLY | O_CREAT | O_TRUNC, 0666);
 364 }
 365
 366 ssize_t sim_read(int fd, void *buf, size_t count)
 367 {
 368     ssize_t result;
 369
 370     mutex_lock(&io.sim_mutex);
 371
 372     /* Setup parameters */
 373     io.fd = fd;
 374     io.buf = buf;
 375     io.count = count;
 376
 377     result = io_trigger_and_wait(IO_READ);
 378
 379     mutex_unlock(&io.sim_mutex);
 380
 381     return result;
 382 }
 383
 384 ssize_t sim_write(int fd, const void *buf, size_t count)
 385 {
 386     ssize_t result;
 387
 388     mutex_lock(&io.sim_mutex);
 389
 390     io.fd = fd;
 391     io.buf = (void*)buf;
 392     io.count = count;
 393
 394     result = io_trigger_and_wait(IO_WRITE);
 395
 396     mutex_unlock(&io.sim_mutex);
 397
 398     return result;
 399 }
 400
 401 int sim_mkdir(const char *name)
 402 {
 403     return MKDIR(get_sim_pathname(name), 0777);
 404 }
 405
 406 int sim_rmdir(const char *name)
 407 {
 408     return RMDIR(get_sim_pathname(name));
 409 }
 410
 411 int sim_remove(const char *name)
 412 {
 413 #ifdef HAVE_DIRCACHE
 414     dircache_remove(name);
 415 #endif
 416     return REMOVE(get_sim_pathname(name));
 417 }
 418
 419 int sim_rename(const char *oldname, const char *newname)
 420 {
 421 #ifdef HAVE_DIRCACHE
 422     dircache_rename(oldname, newname);
 423 #endif
 424     return RENAME(get_sim_pathname(oldname), get_sim_pathname(newname));
 425 }
 426
 427 /* rockbox off_t may be different from system off_t */
 428 long sim_lseek(int fildes, long offset, int whence)
 429 {
 430     return lseek(fildes, offset, whence);
 431 }
 432
 433 long sim_filesize(int fd)
 434 {
 435 #ifdef WIN32
 436     return _filelength(fd);
 437 #else
 438     struct stat buf;
 439
 440     if (!fstat(fd, &buf))
 441         return buf.st_size;
 442     else
 443         return -1;
 444 #endif
 445 }
 446
 447 void fat_size(IF_MV2(int volume,) unsigned long* size, unsigned long* free)
 448 {
 449 #ifdef HAVE_MULTIVOLUME
 450     if (volume != 0) {
 451         /* debugf("io.c: fat_size(volume=%d); simulator only supports volume 0\n",volume); */
 452
 453         if (size) *size = 0;
 454         if (free) *free = 0;
 455         return;
 456     }
 457 #endif
 458
 459 #ifdef WIN32
 460     long secperclus, bytespersec, free_clusters, num_clusters;
 461
 462     if (GetDiskFreeSpace(NULL, &secperclus, &bytespersec, &free_clusters,
 463                      &num_clusters)) {
 464         if (size)
 465             *size = num_clusters * secperclus / 2 * (bytespersec / 512);
 466         if (free)
 467             *free = free_clusters * secperclus / 2 * (bytespersec / 512);
 468     }
 469 #else
 470     struct statfs fs;
 471
 472     if (!statfs(".", &fs)) {
 473         DEBUGF("statfs: bsize=%d blocks=%ld free=%ld\n",
 474                (int)fs.f_bsize, fs.f_blocks, fs.f_bfree);
 475         if (size)
 476             *size = fs.f_blocks * (fs.f_bsize / 1024);
 477         if (free)
 478             *free = fs.f_bfree * (fs.f_bsize / 1024);
 479     }
 480 #endif
 481     else {
 482         if (size)
 483             *size = 0;
 484         if (free)
 485             *free = 0;
 486     }
 487 }
 488
 489 int sim_fsync(int fd)
 490 {
 491 #ifdef WIN32
 492     return _commit(fd);
 493 #else
 494     return fsync(fd);
 495 #endif
 496 }
 497
 498 #ifdef WIN32
 499 /* sim-win32 */
 500 #define dlopen(_x_, _y_) LoadLibraryW(UTF8_TO_OS(_x_))
 501 #define dlsym(_x_, _y_) (void *)GetProcAddress(_x_, _y_)
 502 #define dlclose(_x_) FreeLibrary(_x_)
 503 #else
 504 /* sim-x11 */
 505 #include <dlfcn.h>
 506 #endif
 507
 508 void *sim_codec_load_ram(char* codecptr, int size, void **pd)
 509 {
 510     void *hdr;
 511     char name[MAX_PATH];
 512     char path[MAX_PATH];
 513     int fd;
 514     int codec_count;
 515 #ifdef WIN32
 516     char buf[MAX_PATH];
 517 #endif
 518
 519     *pd = NULL;
 520
 521     /* We have to create the dynamic link library file from ram so we
 522        can simulate the codec loading. With voice and crossfade,
 523        multiple codecs may be loaded at the same time, so we need
 524        to find an unused filename */
 525     for (codec_count = 0; codec_count < 10; codec_count++)
 526     {
 527         snprintf(name, sizeof(name), "/_temp_codec%d.dll", codec_count);
 528         snprintf(path, sizeof(path), "%s", get_sim_pathname(name));
 529         fd = OPEN(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, S_IRWXU);
 530         if (fd >= 0)
 531             break;  /* Created a file ok */
 532     }
 533     if (fd < 0)
 534     {
 535         DEBUGF("failed to open for write: %s\n", path);
 536         return NULL;
 537     }
 538
 539     if (write(fd, codecptr, size) != size)
 540     {
 541         DEBUGF("write failed");
 542         return NULL;
 543     }
 544     close(fd);
 545
 546     /* Now load the library. */
 547     *pd = dlopen(path, RTLD_NOW);
 548     if (*pd == NULL)
 549     {
 550         DEBUGF("failed to load %s\n", path);
 551 #ifdef WIN32
 552         FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
 553                        buf, sizeof buf, NULL);
 554         DEBUGF("dlopen(%s): %s\n", path, buf);
 555 #else
 556         DEBUGF("dlopen(%s): %s\n", path, dlerror());
 557 #endif
 558         return NULL;
 559     }
 560
 561     hdr = dlsym(*pd, "__header");
 562     if (!hdr)
 563         hdr = dlsym(*pd, "___header");
 564
 565     return hdr;       /* maybe NULL if symbol not present */
 566 }
 567
 568 void sim_codec_close(void *pd)
 569 {
 570     dlclose(pd);
 571 }
 572
 573 void *sim_plugin_load(char *plugin, void **pd)
 574 {
 575     void *hdr;
 576     char path[MAX_PATH];
 577 #ifdef WIN32
 578     char buf[MAX_PATH];
 579 #endif
 580
 581     snprintf(path, sizeof(path), "%s", get_sim_pathname(plugin));
 582
 583     *pd = NULL;
 584
 585     *pd = dlopen(path, RTLD_NOW);
 586     if (*pd == NULL) {
 587         DEBUGF("failed to load %s\n", plugin);
 588 #ifdef WIN32
 589         FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0,
 590                        buf, sizeof(buf), NULL);
 591         DEBUGF("dlopen(%s): %s\n", path, buf);
 592 #else
 593         DEBUGF("dlopen(%s): %s\n", path, dlerror());
 594 #endif
 595         return NULL;
 596     }
 597
 598     hdr = dlsym(*pd, "__header");
 599     if (!hdr)
 600         hdr = dlsym(*pd, "___header");
 601
 602     return hdr;    /* maybe NULL if symbol not present */
 603 }
 604
 605 void sim_plugin_close(void *pd)
 606 {
 607     dlclose(pd);
 608 }
 609
 610 #ifdef WIN32
 611 static unsigned old_cp;
 612
 613 void debug_exit(void)
 614 {
 615     /* Reset console output codepage */
 616     SetConsoleOutputCP(old_cp);
 617 }
 618
 619 void debug_init(void)
 620 {
 621     old_cp = GetConsoleOutputCP();
 622     /* Set console output codepage to UTF8. Only works
 623      * correctly when the console uses a truetype font. */
 624     SetConsoleOutputCP(65001);
 625     atexit(debug_exit);
 626 }
 627 #else
 628 void debug_init(void)
 629 {
 630     /* nothing to be done */
 631 }
 632 #endif
 633
 634 void debugf(const char *fmt, ...)
 635 {
 636     va_list ap;
 637     va_start( ap, fmt );
 638     vfprintf( stderr, fmt, ap );
 639     va_end( ap );
 640 }
 641
 642 void ldebugf(const char* file, int line, const char *fmt, ...)
 643 {
 644     va_list ap;
 645     va_start( ap, fmt );
 646     fprintf( stderr, "%s:%d ", file, line );
 647     vfprintf( stderr, fmt, ap );
 648     va_end( ap );
 649 }
 650
 651 /* rockbox off_t may be different from system off_t */
 652 int sim_ftruncate(int fd, long length)
 653 {
 654 #ifdef WIN32
 655     return _chsize(fd, length);
 656 #else
 657     return ftruncate(fd, length);
 658 #endif
 659 }