1 /*-------------------------------------------------------------
2
3 es.c -- ETicket services
4
5 Copyright (C) 2008
6 Michael Wiedenbauer (shagkur)
7 Dave Murphy (WinterMute)
8 Hector Martin (marcan)
9
10 This software is provided 'as-is', without any express or implied
11 warranty. In no event will the authors be held liable for any
12 damages arising from the use of this software.
13
14 Permission is granted to anyone to use this software for any
15 purpose, including commercial applications, and to alter it and
16 redistribute it freely, subject to the following restrictions:
17
18 1. The origin of this software must not be misrepresented; you
19 must not claim that you wrote the original software. If you use
20 this software in a product, an acknowledgment in the product
21 documentation would be appreciated but is not required.
22
23 2. Altered source versions must be plainly marked as such, and
24 must not be misrepresented as being the original software.
25
26 3. This notice may not be removed or altered from any source
27 distribution.
28
29 -------------------------------------------------------------*/
30
31 #if defined(HW_RVL)
32
33 #include <stdlib.h>
34 #include <stdio.h>
35 #include <string.h>
36 #include <malloc.h>
37 #include <time.h>
38 #include <gcutil.h>
39 #include <ipc.h>
40
41 #include "isfs.h"
42
43 #define ISFS_STRUCTSIZE (sizeof(struct isfs_cb))
44 #define ISFS_HEAPSIZE (ISFS_STRUCTSIZE<<4)
45
46 #define ISFS_FUNCNULL 0
47 #define ISFS_FUNCGETSTAT 1
48 #define ISFS_FUNCREADDIR 2
49 #define ISFS_FUNCGETATTR 3
50 #define ISFS_FUNCGETUSAGE 4
51
52 #define ISFS_IOCTL_FORMAT 1
53 #define ISFS_IOCTL_GETSTATS 2
54 #define ISFS_IOCTL_CREATEDIR 3
55 #define ISFS_IOCTL_READDIR 4
56 #define ISFS_IOCTL_SETATTR 5
57 #define ISFS_IOCTL_GETATTR 6
58 #define ISFS_IOCTL_DELETE 7
59 #define ISFS_IOCTL_RENAME 8
60 #define ISFS_IOCTL_CREATEFILE 9
61 #define ISFS_IOCTL_SETFILEVERCTRL 10
62 #define ISFS_IOCTL_GETFILESTATS 11
63 #define ISFS_IOCTL_GETUSAGE 12
64 #define ISFS_IOCTL_SHUTDOWN 13
65
66 struct isfs_cb
67 {
68 char filepath[ISFS_MAXPATH];
69 union {
70 struct {
71 char filepathOld[ISFS_MAXPATH];
72 char filepathNew[ISFS_MAXPATH];
73 } fsrename;
74 struct {
75 u32 owner_id;
76 u16 group_id;
77 char filepath[ISFS_MAXPATH];
78 u8 ownerperm;
79 u8 groupperm;
80 u8 otherperm;
81 u8 attributes;
82 u8 pad0[2];
83 } fsattr;
84 struct {
85 ioctlv vector[4];
86 u32 no_entries;
87 } fsreaddir;
88 struct {
89 ioctlv vector[4];
90 u32 usage1;
91 u8 pad0[28];
92 u32 usage2;
93 } fsusage;
94 struct {
95 u32 a;
96 u32 b;
97 u32 c;
98 u32 d;
99 u32 e;
100 u32 f;
101 u32 g;
102 } fsstats;
103 };
104
105 isfscallback cb;
106 void *usrdata;
107 u32 functype;
108 void *funcargv[8];
109 };
110
111 static s32 hId = -1;
112 static s32 _fs_fd = -1;
113 static char _dev_fs[] ATTRIBUTE_ALIGN(32) = "/dev/fs";
114
__isfsGetStatsCB(s32 result,void * usrdata)115 static s32 __isfsGetStatsCB(s32 result,void *usrdata)
116 {
117 struct isfs_cb *param = (struct isfs_cb*)usrdata;
118 if(result==0) memcpy(param->funcargv[0],¶m->fsstats,sizeof(param->fsstats));
119 return result;
120 }
121
__isfsGetAttrCB(s32 result,void * usrdata)122 static s32 __isfsGetAttrCB(s32 result,void *usrdata)
123 {
124 struct isfs_cb *param = (struct isfs_cb*)usrdata;
125 if(result==0) {
126 *(u32*)(param->funcargv[0]) = param->fsattr.owner_id;
127 *(u16*)(param->funcargv[1]) = param->fsattr.group_id;
128 *(u8*)(param->funcargv[2]) = param->fsattr.attributes;
129 *(u8*)(param->funcargv[3]) = param->fsattr.ownerperm;
130 *(u8*)(param->funcargv[4]) = param->fsattr.groupperm;
131 *(u8*)(param->funcargv[5]) = param->fsattr.otherperm;
132 }
133 return result;
134 }
135
__isfsGetUsageCB(s32 result,void * usrdata)136 static s32 __isfsGetUsageCB(s32 result,void *usrdata)
137 {
138 struct isfs_cb *param = (struct isfs_cb*)usrdata;
139 if(result==0) {
140 *(u32*)(param->funcargv[0]) = param->fsusage.usage1;
141 *(u32*)(param->funcargv[1]) = param->fsusage.usage2;
142 }
143 return result;
144
145 }
__isfsReadDirCB(s32 result,void * usrdata)146 static s32 __isfsReadDirCB(s32 result,void *usrdata)
147 {
148 struct isfs_cb *param = (struct isfs_cb*)usrdata;
149 if(result==0) *(u32*)(param->funcargv[0]) = param->fsreaddir.no_entries;
150 return result;
151 }
152
__isfsFunctionCB(s32 result,void * usrdata)153 static s32 __isfsFunctionCB(s32 result,void *usrdata)
154 {
155 struct isfs_cb *param = (struct isfs_cb*)usrdata;
156
157 if(result>=0) {
158 if(param->functype==ISFS_FUNCGETSTAT) __isfsGetStatsCB(result,usrdata);
159 else if(param->functype==ISFS_FUNCREADDIR) __isfsReadDirCB(result,usrdata);
160 else if(param->functype==ISFS_FUNCGETATTR) __isfsGetAttrCB(result,usrdata);
161 else if(param->functype==ISFS_FUNCGETUSAGE) __isfsGetUsageCB(result,usrdata);
162 }
163 if(param->cb!=NULL) param->cb(result,param->usrdata);
164
165 iosFree(hId,param);
166 return result;
167 }
168
ISFS_Initialize()169 s32 ISFS_Initialize()
170 {
171 s32 ret = IPC_OK;
172
173 if(_fs_fd<0) {
174 _fs_fd = IOS_Open(_dev_fs,0);
175 if(_fs_fd<0) return _fs_fd;
176 }
177
178 if(hId<0) {
179 hId = iosCreateHeap(ISFS_HEAPSIZE);
180 if(hId<0) return IPC_ENOMEM;
181 }
182 return ret;
183 }
184
ISFS_Deinitialize()185 s32 ISFS_Deinitialize()
186 {
187 if(_fs_fd<0) return ISFS_EINVAL;
188
189 IOS_Close(_fs_fd);
190 _fs_fd = -1;
191
192 return 0;
193 }
194
ISFS_ReadDir(const char * filepath,char * name_list,u32 * num)195 s32 ISFS_ReadDir(const char *filepath,char *name_list,u32 *num)
196 {
197 s32 ret;
198 s32 len,cnt;
199 s32 ilen,olen;
200 struct isfs_cb *param;
201
202 if(_fs_fd<0 || filepath==NULL || num==NULL) return ISFS_EINVAL;
203 if(name_list!=NULL && ((u32)name_list%32)!=0) return ISFS_EINVAL;
204
205 len = strnlen(filepath,ISFS_MAXPATH);
206 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
207
208 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
209 if(param==NULL) return ISFS_ENOMEM;
210
211 memcpy(param->filepath,filepath,(len+1));
212
213 param->fsreaddir.vector[0].data = param->filepath;
214 param->fsreaddir.vector[0].len = ISFS_MAXPATH;
215 param->fsreaddir.vector[1].data = ¶m->fsreaddir.no_entries;
216 param->fsreaddir.vector[1].len = sizeof(u32);
217
218 if(name_list!=NULL) {
219 ilen = olen = 2;
220 cnt = *num;
221 param->fsreaddir.no_entries = cnt;
222 param->fsreaddir.vector[2].data = name_list;
223 param->fsreaddir.vector[2].len = (cnt*13);
224 param->fsreaddir.vector[3].data = ¶m->fsreaddir.no_entries;
225 param->fsreaddir.vector[3].len = sizeof(u32);
226 } else
227 ilen = olen = 1;
228
229 ret = IOS_Ioctlv(_fs_fd,ISFS_IOCTL_READDIR,ilen,olen,param->fsreaddir.vector);
230 if(ret==0) *num = param->fsreaddir.no_entries;
231
232 if(param!=NULL) iosFree(hId,param);
233 return ret;
234 }
235
ISFS_ReadDirAsync(const char * filepath,char * name_list,u32 * num,isfscallback cb,void * usrdata)236 s32 ISFS_ReadDirAsync(const char *filepath,char *name_list,u32 *num,isfscallback cb,void *usrdata)
237 {
238 s32 len,cnt;
239 s32 ilen,olen;
240 struct isfs_cb *param;
241
242 if(_fs_fd<0 || filepath==NULL || num==NULL) return ISFS_EINVAL;
243 if(name_list!=NULL && ((u32)name_list%32)!=0) return ISFS_EINVAL;
244
245 len = strnlen(filepath,ISFS_MAXPATH);
246 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
247
248 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
249 if(param==NULL) return ISFS_ENOMEM;
250
251 param->cb = cb;
252 param->usrdata = usrdata;
253 param->funcargv[0] = num;
254 param->functype = ISFS_FUNCREADDIR;
255 memcpy(param->filepath,filepath,(len+1));
256
257 param->fsreaddir.vector[0].data = param->filepath;
258 param->fsreaddir.vector[0].len = ISFS_MAXPATH;
259 param->fsreaddir.vector[1].data = ¶m->fsreaddir.no_entries;
260 param->fsreaddir.vector[1].len = sizeof(u32);
261
262 if(name_list!=NULL) {
263 ilen = olen = 2;
264 cnt = *num;
265 param->fsreaddir.no_entries = cnt;
266 param->fsreaddir.vector[2].data = name_list;
267 param->fsreaddir.vector[2].len = (cnt*13);
268 param->fsreaddir.vector[3].data = ¶m->fsreaddir.no_entries;
269 param->fsreaddir.vector[3].len = sizeof(u32);
270 } else
271 ilen = olen = 1;
272
273 return IOS_IoctlvAsync(_fs_fd,ISFS_IOCTL_READDIR,ilen,olen,param->fsreaddir.vector,__isfsFunctionCB,param);
274 }
275
ISFS_CreateDir(const char * filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm)276 s32 ISFS_CreateDir(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm)
277 {
278 s32 ret;
279 s32 len;
280 struct isfs_cb *param;
281
282 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
283
284 len = strnlen(filepath,ISFS_MAXPATH);
285 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
286
287 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
288 if(param==NULL) return ISFS_ENOMEM;
289
290 memcpy(param->fsattr.filepath ,filepath,(len+1));
291
292 param->fsattr.attributes = attributes;
293 param->fsattr.ownerperm = owner_perm;
294 param->fsattr.groupperm = group_perm;
295 param->fsattr.otherperm = other_perm;
296 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_CREATEDIR,¶m->fsattr,sizeof(param->fsattr),NULL,0);
297
298 if(param!=NULL) iosFree(hId,param);
299 return ret;
300 }
301
ISFS_CreateDirAsync(const char * filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm,isfscallback cb,void * usrdata)302 s32 ISFS_CreateDirAsync(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm,isfscallback cb,void *usrdata)
303 {
304 s32 len;
305 struct isfs_cb *param;
306
307 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
308
309 len = strnlen(filepath,ISFS_MAXPATH);
310 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
311
312 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
313 if(param==NULL) return ISFS_ENOMEM;
314
315 param->cb = cb;
316 param->usrdata = usrdata;
317 param->functype = ISFS_FUNCNULL;
318 memcpy(param->fsattr.filepath,filepath,(len+1));
319
320 param->fsattr.attributes = attributes;
321 param->fsattr.ownerperm = owner_perm;
322 param->fsattr.groupperm = group_perm;
323 param->fsattr.otherperm = other_perm;
324 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_CREATEDIR,¶m->fsattr,sizeof(param->fsattr),NULL,0,__isfsFunctionCB,param);
325 }
326
ISFS_Open(const char * filepath,u8 mode)327 s32 ISFS_Open(const char *filepath,u8 mode)
328 {
329 s32 ret;
330 s32 len;
331 struct isfs_cb *param;
332
333 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
334
335 len = strnlen(filepath,ISFS_MAXPATH);
336 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
337
338 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
339 if(param==NULL) return ISFS_ENOMEM;
340
341 memcpy(param->filepath,filepath,(len+1));
342 ret = IOS_Open(param->filepath,mode);
343
344 if(param!=NULL) iosFree(hId,param);
345 return ret;
346 }
347
ISFS_OpenAsync(const char * filepath,u8 mode,isfscallback cb,void * usrdata)348 s32 ISFS_OpenAsync(const char *filepath,u8 mode,isfscallback cb,void *usrdata)
349 {
350 s32 len;
351 struct isfs_cb *param;
352
353 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
354
355 len = strnlen(filepath,ISFS_MAXPATH);
356 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
357
358 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
359 if(param==NULL) return ISFS_ENOMEM;
360
361 param->cb = cb;
362 param->usrdata = usrdata;
363 param->functype = ISFS_FUNCNULL;
364 memcpy(param->filepath,filepath,(len+1));
365 return IOS_OpenAsync(param->filepath,mode,__isfsFunctionCB,param);
366 }
367
ISFS_Format()368 s32 ISFS_Format()
369 {
370 if(_fs_fd<0) return ISFS_EINVAL;
371
372 return IOS_Ioctl(_fs_fd,ISFS_IOCTL_FORMAT,NULL,0,NULL,0);
373 }
374
ISFS_FormatAsync(isfscallback cb,void * usrdata)375 s32 ISFS_FormatAsync(isfscallback cb,void *usrdata)
376 {
377 struct isfs_cb *param;
378
379 if(_fs_fd<0) return ISFS_EINVAL;
380
381 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
382 if(param==NULL) return ISFS_ENOMEM;
383
384 param->cb = cb;
385 param->usrdata = usrdata;
386 param->functype = ISFS_FUNCNULL;
387 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_FORMAT,NULL,0,NULL,0,__isfsFunctionCB,param);
388 }
389
ISFS_GetStats(void * stats)390 s32 ISFS_GetStats(void *stats)
391 {
392 s32 ret = ISFS_OK;
393 struct isfs_cb *param;
394
395 if(_fs_fd<0 || stats==NULL) return ISFS_EINVAL;
396
397 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
398 if(param==NULL) return ISFS_ENOMEM;
399
400 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_GETSTATS,NULL,0,¶m->fsstats,sizeof(param->fsstats));
401 if(ret==IPC_OK) memcpy(stats,¶m->fsstats,sizeof(param->fsstats));
402
403 if(param!=NULL) iosFree(hId,param);
404 return ret;
405 }
406
ISFS_GetStatsAsync(void * stats,isfscallback cb,void * usrdata)407 s32 ISFS_GetStatsAsync(void *stats,isfscallback cb,void *usrdata)
408 {
409 struct isfs_cb *param;
410
411 if(_fs_fd<0 || stats==NULL) return ISFS_EINVAL;
412
413 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
414 if(param==NULL) return ISFS_ENOMEM;
415
416 param->cb = cb;
417 param->usrdata = usrdata;
418 param->functype = ISFS_FUNCGETSTAT;
419 param->funcargv[0] = stats;
420 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_GETSTATS,NULL,0,¶m->fsstats,sizeof(param->fsstats),__isfsFunctionCB,param);
421 }
422
ISFS_Write(s32 fd,const void * buffer,u32 length)423 s32 ISFS_Write(s32 fd,const void *buffer,u32 length)
424 {
425 if(length<=0 || buffer==NULL) return ISFS_EINVAL;
426
427 return IOS_Write(fd,buffer,length);
428 }
429
ISFS_WriteAsync(s32 fd,const void * buffer,u32 length,isfscallback cb,void * usrdata)430 s32 ISFS_WriteAsync(s32 fd,const void *buffer,u32 length,isfscallback cb,void *usrdata)
431 {
432 struct isfs_cb *param;
433
434 if(length<=0 || buffer==NULL) return ISFS_EINVAL;
435
436 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
437 if(param==NULL) return ISFS_ENOMEM;
438
439 param->cb = cb;
440 param->usrdata = usrdata;
441 param->functype = ISFS_FUNCNULL;
442 return IOS_WriteAsync(fd,buffer,length,__isfsFunctionCB,param);
443 }
444
ISFS_Read(s32 fd,void * buffer,u32 length)445 s32 ISFS_Read(s32 fd,void *buffer,u32 length)
446 {
447 if(length<=0 || buffer==NULL || ((u32)buffer%32)!=0) return ISFS_EINVAL;
448
449 return IOS_Read(fd,buffer,length);
450 }
451
ISFS_ReadAsync(s32 fd,void * buffer,u32 length,isfscallback cb,void * usrdata)452 s32 ISFS_ReadAsync(s32 fd,void *buffer,u32 length,isfscallback cb,void *usrdata)
453 {
454 struct isfs_cb *param;
455
456 if(length<=0 || buffer==NULL || ((u32)buffer%32)!=0) return ISFS_EINVAL;
457
458 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
459 if(param==NULL) return ISFS_ENOMEM;
460
461 param->cb = cb;
462 param->usrdata = usrdata;
463 param->functype = ISFS_FUNCNULL;
464 return IOS_ReadAsync(fd,buffer,length,__isfsFunctionCB,param);
465 }
466
ISFS_Seek(s32 fd,s32 where,s32 whence)467 s32 ISFS_Seek(s32 fd,s32 where,s32 whence)
468 {
469 return IOS_Seek(fd,where,whence);
470 }
471
ISFS_SeekAsync(s32 fd,s32 where,s32 whence,isfscallback cb,void * usrdata)472 s32 ISFS_SeekAsync(s32 fd,s32 where,s32 whence,isfscallback cb,void *usrdata)
473 {
474 struct isfs_cb *param;
475
476 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
477 if(param==NULL) return ISFS_ENOMEM;
478
479 param->cb = cb;
480 param->usrdata = usrdata;
481 param->functype = ISFS_FUNCNULL;
482 return IOS_SeekAsync(fd,where,whence,__isfsFunctionCB,param);
483 }
484
ISFS_CreateFile(const char * filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm)485 s32 ISFS_CreateFile(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm)
486 {
487 s32 ret;
488 s32 len;
489 struct isfs_cb *param;
490
491 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
492
493 len = strnlen(filepath,ISFS_MAXPATH);
494 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
495
496 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
497 if(param==NULL) return ISFS_ENOMEM;
498
499 memcpy(param->fsattr.filepath,filepath,(len+1));
500
501 param->fsattr.attributes = attributes;
502 param->fsattr.ownerperm = owner_perm;
503 param->fsattr.groupperm = group_perm;
504 param->fsattr.otherperm = other_perm;
505 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_CREATEFILE,¶m->fsattr,sizeof(param->fsattr),NULL,0);
506
507 if(param!=NULL) iosFree(hId,param);
508 return ret;
509 }
510
ISFS_CreateFileAsync(const char * filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm,isfscallback cb,void * usrdata)511 s32 ISFS_CreateFileAsync(const char *filepath,u8 attributes,u8 owner_perm,u8 group_perm,u8 other_perm,isfscallback cb,void *usrdata)
512 {
513 s32 len;
514 struct isfs_cb *param;
515
516 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
517
518 len = strnlen(filepath,ISFS_MAXPATH);
519 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
520
521 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
522 if(param==NULL) return ISFS_ENOMEM;
523
524 param->cb = cb;
525 param->usrdata = usrdata;
526 param->functype = ISFS_FUNCNULL;
527 memcpy(param->fsattr.filepath,filepath,(len+1));
528
529 param->fsattr.attributes = attributes;
530 param->fsattr.ownerperm = owner_perm;
531 param->fsattr.groupperm = group_perm;
532 param->fsattr.otherperm = other_perm;
533 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_CREATEFILE,¶m->fsattr,sizeof(param->fsattr),NULL,0,__isfsFunctionCB,param);
534 }
535
ISFS_Delete(const char * filepath)536 s32 ISFS_Delete(const char *filepath)
537 {
538 s32 ret;
539 s32 len;
540 struct isfs_cb *param;
541
542 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
543
544 len = strnlen(filepath,ISFS_MAXPATH);
545 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
546
547 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
548 if(param==NULL) return ISFS_ENOMEM;
549
550 memcpy(param->filepath,filepath,(len+1));
551 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_DELETE,param->filepath,ISFS_MAXPATH,NULL,0);
552
553 if(param!=NULL) iosFree(hId,param);
554 return ret;
555 }
556
ISFS_DeleteAsync(const char * filepath,isfscallback cb,void * usrdata)557 s32 ISFS_DeleteAsync(const char *filepath,isfscallback cb,void *usrdata)
558 {
559 s32 len;
560 struct isfs_cb *param;
561
562 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
563
564 len = strnlen(filepath,ISFS_MAXPATH);
565 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
566
567 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
568 if(param==NULL) return ISFS_ENOMEM;
569
570 param->cb = cb;
571 param->usrdata = usrdata;
572 param->functype = ISFS_FUNCNULL;
573 memcpy(param->filepath,filepath,(len+1));
574 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_DELETE,param->filepath,ISFS_MAXPATH,NULL,0,__isfsFunctionCB,param);
575 }
576
ISFS_Close(s32 fd)577 s32 ISFS_Close(s32 fd)
578 {
579 if(fd<0) return 0;
580
581 return IOS_Close(fd);
582 }
583
ISFS_CloseAsync(s32 fd,isfscallback cb,void * usrdata)584 s32 ISFS_CloseAsync(s32 fd,isfscallback cb,void *usrdata)
585 {
586 struct isfs_cb *param;
587
588 if(fd<0) return 0;
589
590 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
591 if(param==NULL) return ISFS_ENOMEM;
592
593 param->cb = cb;
594 param->usrdata = usrdata;
595 param->functype = ISFS_FUNCNULL;
596 return IOS_CloseAsync(fd,__isfsFunctionCB,param);
597 }
598
ISFS_GetFileStats(s32 fd,fstats * status)599 s32 ISFS_GetFileStats(s32 fd,fstats *status)
600 {
601 if(status==NULL || ((u32)status%32)!=0) return ISFS_EINVAL;
602
603 return IOS_Ioctl(fd,ISFS_IOCTL_GETFILESTATS,NULL,0,status,sizeof(fstats));
604 }
605
ISFS_GetFileStatsAsync(s32 fd,fstats * status,isfscallback cb,void * usrdata)606 s32 ISFS_GetFileStatsAsync(s32 fd,fstats *status,isfscallback cb,void *usrdata)
607 {
608 struct isfs_cb *param;
609
610 if(status==NULL || ((u32)status%32)!=0) return ISFS_EINVAL;
611
612 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
613 if(param==NULL) return ISFS_ENOMEM;
614
615 param->cb = cb;
616 param->usrdata = usrdata;
617 param->functype = ISFS_FUNCNULL;
618 return IOS_IoctlAsync(fd,ISFS_IOCTL_GETFILESTATS,NULL,0,status,sizeof(fstats),__isfsFunctionCB,param);
619 }
620
ISFS_GetAttr(const char * filepath,u32 * ownerID,u16 * groupID,u8 * attributes,u8 * ownerperm,u8 * groupperm,u8 * otherperm)621 s32 ISFS_GetAttr(const char *filepath,u32 *ownerID,u16 *groupID,u8 *attributes,u8 *ownerperm,u8 *groupperm,u8 *otherperm)
622 {
623 s32 ret;
624 s32 len;
625 struct isfs_cb *param;
626
627 if(_fs_fd<0 || filepath==NULL || ownerID==NULL || groupID==NULL
628 || attributes==NULL || ownerperm==NULL || groupperm==NULL || otherperm==NULL) return ISFS_EINVAL;
629
630 len = strnlen(filepath,ISFS_MAXPATH);
631 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
632
633 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
634 if(param==NULL) return ISFS_ENOMEM;
635
636 memcpy(param->filepath,filepath,(len+1));
637 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_GETATTR,param->filepath,ISFS_MAXPATH,¶m->fsattr,sizeof(param->fsattr));
638 if(ret==IPC_OK) {
639 *ownerID = param->fsattr.owner_id;
640 *groupID = param->fsattr.group_id;
641 *ownerperm = param->fsattr.ownerperm;
642 *groupperm = param->fsattr.groupperm;
643 *otherperm = param->fsattr.otherperm;
644 *attributes = param->fsattr.attributes;
645 }
646
647 if(param!=NULL) iosFree(hId,param);
648 return ret;
649 }
650
ISFS_GetAttrAsync(const char * filepath,u32 * ownerID,u16 * groupID,u8 * attributes,u8 * ownerperm,u8 * groupperm,u8 * otherperm,isfscallback cb,void * usrdata)651 s32 ISFS_GetAttrAsync(const char *filepath,u32 *ownerID,u16 *groupID,u8 *attributes,u8 *ownerperm,u8 *groupperm,u8 *otherperm,isfscallback cb,void *usrdata)
652 {
653 s32 len;
654 struct isfs_cb *param;
655
656 if(_fs_fd<0 || filepath==NULL || ownerID==NULL || groupID==NULL
657 || attributes==NULL || ownerperm==NULL || groupperm==NULL || otherperm==NULL) return ISFS_EINVAL;
658
659 len = strnlen(filepath,ISFS_MAXPATH);
660 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
661
662 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
663 if(param==NULL) return ISFS_ENOMEM;
664
665 param->cb = cb;
666 param->usrdata = usrdata;
667 param->functype = ISFS_FUNCGETATTR;
668 param->funcargv[0] = ownerID;
669 param->funcargv[1] = groupID;
670 param->funcargv[2] = attributes;
671 param->funcargv[3] = ownerperm;
672 param->funcargv[4] = groupperm;
673 param->funcargv[5] = otherperm;
674 memcpy(param->filepath,filepath,(len+1));
675 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_GETATTR,param->filepath,ISFS_MAXPATH,¶m->fsattr,sizeof(param->fsattr),__isfsFunctionCB,param);
676 }
677
ISFS_Rename(const char * filepathOld,const char * filepathNew)678 s32 ISFS_Rename(const char *filepathOld,const char *filepathNew)
679 {
680 s32 ret;
681 s32 len0,len1;
682 struct isfs_cb *param;
683
684 if(_fs_fd<0 || filepathOld==NULL || filepathNew==NULL) return ISFS_EINVAL;
685
686 len0 = strnlen(filepathOld,ISFS_MAXPATH);
687 if(len0>=ISFS_MAXPATH) return ISFS_EINVAL;
688
689 len1 = strnlen(filepathNew,ISFS_MAXPATH);
690 if(len1>=ISFS_MAXPATH) return ISFS_EINVAL;
691
692 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
693 if(param==NULL) return ISFS_ENOMEM;
694
695 memcpy(param->fsrename.filepathOld,filepathOld,(len0+1));
696 memcpy(param->fsrename.filepathNew,filepathNew,(len1+1));
697 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_RENAME,¶m->fsrename,sizeof(param->fsrename),NULL,0);
698
699 if(param!=NULL) iosFree(hId,param);
700 return ret;
701 }
702
ISFS_RenameAsync(const char * filepathOld,const char * filepathNew,isfscallback cb,void * usrdata)703 s32 ISFS_RenameAsync(const char *filepathOld,const char *filepathNew,isfscallback cb,void *usrdata)
704 {
705 s32 len0,len1;
706 struct isfs_cb *param;
707
708 if(_fs_fd<0 || filepathOld==NULL || filepathNew==NULL) return ISFS_EINVAL;
709
710 len0 = strnlen(filepathOld,ISFS_MAXPATH);
711 if(len0>=ISFS_MAXPATH) return ISFS_EINVAL;
712
713 len1 = strnlen(filepathNew,ISFS_MAXPATH);
714 if(len1>=ISFS_MAXPATH) return ISFS_EINVAL;
715
716 param = (struct isfs_cb*)iosAlloc(hId,ISFS_STRUCTSIZE);
717 if(param==NULL) return ISFS_ENOMEM;
718
719 param->cb = cb;
720 param->usrdata = usrdata;
721 param->functype = ISFS_FUNCNULL;
722 memcpy(param->fsrename.filepathOld,filepathOld,(len0+1));
723 memcpy(param->fsrename.filepathNew,filepathNew,(len1+1));
724 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_RENAME,¶m->fsrename,sizeof(param->fsrename),NULL,0,__isfsFunctionCB,param);
725 }
726
ISFS_SetAttr(const char * filepath,u32 ownerID,u16 groupID,u8 attributes,u8 ownerperm,u8 groupperm,u8 otherperm)727 s32 ISFS_SetAttr(const char *filepath,u32 ownerID,u16 groupID,u8 attributes,u8 ownerperm,u8 groupperm,u8 otherperm)
728 {
729 s32 ret, len;
730 struct isfs_cb *param;
731
732 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
733
734 len = strnlen(filepath, ISFS_MAXPATH);
735 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
736
737 param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
738 if(param==NULL) return ISFS_ENOMEM;
739
740 memcpy(param->fsattr.filepath, filepath, (len+1));
741 param->fsattr.owner_id = ownerID;
742 param->fsattr.group_id = groupID;
743 param->fsattr.ownerperm = ownerperm;
744 param->fsattr.groupperm = groupperm;
745 param->fsattr.otherperm = otherperm;
746 param->fsattr.attributes = attributes;
747
748 ret = IOS_Ioctl(_fs_fd,ISFS_IOCTL_SETATTR,¶m->fsattr,sizeof(param->fsattr),NULL,0);
749
750 if(param!=NULL) iosFree(hId,param);
751 return ret;
752 }
753
ISFS_SetAttrAsync(const char * filepath,u32 ownerID,u16 groupID,u8 attributes,u8 ownerperm,u8 groupperm,u8 otherperm,isfscallback cb,void * usrdata)754 s32 ISFS_SetAttrAsync(const char *filepath,u32 ownerID,u16 groupID,u8 attributes,u8 ownerperm,u8 groupperm,u8 otherperm,isfscallback cb,void *usrdata)
755 {
756 s32 len;
757 struct isfs_cb *param;
758
759 if(_fs_fd<0 || filepath==NULL) return ISFS_EINVAL;
760
761 len = strnlen(filepath, ISFS_MAXPATH);
762 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
763
764 param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
765 if(param==NULL) return ISFS_ENOMEM;
766
767 param->cb = cb;
768 param->usrdata = usrdata;
769 param->functype = ISFS_FUNCNULL;
770 memcpy(param->fsattr.filepath, filepath, (len+1));
771 param->fsattr.owner_id = ownerID;
772 param->fsattr.group_id = groupID;
773 param->fsattr.ownerperm = ownerperm;
774 param->fsattr.groupperm = groupperm;
775 param->fsattr.otherperm = otherperm;
776 param->fsattr.attributes = attributes;
777 return IOS_IoctlAsync(_fs_fd,ISFS_IOCTL_SETATTR,¶m->fsattr,sizeof(param->fsattr),NULL,0,__isfsFunctionCB,param);
778 }
779
ISFS_GetUsage(const char * filepath,u32 * usage1,u32 * usage2)780 s32 ISFS_GetUsage(const char* filepath, u32* usage1, u32* usage2)
781 {
782 s32 ret,len;
783 struct isfs_cb *param;
784
785 if(_fs_fd<0 || filepath==NULL || usage1==NULL || usage2 == NULL)
786 return ISFS_EINVAL;
787
788 len = strnlen(filepath, ISFS_MAXPATH);
789 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
790
791 param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
792 if(param==NULL) return ISFS_ENOMEM;
793
794 memcpy(param->filepath,filepath,(len+1));
795
796 param->fsusage.vector[0].data = param->filepath;
797 param->fsusage.vector[0].len = ISFS_MAXPATH;
798 param->fsusage.vector[1].data = ¶m->fsusage.usage1;
799 param->fsusage.vector[1].len = sizeof(u32);
800 param->fsusage.vector[2].data = ¶m->fsusage.usage2;
801 param->fsusage.vector[2].len = sizeof(u32);
802 ret = IOS_Ioctlv(_fs_fd,ISFS_IOCTL_GETUSAGE,1,2,param->fsusage.vector);
803 if(ret==IPC_OK) {
804 *usage1 = param->fsusage.usage1;
805 *usage2 = param->fsusage.usage2;
806 }
807
808 if(param!=NULL) iosFree(hId, param);
809 return ret;
810 }
811
ISFS_GetUsageAsync(const char * filepath,u32 * usage1,u32 * usage2,isfscallback cb,void * usrdata)812 s32 ISFS_GetUsageAsync(const char* filepath, u32* usage1, u32* usage2,isfscallback cb,void *usrdata)
813 {
814 s32 len;
815 struct isfs_cb *param;
816
817 if(_fs_fd<0 || filepath==NULL || usage1==NULL || usage2 == NULL)
818 return ISFS_EINVAL;
819
820 len = strnlen(filepath, ISFS_MAXPATH);
821 if(len>=ISFS_MAXPATH) return ISFS_EINVAL;
822
823 param = (struct isfs_cb*)iosAlloc(hId, ISFS_STRUCTSIZE);
824 if(param==NULL) return ISFS_ENOMEM;
825
826 param->cb = cb;
827 param->usrdata = usrdata;
828 param->functype = ISFS_FUNCGETUSAGE;
829 param->funcargv[0] = usage1;
830 param->funcargv[1] = usage2;
831 memcpy(param->filepath,filepath,(len+1));
832
833 param->fsusage.vector[0].data = param->filepath;
834 param->fsusage.vector[0].len = ISFS_MAXPATH;
835 param->fsusage.vector[1].data = ¶m->fsusage.usage1;
836 param->fsusage.vector[1].len = sizeof(u32);
837 param->fsusage.vector[2].data = ¶m->fsusage.usage2;
838 param->fsusage.vector[2].len = sizeof(u32);
839 return IOS_IoctlvAsync(_fs_fd,ISFS_IOCTL_GETUSAGE,1,2,param->fsusage.vector,__isfsFunctionCB,param);
840 }
841
842 #endif /* defined(HW_RVL) */
843