/*
* Class: net_decasdev_dokan_Dokan
* Method: mount
* Signature: (Lnet/decasdev/dokan/DokanOptions;Lnet/decasdev/dokan/DokanOperations;)I
*/
JNIEXPORT jint JNICALL Java_net_decasdev_dokan_Dokan_mount
( JNIEnv* env, jclass, jobject joptions, jobject joperations ) {
try {
//if (jvm != NULL)
// throw "You cannot mount twice at this version of Dokan";
env->GetJavaVM( &jvm );
gOperations = env->NewGlobalRef( joperations );
InitMethodIDs( env );
DOKAN_OPTIONS options;
ZeroMemory( &options, sizeof( DOKAN_OPTIONS ) );
options.Version = 600;
/* mountPoint */
jstring mountPoint = ( jstring ) env->GetObjectField( joptions, mountPointID );
int len = env->GetStringLength( mountPoint );
const jchar* chars = env->GetStringChars( mountPoint, NULL );
wchar_t* wsz = new wchar_t[len+1];
memcpy( wsz, chars, len*2 );
wsz[len] = 0;
options.MountPoint = wsz;
env->ReleaseStringChars( mountPoint, chars );
/* end MountPoint */
options.ThreadCount = env->GetIntField( joptions, threadCountID );
options.Options = env->GetLongField( joptions, optionsModeID );
DOKAN_OPERATIONS operations;
ZeroMemory( &operations, sizeof( DOKAN_OPERATIONS ) );
operations.CreateFile = OnCreateFile;
operations.OpenDirectory = OnOpenDirectory;
operations.CreateDirectoryW = OnCreateDirectory;
operations.Cleanup = OnCleanup;
operations.CloseFile = OnCloseFile;
operations.ReadFile = OnReadFile;
operations.WriteFile = OnWriteFile;
operations.FlushFileBuffers = OnFlushFileBuffers;
operations.GetFileInformation = OnGetFileInformation;
operations.FindFiles = OnFindFiles;
//operations.FindFilesWithPattern = OnFindFilesWithPattern;
operations.SetFileAttributesW = OnSetFileAttributes;
operations.SetFileTime = OnSetFileTime;
operations.DeleteFileW = OnDeleteFile;
operations.DeleteDirectory = OnDeleteDirectory;
operations.MoveFileW = OnMoveFile;
operations.SetEndOfFile = OnSetEndOfFile;
operations.LockFile = OnLockFile;
operations.UnlockFile = OnUnlockFile;
operations.GetDiskFreeSpace = OnGetDiskFreeSpace;
operations.GetVolumeInformation = OnGetVolumeInformation;
operations.Unmount = OnUnmount;
//operations.GetFileSecurity = OnGetFileSecurity;
//operations.SetFileSecurity = OnSetFileSecurity;
return DokanMain( &options, &operations );
} catch ( const char* msg ) {
env->ThrowNew( env->FindClass( "java/lang/NoSuchFieldError" ), msg );
return FALSE;
}
}
DWORD WINAPI th_dokan_mainloop(LPVOID lp)
{
int res;
win32_callback_barrier_init();
res = DokanMain(&dokan.opts, &dokan.ops);
if (res != DOKAN_SUCCESS) {
dokan_clean();
return INT2NUM(res);
}
return ERROR_SUCCESS;
}
int main(int argc, char **argv)
{
if (argc < 2)
{
printf("Usage: %s <drive letter>\n", argv[0]);
return 0;
}
DOKAN_OPTIONS options;
DOKAN_OPERATIONS operations;
ZeroMemory(&options, sizeof(DOKAN_OPTIONS));
options.Version = DOKAN_VERSION;
options.ThreadCount = 0; // use default
std::wstring mountPoint = utf8ToWide(argv[1]);
options.MountPoint = mountPoint.c_str();
options.Options = DOKAN_OPTION_DEBUG | DOKAN_OPTION_STDERR | DOKAN_OPTION_KEEP_ALIVE;
ZeroMemory(&operations, sizeof(DOKAN_OPERATIONS));
operations.CreateFile = WendyCreateFile;
operations.OpenDirectory = WendyOpenDirectory;
operations.CreateDirectory = WendyCreateDirectory;
operations.Cleanup = WendyCleanup;
operations.CloseFile = WendyCloseFile;
operations.ReadFile = WendyReadFile;
operations.WriteFile = WendyWriteFile;
operations.GetFileInformation = WendyGetFileInformation;
operations.FindFiles = WendyFindFiles;
operations.DeleteFile = WendyDeleteFile;
operations.DeleteDirectory = WendyDeleteDirectory;
operations.GetDiskFreeSpace = WendyGetDiskFreeSpace;
operations.GetVolumeInformation = WendyGetVolumeInformation;
fs = new FileSystem;
InitializeCriticalSection(&wendyMutex);
int result = DokanMain(&options, &operations);
DeleteCriticalSection(&wendyMutex);
delete fs;
return result;
}
int __cdecl
wmain(ULONG argc, PWCHAR argv[])
{
int status;
ULONG command;
PDOKAN_OPERATIONS dokanOperations =
(PDOKAN_OPERATIONS)malloc(sizeof(DOKAN_OPERATIONS));
if (dokanOperations == NULL) {
return -1;
}
PDOKAN_OPTIONS dokanOptions =
(PDOKAN_OPTIONS)malloc(sizeof(DOKAN_OPTIONS));
if (dokanOptions == NULL) {
free(dokanOperations);
return -1;
}
if (argc < 5) {
fprintf(stderr, "mirror.exe\n"
" /r RootDirectory (ex. /r c:\\test)\n"
" /l DriveLetter (ex. /l m)\n"
" /t ThreadCount (ex. /t 5)\n"
" /d (enable debug output)\n"
" /s (use stderr for output)\n"
" /n (use network drive)\n"
" /m (use removable drive)\n"
" /i (Timeout in Milliseconds ex. /i 30000)\n");
return -1;
}
g_DebugMode = FALSE;
g_UseStdErr = FALSE;
ZeroMemory(dokanOptions, sizeof(DOKAN_OPTIONS));
dokanOptions->Version = DOKAN_VERSION;
dokanOptions->ThreadCount = 0; // use default
for (command = 1; command < argc; command++) {
switch (towlower(argv[command][1])) {
case L'r':
command++;
wcscpy_s(RootDirectory, sizeof(RootDirectory)/sizeof(WCHAR), argv[command]);
DbgPrint(L"RootDirectory: %ls\n", RootDirectory);
break;
case L'l':
command++;
wcscpy_s(MountPoint, sizeof(MountPoint)/sizeof(WCHAR), argv[command]);
dokanOptions->MountPoint = MountPoint;
break;
case L't':
command++;
dokanOptions->ThreadCount = (USHORT)_wtoi(argv[command]);
break;
case L'd':
g_DebugMode = TRUE;
break;
case L's':
g_UseStdErr = TRUE;
break;
case L'n':
dokanOptions->Options |= DOKAN_OPTION_NETWORK;
break;
case L'm':
dokanOptions->Options |= DOKAN_OPTION_REMOVABLE;
break;
case L'i':
command++;
dokanOptions->Timeout = (ULONG)_wtol(argv[command]);
break;
default:
fwprintf(stderr, L"unknown command: %s\n", argv[command]);
return -1;
}
}
if (g_DebugMode) {
dokanOptions->Options |= DOKAN_OPTION_DEBUG;
}
if (g_UseStdErr) {
dokanOptions->Options |= DOKAN_OPTION_STDERR;
}
dokanOptions->Options |= DOKAN_OPTION_KEEP_ALIVE;
dokanOptions->Options |= DOKAN_OPTION_ALT_STREAM;
ZeroMemory(dokanOperations, sizeof(DOKAN_OPERATIONS));
dokanOperations->CreateFile = MirrorCreateFile;
dokanOperations->OpenDirectory = MirrorOpenDirectory;
dokanOperations->CreateDirectory = MirrorCreateDirectory;
dokanOperations->Cleanup = MirrorCleanup;
dokanOperations->CloseFile = MirrorCloseFile;
dokanOperations->ReadFile = MirrorReadFile;
dokanOperations->WriteFile = MirrorWriteFile;
dokanOperations->FlushFileBuffers = MirrorFlushFileBuffers;
dokanOperations->GetFileInformation = MirrorGetFileInformation;
dokanOperations->FindFiles = MirrorFindFiles;
dokanOperations->FindFilesWithPattern = NULL;
dokanOperations->SetFileAttributes = MirrorSetFileAttributes;
dokanOperations->SetFileTime = MirrorSetFileTime;
dokanOperations->DeleteFile = MirrorDeleteFile;
dokanOperations->DeleteDirectory = MirrorDeleteDirectory;
dokanOperations->MoveFile = MirrorMoveFile;
dokanOperations->SetEndOfFile = MirrorSetEndOfFile;
dokanOperations->SetAllocationSize = MirrorSetAllocationSize;
dokanOperations->LockFile = MirrorLockFile;
dokanOperations->UnlockFile = MirrorUnlockFile;
dokanOperations->GetFileSecurity = MirrorGetFileSecurity;
dokanOperations->SetFileSecurity = MirrorSetFileSecurity;
dokanOperations->GetDiskFreeSpace = NULL;
dokanOperations->GetVolumeInformation = MirrorGetVolumeInformation;
dokanOperations->Unmount = MirrorUnmount;
dokanOperations->EnumerateNamedStreams = MirrorEnumerateNamedStreams;
status = DokanMain(dokanOptions, dokanOperations);
switch (status) {
case DOKAN_SUCCESS:
fprintf(stderr, "Success\n");
break;
case DOKAN_ERROR:
fprintf(stderr, "Error\n");
break;
case DOKAN_DRIVE_LETTER_ERROR:
fprintf(stderr, "Bad Drive letter\n");
break;
case DOKAN_DRIVER_INSTALL_ERROR:
fprintf(stderr, "Can't install driver\n");
break;
case DOKAN_START_ERROR:
fprintf(stderr, "Driver something wrong\n");
break;
case DOKAN_MOUNT_ERROR:
fprintf(stderr, "Can't assign a drive letter\n");
break;
case DOKAN_MOUNT_POINT_ERROR:
fprintf(stderr, "Mount point error\n");
break;
default:
fprintf(stderr, "Unknown error: %d\n", status);
break;
}
free(dokanOptions);
free(dokanOperations);
return 0;
}
int main( int argc, char * const argv[] )
#endif
{
libregf_error_t *error = NULL;
system_character_t *mount_point = NULL;
system_character_t *option_codepage = NULL;
system_character_t *option_extended_options = NULL;
system_character_t *source = NULL;
char *program = "regfmount";
system_integer_t option = 0;
int result = 0;
int verbose = 0;
#if defined( HAVE_LIBFUSE ) || defined( HAVE_LIBOSXFUSE )
struct fuse_operations regfmount_fuse_operations;
struct fuse_args regfmount_fuse_arguments = FUSE_ARGS_INIT(0, NULL);
struct fuse_chan *regfmount_fuse_channel = NULL;
struct fuse *regfmount_fuse_handle = NULL;
#elif defined( HAVE_LIBDOKAN )
DOKAN_OPERATIONS regfmount_dokan_operations;
DOKAN_OPTIONS regfmount_dokan_options;
#endif
libcnotify_stream_set(
stderr,
NULL );
libcnotify_verbose_set(
1 );
if( libclocale_initialize(
"regftools",
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize locale values.\n" );
goto on_error;
}
if( regftools_output_initialize(
_IONBF,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize output settings.\n" );
goto on_error;
}
regftools_output_version_fprint(
stdout,
program );
while( ( option = regftools_getopt(
argc,
argv,
_SYSTEM_STRING( "c:hvVX:" ) ) ) != (system_integer_t) -1 )
{
switch( option )
{
case (system_integer_t) '?':
default:
fprintf(
stderr,
"Invalid argument: %" PRIs_SYSTEM "\n",
argv[ optind - 1 ] );
usage_fprint(
stdout );
return( EXIT_FAILURE );
case (system_integer_t) 'c':
option_codepage = optarg;
break;
case (system_integer_t) 'h':
usage_fprint(
stdout );
return( EXIT_SUCCESS );
case (system_integer_t) 'v':
verbose = 1;
break;
case (system_integer_t) 'V':
regftools_output_copyright_fprint(
stdout );
return( EXIT_SUCCESS );
case (system_integer_t) 'X':
option_extended_options = optarg;
break;
}
}
if( optind == argc )
{
fprintf(
stderr,
"Missing source file.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
source = argv[ optind++ ];
if( optind == argc )
{
fprintf(
stderr,
"Missing mount point.\n" );
usage_fprint(
stdout );
return( EXIT_FAILURE );
}
mount_point = argv[ optind ];
libcnotify_verbose_set(
verbose );
libregf_notify_set_stream(
stderr,
NULL );
libregf_notify_set_verbose(
verbose );
if( mount_handle_initialize(
®fmount_mount_handle,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to initialize mount handle.\n" );
goto on_error;
}
if( option_codepage != NULL )
{
result = mount_handle_set_ascii_codepage(
regfmount_mount_handle,
option_codepage,
&error );
if( result == -1 )
{
fprintf(
stderr,
"Unable to set ASCII codepage in mount handle.\n" );
goto on_error;
}
else if( result == 0 )
{
fprintf(
stderr,
"Unsupported ASCII codepage defaulting to: windows-1252.\n" );
}
}
if( mount_handle_open(
regfmount_mount_handle,
source,
&error ) != 1 )
{
fprintf(
stderr,
"Unable to open source file\n" );
goto on_error;
}
#if defined( HAVE_LIBFUSE ) || defined( HAVE_LIBOSXFUSE )
if( option_extended_options != NULL )
{
/* This argument is required but ignored
*/
if( fuse_opt_add_arg(
®fmount_fuse_arguments,
"" ) != 0 )
{
fprintf(
stderr,
"Unable add fuse arguments.\n" );
goto on_error;
}
if( fuse_opt_add_arg(
®fmount_fuse_arguments,
"-o" ) != 0 )
{
fprintf(
stderr,
"Unable add fuse arguments.\n" );
goto on_error;
}
if( fuse_opt_add_arg(
®fmount_fuse_arguments,
option_extended_options ) != 0 )
{
fprintf(
stderr,
"Unable add fuse arguments.\n" );
goto on_error;
}
}
if( memory_set(
®fmount_fuse_operations,
0,
sizeof( struct fuse_operations ) ) == NULL )
{
fprintf(
stderr,
"Unable to clear fuse operations.\n" );
goto on_error;
}
regfmount_fuse_operations.open = &mount_fuse_open;
regfmount_fuse_operations.read = &mount_fuse_read;
regfmount_fuse_operations.release = &mount_fuse_release;
regfmount_fuse_operations.opendir = &mount_fuse_opendir;
regfmount_fuse_operations.readdir = &mount_fuse_readdir;
regfmount_fuse_operations.releasedir = &mount_fuse_releasedir;
regfmount_fuse_operations.getattr = &mount_fuse_getattr;
regfmount_fuse_operations.destroy = &mount_fuse_destroy;
regfmount_fuse_channel = fuse_mount(
mount_point,
®fmount_fuse_arguments );
if( regfmount_fuse_channel == NULL )
{
fprintf(
stderr,
"Unable to create fuse channel.\n" );
goto on_error;
}
regfmount_fuse_handle = fuse_new(
regfmount_fuse_channel,
®fmount_fuse_arguments,
®fmount_fuse_operations,
sizeof( struct fuse_operations ),
regfmount_mount_handle );
if( regfmount_fuse_handle == NULL )
{
fprintf(
stderr,
"Unable to create fuse handle.\n" );
goto on_error;
}
if( verbose == 0 )
{
if( fuse_daemonize(
0 ) != 0 )
{
fprintf(
stderr,
"Unable to daemonize fuse.\n" );
goto on_error;
}
}
result = fuse_loop(
regfmount_fuse_handle );
if( result != 0 )
{
fprintf(
stderr,
"Unable to run fuse loop.\n" );
goto on_error;
}
fuse_destroy(
regfmount_fuse_handle );
fuse_opt_free_args(
®fmount_fuse_arguments );
return( EXIT_SUCCESS );
#elif defined( HAVE_LIBDOKAN )
if( memory_set(
®fmount_dokan_operations,
0,
sizeof( DOKAN_OPERATIONS ) ) == NULL )
{
fprintf(
stderr,
"Unable to clear dokan operations.\n" );
goto on_error;
}
if( memory_set(
®fmount_dokan_options,
0,
sizeof( DOKAN_OPTIONS ) ) == NULL )
{
fprintf(
stderr,
"Unable to clear dokan options.\n" );
goto on_error;
}
regfmount_dokan_options.Version = DOKAN_VERSION;
regfmount_dokan_options.ThreadCount = 0;
regfmount_dokan_options.MountPoint = mount_point;
if( verbose != 0 )
{
regfmount_dokan_options.Options |= DOKAN_OPTION_STDERR;
#if defined( HAVE_DEBUG_OUTPUT )
regfmount_dokan_options.Options |= DOKAN_OPTION_DEBUG;
#endif
}
/* This will only affect the drive properties
regfmount_dokan_options.Options |= DOKAN_OPTION_REMOVABLE;
*/
#if ( DOKAN_VERSION >= 600 ) && ( DOKAN_VERSION < 800 )
regfmount_dokan_options.Options |= DOKAN_OPTION_KEEP_ALIVE;
regfmount_dokan_operations.CreateFile = &mount_dokan_CreateFile;
regfmount_dokan_operations.OpenDirectory = &mount_dokan_OpenDirectory;
regfmount_dokan_operations.CreateDirectory = NULL;
regfmount_dokan_operations.Cleanup = NULL;
regfmount_dokan_operations.CloseFile = &mount_dokan_CloseFile;
regfmount_dokan_operations.ReadFile = &mount_dokan_ReadFile;
regfmount_dokan_operations.WriteFile = NULL;
regfmount_dokan_operations.FlushFileBuffers = NULL;
regfmount_dokan_operations.GetFileInformation = &mount_dokan_GetFileInformation;
regfmount_dokan_operations.FindFiles = &mount_dokan_FindFiles;
regfmount_dokan_operations.FindFilesWithPattern = NULL;
regfmount_dokan_operations.SetFileAttributes = NULL;
regfmount_dokan_operations.SetFileTime = NULL;
regfmount_dokan_operations.DeleteFile = NULL;
regfmount_dokan_operations.DeleteDirectory = NULL;
regfmount_dokan_operations.MoveFile = NULL;
regfmount_dokan_operations.SetEndOfFile = NULL;
regfmount_dokan_operations.SetAllocationSize = NULL;
regfmount_dokan_operations.LockFile = NULL;
regfmount_dokan_operations.UnlockFile = NULL;
regfmount_dokan_operations.GetFileSecurity = NULL;
regfmount_dokan_operations.SetFileSecurity = NULL;
regfmount_dokan_operations.GetDiskFreeSpace = NULL;
regfmount_dokan_operations.GetVolumeInformation = &mount_dokan_GetVolumeInformation;
regfmount_dokan_operations.Unmount = &mount_dokan_Unmount;
#else
regfmount_dokan_operations.ZwCreateFile = &mount_dokan_ZwCreateFile;
regfmount_dokan_operations.Cleanup = NULL;
regfmount_dokan_operations.CloseFile = &mount_dokan_CloseFile;
regfmount_dokan_operations.ReadFile = &mount_dokan_ReadFile;
regfmount_dokan_operations.WriteFile = NULL;
regfmount_dokan_operations.FlushFileBuffers = NULL;
regfmount_dokan_operations.GetFileInformation = &mount_dokan_GetFileInformation;
regfmount_dokan_operations.FindFiles = &mount_dokan_FindFiles;
regfmount_dokan_operations.FindFilesWithPattern = NULL;
regfmount_dokan_operations.SetFileAttributes = NULL;
regfmount_dokan_operations.SetFileTime = NULL;
regfmount_dokan_operations.DeleteFile = NULL;
regfmount_dokan_operations.DeleteDirectory = NULL;
regfmount_dokan_operations.MoveFile = NULL;
regfmount_dokan_operations.SetEndOfFile = NULL;
regfmount_dokan_operations.SetAllocationSize = NULL;
regfmount_dokan_operations.LockFile = NULL;
regfmount_dokan_operations.UnlockFile = NULL;
regfmount_dokan_operations.GetFileSecurity = NULL;
regfmount_dokan_operations.SetFileSecurity = NULL;
regfmount_dokan_operations.GetDiskFreeSpace = NULL;
regfmount_dokan_operations.GetVolumeInformation = &mount_dokan_GetVolumeInformation;
regfmount_dokan_operations.Unmounted = NULL;
regfmount_dokan_operations.FindStreams = NULL;
regfmount_dokan_operations.Mounted = NULL;
#endif /* ( DOKAN_VERSION >= 600 ) && ( DOKAN_VERSION < 800 ) */
result = DokanMain(
®fmount_dokan_options,
®fmount_dokan_operations );
switch( result )
{
case DOKAN_SUCCESS:
break;
case DOKAN_ERROR:
fprintf(
stderr,
"Unable to run dokan main: generic error\n" );
break;
case DOKAN_DRIVE_LETTER_ERROR:
fprintf(
stderr,
"Unable to run dokan main: bad drive letter\n" );
break;
case DOKAN_DRIVER_INSTALL_ERROR:
fprintf(
stderr,
"Unable to run dokan main: unable to load driver\n" );
break;
case DOKAN_START_ERROR:
fprintf(
stderr,
"Unable to run dokan main: driver error\n" );
break;
case DOKAN_MOUNT_ERROR:
fprintf(
stderr,
"Unable to run dokan main: unable to assign drive letter\n" );
break;
case DOKAN_MOUNT_POINT_ERROR:
fprintf(
stderr,
"Unable to run dokan main: mount point error\n" );
break;
default:
fprintf(
stderr,
"Unable to run dokan main: unknown error: %d\n",
result );
break;
}
return( EXIT_SUCCESS );
#else
fprintf(
stderr,
"No sub system to mount REGF format.\n" );
return( EXIT_FAILURE );
#endif
on_error:
if( error != NULL )
{
libcnotify_print_error_backtrace(
error );
libcerror_error_free(
&error );
}
#if defined( HAVE_LIBFUSE ) || defined( HAVE_LIBOSXFUSE )
if( regfmount_fuse_handle != NULL )
{
fuse_destroy(
regfmount_fuse_handle );
}
fuse_opt_free_args(
®fmount_fuse_arguments );
#endif
if( regfmount_mount_handle != NULL )
{
mount_handle_free(
®fmount_mount_handle,
NULL );
}
return( EXIT_FAILURE );
}
int __cdecl wmain(ULONG argc, PWCHAR argv[]) {
int status;
ULONG command;
PDOKAN_OPERATIONS dokanOperations =
(PDOKAN_OPERATIONS)malloc(sizeof(DOKAN_OPERATIONS));
if (dokanOperations == NULL) {
return EXIT_FAILURE;
}
PDOKAN_OPTIONS dokanOptions = (PDOKAN_OPTIONS)malloc(sizeof(DOKAN_OPTIONS));
if (dokanOptions == NULL) {
free(dokanOperations);
return EXIT_FAILURE;
}
if (argc < 3) {
fprintf(stderr, "mirror.exe\n"
" /r RootDirectory (ex. /r c:\\test)\n"
" /l DriveLetter (ex. /l m)\n"
" /t ThreadCount (ex. /t 5)\n"
" /d (enable debug output)\n"
" /s (use stderr for output)\n"
" /n (use network drive)\n"
" /m (use removable drive)\n"
" /w (write-protect drive)\n"
" /o (use mount manager)\n"
" /c (mount for current session only)\n"
" /u UNC provider name"
" /i (Timeout in Milliseconds ex. /i 30000)\n");
free(dokanOperations);
free(dokanOptions);
return EXIT_FAILURE;
}
g_DebugMode = FALSE;
g_UseStdErr = FALSE;
ZeroMemory(dokanOptions, sizeof(DOKAN_OPTIONS));
dokanOptions->Version = DOKAN_VERSION;
dokanOptions->ThreadCount = 0; // use default
for (command = 1; command < argc; command++) {
switch (towlower(argv[command][1])) {
case L'r':
command++;
wcscpy_s(RootDirectory, sizeof(RootDirectory) / sizeof(WCHAR),
argv[command]);
DbgPrint(L"RootDirectory: %ls\n", RootDirectory);
break;
case L'l':
command++;
wcscpy_s(MountPoint, sizeof(MountPoint) / sizeof(WCHAR), argv[command]);
dokanOptions->MountPoint = MountPoint;
break;
case L't':
command++;
dokanOptions->ThreadCount = (USHORT)_wtoi(argv[command]);
break;
case L'd':
g_DebugMode = TRUE;
break;
case L's':
g_UseStdErr = TRUE;
break;
case L'n':
dokanOptions->Options |= DOKAN_OPTION_NETWORK;
break;
case L'm':
dokanOptions->Options |= DOKAN_OPTION_REMOVABLE;
break;
case L'w':
dokanOptions->Options |= DOKAN_OPTION_WRITE_PROTECT;
break;
case L'o':
dokanOptions->Options |= DOKAN_OPTION_MOUNT_MANAGER;
break;
case L'c':
dokanOptions->Options |= DOKAN_OPTION_CURRENT_SESSION;
break;
case L'u':
command++;
wcscpy_s(UNCName, sizeof(UNCName) / sizeof(WCHAR), argv[command]);
dokanOptions->UNCName = UNCName;
DbgPrint(L"UNC Name: %ls\n", UNCName);
break;
case L'i':
command++;
dokanOptions->Timeout = (ULONG)_wtol(argv[command]);
break;
default:
fwprintf(stderr, L"unknown command: %s\n", argv[command]);
free(dokanOperations);
free(dokanOptions);
return EXIT_FAILURE;
}
}
if (wcscmp(UNCName, L"") != 0 &&
!(dokanOptions->Options & DOKAN_OPTION_NETWORK)) {
fwprintf(
stderr,
L" Warning: UNC provider name should be set on network drive only.\n");
}
if (dokanOptions->Options & DOKAN_OPTION_NETWORK &&
dokanOptions->Options & DOKAN_OPTION_MOUNT_MANAGER) {
fwprintf(stderr, L"Mount manager cannot be used on network drive.\n");
free(dokanOperations);
free(dokanOptions);
return -1;
}
if (!(dokanOptions->Options & DOKAN_OPTION_MOUNT_MANAGER) &&
wcscmp(MountPoint, L"") == 0) {
fwprintf(stderr, L"Mount Point required.\n");
free(dokanOperations);
free(dokanOptions);
return -1;
}
if ((dokanOptions->Options & DOKAN_OPTION_MOUNT_MANAGER) &&
(dokanOptions->Options & DOKAN_OPTION_CURRENT_SESSION)) {
fwprintf(stderr,
L"Mount Manager always mount the drive for all user sessions.\n");
free(dokanOperations);
free(dokanOptions);
return -1;
}
// Add security name privilege. Required here to handle GetFileSecurity
// properly.
if (!AddSeSecurityNamePrivilege()) {
fwprintf(stderr, L" Failed to add security privilege to process\n");
fwprintf(stderr,
L" => GetFileSecurity/SetFileSecurity may not work properly\n");
fwprintf(stderr, L" => Please restart mirror sample with administrator "
L"rights to fix it\n");
}
if (g_DebugMode) {
dokanOptions->Options |= DOKAN_OPTION_DEBUG;
}
if (g_UseStdErr) {
dokanOptions->Options |= DOKAN_OPTION_STDERR;
}
dokanOptions->Options |= DOKAN_OPTION_ALT_STREAM;
ZeroMemory(dokanOperations, sizeof(DOKAN_OPERATIONS));
dokanOperations->ZwCreateFile = MirrorCreateFile;
dokanOperations->Cleanup = MirrorCleanup;
dokanOperations->CloseFile = MirrorCloseFile;
dokanOperations->ReadFile = MirrorReadFile;
dokanOperations->WriteFile = MirrorWriteFile;
dokanOperations->FlushFileBuffers = MirrorFlushFileBuffers;
dokanOperations->GetFileInformation = MirrorGetFileInformation;
dokanOperations->FindFiles = MirrorFindFiles;
dokanOperations->FindFilesWithPattern = NULL;
dokanOperations->SetFileAttributes = MirrorSetFileAttributes;
dokanOperations->SetFileTime = MirrorSetFileTime;
dokanOperations->DeleteFile = MirrorDeleteFile;
dokanOperations->DeleteDirectory = MirrorDeleteDirectory;
dokanOperations->MoveFile = MirrorMoveFile;
dokanOperations->SetEndOfFile = MirrorSetEndOfFile;
dokanOperations->SetAllocationSize = MirrorSetAllocationSize;
dokanOperations->LockFile = MirrorLockFile;
dokanOperations->UnlockFile = MirrorUnlockFile;
dokanOperations->GetFileSecurity = MirrorGetFileSecurity;
dokanOperations->SetFileSecurity = MirrorSetFileSecurity;
dokanOperations->GetDiskFreeSpace = NULL;
dokanOperations->GetVolumeInformation = MirrorGetVolumeInformation;
dokanOperations->Unmounted = MirrorUnmounted;
dokanOperations->FindStreams = MirrorFindStreams;
dokanOperations->Mounted = MirrorMounted;
status = DokanMain(dokanOptions, dokanOperations);
switch (status) {
case DOKAN_SUCCESS:
fprintf(stderr, "Success\n");
break;
case DOKAN_ERROR:
fprintf(stderr, "Error\n");
break;
case DOKAN_DRIVE_LETTER_ERROR:
fprintf(stderr, "Bad Drive letter\n");
break;
case DOKAN_DRIVER_INSTALL_ERROR:
fprintf(stderr, "Can't install driver\n");
break;
case DOKAN_START_ERROR:
fprintf(stderr, "Driver something wrong\n");
break;
case DOKAN_MOUNT_ERROR:
fprintf(stderr, "Can't assign a drive letter\n");
break;
case DOKAN_MOUNT_POINT_ERROR:
fprintf(stderr, "Mount point error\n");
break;
case DOKAN_VERSION_ERROR:
fprintf(stderr, "Version error\n");
break;
default:
fprintf(stderr, "Unknown error: %d\n", status);
break;
}
free(dokanOptions);
free(dokanOperations);
return EXIT_SUCCESS;
}
int __cdecl
main(ULONG argc, PCHAR argv[])
{
ULONG argNo = 0;
int status;
ULONG command;
PDOKAN_OPERATIONS dokanOperations =
(PDOKAN_OPERATIONS)malloc(sizeof(DOKAN_OPERATIONS));
PDOKAN_OPTIONS dokanOptions =
(PDOKAN_OPTIONS)malloc(sizeof(DOKAN_OPTIONS));
if (argc < 5) {
fprintf(stderr, "mirror.exe\n"
" /r RootDirectory (ex. /r c:\\test)\n"
" /l DriveLetter (ex. /l m)\n"
" /t ThreadCount (ex. /t 5)\n"
" /d (enable debug output)\n"
" /s (use stderr for output)\n"
" /n (use network drive)\n"
" /m (use removable drive)\n");
return -1;
}
g_DebugMode = FALSE;
g_UseStdErr = FALSE;
ZeroMemory(dokanOptions, sizeof(DOKAN_OPTIONS));
dokanOptions->ThreadCount = 0; // use default
for (command = 1; command < argc; command++) {
switch (tolower(argv[command][1])) {
case 'r':
command++;
mbstowcs(RootDirectory, argv[command], strlen(argv[command]));
DbgPrint(L"RootDirectory: %ls\n", RootDirectory);
break;
case 'l':
command++;
dokanOptions->DriveLetter = argv[command][0];
break;
case 't':
command++;
dokanOptions->ThreadCount = (USHORT)atoi(argv[command]);
break;
case 'd':
g_DebugMode = TRUE;
break;
case 's':
g_UseStdErr = TRUE;
break;
case 'n':
dokanOptions->Options |= DOKAN_OPTION_NETWORK;
break;
case 'm':
dokanOptions->Options |= DOKAN_OPTION_REMOVABLE;
break;
default:
fprintf(stderr, "unknown command: %s\n", argv[command]);
return -1;
}
}
if (g_DebugMode)
dokanOptions->Options |= DOKAN_OPTION_DEBUG;
if (g_UseStdErr)
dokanOptions->Options |= DOKAN_OPTION_STDERR;
dokanOptions->Options |= DOKAN_OPTION_KEEP_ALIVE;
ZeroMemory(dokanOperations, sizeof(DOKAN_OPERATIONS));
dokanOperations->CreateFile = MirrorCreateFile;
dokanOperations->OpenDirectory = MirrorOpenDirectory;
dokanOperations->CreateDirectory = MirrorCreateDirectory;
dokanOperations->Cleanup = MirrorCleanup;
dokanOperations->CloseFile = MirrorCloseFile;
dokanOperations->ReadFile = MirrorReadFile;
dokanOperations->WriteFile = MirrorWriteFile;
dokanOperations->FlushFileBuffers = MirrorFlushFileBuffers;
dokanOperations->GetFileInformation = MirrorGetFileInformation;
dokanOperations->FindFiles = MirrorFindFiles;
dokanOperations->FindFilesWithPattern = NULL;
dokanOperations->SetFileAttributes = MirrorSetFileAttributes;
dokanOperations->SetFileTime = MirrorSetFileTime;
dokanOperations->DeleteFile = MirrorDeleteFile;
dokanOperations->DeleteDirectory = MirrorDeleteDirectory;
dokanOperations->MoveFile = MirrorMoveFile;
dokanOperations->SetEndOfFile = MirrorSetEndOfFile;
dokanOperations->SetAllocationSize = MirrorSetAllocationSize;
dokanOperations->LockFile = MirrorLockFile;
dokanOperations->UnlockFile = MirrorUnlockFile;
dokanOperations->GetDiskFreeSpace = NULL;
dokanOperations->GetVolumeInformation = NULL;
dokanOperations->Unmount = MirrorUnmount;
status = DokanMain(dokanOptions, dokanOperations);
switch (status) {
case DOKAN_SUCCESS:
fprintf(stderr, "Success\n");
break;
case DOKAN_ERROR:
fprintf(stderr, "Error\n");
break;
case DOKAN_DRIVE_LETTER_ERROR:
fprintf(stderr, "Bad Drive letter\n");
break;
case DOKAN_DRIVER_INSTALL_ERROR:
fprintf(stderr, "Can't install driver\n");
break;
case DOKAN_START_ERROR:
fprintf(stderr, "Driver something wrong\n");
break;
case DOKAN_MOUNT_ERROR:
fprintf(stderr, "Can't assign a drive letter\n");
break;
default:
fprintf(stderr, "Unknown error: %d\n", status);
break;
}
free(dokanOptions);
free(dokanOperations);
return 0;
}
