00001
00010 #include "dkcGenericFileSystem.h"
00011
00012 #ifdef WIN32
00013
00014 #ifdef _MSC_VER
00015
00016 # pragma warning(disable:4055 4152)
00017 #endif
00018
00019 enum{
00020 edkcWin32SJIS = 0,
00021 edkcWin32Unicode = 1,
00022 };
00023
00024
00025 typedef HANDLE (WINAPI *CreateFileA_FT)(
00026 LPCSTR lpFileName,
00027 DWORD dwDesiredAccess,
00028 DWORD dwShareMode,
00029 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
00030 DWORD dwCreationDisposition,
00031 DWORD dwFlagsAndAttributes,
00032 HANDLE hTemplateFile
00033 );
00034
00035
00036 typedef HANDLE (WINAPI *CreateFileW_FT)(
00037 LPCWSTR lpFileName,
00038 DWORD dwDesiredAccess,
00039 DWORD dwShareMode,
00040 LPSECURITY_ATTRIBUTES lpSecurityAttributes,
00041 DWORD dwCreationDisposition,
00042 DWORD dwFlagsAndAttributes,
00043 HANDLE hTemplateFile
00044 );
00045
00046
00047 typedef BOOL (WINAPI *SetFileAttributesA_FT)(
00048 LPCSTR lpFileName,
00049 DWORD dwFileAttributes
00050 );
00051
00052
00053 typedef BOOL (WINAPI *SetFileAttributesW_FT)(
00054 LPCWSTR lpFileName,
00055 DWORD dwFileAttributes
00056 );
00057
00058
00059
00060 typedef DWORD (WINAPI *GetFileAttributesA_FT)(
00061 LPCSTR lpFileName
00062 );
00063
00064 typedef DWORD (WINAPI *GetFileAttributesW_FT)(
00065 LPCWSTR lpFileName
00066 );
00067
00068
00069 typedef BOOL (WINAPI *DeleteFileA_FT)(
00070 LPCSTR lpFileName
00071 );
00072
00073 typedef BOOL (WINAPI *DeleteFileW_FT)(
00074 LPCWSTR lpFileName
00075 );
00076
00077
00078
00079
00080 DKC_INLINE void dkc_to_CreateFile_arg_data(DKC_OPEN_ARG_DATA *data,uint32 flag)
00081 {
00082 BOOL wm = (flag & edkcWriteMode) != 0;
00083 BOOL rm = (flag & edkcReadMode) != 0;
00084 BOOL pm = (flag & edkcPostScriptMode) != 0;
00085
00086 if(pm){
00087
00088
00089
00090
00091
00092
00093
00094 data->CreationDisposition |= OPEN_EXISTING;
00095 }else{
00096 if(wm && rm){
00097
00098 data->CreationDisposition |= OPEN_EXISTING;
00099 }else if(wm){
00100
00101 data->CreationDisposition |= CREATE_ALWAYS;
00102 }else if(rm){
00103
00104 data->CreationDisposition |= OPEN_EXISTING;
00105 }
00106
00107 }
00108
00109
00110 if(wm){
00111
00112 data->ShareMode |= FILE_SHARE_READ;
00113
00114 data->DesiredAccess |= GENERIC_WRITE;
00115 }
00116 if(rm){
00117
00118 data->ShareMode |= FILE_SHARE_READ;
00119
00120 data->DesiredAccess |= GENERIC_READ;
00121 }
00122
00123
00124
00125
00126 data->FlagsAndAttributes |= FILE_ATTRIBUTE_NORMAL;
00127
00128
00129 }
00130
00131
00132 #define WIN32_FS_CALL(type,obj,function_address)\
00133 (type)(function_address)
00134
00135
00136 static void *win32_open(void *pobj,uint32 flags,const void *filename){
00137 DKC_WIN32_FS *pfs = pobj;
00138 HANDLE fp;
00139 DKC_OPEN_ARG_DATA Arg;
00140 CreateFileA_FT af = pfs->CreateFile;
00141 CreateFileW_FT wf = pfs->CreateFile;
00142
00143
00144 dkc_to_CreateFile_arg_data(&Arg,flags);
00145
00146
00147 if(edkcWin32SJIS == pfs->mFlag){
00148 fp = af(
00149 filename,
00150 Arg.DesiredAccess,
00151 Arg.ShareMode,
00152 Arg.lpSecurityAttributes,
00153 Arg.CreationDisposition,
00154 Arg.FlagsAndAttributes,
00155 Arg.TemplateFile
00156
00157 );
00158 }else{
00159 fp = wf(
00160 filename,
00161 Arg.DesiredAccess,
00162 Arg.ShareMode,
00163 Arg.lpSecurityAttributes,
00164 Arg.CreationDisposition,
00165 Arg.FlagsAndAttributes,
00166 Arg.TemplateFile
00167
00168 );
00169
00170 }
00171
00172 if(fp==INVALID_HANDLE_VALUE){
00173
00174 return NULL;
00175 }
00176 pfs->mHandle = fp;
00177 memcpy(&(pfs->mArg),&Arg,sizeof(pfs->mArg));
00178
00179 return fp;
00180 }
00181
00182
00183 static int win32_read(void *pobj,void *pb,size_t size,size_t *readsize){
00184 DKC_WIN32_FS *pfs = pobj;
00185 HANDLE h = pfs->mHandle;
00186
00187 BOOL r = ReadFile(
00188 h,
00189 pb,
00190 size,
00191 (LPDWORD)&readsize,
00192 NULL
00193 );
00194
00195 if(0==r){
00196 pfs->mLastError = GetLastError();
00197
00198 r = edk_FAILED;
00199 goto End;
00200 }
00201 if (r && readsize== 0)
00202 {
00203
00204 }
00205 r = edk_SUCCEEDED;
00206 End:
00207
00208 return r;
00209 }
00210
00211 static int win32_write(void *pobj,const void *pb,size_t size,size_t *writesize){
00212 DKC_WIN32_FS *pfs = pobj;
00213
00214
00215
00216 BOOL r = WriteFile(pfs->mHandle, pb, size , (LPDWORD)&writesize, NULL);
00217
00218 if(r==FALSE){
00219
00220 pfs->mLastError = GetLastError();
00221 r = edk_FAILED;
00222 goto End;
00223 }
00224 r = edk_SUCCEEDED;
00225 End:
00226
00227 return r;
00228
00229 }
00230 static int win32_close(void *pobj){
00231 DKC_WIN32_FS *pfs = pobj;
00232 int r;
00233 if(FALSE==CloseHandle(pfs->mHandle)){
00234 r = edk_FAILED;
00235 goto End;
00236 }
00237 pfs->mHandle = INVALID_HANDLE_VALUE;
00238 r = edk_SUCCEEDED;
00239 End:
00240 return r;
00241 }
00242
00243 static int win32_seek(void *pobj,const DKC_GFS_SEEK_ARG *parg){
00244 DKC_WIN32_FS *pfs = pobj;
00245 DWORD origin = 0xFFFFFFFF;
00246 DWORD dw;
00247 DWORD LastError;
00248 int r;
00249
00250 switch(parg->origin){
00251 case edkcSeekSet:
00252 origin = FILE_BEGIN;
00253 break;
00254 case edkcSeekCurrent:
00255 origin = FILE_CURRENT;
00256 break;
00257 case edkcSeekEnd:
00258 origin = FILE_END;
00259 break;
00260 }
00261 dkcmNOT_ASSERT(0xFFFFFFFF==origin);
00262
00263
00264
00265
00266 dw = SetFilePointer(pfs->mHandle,
00267 parg->Point.u.LowPart,
00268 (PLONG)&(parg->Point.u.HighPart),
00269 origin
00270 );
00271
00272
00273
00274
00275
00276 LastError = GetLastError();
00277 pfs->mLastError = LastError;
00278 if(LastError != NOERROR)
00279 {
00280
00281
00282
00283
00284 r = edk_FAILED;
00285 goto End;
00286 }
00287
00288
00289 r = edk_SUCCEEDED;
00290 End:
00291
00292 return r;
00293 }
00294
00295
00296 static int win32_tell(void *pobj,DKC_UINT64_STRUCT *dest){
00297 DKC_WIN32_FS *pfs = pobj;
00298 LONG high = 0, low = 0;
00299 DKC_UINT64_STRUCT ull;
00300 DWORD LastError;
00301 int r;
00302
00303 low = SetFilePointer(pfs->mHandle,
00304 low,
00305 &high, FILE_CURRENT
00306 );
00307
00308
00309
00310
00311
00312
00313 LastError = GetLastError();
00314 pfs->mLastError = LastError;
00315 if(LastError != NOERROR)
00316 {
00317
00318
00319
00320
00321 r = edk_FAILED;
00322 goto End;
00323 }
00324
00325
00326 r = edk_SUCCEEDED;
00327 ull.u.LowPart = low;
00328 ull.u.HighPart = high;
00329 memcpy(dest,&ull,sizeof(*dest));
00330 End:
00331
00332 return r;
00333
00334 }
00335
00336 static int win32_delete_file(void *pobj,const void *filename_){
00337 DKC_WIN32_FS *pfs = pobj;
00338 BOOL r;
00339 DeleteFileA_FT af = pfs->DeleteFile;
00340 DeleteFileW_FT wf = pfs->DeleteFile;
00341 if(edkcWin32SJIS == pfs->mFlag){
00342 r = af(filename_);
00343 }else{
00344 r = wf(filename_);
00345 }
00346 if(FALSE==r){
00347 return edk_FAILED;
00348 }
00349 return edk_SUCCEEDED;
00350 }
00351
00352
00353
00354
00355 #define LoadFunctionGFS(funcname,dest) \
00356 tp = dkcGetProcAddress(dllp,funcname);\
00357 if(NULL==tp){\
00358 return FALSE;\
00359 }\
00360 dest = tp
00361
00362 static BOOL load_function_win32_sjis(DKC_DLL *dllp,DKC_WIN32_FS *p){
00363 void *tp;
00364 LoadFunctionGFS("CreateFileA",p->CreateFile);
00365 LoadFunctionGFS("SetFileAttributesA",p->SetFileAttributes);
00366 LoadFunctionGFS("GetFileAttributesA",p->GetFileAttributes);
00367 LoadFunctionGFS("DeleteFileA",p->DeleteFile);
00368 p->mFlag = edkcWin32SJIS;
00369 return TRUE;
00370 }
00371
00372 static BOOL load_function_win32_unicode(DKC_DLL *dllp,DKC_WIN32_FS *p){
00373 void *tp;
00374 LoadFunctionGFS("CreateFileW",p->CreateFile);
00375 LoadFunctionGFS("SetFileAttributesW",p->SetFileAttributes);
00376 LoadFunctionGFS("GetFileAttributesW",p->GetFileAttributes);
00377 LoadFunctionGFS("DeleteFileW",p->DeleteFile);
00378 p->mFlag = edkcWin32Unicode;
00379 return TRUE;
00380 }
00381 typedef BOOL (*load_fs_func_win32_t)(DKC_DLL *,DKC_WIN32_FS *);
00382
00383 static DKC_WIN32_FS *alloc_win32_fs(load_fs_func_win32_t ploadfunc){
00384
00385 DKC_WIN32_FS *p;
00386 DKC_DLL *dllp;
00387
00388 p = dkcAllocate(sizeof(DKC_WIN32_FS));
00389 if(NULL==p){
00390 return NULL;
00391 }
00392
00393 dllp = dkcLoadLibrary("kernel32.dll");
00394 if(NULL==dllp){
00395 goto Error;
00396 }
00397
00398
00399
00400
00401
00402
00403
00404
00405 if(FALSE==ploadfunc(dllp,p)){
00406 goto Error;
00407 }
00408
00409 p->mdllobj = dllp;
00410 return p;
00411
00412 Error:
00413 dkcFree(&p);
00414 return NULL;
00415 }
00416
00417
00418
00419 static int free_win32_fs(void *pa){
00420 DKC_WIN32_FS *p = pa;
00421 if(p->mHandle){
00422 win32_close(p->mHandle);
00423
00424 }
00425 if(DKUTIL_FAILED(dkcUnloadLibrary(&(p->mdllobj))))
00426 {
00427 return edk_FAILED;
00428 }
00429 memset(p,0,sizeof(*p));
00430 return edk_SUCCEEDED;
00431 }
00432
00433 static DKC_GENERIC_FILESYSTEM *WINAPI dkcAlloc_Win32_FileSystem(BOOL isSJIS){
00434 void *fp;
00435
00436 DKC_GENERIC_FILESYSTEM *pfs = dkcAllocate(sizeof(DKC_GENERIC_FILESYSTEM));
00437 if(NULL==pfs){
00438 return NULL;
00439 }
00440
00441 if(isSJIS){
00442 fp = load_function_win32_sjis;
00443 }else{
00444 fp = load_function_win32_unicode;
00445 }
00446
00447 pfs->mfp = alloc_win32_fs(fp);
00448
00449 if(NULL==pfs->mfp){
00450 goto Error;
00451 }
00452 pfs->mfClose = win32_close;
00453 pfs->mfOpen = win32_open;
00454 pfs->mfRead = win32_read;
00455 pfs->mfSeek = win32_seek;
00456 pfs->mfTell = win32_tell;
00457 pfs->mfWrite = win32_write;
00458 pfs->mfDeleteFile = win32_delete_file;
00459
00460 pfs->mfObjFree = free_win32_fs;
00461 return pfs;
00462
00463 Error:
00464
00465 dkcFree(&pfs);
00466 return NULL;
00467 }
00468
00469
00470 DKC_GENERIC_FILESYSTEM *WINAPI dkcAlloc_SJIS_FileSystem()
00471 {
00472 return dkcAlloc_Win32_FileSystem(TRUE);
00473 }
00474
00475
00476
00477 DKC_GENERIC_FILESYSTEM *WINAPI dkcAlloc_UNICODE_FileSystem()
00478 {
00479 return dkcAlloc_Win32_FileSystem(FALSE);
00480 }
00481
00482
00483 #endif
00484
00485 int WINAPI dkcFreeGenericFileSystem(DKC_GENERIC_FILESYSTEM **pp){
00486 DKC_GENERIC_FILESYSTEM *p = *pp;
00487 DKC_GFS_FREE_F_TYPE fff;
00488 int r;
00489
00490 if(NULL==pp || NULL==p){
00491 return edk_FAILED;
00492 }
00493
00494 fff = p->mfObjFree;
00495 r = fff(p);
00496 if(DKUTIL_FAILED(r)){
00497 return edk_FAILED;
00498 }
00499
00500 return dkcFree(pp);
00501 }
00502
00503 int WINAPI dkcGenericFileSystemOpen(DKC_GENERIC_FILESYSTEM *ptr,uint32 flags,const void *filename){
00504 void *p = ptr->mfOpen(ptr,flags,filename);
00505 if(NULL==p){
00506 return edk_FAILED;
00507 }
00508 return edk_SUCCEEDED;
00509 }
00510
00511 int WINAPI dkcGenericFileSystemClose(DKC_GENERIC_FILESYSTEM *ptr){
00512 return ptr->mfClose(ptr);
00513 }
00514
00515 int WINAPI dkcGenericFileSystemRead(DKC_GENERIC_FILESYSTEM *ptr,void *pbuff,size_t size,size_t *read_size)
00516 {
00517 return ptr->mfRead(ptr,pbuff,size,read_size);
00518 }
00519
00520 int WINAPI dkcGenericFileSystemWrite(DKC_GENERIC_FILESYSTEM *ptr,const void *pbuff,size_t size,size_t *write_size)
00521 {
00522 return ptr->mfWrite(ptr,pbuff,size,write_size);
00523 }
00524
00525 int WINAPI dkcGenericFileSystemSeek(DKC_GENERIC_FILESYSTEM *ptr,const DKC_GFS_SEEK_ARG *parg)
00526 {
00527 return ptr->mfSeek(ptr,parg);
00528 }
00529
00530 int WINAPI dkcGenericFileSystemTell(DKC_GENERIC_FILESYSTEM *ptr,DKC_UINT64_STRUCT *offset)
00531 {
00532 return ptr->mfTell(ptr,offset);
00533 }
00534
00535 #ifdef _MSC_VER
00536 # pragma warning(default:4055 4152)
00537 #endif