// see Win32 API GetDiskFreeSpaceEx int DOKAN_CALLBACK OnGetDiskFreeSpace( PULONGLONG FreeBytesAvailable, PULONGLONG TotalNumberOfBytes, PULONGLONG TotalNumberOfFreeBytes, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnGetDiskFreeSpace]\n" ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); NewDokanDiskFreeSpace( env ); jobject jdiskFreeSpace = env->CallObjectMethod( gOperations, onGetDiskFreeSpaceID, jdokanFileInfo ); result = GetOperationResult( env ); if ( FreeBytesAvailable ) *FreeBytesAvailable = env->GetLongField( jdiskFreeSpace, freeBytesAvailableID ); if ( TotalNumberOfBytes ) *TotalNumberOfBytes = env->GetLongField( jdiskFreeSpace, totalNumberOfBytesID ); if ( TotalNumberOfFreeBytes ) *TotalNumberOfFreeBytes = env->GetLongField( jdiskFreeSpace, totalNumberOfFreeBytesID ); } catch ( const char* msg ) { LOG( L"[OnGetDiskFreeSpace] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnGetFileSecurity( LPCWSTR FileName, PSECURITY_INFORMATION RequestedSecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptorBuffer, ULONG BufferLength, PULONG BufferLengthNeeded, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[GetFileSecurity]\n" ); JNIEnv* env = get_env(); int result = -ERROR_GEN_FAILURE; try { //jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); LOG( L"GetFileSecurity FileName: %s \n", FileName ); LOG( L"GetFileSecurity RequestedSecurityInformation: %d\n", RequestedSecurityInformation ); LOG( L"GetFileSecurity SecurityDescriptorBuffer: %d\n", SecurityDescriptorBuffer ); LOG( L"GetFileSecurity BufferLength: %d\n", BufferLength ); LOG( L"GetFileSecurity BufferLengthNeeded: %d\n", BufferLengthNeeded ); } catch ( const char* msg ) { LOGA( "[GetFileSecurity] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnReadFile( LPCWSTR FileName, LPVOID Buffer, DWORD NumberOfBytesToRead, LPDWORD NumberOfBytesRead, LONGLONG Offset, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnReadFile] FileName = %s, Offset = %lld, NumberOfBytesToRead = %d\n", FileName, Offset, NumberOfBytesToRead ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); DWORD readed = env->CallIntMethod( gOperations, onReadFileID, jfileName, env->NewDirectByteBuffer( Buffer, NumberOfBytesToRead ), Offset, jdokanFileInfo ); if ( NumberOfBytesRead ) *NumberOfBytesRead = readed; result = GetOperationResult( env ); if ( result != 0 ) { LOGA( "[OnReadFile] result = %d\n", result ); } } catch ( const char* msg ) { LOGA( "[OnReadFile] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnMoveFile( LPCWSTR ExistingFileName, LPCWSTR NewFileName, BOOL ReplaceExisiting, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnMoveFile] ExistingFileName = %s\n", ExistingFileName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jExistingFileName = ToJavaString( env, ExistingFileName ); jstring jNewFileName = ToJavaString( env, NewFileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); env->CallVoidMethod( gOperations, onMoveFileID, jExistingFileName, jNewFileName, ReplaceExisiting, jdokanFileInfo ); result = GetOperationResult( env ); } catch ( const char* msg ) { LOGA( "[OnMoveFile] %s\n", msg ); } release_env( env ); return result; }
//You should implement either FindFires or FindFilesWithPattern int DOKAN_CALLBACK OnFindFilesWithPattern( LPCWSTR PathName, LPCWSTR SearchPattern, PFillFindData pFillFindData, // call this function with PWIN32_FIND_DATAW PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnFindFilesWithPattern] PathName = %s\n", PathName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jpathName = ToJavaString( env, PathName ); jstring jsearchPattern = ToJavaString( env, SearchPattern ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); jobjectArray ary = ( jobjectArray )env->CallObjectMethod( gOperations, onFindFilesWithPatternID, jpathName, jsearchPattern, jdokanFileInfo ); result = GetOperationResult( env ); if ( result == 0 && ary != NULL && pFillFindData != NULL ) { for ( int i = 0; i < env->GetArrayLength( ary ); i++ ) { WIN32_FIND_DATAW win32FindData; ToWin32FindData( env, env->GetObjectArrayElement( ary, i ), &win32FindData ); pFillFindData( &win32FindData, DokanFileInfo ); } } } catch ( const char* msg ) { LOGA( "[OnFindFilesWithPattern] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnOpenDirectory( LPCWSTR FileName, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnOpenDirectory] FileName = %s\n", FileName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); jlong handle = env->CallLongMethod( gOperations, onOpenDirectoryID, jfileName, jdokanFileInfo ); result = GetOperationResult( env ); if ( result == 0 ) { DokanFileInfo->Context = handle; } } catch ( const char* msg ) { LOGA( "[OnOpenDirectory] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnCreateFile( LPCWSTR FileName, DWORD DesiredAccess, DWORD ShareMode, DWORD CreationDisposition, DWORD FlagsAndAttributes, //HANDLE, // TemplateFile PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnCreateFile] FileName = %s\n", FileName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); jlong handle = env->CallLongMethod( gOperations, onCreateFileID, jfileName, DesiredAccess, ShareMode, CreationDisposition, FlagsAndAttributes, jdokanFileInfo ); result = GetOperationResult( env ); if ( result == 0 ) { DokanFileInfo->Context = handle; } LOG( L"[OnCreateFile] result = %d, handle = %d\n", result, handle ); } catch ( const char* msg ) { LOGA( "[OnCreateFile] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnSetFileTime( LPCWSTR FileName, CONST FILETIME* CreationTime, CONST FILETIME* LastAccessTime, CONST FILETIME* LastWriteTime, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnSetFileTime] FileName = %s\n", FileName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); env->CallVoidMethod( gOperations, onSetFileTimeID, jfileName, FileTime2LongLong( CreationTime ), FileTime2LongLong( LastAccessTime ), FileTime2LongLong( LastWriteTime ), jdokanFileInfo ); result = GetOperationResult( env ); } catch ( const char* msg ) { LOGA( "[OnSetFileTime] %s\n", msg ); } release_env( env ); return result; }
/* * Copy to statvfs struct from statvfs object. */ void copyStatvfsIn(struct statvfs *buf, jobject statvfsObj) { JNIEnv *env = get_env(); buf->f_bsize = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_bsize); buf->f_frsize = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_frsize); buf->f_blocks = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_blocks); buf->f_bfree = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_bfree); buf->f_bavail = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_bavail); buf->f_files = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_files); buf->f_ffree = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_ffree); buf->f_favail = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_favail); buf->f_fsid = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_fsid); buf->f_flag = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_flag); buf->f_namemax = (*env)->GetLongField(env, statvfsObj, fuseSt.statvfsID.f_namemax); release_env(env); }
/* * Copy to statvfs object from statvfs struct. */ void copyStatvfsOut(jobject statvfsObj, struct statvfs *buf) { JNIEnv *env = get_env(); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_bsize, buf->f_bsize); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_frsize, buf->f_frsize); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_blocks, buf->f_blocks); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_bfree, buf->f_bfree); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_bavail, buf->f_bavail); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_files, buf->f_files); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_ffree, buf->f_ffree); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_favail, buf->f_favail); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_fsid, buf->f_fsid); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_flag, buf->f_flag); (*env)->SetLongField(env, statvfsObj, fuseSt.statvfsID.f_namemax, buf->f_namemax); release_env(env); }
int DOKAN_CALLBACK OnWriteFile( LPCWSTR FileName, LPCVOID Buffer, DWORD NumberOfBytesToWrite, LPDWORD NumberOfBytesWritten, LONGLONG Offset, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnWriteFile] FileName = %s, Offset = %lld, NumberOfBytesToWrite = %d\n", FileName, Offset, NumberOfBytesToWrite ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); // Some one please modify here for the faster way !! LPVOID tmpBuffer = malloc( NumberOfBytesToWrite ); if ( tmpBuffer == NULL ) throw "Cannot allocate memory"; CopyMemory( tmpBuffer, Buffer, NumberOfBytesToWrite ); DWORD written = env->CallIntMethod( gOperations, onWriteFileID, jfileName, env->NewDirectByteBuffer( tmpBuffer, NumberOfBytesToWrite ), Offset, jdokanFileInfo ); free( tmpBuffer ); if ( NumberOfBytesWritten ) *NumberOfBytesWritten = written; result = GetOperationResult( env ); if ( result != 0 ) { LOGA( "[OnWriteFile] ERROR result = %d\n", result ); } else { LOGA( "[OnWriteFile] written = %d\n", written ); } } catch ( const char* msg ) { LOGA( "[OnWriteFile] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnUnmount( PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnUnmount]\n" ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); env->CallVoidMethod( gOperations, onUnmountID, jdokanFileInfo ); result = GetOperationResult( env ); } catch ( const char* msg ) { LOGA( "[OnUnmount] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnSetFileSecurity( LPCWSTR FileName, PSECURITY_INFORMATION RequestedSecurityInformation, PSECURITY_DESCRIPTOR SecurityDescriptorBuffer, ULONG BufferLength, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[SetFileSecurity]\n" ); JNIEnv* env = get_env(); int result = -ERROR_GEN_FAILURE; try { jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); LOG( L"SetFileSecurity has ben called!" ); } catch ( const char* msg ) { LOGA( "[SetFileSecurity] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnGetFileInformation( LPCWSTR FileName, LPBY_HANDLE_FILE_INFORMATION ByHandleFileInfo, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnGetFileInformation] FileName = %s\n", FileName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); jobject jobj = env->CallObjectMethod( gOperations, onGetFileInformationID, jfileName, jdokanFileInfo ); result = GetOperationResult( env ); if ( result == 0 ) { ToByHandleFileInfo( env, jobj, ByHandleFileInfo ); LOGA( "[OnGetFileInformation] %d %d %d\n", ByHandleFileInfo->dwFileAttributes, ByHandleFileInfo->nFileSizeHigh, ByHandleFileInfo->nFileSizeLow ); LOGA( "[OnGetFileInformation] CreationTime: %d %d\n", ByHandleFileInfo->ftCreationTime.dwHighDateTime, ByHandleFileInfo->ftCreationTime.dwLowDateTime ); LOGA( "[OnGetFileInformation] LastAccess: %d %d\n", ByHandleFileInfo->ftLastAccessTime.dwHighDateTime, ByHandleFileInfo->ftLastAccessTime.dwLowDateTime ); LOGA( "[OnGetFileInformation] LastWrite: %d %d\n", ByHandleFileInfo->ftLastWriteTime.dwHighDateTime, ByHandleFileInfo->ftLastWriteTime.dwLowDateTime ); } } catch ( const char* msg ) { LOGA( "[OnGetFileInformation] %s\n", msg ); } release_env( env ); return result; }
// see Win32 API GetVolumeInformation int DOKAN_CALLBACK OnGetVolumeInformation( LPWSTR VolumeNameBuffer, DWORD VolumeNameSize, LPDWORD VolumeSerialNumber, LPDWORD MaximumComponentLength, LPDWORD FileSystemFlags, LPWSTR FileSystemNameBuffer, DWORD FileSystemNameSize, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnGetVolumeInformation]\n" ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jvolumeName = ToJavaString( env, L"dokan" ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); jobject jvolumeInfo= env->CallObjectMethod( gOperations, onGetVolumeInformationID, jvolumeName, jdokanFileInfo ); result = GetOperationResult( env ); if ( VolumeSerialNumber ) *VolumeSerialNumber = env->GetIntField( jvolumeInfo, volumeSerialNumberID ); if ( MaximumComponentLength ) *MaximumComponentLength = env->GetIntField( jvolumeInfo, maximumComponentLengthID ); if ( FileSystemFlags ) *FileSystemFlags = env->GetIntField( jvolumeInfo, fileSystemFlagsID ); // VolumeName, FileSystemName CopyStringField( env, jvolumeInfo, volumeNameID, VolumeNameBuffer, VolumeNameSize ); CopyStringField( env, jvolumeInfo, fileSystemNameID, FileSystemNameBuffer, FileSystemNameSize ); } catch ( const char* msg ) { LOGA( "[OnGetVolumeInformation] %s\n", msg ); } release_env( env ); return result; }
int DOKAN_CALLBACK OnFlushFileBuffers( LPCWSTR FileName, PDOKAN_FILE_INFO DokanFileInfo ) { LOG( L"[OnFlushFileBuffers] FileName = %s\n", FileName ); JNIEnv* env = get_env(); //jvm->AttachCurrentThread((void **)&env, NULL); int result = -ERROR_GEN_FAILURE; try { jstring jfileName = ToJavaString( env, FileName ); jobject jdokanFileInfo = ToDokanFileInfoJavaObject( env, DokanFileInfo ); env->CallVoidMethod( gOperations, onFlushFileBuffersID, jfileName, jdokanFileInfo ); result = GetOperationResult( env ); } catch ( const char* msg ) { LOGA( "[OnFlushFileBuffers] %s\n", msg ); } release_env( env ); return result; }
/* * Initilize the statvfs class. */ void init_statvfsClass() { JNIEnv *env = get_env(); jclass _statvfsClass = (*env)->FindClass(env, "javafuse/Statvfs"); fuseSt.statvfsClass = (*env)->NewGlobalRef(env, _statvfsClass); assert(fuseSt.statvfsClass != NULL); fuseSt.statvfsID.Ctor = (*env)->GetMethodID(env, fuseSt.statvfsClass, "<init>", "()V"); assert(fuseSt.statvfsID.Ctor != NULL); fuseSt.statvfsID.finalize = (*env)->GetMethodID(env, fuseSt.statvfsClass, "finalize", "()V"); assert(fuseSt.statvfsID.finalize != NULL); fuseSt.statvfsID.f_bsize = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_bsize", "J"); assert(fuseSt.statvfsID.f_bsize != NULL); fuseSt.statvfsID.f_frsize = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_frsize", "J"); assert(fuseSt.statvfsID.f_frsize != NULL); fuseSt.statvfsID.f_blocks = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_blocks", "J"); assert(fuseSt.statvfsID.f_blocks != NULL); fuseSt.statvfsID.f_bfree = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_bfree", "J"); assert(fuseSt.statvfsID.f_bfree != NULL); fuseSt.statvfsID.f_bavail = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_bavail", "J"); assert(fuseSt.statvfsID.f_bavail != NULL); fuseSt.statvfsID.f_files = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_files", "J"); assert(fuseSt.statvfsID.f_files != NULL); fuseSt.statvfsID.f_ffree = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_ffree", "J"); assert(fuseSt.statvfsID.f_ffree != NULL); fuseSt.statvfsID.f_favail = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_favail", "J"); assert(fuseSt.statvfsID.f_favail != NULL); fuseSt.statvfsID.f_fsid = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_fsid", "J"); assert(fuseSt.statvfsID.f_fsid != NULL); fuseSt.statvfsID.f_flag = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_flag", "J"); assert(fuseSt.statvfsID.f_flag != NULL); fuseSt.statvfsID.f_namemax = (*env)->GetFieldID(env, fuseSt.statvfsClass, "f_namemax", "J"); assert(fuseSt.statvfsID.f_namemax != NULL); release_env(env); }
static lisp_obj *apply(lisp_expr_application *app, lisp_env *env, lisp_err *err) { lisp_obj *callable = FORCE_VALUE(app->proc, env, err); if (! callable){ return NULL; } lisp_obj *res = NIL; /* Internal procedure */ if (callable->type == PROC){ /* Eval args */ lisp_obj **args = calloc(app->nparams, sizeof(lisp_obj*)); for (size_t i=0; i<app->nparams; i++){ lisp_obj *arg = FORCE_VALUE(app->params[i], env, err); if (! arg){ for (size_t j=0; j<i; j++){ release(args[j]); } free(args); return NULL; } args[i] = arg; } /* Eval internal */ res = callable->value.p(app->nparams, args); /* Free args */ for (size_t i=0; i<app->nparams; i++){ release(args[i]); } free(args); } /* Lisp func */ else if (callable->type == LAMBDA){ lisp_lambda *lambda = &(callable->value.l); lisp_expr_lambda *lambda_expr = &(lambda->declaration->value.mklambda); /* Check arity */ if (app->nparams != lambda_expr->nparams){ raise_error(err, WRONG_ARITY, "Arity error ! Expected %d params, got %d", lambda_expr->nparams, app->nparams); return NULL; } /* Extend env */ lisp_env *locals = create_env(lambda->context); for (size_t i=0; i<lambda_expr->nparams; i++){ lisp_obj *param = eval_expression(app->params[i], env, err); if (! param){ release_env(locals); return NULL; } DEBUG("Extend env with %s", lambda_expr->param_names[i]); release(set_env(locals, lambda_expr->param_names[i], param)); } if (enable_debug){ printf("\033[1mCALL\033[0m "); dump_expr(lambda_expr->body); printf(" with env\n"); dump_env(locals); } /* Wrap in thunk for trampoline */ res = make_thunk(lambda_expr->body, locals); release_env(locals); } else { lisp_print(callable); raise_error(err, NOT_CALLABLE, "CANNOT CALL obj %p", callable); return NULL; } release(callable); return res; }