Björn Stenberg | 32125d4 | 2002-05-13 15:23:30 +0000 | [diff] [blame] | 1 | /*************************************************************************** |
| 2 | * __________ __ ___. |
| 3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ |
| 4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / |
| 5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < |
| 6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ |
| 7 | * \/ \/ \/ \/ \/ |
| 8 | * $Id$ |
| 9 | * |
| 10 | * Copyright (C) 2002 Daniel Stenberg |
| 11 | * |
| 12 | * All files in this archive are subject to the GNU General Public License. |
| 13 | * See the file COPYING in the source tree root for full license agreement. |
| 14 | * |
| 15 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY |
| 16 | * KIND, either express or implied. |
| 17 | * |
| 18 | ****************************************************************************/ |
Daniel Stenberg | 7b3abdc | 2002-04-30 13:14:59 +0000 | [diff] [blame] | 19 | |
Daniel Stenberg | ed6c7e4 | 2002-06-14 11:00:13 +0000 | [diff] [blame] | 20 | #include <stdio.h> |
| 21 | #include <stdlib.h> |
| 22 | #include <string.h> |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 23 | #include <stdarg.h> |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 24 | #include <sys/stat.h> |
Björn Stenberg | f6ed970 | 2003-07-04 08:30:01 +0000 | [diff] [blame] | 25 | #ifdef __FreeBSD__ |
| 26 | #include <sys/param.h> |
| 27 | #include <sys/mount.h> |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 28 | #elif !defined(WIN32) |
Björn Stenberg | 6fb512a | 2002-11-12 11:32:26 +0000 | [diff] [blame] | 29 | #include <sys/vfs.h> |
Björn Stenberg | f6ed970 | 2003-07-04 08:30:01 +0000 | [diff] [blame] | 30 | #endif |
Hardeep Sidhu | fb26bfb | 2004-06-14 07:00:50 +0000 | [diff] [blame] | 31 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 32 | #ifdef WIN32 |
| 33 | #include <windows.h> |
| 34 | #endif |
| 35 | |
Hardeep Sidhu | fb26bfb | 2004-06-14 07:00:50 +0000 | [diff] [blame] | 36 | #ifndef _MSC_VER |
Daniel Stenberg | e3a12d3 | 2002-05-07 12:25:30 +0000 | [diff] [blame] | 37 | #include <dirent.h> |
Björn Stenberg | 2ba4fed | 2003-01-28 23:14:41 +0000 | [diff] [blame] | 38 | #include <unistd.h> |
Hardeep Sidhu | fb26bfb | 2004-06-14 07:00:50 +0000 | [diff] [blame] | 39 | #else |
| 40 | #include "dir-win32.h" |
| 41 | #endif |
Daniel Stenberg | 7b3abdc | 2002-04-30 13:14:59 +0000 | [diff] [blame] | 42 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 43 | #define MAX_PATH 260 |
| 44 | |
Daniel Stenberg | ed6c7e4 | 2002-06-14 11:00:13 +0000 | [diff] [blame] | 45 | #include <fcntl.h> |
| 46 | #include "debug.h" |
| 47 | |
Daniel Stenberg | e3a12d3 | 2002-05-07 12:25:30 +0000 | [diff] [blame] | 48 | #define SIMULATOR_ARCHOS_ROOT "archos" |
| 49 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 50 | struct sim_dirent { |
| 51 | unsigned char d_name[MAX_PATH]; |
| 52 | int attribute; |
| 53 | int size; |
| 54 | int startcluster; |
| 55 | unsigned short wrtdate; /* Last write date */ |
| 56 | unsigned short wrttime; /* Last write time */ |
| 57 | }; |
| 58 | |
| 59 | struct dirstruct { |
| 60 | void *dir; /* actually a DIR* dir */ |
| 61 | char *name; |
| 62 | } SIM_DIR; |
| 63 | |
Daniel Stenberg | e3a12d3 | 2002-05-07 12:25:30 +0000 | [diff] [blame] | 64 | struct mydir { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 65 | DIR *dir; |
| 66 | char *name; |
Daniel Stenberg | e3a12d3 | 2002-05-07 12:25:30 +0000 | [diff] [blame] | 67 | }; |
| 68 | |
| 69 | typedef struct mydir MYDIR; |
Daniel Stenberg | 7b3abdc | 2002-04-30 13:14:59 +0000 | [diff] [blame] | 70 | |
Jens Arnold | 527e121 | 2005-02-24 23:11:21 +0000 | [diff] [blame] | 71 | #if 1 /* maybe this needs disabling for MSVC... */ |
Daniel Stenberg | 36c9a95 | 2004-06-14 22:22:49 +0000 | [diff] [blame] | 72 | static unsigned int rockbox2sim(int opt) |
| 73 | { |
| 74 | int newopt = 0; |
| 75 | if(opt & 1) |
| 76 | newopt |= O_WRONLY; |
| 77 | if(opt & 2) |
| 78 | newopt |= O_RDWR; |
| 79 | if(opt & 4) |
| 80 | newopt |= O_CREAT; |
| 81 | if(opt & 8) |
| 82 | newopt |= O_APPEND; |
| 83 | if(opt & 0x10) |
| 84 | newopt |= O_TRUNC; |
| 85 | |
| 86 | return newopt; |
| 87 | } |
Linus Nielsen Feltzing | b6f67a8 | 2004-07-08 05:50:20 +0000 | [diff] [blame] | 88 | #endif |
Daniel Stenberg | 36c9a95 | 2004-06-14 22:22:49 +0000 | [diff] [blame] | 89 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 90 | MYDIR *sim_opendir(const char *name) |
Daniel Stenberg | 7b3abdc | 2002-04-30 13:14:59 +0000 | [diff] [blame] | 91 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 92 | char buffer[256]; /* sufficiently big */ |
| 93 | DIR *dir; |
Daniel Stenberg | 7b3abdc | 2002-04-30 13:14:59 +0000 | [diff] [blame] | 94 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 95 | if(name[0] == '/') { |
| 96 | sprintf(buffer, "%s%s", SIMULATOR_ARCHOS_ROOT, name); |
| 97 | dir=(DIR *)opendir(buffer); |
| 98 | } |
| 99 | else |
| 100 | dir=(DIR *)opendir(name); |
| 101 | |
| 102 | if(dir) { |
| 103 | MYDIR *my = (MYDIR *)malloc(sizeof(MYDIR)); |
| 104 | my->dir = dir; |
| 105 | my->name = (char *)strdup(name); |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 106 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 107 | return my; |
| 108 | } |
| 109 | /* failed open, return NULL */ |
| 110 | return (MYDIR *)0; |
Daniel Stenberg | 7b3abdc | 2002-04-30 13:14:59 +0000 | [diff] [blame] | 111 | } |
Daniel Stenberg | 91f165e | 2002-05-05 10:28:23 +0000 | [diff] [blame] | 112 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 113 | struct sim_dirent *sim_readdir(MYDIR *dir) |
Daniel Stenberg | 159d448 | 2002-05-07 11:35:03 +0000 | [diff] [blame] | 114 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 115 | char buffer[512]; /* sufficiently big */ |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 116 | static struct sim_dirent secret; |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 117 | struct stat s; |
| 118 | struct dirent *x11 = (readdir)(dir->dir); |
Daniel Stenberg | 159d448 | 2002-05-07 11:35:03 +0000 | [diff] [blame] | 119 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 120 | if(!x11) |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 121 | return (struct sim_dirent *)0; |
Daniel Stenberg | 159d448 | 2002-05-07 11:35:03 +0000 | [diff] [blame] | 122 | |
Daniel Stenberg | ee76cc3 | 2005-11-28 09:36:26 +0000 | [diff] [blame] | 123 | strcpy((char *)secret.d_name, x11->d_name); |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 124 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 125 | /* build file name */ |
| 126 | sprintf(buffer, SIMULATOR_ARCHOS_ROOT "%s/%s", |
| 127 | dir->name, x11->d_name); |
| 128 | stat(buffer, &s); /* get info */ |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 129 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 130 | #define ATTR_DIRECTORY 0x10 |
| 131 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 132 | secret.attribute = S_ISDIR(s.st_mode)?ATTR_DIRECTORY:0; |
| 133 | secret.size = s.st_size; |
Jörg Hohensohn | 74eb642 | 2004-06-20 16:34:29 +0000 | [diff] [blame] | 134 | secret.wrtdate = (unsigned short)(s.st_mtime >> 16); |
| 135 | secret.wrttime = (unsigned short)(s.st_mtime & 0xFFFF); |
Daniel Stenberg | 159d448 | 2002-05-07 11:35:03 +0000 | [diff] [blame] | 136 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 137 | return &secret; |
Daniel Stenberg | 159d448 | 2002-05-07 11:35:03 +0000 | [diff] [blame] | 138 | } |
| 139 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 140 | void sim_closedir(MYDIR *dir) |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 141 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 142 | free(dir->name); |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 143 | closedir(dir->dir); |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 144 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 145 | free(dir); |
Daniel Stenberg | 27dfc7c | 2002-05-07 12:06:32 +0000 | [diff] [blame] | 146 | } |
| 147 | |
Daniel Stenberg | 36c9a95 | 2004-06-14 22:22:49 +0000 | [diff] [blame] | 148 | int sim_open(const char *name, int o) |
Daniel Stenberg | 91f165e | 2002-05-05 10:28:23 +0000 | [diff] [blame] | 149 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 150 | char buffer[256]; /* sufficiently big */ |
Daniel Stenberg | 36c9a95 | 2004-06-14 22:22:49 +0000 | [diff] [blame] | 151 | int opts = rockbox2sim(o); |
Daniel Stenberg | 91f165e | 2002-05-05 10:28:23 +0000 | [diff] [blame] | 152 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 153 | if(name[0] == '/') { |
| 154 | sprintf(buffer, "%s%s", SIMULATOR_ARCHOS_ROOT, name); |
Jens Arnold | 399c081 | 2005-02-28 18:32:57 +0000 | [diff] [blame] | 155 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 156 | debugf("We open the real file '%s'\n", buffer); |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 157 | return open(buffer, opts, 0666); |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 158 | } |
Daniel Stenberg | 56e6335 | 2004-06-14 22:32:13 +0000 | [diff] [blame] | 159 | fprintf(stderr, "WARNING, bad file name lacks slash: %s\n", |
| 160 | name); |
| 161 | return -1; |
Daniel Stenberg | 91f165e | 2002-05-05 10:28:23 +0000 | [diff] [blame] | 162 | } |
Björn Stenberg | 6fb512a | 2002-11-12 11:32:26 +0000 | [diff] [blame] | 163 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 164 | int sim_creat(const char *name, mode_t mode) |
Björn Stenberg | c78e1b0 | 2003-01-09 00:55:00 +0000 | [diff] [blame] | 165 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 166 | char buffer[256]; /* sufficiently big */ |
| 167 | (void)mode; |
| 168 | if(name[0] == '/') { |
| 169 | sprintf(buffer, "%s%s", SIMULATOR_ARCHOS_ROOT, name); |
| 170 | |
| 171 | debugf("We create the real file '%s'\n", buffer); |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 172 | return creat(buffer, 0666); |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 173 | } |
Daniel Stenberg | 56e6335 | 2004-06-14 22:32:13 +0000 | [diff] [blame] | 174 | fprintf(stderr, "WARNING, bad file name lacks slash: %s\n", |
| 175 | name); |
| 176 | return -1; |
Jens Arnold | 399c081 | 2005-02-28 18:32:57 +0000 | [diff] [blame] | 177 | } |
Björn Stenberg | c78e1b0 | 2003-01-09 00:55:00 +0000 | [diff] [blame] | 178 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 179 | int sim_mkdir(const char *name, mode_t mode) |
Linus Nielsen Feltzing | ef7293f | 2004-01-21 14:58:40 +0000 | [diff] [blame] | 180 | { |
| 181 | char buffer[256]; /* sufficiently big */ |
| 182 | (void)mode; |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 183 | |
| 184 | sprintf(buffer, "%s%s", SIMULATOR_ARCHOS_ROOT, name); |
Linus Nielsen Feltzing | ef7293f | 2004-01-21 14:58:40 +0000 | [diff] [blame] | 185 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 186 | debugf("We create the real directory '%s'\n", buffer); |
| 187 | #ifdef WIN32 |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 188 | /* since we build with -DNOCYGWIN we have the plain win32 version */ |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 189 | return mkdir(buffer); |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 190 | #else |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 191 | return mkdir(buffer, 0666); |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 192 | #endif |
Linus Nielsen Feltzing | ef7293f | 2004-01-21 14:58:40 +0000 | [diff] [blame] | 193 | } |
| 194 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 195 | int sim_rmdir(const char *name) |
Linus Nielsen Feltzing | 8fa821d | 2004-04-16 09:24:38 +0000 | [diff] [blame] | 196 | { |
| 197 | char buffer[256]; /* sufficiently big */ |
| 198 | if(name[0] == '/') { |
| 199 | sprintf(buffer, "%s%s", SIMULATOR_ARCHOS_ROOT, name); |
| 200 | |
| 201 | debugf("We remove the real directory '%s'\n", buffer); |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 202 | return rmdir(buffer); |
Linus Nielsen Feltzing | 8fa821d | 2004-04-16 09:24:38 +0000 | [diff] [blame] | 203 | } |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 204 | return rmdir(name); |
Linus Nielsen Feltzing | 8fa821d | 2004-04-16 09:24:38 +0000 | [diff] [blame] | 205 | } |
| 206 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 207 | int sim_remove(const char *name) |
Björn Stenberg | c78e1b0 | 2003-01-09 00:55:00 +0000 | [diff] [blame] | 208 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 209 | char buffer[256]; /* sufficiently big */ |
Björn Stenberg | c78e1b0 | 2003-01-09 00:55:00 +0000 | [diff] [blame] | 210 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 211 | if(name[0] == '/') { |
| 212 | sprintf(buffer, "%s%s", SIMULATOR_ARCHOS_ROOT, name); |
Björn Stenberg | c78e1b0 | 2003-01-09 00:55:00 +0000 | [diff] [blame] | 213 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 214 | debugf("We remove the real file '%s'\n", buffer); |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 215 | return remove(buffer); |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 216 | } |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 217 | return remove(name); |
Björn Stenberg | c78e1b0 | 2003-01-09 00:55:00 +0000 | [diff] [blame] | 218 | } |
| 219 | |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 220 | int sim_rename(const char *oldpath, const char* newpath) |
Björn Stenberg | 7d80ba0 | 2003-01-15 11:38:03 +0000 | [diff] [blame] | 221 | { |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 222 | char buffer1[256]; |
| 223 | char buffer2[256]; |
Björn Stenberg | 7d80ba0 | 2003-01-15 11:38:03 +0000 | [diff] [blame] | 224 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 225 | if(oldpath[0] == '/') { |
| 226 | sprintf(buffer1, "%s%s", SIMULATOR_ARCHOS_ROOT, oldpath); |
| 227 | sprintf(buffer2, "%s%s", SIMULATOR_ARCHOS_ROOT, newpath); |
Björn Stenberg | 7d80ba0 | 2003-01-15 11:38:03 +0000 | [diff] [blame] | 228 | |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 229 | debugf("We rename the real file '%s' to '%s'\n", buffer1, buffer2); |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 230 | return rename(buffer1, buffer2); |
Daniel Stenberg | 11d9ecb | 2003-03-05 22:59:36 +0000 | [diff] [blame] | 231 | } |
| 232 | return -1; |
Björn Stenberg | 7d80ba0 | 2003-01-15 11:38:03 +0000 | [diff] [blame] | 233 | } |
| 234 | |
Jens Arnold | 399c081 | 2005-02-28 18:32:57 +0000 | [diff] [blame] | 235 | /* rockbox off_t may be different from system off_t */ |
| 236 | long sim_lseek(int fildes, long offset, int whence) |
Linus Nielsen Feltzing | e98bad5 | 2003-03-18 00:39:57 +0000 | [diff] [blame] | 237 | { |
Jens Arnold | 399c081 | 2005-02-28 18:32:57 +0000 | [diff] [blame] | 238 | return lseek(fildes, offset, whence); |
| 239 | } |
| 240 | |
| 241 | long sim_filesize(int fd) |
| 242 | { |
Jens Arnold | bb9dfa0 | 2005-03-09 19:26:59 +0000 | [diff] [blame] | 243 | #ifdef WIN32 |
| 244 | return _filelength(fd); |
| 245 | #else |
| 246 | struct stat buf; |
| 247 | |
| 248 | if (!fstat(fd, &buf)) |
| 249 | return buf.st_size; |
| 250 | else |
| 251 | return -1; |
| 252 | #endif |
Linus Nielsen Feltzing | e98bad5 | 2003-03-18 00:39:57 +0000 | [diff] [blame] | 253 | } |
| 254 | |
Björn Stenberg | 6fb512a | 2002-11-12 11:32:26 +0000 | [diff] [blame] | 255 | void fat_size(unsigned int* size, unsigned int* free) |
| 256 | { |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 257 | #ifdef WIN32 |
Jens Arnold | 7872426 | 2005-02-22 21:55:48 +0000 | [diff] [blame] | 258 | long secperclus, bytespersec, free_clusters, num_clusters; |
| 259 | |
| 260 | if (GetDiskFreeSpace(NULL, &secperclus, &bytespersec, &free_clusters, |
| 261 | &num_clusters)) { |
| 262 | if (size) |
| 263 | *size = num_clusters * secperclus / 2 * (bytespersec / 512); |
| 264 | if (free) |
| 265 | *free = free_clusters * secperclus / 2 * (bytespersec / 512); |
| 266 | } |
Linus Nielsen Feltzing | a6142ab | 2004-06-10 13:29:52 +0000 | [diff] [blame] | 267 | #else |
Björn Stenberg | 6fb512a | 2002-11-12 11:32:26 +0000 | [diff] [blame] | 268 | struct statfs fs; |
| 269 | |
| 270 | if (!statfs(".", &fs)) { |
| 271 | DEBUGF("statfs: bsize=%d blocks=%d free=%d\n", |
| 272 | fs.f_bsize, fs.f_blocks, fs.f_bfree); |
| 273 | if (size) |
| 274 | *size = fs.f_blocks * (fs.f_bsize / 1024); |
| 275 | if (free) |
| 276 | *free = fs.f_bfree * (fs.f_bsize / 1024); |
| 277 | } |
Jens Arnold | 7872426 | 2005-02-22 21:55:48 +0000 | [diff] [blame] | 278 | #endif |
Björn Stenberg | 6fb512a | 2002-11-12 11:32:26 +0000 | [diff] [blame] | 279 | else { |
| 280 | if (size) |
| 281 | *size = 0; |
| 282 | if (free) |
| 283 | *free = 0; |
| 284 | } |
| 285 | } |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 286 | |
| 287 | int sim_fsync(int fd) |
| 288 | { |
| 289 | #ifdef WIN32 |
| 290 | return _commit(fd); |
| 291 | #else |
| 292 | return fsync(fd); |
| 293 | #endif |
| 294 | } |
| 295 | |
| 296 | #ifdef WIN32 |
| 297 | /* sim-win32 */ |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 298 | #define dlopen(_x_, _y_) LoadLibrary(_x_) |
Jens Arnold | cf208c5 | 2005-02-22 18:21:16 +0000 | [diff] [blame] | 299 | #define dlsym(_x_, _y_) (void *)GetProcAddress(_x_, _y_) |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 300 | #define dlclose(_x_) FreeLibrary(_x_) |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 301 | #else |
| 302 | /* sim-x11 */ |
| 303 | #include <dlfcn.h> |
| 304 | #endif |
| 305 | |
Jens Arnold | a790277 | 2006-01-16 23:20:58 +0000 | [diff] [blame^] | 306 | void *sim_codec_load_ram(char* codecptr, int size, |
Miika Pekkarinen | 645a2e1 | 2005-07-10 16:33:03 +0000 | [diff] [blame] | 307 | void* ptr2, int bufwrap, int *pd_fd) |
| 308 | { |
| 309 | void *pd; |
| 310 | char *path = "archos/_temp_codec.dll"; |
| 311 | int (*codec_start)(void * api); |
| 312 | int fd; |
| 313 | int copy_n; |
| 314 | #ifdef WIN32 |
| 315 | char buf[256]; |
| 316 | #endif |
| 317 | |
| 318 | /* We have to create the dynamic link library file from ram |
| 319 | * so we could simulate the codec loading. |
| 320 | */ |
| 321 | *pd_fd = -1; |
| 322 | fd = open(path, O_WRONLY | O_CREAT, S_IRWXU); |
| 323 | if (fd < 0) { |
| 324 | DEBUGF("failed to open for write: %s\n", path); |
| 325 | return NULL; |
| 326 | } |
| 327 | |
| 328 | if (bufwrap == 0) |
| 329 | bufwrap = size; |
| 330 | |
| 331 | copy_n = bufwrap < size ? bufwrap : size; |
| 332 | if (write(fd, codecptr, copy_n) != copy_n) { |
| 333 | DEBUGF("write failed"); |
| 334 | return NULL; |
| 335 | } |
| 336 | size -= copy_n; |
| 337 | if (size > 0) { |
| 338 | if (write(fd, ptr2, size) != size) { |
| 339 | DEBUGF("write failed [2]"); |
| 340 | return NULL; |
| 341 | } |
| 342 | } |
| 343 | close(fd); |
| 344 | |
| 345 | /* Now load the library. */ |
| 346 | pd = dlopen(path, RTLD_NOW); |
| 347 | if (!pd) { |
| 348 | DEBUGF("failed to load %s\n", path); |
| 349 | #ifdef WIN32 |
| 350 | FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0, |
| 351 | buf, sizeof buf, NULL); |
| 352 | DEBUGF("dlopen(%s): %s\n", path, buf); |
| 353 | #else |
| 354 | DEBUGF("dlopen(%s): %s\n", path, dlerror()); |
| 355 | #endif |
| 356 | dlclose(pd); |
| 357 | return NULL; |
| 358 | } |
| 359 | |
| 360 | codec_start = dlsym(pd, "codec_start"); |
| 361 | if (!codec_start) { |
| 362 | codec_start = dlsym(pd, "_codec_start"); |
| 363 | if (!codec_start) { |
| 364 | dlclose(pd); |
| 365 | return NULL; |
| 366 | } |
| 367 | } |
| 368 | |
| 369 | *pd_fd = (int)pd; |
| 370 | return codec_start; |
| 371 | } |
| 372 | |
| 373 | void sim_codec_close(int pd) |
| 374 | { |
Jens Arnold | a790277 | 2006-01-16 23:20:58 +0000 | [diff] [blame^] | 375 | dlclose((void *)pd); |
Miika Pekkarinen | 645a2e1 | 2005-07-10 16:33:03 +0000 | [diff] [blame] | 376 | } |
| 377 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 378 | void *sim_plugin_load(char *plugin, int *fd) |
| 379 | { |
Jens Arnold | a790277 | 2006-01-16 23:20:58 +0000 | [diff] [blame^] | 380 | void *pd, *hdr; |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 381 | char path[256]; |
Jens Arnold | cf208c5 | 2005-02-22 18:21:16 +0000 | [diff] [blame] | 382 | #ifdef WIN32 |
| 383 | char buf[256]; |
| 384 | #endif |
| 385 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 386 | snprintf(path, sizeof path, "archos%s", plugin); |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 387 | |
Jens Arnold | a790277 | 2006-01-16 23:20:58 +0000 | [diff] [blame^] | 388 | *fd = 0; |
| 389 | |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 390 | pd = dlopen(path, RTLD_NOW); |
| 391 | if (!pd) { |
Jens Arnold | cf208c5 | 2005-02-22 18:21:16 +0000 | [diff] [blame] | 392 | DEBUGF("failed to load %s\n", plugin); |
| 393 | #ifdef WIN32 |
| 394 | FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(), 0, |
| 395 | buf, sizeof buf, NULL); |
| 396 | DEBUGF("dlopen(%s): %s\n", path, buf); |
| 397 | #else |
| 398 | DEBUGF("dlopen(%s): %s\n", path, dlerror()); |
| 399 | #endif |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 400 | dlclose(pd); |
| 401 | return NULL; |
| 402 | } |
| 403 | |
Jens Arnold | a790277 | 2006-01-16 23:20:58 +0000 | [diff] [blame^] | 404 | hdr = dlsym(pd, "__header"); |
| 405 | if (!hdr) |
| 406 | hdr = dlsym(pd, "___header"); |
| 407 | |
Jens Arnold | cf208c5 | 2005-02-22 18:21:16 +0000 | [diff] [blame] | 408 | *fd = (int)pd; /* success */ |
Jens Arnold | a790277 | 2006-01-16 23:20:58 +0000 | [diff] [blame^] | 409 | return hdr; /* maybe NULL if symbol not present */ |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 410 | } |
| 411 | |
| 412 | void sim_plugin_close(int pd) |
| 413 | { |
Jens Arnold | cf208c5 | 2005-02-22 18:21:16 +0000 | [diff] [blame] | 414 | dlclose((void *)pd); |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 415 | } |
| 416 | |
| 417 | #ifndef WIN32 |
| 418 | /* the win32 version is in debug-win32.c */ |
| 419 | |
| 420 | void debug_init(void) |
| 421 | { |
| 422 | /* nothing to be done */ |
| 423 | } |
| 424 | |
| 425 | void debugf(const char *fmt, ...) |
| 426 | { |
| 427 | va_list ap; |
| 428 | va_start( ap, fmt ); |
| 429 | vfprintf( stderr, fmt, ap ); |
| 430 | va_end( ap ); |
| 431 | } |
| 432 | |
| 433 | void ldebugf(const char* file, int line, const char *fmt, ...) |
| 434 | { |
| 435 | va_list ap; |
| 436 | va_start( ap, fmt ); |
| 437 | fprintf( stderr, "%s:%d ", file, line ); |
| 438 | vfprintf( stderr, fmt, ap ); |
| 439 | va_end( ap ); |
| 440 | } |
| 441 | |
| 442 | #endif |
| 443 | |
Jens Arnold | 576d029 | 2005-03-05 21:48:58 +0000 | [diff] [blame] | 444 | /* rockbox off_t may be different from system off_t */ |
| 445 | int sim_ftruncate(int fd, long length) |
Daniel Stenberg | 22b7701 | 2005-02-22 12:19:12 +0000 | [diff] [blame] | 446 | { |
| 447 | #ifdef WIN32 |
| 448 | return _chsize(fd, length); |
| 449 | #else |
| 450 | return ftruncate(fd, length); |
| 451 | #endif |
| 452 | } |