メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

dkcGenericFileSystem.c

説明を見る。
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         /*if(wm && rm){
00088             data->CreationDisposition |= OPEN_EXISTING;
00089         }else if(wm){
00090             data->CreationDisposition |= OPEN_EXISTING;
00091         }else if(rm){
00092             data->CreationDisposition |= OPEN_EXISTING;
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, // access (read-write) mode
00151                 Arg.ShareMode, // share mode
00152                 Arg.lpSecurityAttributes,// pointer to security attributes
00153                 Arg.CreationDisposition, // how to create
00154                 Arg.FlagsAndAttributes,// file attributes
00155                 Arg.TemplateFile // handle to file with 
00156             //GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL
00157         );
00158     }else{
00159         fp = wf(
00160                 filename,
00161                 Arg.DesiredAccess, // access (read-write) mode
00162                 Arg.ShareMode, // share mode
00163                 Arg.lpSecurityAttributes,// pointer to security attributes
00164                 Arg.CreationDisposition, // how to create
00165                 Arg.FlagsAndAttributes,// file attributes
00166                 Arg.TemplateFile // handle to file with 
00167             //GENERIC_WRITE, 0, 0, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL
00168         );
00169 
00170     }
00171 
00172     if(fp==INVALID_HANDLE_VALUE){
00173         //visual_lasterror();
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     //thread lock
00187     BOOL r = ReadFile(
00188             h, // handle of file to read
00189             pb, // pointer to buffer that receives data
00190             size, // number of bytes to read
00191             (LPDWORD)&readsize, // pointer to number of bytes read
00192             NULL//&mOL // pointer to structure for data
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         //mIsEOF = true;
00204     }
00205     r = edk_SUCCEEDED;
00206 End:
00207     //thread unlock
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     //thread lock
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     //thread unlock
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     //hFile ハンドルが FILE_FLAG_NO_BUFFERING を持つ場合は、
00264     //セクタサイズの整数倍の位置にしかファイルポインタを移動できません。
00265     // 事例 2 : lpDistanceToMoveHigh != NULL の場合
00266     dw = SetFilePointer(pfs->mHandle,
00267                             parg->Point.u.LowPart,
00268                             (PLONG)&(parg->Point.u.HighPart),
00269                             origin//FILE_BEGIN
00270         );
00271 
00272     //multithread lock
00273     //これではダメ
00274     //if (dw == 0xFFFFFFFF && error())
00275     
00276     LastError = GetLastError();
00277     pfs->mLastError = LastError;
00278     if(LastError != NOERROR)
00279     {
00280         //visual_lasterror();
00281         //< エラー処理 >
00282         //return false;
00283 
00284         r = edk_FAILED;
00285         goto End;
00286     }
00287     //シーク成功したらとりあえずEOF解除・・・ ヽ(`Д´)ノウワァン
00288     //mIsEOF = false;
00289     r = edk_SUCCEEDED;
00290 End:
00291     //thread unlock
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     //multithread lock
00309     
00310     //lowと high を一緒にゲットしているので・・・ これは間違い
00311     //if (low == 0xFFFFFFFF && error())
00312 
00313     LastError = GetLastError();
00314     pfs->mLastError = LastError;
00315     if(LastError != NOERROR)
00316     {
00317         //visual_lasterror();
00318         //< エラー処理 >
00319         //return false;
00320 
00321         r = edk_FAILED;
00322         goto End;
00323     }
00324     //シーク成功したらとりあえずEOF解除・・・ ヽ(`Д´)ノウワァン
00325     //mIsEOF = false;
00326     r = edk_SUCCEEDED;
00327     ull.u.LowPart = low;
00328     ull.u.HighPart = high;
00329     memcpy(dest,&ull,sizeof(*dest));
00330 End:
00331     //thread unlock
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     //void *tp;
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     tp = dkcGetProcAddress(dllp,"CreateFileA");
00400     if(NULL==tp){
00401         goto Error;
00402     }
00403     p->CreateFile = (CreateFileA_FT)tp;
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         //p->mHandle = NULL;
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     //free_sjis
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

dkutil_cに対してTue Feb 22 02:01:47 2005に生成されました。 doxygen 1.3.6