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