public static void Ctor_String_Exception()
{
string message = "That page was missing from the directory.";
var innerException = new Exception("Inner exception");
var exception = new DirectoryNotFoundException(message, innerException);
ExceptionUtility.ValidateExceptionProperties(exception, hResult: HResults.COR_E_DIRECTORYNOTFOUND, innerException: innerException, message: message);
}
/// <summary>
/// Handles any errors that CreateDirectoryEx may encounter
/// </summary>
private static void HandleCreateDirectoryExError(string template, string target, int errorCode)
{
Win32Exception win32Exception = new Win32Exception(errorCode);
Exception error;
switch ((Win32Error)errorCode)
{
case Win32Error.ACCESS_DENIED:
error = new UnauthorizedAccessException(
string.Format("Access was denied to clone '{0}' to '{1}'.", template, target),
win32Exception);
break;
case Win32Error.PATH_NOT_FOUND:
error = new DirectoryNotFoundException(
string.Format("The path '{0}' or '{1}' could not be found.", template, target),
win32Exception);
break;
case Win32Error.SHARING_VIOLATION:
error = new SharingViolationException(
string.Format("The source or destination file was in use when copying '{0}' to '{1}'.", template, target),
win32Exception);
break;
case Win32Error.ALREADY_EXISTS:
//If the directory already exists don't worry about it.
return;
default:
error = win32Exception;
break;
}
throw error;
}
public static void HandleException(Window window, DirectoryNotFoundException ex)
{
try
{
string message = string.Format(Properties.Resources.MessageDirectoryNotFoundException);
TaskDialog dialog = new TaskDialog();
dialog.InstructionText = message;
//dialog.Text
dialog.Icon = TaskDialogStandardIcon.Error;
dialog.StandardButtons = TaskDialogStandardButtons.Ok;
dialog.DetailsExpandedText = ex.Message;
dialog.Caption = App.Current.ApplicationTitle;
if (window != null)
{
dialog.OwnerWindowHandle = new WindowInteropHelper(window).Handle;
}
dialog.Show();
}
catch (PlatformNotSupportedException)
{
MessageBox.Show(ex.Message);
}
}
private bool Validate(string path)
{
if (Directory.Exists(path))
{
return true;
}
else
{
var message = string.Format(Resources.Error_InvalidDirectory, path);
var ex = new DirectoryNotFoundException(message);
var error = new ErrorRecord(ex, AddSourceCommand.ErrorId, ErrorCategory.ResourceUnavailable, path);
base.WriteError(error);
return false;
}
}
public static void Ctor_Empty()
{
var exception = new DirectoryNotFoundException();
ExceptionUtility.ValidateExceptionProperties(exception, hResult: HResults.COR_E_DIRECTORYNOTFOUND, validateMessage: false);
}
public void Start()
{
if (!Directory.Exists(_sourceWatchFolder))
{
var inner = new DirectoryNotFoundException(_sourceWatchFolder);
throw new NancyAutoHostException("You need to provide a valid folder to watch", inner);
}
_watcher = CreateFolderWatcher(_sourceWatchFolder);
_watcher.EnableRaisingEvents = true;
OnChange(null);
}
private unsafe void OpenSqlFileStream
(
string sPath,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
long allocationSize
)
{
//-----------------------------------------------------------------
// precondition validation
// these should be checked by any caller of this method
// ensure we have validated and normalized the path before
Debug.Assert(sPath != null);
Debug.Assert(transactionContext != null);
if (access != System.IO.FileAccess.Read && access != System.IO.FileAccess.Write && access != System.IO.FileAccess.ReadWrite)
{
throw ADP.ArgumentOutOfRange("access");
}
// FileOptions is a set of flags, so AND the given value against the set of values we do not support
if ((options & ~(System.IO.FileOptions.WriteThrough | System.IO.FileOptions.Asynchronous | System.IO.FileOptions.RandomAccess | System.IO.FileOptions.SequentialScan)) != 0)
{
throw ADP.ArgumentOutOfRange("options");
}
//-----------------------------------------------------------------
// normalize the provided path
// * compress path to remove any occurrences of '.' or '..'
// * trim whitespace from the beginning and end of the path
// * ensure that the path starts with '\\'
// * ensure that the path does not start with '\\.\'
sPath = GetFullPathInternal(sPath);
Microsoft.Win32.SafeHandles.SafeFileHandle hFile = null;
Interop.NtDll.DesiredAccess nDesiredAccess = Interop.NtDll.DesiredAccess.FILE_READ_ATTRIBUTES | Interop.NtDll.DesiredAccess.SYNCHRONIZE;
Interop.NtDll.CreateOptions dwCreateOptions = 0;
Interop.NtDll.CreateDisposition dwCreateDisposition = 0;
System.IO.FileShare nShareAccess = System.IO.FileShare.None;
switch (access)
{
case System.IO.FileAccess.Read:
nDesiredAccess |= Interop.NtDll.DesiredAccess.FILE_READ_DATA;
nShareAccess = System.IO.FileShare.Delete | System.IO.FileShare.ReadWrite;
dwCreateDisposition = Interop.NtDll.CreateDisposition.FILE_OPEN;
break;
case System.IO.FileAccess.Write:
nDesiredAccess |= Interop.NtDll.DesiredAccess.FILE_WRITE_DATA;
nShareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = Interop.NtDll.CreateDisposition.FILE_OVERWRITE;
break;
case System.IO.FileAccess.ReadWrite:
default:
// we validate the value of 'access' parameter in the beginning of this method
Debug.Assert(access == System.IO.FileAccess.ReadWrite);
nDesiredAccess |= Interop.NtDll.DesiredAccess.FILE_READ_DATA | Interop.NtDll.DesiredAccess.FILE_WRITE_DATA;
nShareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = Interop.NtDll.CreateDisposition.FILE_OVERWRITE;
break;
}
if ((options & System.IO.FileOptions.WriteThrough) != 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_WRITE_THROUGH;
}
if ((options & System.IO.FileOptions.Asynchronous) == 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_SYNCHRONOUS_IO_NONALERT;
}
if ((options & System.IO.FileOptions.SequentialScan) != 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_SEQUENTIAL_ONLY;
}
if ((options & System.IO.FileOptions.RandomAccess) != 0)
{
dwCreateOptions |= Interop.NtDll.CreateOptions.FILE_RANDOM_ACCESS;
}
try
{
// NOTE: the Name property is intended to reveal the publicly available moniker for the
// FILESTREAM attributed column data. We will not surface the internal processing that
// takes place to create the mappedPath.
string mappedPath = InitializeNtPath(sPath);
int retval = 0;
Interop.Kernel32.SetThreadErrorMode(Interop.Kernel32.SEM_FAILCRITICALERRORS, out uint oldMode);
try
{
if (transactionContext.Length >= ushort.MaxValue)
{
throw ADP.ArgumentOutOfRange("transactionContext");
}
int headerSize = sizeof(Interop.NtDll.FILE_FULL_EA_INFORMATION);
int fullSize = headerSize + transactionContext.Length + s_eaNameString.Length;
byte[] buffer = ArrayPool <byte> .Shared.Rent(fullSize);
fixed(byte *b = buffer)
{
Interop.NtDll.FILE_FULL_EA_INFORMATION *ea = (Interop.NtDll.FILE_FULL_EA_INFORMATION *)b;
ea->NextEntryOffset = 0;
ea->Flags = 0;
ea->EaNameLength = (byte)(s_eaNameString.Length - 1); // Length does not include terminating null character.
ea->EaValueLength = (ushort)transactionContext.Length;
// We could continue to do pointer math here, chose to use Span for convenience to
// make sure we get the other members in the right place.
Span <byte> data = buffer.AsSpan(headerSize);
s_eaNameString.AsSpan().CopyTo(data);
data = data.Slice(s_eaNameString.Length);
transactionContext.AsSpan().CopyTo(data);
(int status, IntPtr handle) = Interop.NtDll.CreateFile(
path: mappedPath.AsSpan(),
rootDirectory: IntPtr.Zero,
createDisposition: dwCreateDisposition,
desiredAccess: nDesiredAccess,
shareAccess: nShareAccess,
fileAttributes: 0,
createOptions: dwCreateOptions,
eaBuffer: b,
eaLength: (uint)fullSize);
retval = status;
hFile = new SafeFileHandle(handle, true);
}
ArrayPool <byte> .Shared.Return(buffer);
}
finally
{
Interop.Kernel32.SetThreadErrorMode(oldMode, out oldMode);
}
switch (retval)
{
case 0:
break;
case Interop.Errors.ERROR_SHARING_VIOLATION:
throw ADP.InvalidOperation(System.SRHelper.GetString(SR.SqlFileStream_FileAlreadyInTransaction));
case Interop.Errors.ERROR_INVALID_PARAMETER:
throw ADP.Argument(System.SRHelper.GetString(SR.SqlFileStream_InvalidParameter));
case Interop.Errors.ERROR_FILE_NOT_FOUND:
{
System.IO.DirectoryNotFoundException e = new System.IO.DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
default:
{
uint error = Interop.NtDll.RtlNtStatusToDosError(retval);
if (error == ERROR_MR_MID_NOT_FOUND)
{
// status code could not be mapped to a Win32 error code
error = (uint)retval;
}
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(unchecked ((int)error));
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
if (hFile.IsInvalid)
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(Interop.Errors.ERROR_INVALID_HANDLE);
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
if (Interop.Kernel32.GetFileType(hFile) != Interop.Kernel32.FileTypes.FILE_TYPE_DISK)
{
hFile.Dispose();
throw ADP.Argument(System.SRHelper.GetString(SR.SqlFileStream_PathNotValidDiskResource));
}
// if the user is opening the SQL FileStream in read/write mode, we assume that they want to scan
// through current data and then append new data to the end, so we need to tell SQL Server to preserve
// the existing file contents.
if (access == System.IO.FileAccess.ReadWrite)
{
uint ioControlCode = Interop.Kernel32.CTL_CODE(FILE_DEVICE_FILE_SYSTEM,
IoControlCodeFunctionCode, (byte)Interop.Kernel32.IoControlTransferType.METHOD_BUFFERED,
(byte)Interop.Kernel32.IoControlCodeAccess.FILE_ANY_ACCESS);
if (!Interop.Kernel32.DeviceIoControl(hFile, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out uint cbBytesReturned, IntPtr.Zero))
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
// now that we've successfully opened a handle on the path and verified that it is a file,
// use the SafeFileHandle to initialize our internal System.IO.FileStream instance
System.Diagnostics.Debug.Assert(_m_fs == null);
_m_fs = new System.IO.FileStream(hFile, access, DefaultBufferSize, ((options & System.IO.FileOptions.Asynchronous) != 0));
}
catch
{
if (hFile != null && !hFile.IsInvalid)
{
hFile.Dispose();
}
throw;
}
}
public void writeToFile(string filepath)
{
try
{
System.IO.File.WriteAllText(filepath, conversation);
setFinalOutput("Your chat has been exported to " + filepath);
}
catch (DirectoryNotFoundException e)
{
e = new DirectoryNotFoundException(e.Message + "\nThe filepath " + filepath + " could not be found.\nPlease ensure that you are not using characters such as '\\' and try again.");
throw e;
}
catch (Exception e)
{
throw e;
}
}
[System.Security.SecurityCritical] // auto-generated
private static Exception _HandleErrorCode(int errorCode, string name, SafeHandle handle, object context)
{
System.Exception exception = null;
switch (errorCode)
{
case Interop.mincore.Errors.ERROR_INVALID_NAME:
exception = new ArgumentException(SR.Argument_InvalidName, nameof(name));
break;
case Interop.mincore.Errors.ERROR_INVALID_HANDLE:
exception = new ArgumentException(SR.AccessControl_InvalidHandle);
break;
case Interop.mincore.Errors.ERROR_FILE_NOT_FOUND:
if ((context != null) && (context is bool) && ((bool)context))
{ // DirectorySecurity
if ((name != null) && (name.Length != 0))
exception = new DirectoryNotFoundException(name);
else
exception = new DirectoryNotFoundException();
}
else
{
if ((name != null) && (name.Length != 0))
exception = new FileNotFoundException(name);
else
exception = new FileNotFoundException();
}
break;
default:
break;
}
return exception;
}
private void OpenSqlFileStream(string path, byte[] transactionContext, FileAccess access, FileOptions options, long allocationSize)
{
if (((access != FileAccess.Read) && (access != FileAccess.Write)) && (access != FileAccess.ReadWrite))
{
throw ADP.ArgumentOutOfRange("access");
}
if ((options & ~(FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.SequentialScan | FileOptions.WriteThrough)) != FileOptions.None)
{
throw ADP.ArgumentOutOfRange("options");
}
path = GetFullPathInternal(path);
DemandAccessPermission(path, access);
FileFullEaInformation eaBuffer = null;
SecurityQualityOfService service = null;
UnicodeString str = null;
SafeFileHandle fileHandle = null;
int num2 = 0x100080;
uint num = 0;
uint num4 = 0;
FileShare none = FileShare.None;
switch (access)
{
case FileAccess.Read:
num2 |= 1;
none = FileShare.Delete | FileShare.ReadWrite;
num4 = 1;
break;
case FileAccess.Write:
num2 |= 2;
none = FileShare.Delete | FileShare.Read;
num4 = 4;
break;
default:
num2 |= 3;
none = FileShare.Delete | FileShare.Read;
num4 = 4;
break;
}
if ((options & (FileOptions.None | FileOptions.WriteThrough)) != FileOptions.None)
{
num |= 2;
}
if ((options & FileOptions.Asynchronous) == FileOptions.None)
{
num |= 0x20;
}
if ((options & FileOptions.SequentialScan) != FileOptions.None)
{
num |= 4;
}
if ((options & FileOptions.RandomAccess) != FileOptions.None)
{
num |= 0x800;
}
try
{
System.Data.SqlTypes.UnsafeNativeMethods.OBJECT_ATTRIBUTES object_attributes;
eaBuffer = new FileFullEaInformation(transactionContext);
service = new SecurityQualityOfService(System.Data.SqlTypes.UnsafeNativeMethods.SecurityImpersonationLevel.SecurityAnonymous, false, false);
str = new UnicodeString(InitializeNtPath(path));
object_attributes.length = Marshal.SizeOf(typeof(System.Data.SqlTypes.UnsafeNativeMethods.OBJECT_ATTRIBUTES));
object_attributes.rootDirectory = IntPtr.Zero;
object_attributes.attributes = 0x40;
object_attributes.securityDescriptor = IntPtr.Zero;
object_attributes.securityQualityOfService = service;
object_attributes.objectName = str;
uint mode = System.Data.SqlTypes.UnsafeNativeMethods.SetErrorMode(1);
uint status = 0;
try
{
System.Data.SqlTypes.UnsafeNativeMethods.IO_STATUS_BLOCK io_status_block;
Bid.Trace("<sc.SqlFileStream.OpenSqlFileStream|ADV> %d#, desiredAccess=0x%08x, allocationSize=%I64d, fileAttributes=0x%08x, shareAccess=0x%08x, dwCreateDisposition=0x%08x, createOptions=0x%08x\n", this.ObjectID, num2, allocationSize, 0, (int) none, num4, num);
status = System.Data.SqlTypes.UnsafeNativeMethods.NtCreateFile(out fileHandle, num2, ref object_attributes, out io_status_block, ref allocationSize, 0, none, num4, num, eaBuffer, (uint) eaBuffer.Length);
}
finally
{
System.Data.SqlTypes.UnsafeNativeMethods.SetErrorMode(mode);
}
switch (status)
{
case 0:
break;
case 0xc000000d:
throw ADP.Argument(Res.GetString("SqlFileStream_InvalidParameter"));
case 0xc0000034:
{
DirectoryNotFoundException e = new DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
case 0xc0000043:
throw ADP.InvalidOperation(Res.GetString("SqlFileStream_FileAlreadyInTransaction"));
default:
{
uint num6 = System.Data.SqlTypes.UnsafeNativeMethods.RtlNtStatusToDosError(status);
if (num6 == 0x13d)
{
num6 = status;
}
Win32Exception exception3 = new Win32Exception((int) num6);
ADP.TraceExceptionAsReturnValue(exception3);
throw exception3;
}
}
if (fileHandle.IsInvalid)
{
Win32Exception exception2 = new Win32Exception(6);
ADP.TraceExceptionAsReturnValue(exception2);
throw exception2;
}
if (System.Data.SqlTypes.UnsafeNativeMethods.GetFileType(fileHandle) != System.Data.SqlTypes.UnsafeNativeMethods.FileType.Disk)
{
fileHandle.Dispose();
throw ADP.Argument(Res.GetString("SqlFileStream_PathNotValidDiskResource"));
}
if (access == FileAccess.ReadWrite)
{
uint ioControlCode = System.Data.SqlTypes.UnsafeNativeMethods.CTL_CODE(9, 0x958, 0, 0);
uint cbBytesReturned = 0;
if (!System.Data.SqlTypes.UnsafeNativeMethods.DeviceIoControl(fileHandle, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out cbBytesReturned, IntPtr.Zero))
{
Win32Exception exception = new Win32Exception(Marshal.GetLastWin32Error());
ADP.TraceExceptionAsReturnValue(exception);
throw exception;
}
}
bool flag = false;
try
{
new SecurityPermission(SecurityPermissionFlag.UnmanagedCode).Assert();
flag = true;
this.m_fs = new FileStream(fileHandle, access, 1, (options & FileOptions.Asynchronous) != FileOptions.None);
}
finally
{
if (flag)
{
CodeAccessPermission.RevertAssert();
}
}
}
catch
{
if ((fileHandle != null) && !fileHandle.IsInvalid)
{
fileHandle.Dispose();
}
throw;
}
finally
{
if (eaBuffer != null)
{
eaBuffer.Dispose();
eaBuffer = null;
}
if (service != null)
{
service.Dispose();
service = null;
}
if (str != null)
{
str.Dispose();
str = null;
}
}
}
private void OpenSqlFileStream
(
string path,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
Int64 allocationSize
)
{
//-----------------------------------------------------------------
// precondition validation
// these should be checked by any caller of this method
// ensure we have validated and normalized the path before
Debug.Assert ( path != null );
Debug.Assert (transactionContext != null);
if (access != FileAccess.Read && access != FileAccess.Write && access != FileAccess.ReadWrite)
throw ADP.ArgumentOutOfRange ("access");
// FileOptions is a set of flags, so AND the given value against the set of values we do not support
if ( ( options & ~( FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.SequentialScan ) ) != 0 )
throw ADP.ArgumentOutOfRange ( "options" );
//-----------------------------------------------------------------
// normalize the provided path
// * compress path to remove any occurences of '.' or '..'
// * trim whitespace from the beginning and end of the path
// * ensure that the path starts with '\\'
// * ensure that the path does not start with '\\.\'
// * ensure that the path is not longer than Int16.MaxValue
path = GetFullPathInternal ( path );
// ensure the running code has permission to read/write the file
DemandAccessPermission(path, access);
FileFullEaInformation eaBuffer = null;
SecurityQualityOfService qos = null;
UnicodeString objectName = null;
Microsoft.Win32.SafeHandles.SafeFileHandle hFile = null;
int nDesiredAccess = UnsafeNativeMethods.FILE_READ_ATTRIBUTES | UnsafeNativeMethods.SYNCHRONIZE;
UInt32 dwCreateOptions = 0;
UInt32 dwCreateDisposition = 0;
System.IO.FileShare shareAccess = System.IO.FileShare.None;
switch (access)
{
case System.IO.FileAccess.Read:
nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.ReadWrite;
dwCreateDisposition = (uint) UnsafeNativeMethods.CreationDisposition.FILE_OPEN;
break;
case System.IO.FileAccess.Write:
nDesiredAccess |= UnsafeNativeMethods.FILE_WRITE_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = (uint) UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE;
break;
case System.IO.FileAccess.ReadWrite:
default:
// we validate the value of 'access' parameter in the beginning of this method
Debug.Assert(access == System.IO.FileAccess.ReadWrite);
nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA | UnsafeNativeMethods.FILE_WRITE_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = (uint) UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE;
break;
}
if ((options & System.IO.FileOptions.WriteThrough) != 0)
{
dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_WRITE_THROUGH;
}
if ((options & System.IO.FileOptions.Asynchronous) == 0)
{
dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_SYNCHRONOUS_IO_NONALERT;
}
if ((options & System.IO.FileOptions.SequentialScan) != 0)
{
dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_SEQUENTIAL_ONLY;
}
if ( (options & System.IO.FileOptions.RandomAccess) != 0)
{
dwCreateOptions |= (uint) UnsafeNativeMethods.CreateOption.FILE_RANDOM_ACCESS;
}
try
{
eaBuffer = new FileFullEaInformation(transactionContext);
qos = new SecurityQualityOfService(UnsafeNativeMethods.SecurityImpersonationLevel.SecurityAnonymous,
false, false);
// NOTE: the Name property is intended to reveal the publicly available moniker for the
// FILESTREAM attributed column data. We will not surface the internal processing that
// takes place to create the mappedPath.
string mappedPath = InitializeNtPath(path);
objectName = new UnicodeString(mappedPath);
UnsafeNativeMethods.OBJECT_ATTRIBUTES oa;
oa.length = Marshal.SizeOf(typeof(UnsafeNativeMethods.OBJECT_ATTRIBUTES));
oa.rootDirectory = IntPtr.Zero;
oa.attributes = (int)UnsafeNativeMethods.Attributes.CaseInsensitive;
oa.securityDescriptor = IntPtr.Zero;
oa.securityQualityOfService = qos;
oa.objectName = objectName;
UnsafeNativeMethods.IO_STATUS_BLOCK ioStatusBlock;
uint oldMode;
uint retval = 0;
UnsafeNativeMethods.SetErrorModeWrapper ( UnsafeNativeMethods.SEM_FAILCRITICALERRORS, out oldMode );
try
{
Bid.Trace("<sc.SqlFileStream.OpenSqlFileStream|ADV> %d#, desiredAccess=0x%08x, allocationSize=%I64d, fileAttributes=0x%08x, shareAccess=0x%08x, dwCreateDisposition=0x%08x, createOptions=0x%08x\n",
ObjectID, (int) nDesiredAccess, allocationSize, 0, (int) shareAccess, dwCreateDisposition, dwCreateOptions );
retval = UnsafeNativeMethods.NtCreateFile(out hFile, nDesiredAccess,
ref oa, out ioStatusBlock, ref allocationSize,
0, shareAccess, dwCreateDisposition, dwCreateOptions,
eaBuffer, (uint) eaBuffer.Length);
}
finally
{
UnsafeNativeMethods.SetErrorModeWrapper( oldMode, out oldMode );
}
switch ( retval )
{
case 0:
break;
case UnsafeNativeMethods.STATUS_SHARING_VIOLATION:
throw ADP.InvalidOperation ( Res.GetString ( Res.SqlFileStream_FileAlreadyInTransaction ) );
case UnsafeNativeMethods.STATUS_INVALID_PARAMETER:
throw ADP.Argument ( Res.GetString ( Res.SqlFileStream_InvalidParameter ) );
case UnsafeNativeMethods.STATUS_OBJECT_NAME_NOT_FOUND:
{
System.IO.DirectoryNotFoundException e = new System.IO.DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue ( e );
throw e;
}
default:
{
uint error = UnsafeNativeMethods.RtlNtStatusToDosError ( retval );
if ( error == UnsafeNativeMethods.ERROR_MR_MID_NOT_FOUND )
{
// status code could not be mapped to a Win32 error code
error = retval;
}
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception ( unchecked ( (int) error ) );
ADP.TraceExceptionAsReturnValue ( e );
throw e;
}
}
if ( hFile.IsInvalid )
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception ( UnsafeNativeMethods.ERROR_INVALID_HANDLE );
ADP.TraceExceptionAsReturnValue ( e );
throw e;
}
UnsafeNativeMethods.FileType fileType = UnsafeNativeMethods.GetFileType(hFile);
if (fileType != UnsafeNativeMethods.FileType.Disk)
{
hFile.Dispose();
throw ADP.Argument ( Res.GetString ( Res.SqlFileStream_PathNotValidDiskResource ) );
}
// if the user is opening the SQL FileStream in read/write mode, we assume that they want to scan
// through current data and then append new data to the end, so we need to tell SQL Server to preserve
// the existing file contents.
if ( access == System.IO.FileAccess.ReadWrite )
{
uint ioControlCode = UnsafeNativeMethods.CTL_CODE ( UnsafeNativeMethods.FILE_DEVICE_FILE_SYSTEM,
IoControlCodeFunctionCode, (byte) UnsafeNativeMethods.Method.METHOD_BUFFERED,
(byte) UnsafeNativeMethods.Access.FILE_ANY_ACCESS);
uint cbBytesReturned = 0;
if ( !UnsafeNativeMethods.DeviceIoControl ( hFile, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out cbBytesReturned, IntPtr.Zero ) )
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception ( Marshal.GetLastWin32Error() );
ADP.TraceExceptionAsReturnValue ( e );
throw e;
}
}
// now that we've successfully opened a handle on the path and verified that it is a file,
// use the SafeFileHandle to initialize our internal System.IO.FileStream instance
// NOTE: need to assert UnmanagedCode permissions for this constructor. This is relatively benign
// in that we've done much the same validation as in the FileStream(string path, ...) ctor case
// most notably, validating that the handle type corresponds to an on-disk file.
bool bRevertAssert = false;
try
{
SecurityPermission sp = new SecurityPermission ( SecurityPermissionFlag.UnmanagedCode );
sp.Assert();
bRevertAssert = true;
System.Diagnostics.Debug.Assert ( m_fs == null );
#if MOBILE
m_fs = new System.IO.FileStream ( hFile.DangerousGetHandle (), access, ( ( options & System.IO.FileOptions.Asynchronous ) != 0 ), DefaultBufferSize );
#else
m_fs = new System.IO.FileStream ( hFile, access, DefaultBufferSize, ( ( options & System.IO.FileOptions.Asynchronous ) != 0 ) );
#endif
}
finally
{
if ( bRevertAssert )
SecurityPermission.RevertAssert();
}
}
catch
{
if ( hFile != null && !hFile.IsInvalid )
hFile.Dispose();
throw;
}
finally
{
if (eaBuffer != null)
{
eaBuffer.Dispose();
eaBuffer = null;
}
if (qos != null)
{
qos.Dispose();
qos = null;
}
if (objectName != null)
{
objectName.Dispose();
objectName = null;
}
}
}
void IPscxErrorHandler.WriteDirectoryNotFoundError(string path)
{
string msg = string.Format(Resources.Errors.DirectoryNotFound, path);
Exception ex = new DirectoryNotFoundException(msg);
ErrorHandler.WriteFileError(path, ex);
}
public static void Handle(DirectoryNotFoundException exception)
{
ConsoleLogExceptionMessage(exception);
}
public ProjectExceptions(string errorText, DirectoryNotFoundException innerException)
: base(errorText, innerException)
{
}
/// <summary>
/// WriteXML
/// </summary>
/// <param name="xmlDoc"></param>
/// <param name="fileName"></param>
/// <param name="keyPathFile"></param>
/// <param name="hasAppendCouter"></param>
/// <returns></returns>
private static FileInfo WriteXML(XmlDocument xmlDoc, string fileName, string pathFile, string appendTime, bool hasAppendCouter)
{
//var path = GetPathByKey(keyPathFile);
//input is XML XmlReader
string tmpFilePath = string.Empty;
//Check path is valid
if (objRegexPattern.IsMatch(pathFile) == true)
{
//Path not exist
if (Directory.Exists(pathFile) == false)
{
//Create new path
Directory.CreateDirectory(pathFile);
}
tmpFilePath = GetPath(pathFile);
}
//else path is not valid
else
{
DirectoryNotFoundException ex = new DirectoryNotFoundException(string.Format("{0} Directory is not valid", pathFile));
//////Throw exception
throw ex;
}
//Save
var savedPath = Path.Combine(tmpFilePath, FormatFileName(fileName, tmpFilePath, appendTime, hasAppendCouter));
xmlDoc.Save(savedPath);
return new FileInfo(savedPath);
}
/// <summary>
/// Deletes shapefile and associated files (.shx, .dbf, .prj).
/// </summary>
/// <param name="ShapefilePath">Full path to shapefile, including .shp extension</param>
public static void Delete(string ShapefilePath)
{
List<string> ParamList = new List<string>();
ParamList.Add("ShapefilePath: " + ShapefilePath);
LogManager.DefaultLogManager.PublicMethodEntered("MapWindow.Analysis.DataManagement.Shapefile.Delete", ParamList);
string Filename, Directory;
if (ShapefilePath == null)
{
ArgumentNullException ex = new ArgumentNullException("ShapefilePath cannot be null.");
LogManager.DefaultLogManager.Exception(ex);
throw ex;
}
Directory = System.IO.Path.GetDirectoryName(ShapefilePath);
if (System.IO.Directory.Exists(Directory) == false)
{
System.IO.DirectoryNotFoundException ex = new System.IO.DirectoryNotFoundException("The specified directory: " + Directory + " does not exist.");
LogManager.DefaultLogManager.Exception(ex);
throw ex;
}
Filename = ShapefilePath;
try
{
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".shx");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".dbf");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".prj");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".spx");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".sbn");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".xml");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
Filename = System.IO.Path.ChangeExtension(Filename, ".shp.xml");
if (System.IO.File.Exists(Filename)) System.IO.File.Delete(Filename);
}
catch (Exception Ex)
{
LogManager.DefaultLogManager.Exception(Ex);
throw Ex;
}
LogManager.DefaultLogManager.PublicMethodLeft("MapWindow.Analysis.DataManagement.Shapefile.Delete");
return;
}
/// <summary>
/// Displays an error message when DirectoryNotFoundException is thrown.
/// </summary>
/// <param name="ex">The exception</param>
private static void ShowException(DirectoryNotFoundException ex)
{
PrepareToShow();
string errorMessage = Util.CombineMessageParts(SharedStrings.DIRECTORY_NOT_FOUND, ex.Message);
ShowError(errorMessage, false);
}
DirectoryNotFoundException DirectoryNotFoundExceptionWithSourceFilename(IFile file, DirectoryNotFoundException ex)
{
return new DirectoryNotFoundException(
string.Format(
"{0}{1}Referenced by an @import in '{2}'.",
ex.Message,
Environment.NewLine,
file.FullPath
),
ex
);
}
/// <summary>
/// Compiles a mod from its source folder.
/// </summary>
/// <param name="folder">The mod's folder. Either an absolute path,
/// relative to the working directory or the name of a folder in the Mods\Sources folder</param>
/// <returns>The output of the compiler.</returns>
public CompilerOutput CompileFromSource (string folder)
{
for (int i = 0; i < Loggers.Count; i++)
Loggers[i].compiler_wr = new WeakReference<ModCompiler>(this);
folder = Environment.ExpandEnvironmentVariables(folder);
if (folder.EndsWith("\\"))
folder = folder.Remove(folder.Length - 1);
if (folder[1] != ':' && !folder.StartsWith("\\")) // <drive>:\path or \\ServerName\path
// if the folder doesn't exist, it's maybe a folder in the Mods\Sources directory?
if (!Directory.Exists(folder))
folder = Mods.pathSources + "\\" + folder;
else
folder = Path.GetFullPath(folder);
Log("Compiling source " + folder, MessageImportance.Normal);
building = new ModData(this);
try
{
building.OriginPath = folder;
building.OriginName = Path.GetFileName(folder);
if (!BeginCompile(folder))
{
Exception cause;
LogError(cause = new CompilerException("Mod already building!"));
CompilerOutput o;
LogResult(o = CreateOutput(new List<CompilerError>()
{
new CompilerError(building)
{
Cause = cause,
FilePath = folder,
IsWarning = true,
Message = "The mod is already being built."
}
}));
return o;
}
#region check if folder exists
if (!Directory.Exists(folder))
{
EndCompile(folder);
Exception cause;
LogError(cause = new DirectoryNotFoundException("Directory '" + folder + "' not found."));
CompilerOutput o;
LogResult(o = new CompilerOutput()
{
Succeeded = false,
errors = new List<CompilerError>()
{
new CompilerError(building)
{
Cause = cause,
Message = "The mod directory (" + folder + ") was not found",
IsWarning = false,
FilePath = folder
}
}
});
return o;
}
#endregion
CompilerOutput outp;
Log("Loading files.", MessageImportance.High);
var readFiles = new FileLoader(this).LoadFiles(folder);
outp = CreateOutput(readFiles.Item3);
if (!outp.Succeeded)
{
LogResult (outp );
EndCompile(folder);
return outp;
}
Log("Validating JSONs.", MessageImportance.High);
outp = Validate(readFiles.Item1, readFiles.Item2, true);
if (!outp.Succeeded)
{
LogResult (outp );
EndCompile(folder);
return outp;
}
Log("Building sources.", MessageImportance.High);
var compiled = new Builder(this).Build();
outp = CreateOutput(compiled.Item3);
outp.Succeeded &= compiled.Item1 != null;
if (!outp.Succeeded)
{
LogResult (outp );
EndCompile(folder);
return outp;
}
return MainCompileStuff(building, compiled.Item1);
}
catch (Exception e)
{
LogError(e, "Unexpected error.");
EndCompile(folder);
CompilerOutput o;
LogResult(o = CreateOutput(new List<CompilerError>()
{
new CompilerError(building)
{
Cause = e,
FilePath = folder,
IsWarning = false,
Message = "An unexpected error occured while compiling."
}
}));
return o;
}
}
/// <summary>
/// Serialise the CDA document to an XML file
/// </summary>
/// <param name="fileLocation">filename of the XML file to be created</param>
public void CreateXML(string fileLocation)
{
FileInfo tagetInfo = new FileInfo(fileLocation);
if (tagetInfo.Directory.Exists)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Indent = true;
settings.IndentChars = (" ");
using (XmlWriter writer = XmlWriter.Create(fileLocation, settings))
{
writeXmlCommentBlock(writer);
writer.WriteStartElement("ClinicalDocument", "urn:hl7-org:v3");
writeXml(writer);
writer.WriteEndElement();
writer.Flush();
}
}
else
{
ApplicationException exInner = new ApplicationException(tagetInfo.DirectoryName);
DirectoryNotFoundException ex = new DirectoryNotFoundException("Target Directory does not exist", exInner);
throw ex;
}
}
public static bool ShowFile(HttpResponse httpResponse, NameValueCollection queryString, CommonUtils.AppSettingKey settingKey, out Exception message)
{
try
{
string fileName = queryString["file"];
if (string.IsNullOrEmpty(fileName))
{
message = new Exception("Query string 'file' missing from url.");
return false;
}
string folderConfig = GetAppSettingValue(settingKey);
string folderPath = Path.Combine(folderConfig, fileName);
if (!Directory.Exists(folderPath))
{
message = new DirectoryNotFoundException(string.Format(@"Failed to find file '{0}' from this location: ({1}).
Please ask your administrator to check whether the folder exists.", fileName, folderPath));
return false;
}
var files = Directory.GetFiles(folderPath);
if (files.Any())
{
string filePath = files[0];
httpResponse.Clear();
httpResponse.ClearContent();
//Response.OutputStream.f
httpResponse.BufferOutput = true;
httpResponse.ContentType = "application/unknown";
httpResponse.AddHeader("Content-Disposition", string.Format("attachment; filename=\"{0}\"", Path.GetFileName(filePath)));
byte[] fileContent = File.ReadAllBytes(filePath);
BinaryWriter binaryWriter = new BinaryWriter(httpResponse.OutputStream);
binaryWriter.Write(fileContent, 0, fileContent.Length);
binaryWriter.Flush();
binaryWriter.Close();
//httpResponse.Flush();
}
}
catch (Exception ex)
{
message = ex;
return false;
}
message = null;
return true;
}
private void OpenSqlFileStream
(
string path,
byte[] transactionContext,
System.IO.FileAccess access,
System.IO.FileOptions options,
Int64 allocationSize
)
{
//-----------------------------------------------------------------
// precondition validation
// these should be checked by any caller of this method
// ensure we have validated and normalized the path before
Debug.Assert(path != null);
Debug.Assert(transactionContext != null);
if (access != FileAccess.Read && access != FileAccess.Write && access != FileAccess.ReadWrite)
{
throw ADP.ArgumentOutOfRange("access");
}
// FileOptions is a set of flags, so AND the given value against the set of values we do not support
if ((options & ~(FileOptions.WriteThrough | FileOptions.Asynchronous | FileOptions.RandomAccess | FileOptions.SequentialScan)) != 0)
{
throw ADP.ArgumentOutOfRange("options");
}
//-----------------------------------------------------------------
// normalize the provided path
// * compress path to remove any occurences of '.' or '..'
// * trim whitespace from the beginning and end of the path
// * ensure that the path starts with '\\'
// * ensure that the path does not start with '\\.\'
// * ensure that the path is not longer than Int16.MaxValue
path = GetFullPathInternal(path);
// ensure the running code has permission to read/write the file
DemandAccessPermission(path, access);
FileFullEaInformation eaBuffer = null;
SecurityQualityOfService qos = null;
UnicodeString objectName = null;
Microsoft.Win32.SafeHandles.SafeFileHandle hFile = null;
int nDesiredAccess = UnsafeNativeMethods.FILE_READ_ATTRIBUTES | UnsafeNativeMethods.SYNCHRONIZE;
UInt32 dwCreateOptions = 0;
UInt32 dwCreateDisposition = 0;
System.IO.FileShare shareAccess = System.IO.FileShare.None;
switch (access)
{
case System.IO.FileAccess.Read:
nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.ReadWrite;
dwCreateDisposition = (uint)UnsafeNativeMethods.CreationDisposition.FILE_OPEN;
break;
case System.IO.FileAccess.Write:
nDesiredAccess |= UnsafeNativeMethods.FILE_WRITE_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = (uint)UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE;
break;
case System.IO.FileAccess.ReadWrite:
default:
// we validate the value of 'access' parameter in the beginning of this method
Debug.Assert(access == System.IO.FileAccess.ReadWrite);
nDesiredAccess |= UnsafeNativeMethods.FILE_READ_DATA | UnsafeNativeMethods.FILE_WRITE_DATA;
shareAccess = System.IO.FileShare.Delete | System.IO.FileShare.Read;
dwCreateDisposition = (uint)UnsafeNativeMethods.CreationDisposition.FILE_OVERWRITE;
break;
}
if ((options & System.IO.FileOptions.WriteThrough) != 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_WRITE_THROUGH;
}
if ((options & System.IO.FileOptions.Asynchronous) == 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_SYNCHRONOUS_IO_NONALERT;
}
if ((options & System.IO.FileOptions.SequentialScan) != 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_SEQUENTIAL_ONLY;
}
if ((options & System.IO.FileOptions.RandomAccess) != 0)
{
dwCreateOptions |= (uint)UnsafeNativeMethods.CreateOption.FILE_RANDOM_ACCESS;
}
try
{
eaBuffer = new FileFullEaInformation(transactionContext);
qos = new SecurityQualityOfService(UnsafeNativeMethods.SecurityImpersonationLevel.SecurityAnonymous,
false, false);
// NOTE: the Name property is intended to reveal the publicly available moniker for the
// FILESTREAM attributed column data. We will not surface the internal processing that
// takes place to create the mappedPath.
string mappedPath = InitializeNtPath(path);
objectName = new UnicodeString(mappedPath);
UnsafeNativeMethods.OBJECT_ATTRIBUTES oa;
oa.length = Marshal.SizeOf(typeof(UnsafeNativeMethods.OBJECT_ATTRIBUTES));
oa.rootDirectory = IntPtr.Zero;
oa.attributes = (int)UnsafeNativeMethods.Attributes.CaseInsensitive;
oa.securityDescriptor = IntPtr.Zero;
oa.securityQualityOfService = qos;
oa.objectName = objectName;
UnsafeNativeMethods.IO_STATUS_BLOCK ioStatusBlock;
uint oldMode;
uint retval = 0;
UnsafeNativeMethods.SetErrorModeWrapper(UnsafeNativeMethods.SEM_FAILCRITICALERRORS, out oldMode);
try
{
Bid.Trace("<sc.SqlFileStream.OpenSqlFileStream|ADV> %d#, desiredAccess=0x%08x, allocationSize=%I64d, fileAttributes=0x%08x, shareAccess=0x%08x, dwCreateDisposition=0x%08x, createOptions=0x%08x\n",
ObjectID, (int)nDesiredAccess, allocationSize, 0, (int)shareAccess, dwCreateDisposition, dwCreateOptions);
retval = UnsafeNativeMethods.NtCreateFile(out hFile, nDesiredAccess,
ref oa, out ioStatusBlock, ref allocationSize,
0, shareAccess, dwCreateDisposition, dwCreateOptions,
eaBuffer, (uint)eaBuffer.Length);
}
finally
{
UnsafeNativeMethods.SetErrorModeWrapper(oldMode, out oldMode);
}
switch (retval)
{
case 0:
break;
case UnsafeNativeMethods.STATUS_SHARING_VIOLATION:
throw ADP.InvalidOperation(Res.GetString(Res.SqlFileStream_FileAlreadyInTransaction));
case UnsafeNativeMethods.STATUS_INVALID_PARAMETER:
throw ADP.Argument(Res.GetString(Res.SqlFileStream_InvalidParameter));
case UnsafeNativeMethods.STATUS_OBJECT_NAME_NOT_FOUND:
{
System.IO.DirectoryNotFoundException e = new System.IO.DirectoryNotFoundException();
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
default:
{
uint error = UnsafeNativeMethods.RtlNtStatusToDosError(retval);
if (error == UnsafeNativeMethods.ERROR_MR_MID_NOT_FOUND)
{
// status code could not be mapped to a Win32 error code
error = retval;
}
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(unchecked ((int)error));
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
if (hFile.IsInvalid)
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(UnsafeNativeMethods.ERROR_INVALID_HANDLE);
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
UnsafeNativeMethods.FileType fileType = UnsafeNativeMethods.GetFileType(hFile);
if (fileType != UnsafeNativeMethods.FileType.Disk)
{
hFile.Dispose();
throw ADP.Argument(Res.GetString(Res.SqlFileStream_PathNotValidDiskResource));
}
// if the user is opening the SQL FileStream in read/write mode, we assume that they want to scan
// through current data and then append new data to the end, so we need to tell SQL Server to preserve
// the existing file contents.
if (access == System.IO.FileAccess.ReadWrite)
{
uint ioControlCode = UnsafeNativeMethods.CTL_CODE(UnsafeNativeMethods.FILE_DEVICE_FILE_SYSTEM,
IoControlCodeFunctionCode, (byte)UnsafeNativeMethods.Method.METHOD_BUFFERED,
(byte)UnsafeNativeMethods.Access.FILE_ANY_ACCESS);
uint cbBytesReturned = 0;
if (!UnsafeNativeMethods.DeviceIoControl(hFile, ioControlCode, IntPtr.Zero, 0, IntPtr.Zero, 0, out cbBytesReturned, IntPtr.Zero))
{
System.ComponentModel.Win32Exception e = new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
ADP.TraceExceptionAsReturnValue(e);
throw e;
}
}
// now that we've successfully opened a handle on the path and verified that it is a file,
// use the SafeFileHandle to initialize our internal System.IO.FileStream instance
// NOTE: need to assert UnmanagedCode permissions for this constructor. This is relatively benign
// in that we've done much the same validation as in the FileStream(string path, ...) ctor case
// most notably, validating that the handle type corresponds to an on-disk file.
bool bRevertAssert = false;
try
{
SecurityPermission sp = new SecurityPermission(SecurityPermissionFlag.UnmanagedCode);
sp.Assert();
bRevertAssert = true;
System.Diagnostics.Debug.Assert(m_fs == null);
m_fs = new System.IO.FileStream(hFile, access, DefaultBufferSize, ((options & System.IO.FileOptions.Asynchronous) != 0));
}
finally
{
if (bRevertAssert)
{
SecurityPermission.RevertAssert();
}
}
}
catch
{
if (hFile != null && !hFile.IsInvalid)
{
hFile.Dispose();
}
throw;
}
finally
{
if (eaBuffer != null)
{
eaBuffer.Dispose();
eaBuffer = null;
}
if (qos != null)
{
qos.Dispose();
qos = null;
}
if (objectName != null)
{
objectName.Dispose();
objectName = null;
}
}
}
public static DirectoryNotFoundException/*!*/ Create(RubyClass/*!*/ self, [DefaultProtocol, DefaultParameterValue(null)]MutableString message) {
DirectoryNotFoundException result = new DirectoryNotFoundException(RubyExceptions.MakeMessage(ref message, "Not a directory"));
RubyExceptionData.InitializeException(result, message);
return result;
}
public void Validate()
{
if (!Directory.Exists(basePath))
{
throw new DirectoryNotFoundException(basePath);
}
Array serverFolders = Enum.GetValues(typeof(ServerFolders));
foreach (Enum serverFolder in serverFolders)
{
string path = GetPath((ServerFolders)serverFolder);
if ((IsVital((ServerFolders)serverFolder)) && (!Directory.Exists(path)))
{
Directory.CreateDirectory(path);
DirectoryNotFoundException exception = new DirectoryNotFoundException(path);
ProcessException.WriteErrorLog(exception.StackTrace, exception.Message);
ProcessException.WriteInfoLog("\r\nCreated folder: " + path,"ServerEnviroment.Validate()");
}
}
}
protected override void ProcessRecord()
{
foreach (var computer in _computername)
{
ConnectionInfo connectInfo;
if (_keyfile.Equals(""))
{
WriteVerbose("Using SSH Username and Password authentication for connection.");
var kIconnectInfo = new KeyboardInteractiveAuthenticationMethod(_credential.UserName);
connectInfo = ConnectionInfoGenerator.GetCredConnectionInfo(computer,
_port,
_credential,
_proxyserver,
_proxytype,
_proxyport,
_proxycredential,
kIconnectInfo);
// Event Handler for interactive Authentication
kIconnectInfo.AuthenticationPrompt += delegate(object sender, AuthenticationPromptEventArgs e)
{
foreach (var prompt in e.Prompts)
{
if (prompt.Request.Contains("Password"))
prompt.Response = _credential.GetNetworkCredential().Password;
}
};
}
else
{
WriteVerbose("Using SSH Key authentication for connection.");
connectInfo = ConnectionInfoGenerator.GetKeyConnectionInfo(computer,
_port,
_keyfile,
_credential,
_proxyserver,
_proxytype,
_proxyport,
_proxycredential);
}
//Ceate instance of SSH Client with connection info
var client = new ScpClient(connectInfo);
// Handle host key
if (_force)
{
WriteWarning("Host key is not being verified since Force switch is used.");
}
else
{
var computer1 = computer;
client.HostKeyReceived += delegate(object sender, HostKeyEventArgs e)
{
var sb = new StringBuilder();
foreach (var b in e.FingerPrint)
{
sb.AppendFormat("{0:x}:", b);
}
var fingerPrint = sb.ToString().Remove(sb.ToString().Length - 1);
if (MyInvocation.BoundParameters.ContainsKey("Verbose"))
{
Host.UI.WriteVerboseLine("Fingerprint for " + computer1 + ": " + fingerPrint);
}
if (_sshHostKeys.ContainsKey(computer1))
{
if (_sshHostKeys[computer1] == fingerPrint)
{
if (MyInvocation.BoundParameters.ContainsKey("Verbose"))
{
Host.UI.WriteVerboseLine("Fingerprint matched trusted fingerprint for host " + computer1);
}
e.CanTrust = true;
}
else
{
e.CanTrust = false;
}
}
else
{
if (_errorOnUntrusted)
{
e.CanTrust = false;
}
else
{
int choice;
if (_acceptkey)
{
choice = 0;
}
else
{
var choices = new Collection<ChoiceDescription>
{
new ChoiceDescription("Y"),
new ChoiceDescription("N")
};
choice = Host.UI.PromptForChoice("Server SSH Fingerprint", "Do you want to trust the fingerprint " + fingerPrint, choices, 1);
}
if (choice == 0)
{
var keymng = new TrustedKeyMng();
keymng.SetKey(computer1, fingerPrint);
e.CanTrust = true;
}
else
{
e.CanTrust = false;
}
}
}
};
}
try
{
// Set the connection timeout
client.ConnectionInfo.Timeout = TimeSpan.FromSeconds(_connectiontimeout);
// Connect to host using Connection info
client.Connect();
}
catch (Renci.SshNet.Common.SshConnectionException e)
{
ErrorRecord erec = new ErrorRecord(e, null, ErrorCategory.SecurityError, client);
WriteError(erec);
}
catch (Renci.SshNet.Common.SshOperationTimeoutException e)
{
ErrorRecord erec = new ErrorRecord(e, null, ErrorCategory.OperationTimeout, client);
WriteError(erec);
}
catch (Renci.SshNet.Common.SshAuthenticationException e)
{
ErrorRecord erec = new ErrorRecord(e, null, ErrorCategory.SecurityError, client);
WriteError(erec);
}
catch (Exception e)
{
ErrorRecord erec = new ErrorRecord(e, null, ErrorCategory.InvalidOperation, client);
WriteError(erec);
}
if (client.IsConnected)
{
client.BufferSize = 1024;
// Print progess of upload.
if (!_noProgress)
{
client.Uploading += delegate(object sender, ScpUploadEventArgs e)
{
var progressRecord = new ProgressRecord(1, "Uploading " + e.Filename, String.Format("{0} Bytes Uploaded of {1}", e.Uploaded, e.Size))
{
PercentComplete = Convert.ToInt32((e.Uploaded * 100) / e.Size)
};
Host.UI.WriteProgress(1, progressRecord);
};
}
// Resolve the path even if a relative one is given.
ProviderInfo provider;
var pathinfo = GetResolvedProviderPathFromPSPath(_localfolder, out provider);
var localfullPath = pathinfo[0];
//var localfullPath = Path.GetFullPath(_localfolder);
if (Directory.Exists(localfullPath))
{
try
{
WriteVerbose("Uploading " + _remotefolder);
var dirinfo = new DirectoryInfo(@localfullPath);
client.Upload(dirinfo, _remotefolder);
}
catch (Exception e)
{
ErrorRecord erec = new ErrorRecord(e, null, ErrorCategory.InvalidOperation, client);
WriteError(erec);
}
}
else
{
var ex = new DirectoryNotFoundException("Directory " + localfullPath + " was not found.");
WriteError(new ErrorRecord(ex,
"Directory " + localfullPath + " was not found.",
ErrorCategory.InvalidArgument,
localfullPath));
}
client.Disconnect();
}
}
}
