public LogStore(
string path,
FileMode mode,
FileAccess access)
: this(path, mode, access, FileShare.None)
{
}
public static FileStream OpenSequentialStream(string path, FileMode mode, FileAccess access, FileShare share)
{
var options = FileOptions.SequentialScan;
if (concurrency > 0)
{
options |= FileOptions.Asynchronous;
}
#if MONO
return new FileStream( path, mode, access, share, bufferSize, options );
#else
if (unbuffered)
{
options |= NoBuffering;
}
else
{
return new FileStream(path, mode, access, share, bufferSize, options);
}
SafeFileHandle fileHandle = CreateFile(path, (int)access, share, IntPtr.Zero, mode, (int)options, IntPtr.Zero);
if (fileHandle.IsInvalid)
{
throw new IOException();
}
return new UnbufferedFileStream(fileHandle, access, bufferSize, (concurrency > 0));
#endif
}
public static Stream CreateFile(
string fileName, FileAccess fileAccess, FileShare fileShare, FileMode fileMode, FileAttributes flags)
{
// TODO: This is not quite right, but it's close.
//
var nativeAccess = fileAccess;
if ((nativeAccess & FileAccess.Read) != 0)
{
nativeAccess &= ~FileAccess.Read;
nativeAccess |= (FileAccess)GENERIC_READ;
}
if ((nativeAccess & FileAccess.Write) != 0)
{
nativeAccess &= ~FileAccess.Write;
nativeAccess |= (FileAccess)GENERIC_WRITE;
}
var handle = _CreateFile(fileName, nativeAccess, fileShare, IntPtr.Zero, fileMode, flags, IntPtr.Zero);
if (handle.IsInvalid)
{
Marshal.ThrowExceptionForHR(Marshal.GetHRForLastWin32Error());
}
return new SimpleFileStream(handle);
}
public void Compress(string sourceFilename, string targetFilename, FileMode fileMode, OutArchiveFormat archiveFormat,
CompressionMethod compressionMethod, CompressionLevel compressionLevel, ZipEncryptionMethod zipEncryptionMethod,
string password, int bufferSize, int preallocationPercent, bool check, Dictionary<string, string> customParameters)
{
bufferSize *= this._sectorSize;
SevenZipCompressor compressor = new SevenZipCompressor();
compressor.FastCompression = true;
compressor.ArchiveFormat = archiveFormat;
compressor.CompressionMethod = compressionMethod;
compressor.CompressionLevel = compressionLevel;
compressor.DefaultItemName = Path.GetFileName(sourceFilename);
compressor.DirectoryStructure = false;
compressor.ZipEncryptionMethod = zipEncryptionMethod;
foreach (var pair in customParameters)
{
compressor.CustomParameters[pair.Key] = pair.Value;
}
using (FileStream sourceFileStream = new FileStream(sourceFilename,
FileMode.Open, FileAccess.Read, FileShare.None, bufferSize,
Win32.FileFlagNoBuffering | FileOptions.SequentialScan))
{
using (FileStream targetFileStream = new FileStream(targetFilename,
fileMode, FileAccess.ReadWrite, FileShare.ReadWrite, 8,
FileOptions.WriteThrough | Win32.FileFlagNoBuffering))
{
this.Compress(compressor, sourceFileStream, targetFileStream,
password, preallocationPercent, check, bufferSize);
}
}
}
/**
* open file.
* @param void.
* @return void.
*/
public bool Open(string strFileName, FileMode eMode, FileAccess eAccess)
{
if (string.IsNullOrEmpty(strFileName))
{
return false;
}
if ((FileMode.Open == eMode) && !File.Exists(strFileName))
{
return false;
}
try
{
m_cStream = new FileStream(strFileName, eMode, eAccess);
}
catch (Exception cEx)
{
Console.Write(cEx.Message);
}
if (null == m_cStream)
{
return false;
}
m_bOpen = true;
return true;
}
// This plug basically forwards all calls to the $$InnerStream$$ stream, which is supplied by the file system.
// public static unsafe void Ctor(String aThis, [FieldAccess(Name = "$$Storage$$")]ref Char[] aStorage, Char[] aChars, int aStartIndex, int aLength,
public static void Ctor(FileStream aThis, string aPathname, FileMode aMode,
[FieldAccess(Name = "$$InnerStream$$")] ref Stream innerStream)
{
Global.mFileSystemDebugger.SendInternal("FileStream.Ctor:");
innerStream = InitializeStream(aPathname, aMode);
}
private static void FileModeChanged(string[] assets, FileMode mode)
{
if (Provider.enabled && Provider.PromptAndCheckoutIfNeeded(assets, ""))
{
Provider.SetFileMode(assets, mode);
}
}
private static FileStream GetFileStream(string fileName, FileMode mode)
{
using (var storageFile = IsolatedStorageFile.GetUserStoreForApplication())
{
return new IsolatedStorageFileStream(fileName, mode, storageFile);
}
}
/// <summary>
/// File might be locked when attempting to open it. This will attempt to open the file the number of times specified by <paramref name="retry"/>
/// </summary>
/// <param name="filePath">The file to attempt to get a file stream for</param>
/// <param name="retry">The number of times a file open should be attempted</param>
/// <param name="fileMode">The file mode to use</param>
/// <param name="fileAccess">The file access to use</param>
/// <param name="fileShare">The file sharing to use</param>
/// <returns>A file stream of the file</returns>
/// <remarks>
/// It attempt to open the file in increasingly longer periods and throw an exception if it cannot open it within the
/// specified number of retries.
/// </remarks>
public Stream OpenFileStream(string filePath, int retry, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
var delay = 0;
for(var i = 0; i < retry; i++)
{
try
{
var stream = new FileStream(filePath, fileMode, fileAccess, fileShare);
return stream;
}
catch(DirectoryNotFoundException)
{
CreateDirectoryStructure(filePath);
}
catch(FileNotFoundException)
{
throw;
}
catch(IOException)
{
delay += 100;
if(i == retry) throw;
}
Thread.Sleep(delay);
}
//We will never get here
throw new IOException(string.Format("Unable to open file '{0}'", filePath));
}
private SafeFileHandle OpenHandle(FileMode mode, FileShare share, FileOptions options)
{
// FileStream performs most of the general argument validation. We can assume here that the arguments
// are all checked and consistent (e.g. non-null-or-empty path; valid enums in mode, access, share, and options; etc.)
// Store the arguments
_mode = mode;
_options = options;
if (_useAsyncIO)
_asyncState = new AsyncState();
// Translate the arguments into arguments for an open call.
Interop.Sys.OpenFlags openFlags = PreOpenConfigurationFromOptions(mode, _access, options); // FileShare currently ignored
// If the file gets created a new, we'll select the permissions for it. Most Unix utilities by default use 666 (read and
// write for all), so we do the same (even though this doesn't match Windows, where by default it's possible to write out
// a file and then execute it). No matter what we choose, it'll be subject to the umask applied by the system, such that the
// actual permissions will typically be less than what we select here.
const Interop.Sys.Permissions OpenPermissions =
Interop.Sys.Permissions.S_IRUSR | Interop.Sys.Permissions.S_IWUSR |
Interop.Sys.Permissions.S_IRGRP | Interop.Sys.Permissions.S_IWGRP |
Interop.Sys.Permissions.S_IROTH | Interop.Sys.Permissions.S_IWOTH;
// Open the file and store the safe handle.
return SafeFileHandle.Open(_path, openFlags, (int)OpenPermissions);
}
public Stream FileOpen(string filePath, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
#if WINDOWS_STORE_APP
var folder = ApplicationData.Current.LocalFolder;
if (fileMode == FileMode.Create || fileMode == FileMode.CreateNew)
{
return folder.OpenStreamForWriteAsync(filePath, CreationCollisionOption.ReplaceExisting).GetAwaiter().GetResult();
}
else if (fileMode == FileMode.OpenOrCreate)
{
if (fileAccess == FileAccess.Read)
return folder.OpenStreamForReadAsync(filePath).GetAwaiter().GetResult();
else
{
// Not using OpenStreamForReadAsync because the stream position is placed at the end of the file, instead of the beginning
var f = folder.CreateFileAsync(filePath, CreationCollisionOption.OpenIfExists).AsTask().GetAwaiter().GetResult();
return f.OpenAsync(FileAccessMode.ReadWrite).AsTask().GetAwaiter().GetResult().AsStream();
}
}
else if (fileMode == FileMode.Truncate)
{
return folder.OpenStreamForWriteAsync(filePath, CreationCollisionOption.ReplaceExisting).GetAwaiter().GetResult();
}
else
{
//if (fileMode == FileMode.Append)
// Not using OpenStreamForReadAsync because the stream position is placed at the end of the file, instead of the beginning
folder.CreateFileAsync(filePath, CreationCollisionOption.OpenIfExists).AsTask().GetAwaiter().GetResult().OpenAsync(FileAccessMode.ReadWrite).AsTask().GetAwaiter().GetResult().AsStream();
var f = folder.CreateFileAsync(filePath, CreationCollisionOption.OpenIfExists).AsTask().GetAwaiter().GetResult();
return f.OpenAsync(FileAccessMode.ReadWrite).AsTask().GetAwaiter().GetResult().AsStream();
}
#else
return File.Open(filePath, fileMode, fileAccess, fileShare);
#endif
}
public void Process(FileMode mode, bool agreement)
{
PropertyBag["mode"] = mode;
PropertyBag["agreement"] = agreement;
RenderView("result");
}
private static extern SafeFileHandle CreateFile(string filename,
FileAccess desiredAccess,
FileShare shareMode,
IntPtr attributes,
FileMode creationDisposition,
uint flagsAndAttributes = 0,
IntPtr templateFile = default(IntPtr));
public static void WriteTextToFile(string strFilePath, string strText, FileMode fileMode)
{
StreamWriter SW = File.AppendText(strFilePath);
FileStream FS;
char[] arrChar = strText.ToCharArray();
try
{
if(FileExists(strFilePath))
{
SW.WriteLine(strText);
}
else
{
FS = File.Open(strFilePath, fileMode);
for(int i = 0; i < strText.Length; i++)
{
FS.WriteByte(Convert.ToByte(arrChar[i]));
}
FS.Flush();
FS.Close();
}
}
catch
{
}
finally
{
SW.Flush();
SW.Close();
}
}
public RemoteFileSystemFileStream(RemoteFileSystem RemoteFileSystem, String FileName, FileMode FileMode)
: base(RemoteFileSystem, (Lazy<Stream>)null)
{
this.RemoteFileSystem = RemoteFileSystem;
this.FileName = FileName;
this.FileMode = FileMode;
}
public int CreateFile(string filename, FileAccess access, FileShare share, FileMode mode, FileOptions options, DokanFileInfo info)
{
Trace.WriteLine(string.Format("CreateFile FILENAME({0}) ACCESS({1}) SHARE({2}) MODE({3})", filename, access, share, mode));
if (mode == FileMode.Create || mode == FileMode.OpenOrCreate || mode == FileMode.CreateNew)
{
// we want to write a file
var fileRef = Extensions.GetFileReference(root, filename.ToFileString());
fileRef.Create(0);
return 0;
}
if (share == FileShare.Delete)
{
return DeleteFile(filename, info);
}
if (GetFileInformation(filename, new FileInformation(), new DokanFileInfo(0)) == 0)
{
return 0;
}
else
{
return -DokanNet.ERROR_FILE_NOT_FOUND;
}
}
protected ShapefileWriter(string path, ShapefileHeader header, FileMode fileMode, FileAccess fileAccess)
{
_writerShape = new BinaryWriter(new FileStream(path, fileMode, fileAccess));
_writerIndex = new BinaryWriter(new FileStream(Path.ChangeExtension(path, ".shx"), fileMode, fileAccess));
_header = header;
}
static internal string ToString(string path, FileMode mode, FileAccess access, FileShare share)
{
// http://ee.php.net/fopen
//'r' Open for reading only; place the file pointer at the beginning of the file.
//'r+' Open for reading and writing; place the file pointer at the beginning of the file.
//'w' Open for writing only; place the file pointer at the beginning of the file and truncate the file to zero length. If the file does not exist, attempt to create it.
//'w+' Open for reading and writing; place the file pointer at the beginning of the file and truncate the file to zero length. If the file does not exist, attempt to create it.
//'a' Open for writing only; place the file pointer at the end of the file. If the file does not exist, attempt to create it.
//'a+' Open for reading and writing; place the file pointer at the end of the file. If the file does not exist, attempt to create it.
//'x' Create and open for writing only; place the file pointer at the beginning of the file. If the file already exists, the fopen() call will fail by returning FALSE and generating an error of level E_WARNING. If the file does not exist, attempt to create it. This is equivalent to specifying O_EXCL|O_CREAT flags for the underlying open(2) system call.
//'x+' Create and open for reading and writing; place the file pointer at the beginning of the file. If the file already exists, the fopen() call will fail by returning FALSE and generating an error of level E_WARNING. If the file does not exist, attempt to create it. This is equivalent to specifying O_EXCL|O_CREAT flags for the underlying open(2) system call.
if (mode == FileMode.OpenOrCreate)
{
if (access == FileAccess.Write)
{
if (File.Exists(path))
return "r+b";
else
return "x+b";
}
if (access == FileAccess.Read)
{
if (File.Exists(path))
return "rb";
else
return "xb";
}
}
var e = new { mode, access, share };
throw new NotImplementedException(e.ToString());
}
public MongoGridFSStream(
MongoGridFSFileInfo fileInfo,
FileMode mode
)
: this(fileInfo, mode, FileAccess.ReadWrite)
{
}
/// <summary>
/// File might be locked when attempting to open it. This will attempt to open the file the number of times specified by <paramref name="retry"/>
/// </summary>
/// <param name="fileInfo">The file to attempt to get a file stream for</param>
/// <param name="retry">The number of times a file open should be attempted</param>
/// <param name="fileMode">The file mode to use</param>
/// <param name="fileAccess">The file access to use</param>
/// <param name="fileShare">The file sharing to use</param>
/// <returns>A file stream of the file</returns>
/// <remarks>
/// It attempt to open the file in increasingly longer periods and throw an exception if it cannot open it within the
/// specified number of retries.
/// </remarks>
public FileStream OpenFileStream(FileInfo fileInfo, int retry, FileMode fileMode, FileAccess fileAccess, FileShare fileShare)
{
var delay = 0;
for (var i = 0; i < retry; i++)
{
try
{
var stream = new FileStream(fileInfo.FullName, fileMode, fileAccess, fileShare);
return stream;
}
catch(FileNotFoundException)
{
throw;
}
catch (IOException)
{
delay += 100;
if (i == retry) throw;
}
Thread.Sleep(delay);
}
//We will never get here
throw new IOException("Unable to open file - " + fileInfo.FullName);
}
internal LogStream(string path, int bufferSize, LogRetentionOption retention, long maxFileSize, int maxNumOfFiles)
{
string fullPath = Path.GetFullPath(path);
this._fileName = fullPath;
if (fullPath.StartsWith(@"\\.\", StringComparison.Ordinal))
{
throw new NotSupportedException(System.SR.GetString("NotSupported_IONonFileDevices"));
}
Microsoft.Win32.UnsafeNativeMethods.SECURITY_ATTRIBUTES secAttrs = GetSecAttrs(FileShare.Read);
int num = 0x100000;
this._canWrite = true;
this._pathSav = fullPath;
this._fAccessSav = 0x40000000;
this._shareSav = FileShare.Read;
this._secAttrsSav = secAttrs;
this._secAccessSav = FileIOPermissionAccess.Write;
this._modeSav = (retention != LogRetentionOption.SingleFileUnboundedSize) ? FileMode.Create : FileMode.OpenOrCreate;
this._flagsAndAttributesSav = num;
this._seekToEndSav = retention == LogRetentionOption.SingleFileUnboundedSize;
base.bufferSize = bufferSize;
this._retention = retention;
this._maxFileSize = maxFileSize;
this._maxNumberOfFiles = maxNumOfFiles;
this._Init(fullPath, this._fAccessSav, this._shareSav, this._secAttrsSav, this._secAccessSav, this._modeSav, this._flagsAndAttributesSav, this._seekToEndSav);
}
private void WriteFile(string filename, byte[] content, FileMode fileMode)
{
Stream target = null;
BinaryWriter writer = null;
try
{
target = File.Open(filename, fileMode);
writer = new BinaryWriter(target);
writer.Write(content);
}
catch (Exception ex)
{
throw new Exception("Could not write to file: " + filename + " - " + ex.Message);
}
finally
{
if (target != null)
{
target.Close();
}
if (writer != null)
{
writer.Close();
}
}
}
internal static void FileAccess(FileMode fileMode, FileAccess fileAccess)
{
// exception if:
// !write && append
// !write && create
// !write && createNew
// !write && truncate
var noWrite = (fileAccess & System.IO.FileAccess.Write) == 0;
if (noWrite && fileMode == FileMode.CreateNew)
throw new ArgumentException(string.Format(
"Can only open files in {0} mode when requesting FileAccess.Write access.", fileMode));
if (noWrite && fileMode == FileMode.Truncate)
throw new IOException("Cannot truncate a file if file mode doesn't include WRITE.");
// or if:
// readwrite && append
// read && append
if (fileAccess == System.IO.FileAccess.Read && fileMode == FileMode.Append)
throw new ArgumentException("Cannot open file in read-mode when having FileMode.Append");
//if (
// ((fileMode == FileMode.Append) && fileAccess != FileAccess.Write) ||
// ((fileMode == FileMode.CreateNew || fileMode == FileMode.Create || fileMode == FileMode.Truncate)
// && (fileAccess != FileAccess.Write && fileAccess != FileAccess.ReadWrite)) ||
// false //((Exists && fileMode == FileMode.OpenOrCreate && fileAccess == FileAccess.Write))
// )
}
public static void SerializeToFile(object obj, string file, FileMode fileMode, XmlSerializerNamespaces namespaces, bool omitXmlDeclaration)
{
using (FileStream fileStream = new FileStream(file, fileMode))
{
SerializeToStream(obj, fileStream, namespaces, omitXmlDeclaration);
}
}
// uint GetMode( FileMode mode )
// Converts the filemode constant to win32 constant
#region GetMode
private static uint GetMode(FileMode mode)
{
uint umode = 0;
switch (mode)
{
case FileMode.CreateNew:
umode = CREATE_NEW;
break;
case FileMode.Create:
umode = CREATE_ALWAYS;
break;
case FileMode.Append:
umode = OPEN_ALWAYS;
break;
case FileMode.Open:
umode = OPEN_EXISTING;
break;
case FileMode.OpenOrCreate:
umode = OPEN_ALWAYS;
break;
case FileMode.Truncate:
umode = TRUNCATE_EXISTING;
break;
}
return umode;
}
private static extern IntPtr CreateFile(string fileName,
FILE_ACCESS_RIGHTS access,
FileShare share,
int securityAttributes,
FileMode creation,
FILE_FLAGS flags,
IntPtr templateFile);
public Output(string filename, FileMode mode)
{
StandardOutput = IsStandardOutput(filename);
Name = StandardOutput ? "(standard output)" : filename;
Mode = mode;
Open = () => StandardOutput ? Console.OpenStandardOutput() : File.Open(Name, Mode);
}
public static IStream FromFile(string fileName, FileMode mode, StreamInfo streamInfo)
{
if (fileName == null)
throw new ArgumentNullException("fileName");
return FromStream(File.Open(fileName, mode), streamInfo ?? StreamInfo.FromFile(fileName));
}
public static extern SafeFileHandle CreateFile(String fileName,
FileAccess desiredAccess,
FileShare shareMode,
IntPtr securityAttrs,
FileMode creationDisposition,
int flagsAndAttributes,
IntPtr templateFile);
public override void Open(FileMode mode = FileMode.OpenOrCreate)
{
if (this.isOpen)
{
Console.WriteLine("DataFile::Open File is already open: " + this.name);
return;
}
if (!this.OpenFileStream(this.name, mode))
{
this.beginPosition = 62L;
this.endPosition = 62L;
this.keysPosition = 62L;
this.freePosition = 62L;
this.keysLength = 0;
this.freeLength = 0;
this.keysNumber = 0;
this.freeNumber = 0;
this.isModified = true;
base.WriteHeader();
}
else
{
if (!base.ReadHeader())
{
Console.WriteLine("DataFile::Open Error opening file " + this.name);
return;
}
base.ReadKeys();
base.ReadFree();
}
this.isOpen = true;
}
internal AsyncWindowsFileStreamStrategy(string path, FileMode mode, FileAccess access, FileShare share, FileOptions options, long preallocationSize)
: base(path, mode, access, share, options, preallocationSize)
{
}
private static byte[] CreateSendFileRequest(String command, String path, FileMode mode)
{
return(CreateSendFileRequest(Encoding.Default.GetBytes(command), Encoding.Default.GetBytes(path), mode));
}
public Stream CreateFileStream(string filename, FileMode mode, FileAccess access, FileShare share)
{
return(new FileStream(filename, mode, access, share));
}
public Stream CreateFileStream(string filename, FileMode mode)
{
return(new FileStream(filename, mode));
}
public static FileStream Open(String path, FileMode mode, FileAccess access, FileShare share)
{
return(new FileStream(path, mode, access, share, NativeFileStream.BufferSizeDefault));
}
public static FileStream Open(String path, FileMode mode)
{
return(new FileStream(path, mode, (mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite), FileShare.None, NativeFileStream.BufferSizeDefault));
}
private static FileStreamStrategy ChooseStrategyCore(string path, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, long preallocationSize) => new Net5CompatFileStreamStrategy(path, mode, access, share, bufferSize == 0 ? 1 : bufferSize, options, preallocationSize);
public static FileStream Open(string path, FileMode mode, FileAccess access)
{
return(Open(path, mode, access, FileShare.None));
}
public static TaskFunc ProcessNand(string nandDump, NandTasks task)
{
return((Tasker tasker, Object sync) =>
{
NandTasks[] validTasks = { NandTasks.DumpNand, NandTasks.DumpNandB, NandTasks.DumpNandC, NandTasks.FlashNandB, NandTasks.FlashNandC, NandTasks.FormatNandC };
if (!validTasks.Contains(task))
{
throw new ArgumentOutOfRangeException("task");
}
if (task == NandTasks.FlashNandB && !Files.CheckFileType.IsSquashFs(nandDump))
{
throw new Exception(Properties.Resources.InvalidHsqs);
}
bool isTar = false;
if (task == NandTasks.FlashNandC)
{
isTar = Files.CheckFileType.IsTar(nandDump);
if (!(isTar || Files.CheckFileType.IsExtFs(nandDump)))
{
throw new Exception(Properties.Resources.InvalidUserDataBackup);
}
}
long partitionSize = 300 * 1024 * 1024;
var splitStream = new SplitterStream(Program.debugStreams);
switch (task)
{
case NandTasks.DumpNandB:
case NandTasks.FlashNandB:
hakchi.Shell.Execute("umount /newroot");
hakchi.Shell.Execute("cryptsetup close root-crypt");
hakchi.Shell.ExecuteSimple("cryptsetup open /dev/nandb root-crypt --type plain --cipher aes-xts-plain --key-file /key-file", 2000, true);
if (task == NandTasks.DumpNandB)
{
partitionSize = long.Parse(hakchi.Shell.ExecuteSimple("echo $((($(hexdump -e '1/4 \"%u\"' -s $((0x28)) -n 4 /dev/mapper/root-crypt)+0xfff)/0x1000))", throwOnNonZero: true).Trim()) * 4 * 1024;
}
if (task == NandTasks.FlashNandB)
{
partitionSize = long.Parse(hakchi.Shell.ExecuteSimple("blockdev --getsize64 /dev/mapper/root-crypt", throwOnNonZero: true));
}
break;
case NandTasks.DumpNandC:
hakchi.Shell.Execute("hakchi mount_base", null, null, null, 0, true);
partitionSize = long.Parse(hakchi.Shell.ExecuteSimple("df -B 1 | grep /newroot/var/lib | head -n 1 | awk -e '{print $3 }'", throwOnNonZero: true).Trim());
break;
case NandTasks.FlashNandC:
partitionSize = long.Parse(hakchi.Shell.ExecuteSimple("blockdev --getsize64 /dev/nandc", throwOnNonZero: true));
break;
case NandTasks.DumpNand:
partitionSize = 536870912;
break;
case NandTasks.FormatNandC:
hakchi.Shell.Execute("cat > /bin/mke2fs; chmod +x /bin/mke2fs", File.OpenRead(Shared.PathCombine(Program.BaseDirectoryInternal, "tools", "arm", "mke2fs.static")), null, null, 0, true);
hakchi.Shell.Execute("hakchi umount_base", null, splitStream, splitStream);
hakchi.Shell.Execute("yes | mke2fs -t ext4 -L data -b 4K -E stripe-width=32 -O ^huge_file,^metadata_csum /dev/nandc", null, splitStream, splitStream, 0, true);
hakchi.Shell.Execute("rm /bin/mke2fs");
return Conclusion.Success;
}
FileMode mode = FileMode.Create;
if (task == NandTasks.FlashNandC || task == NandTasks.FlashNandB)
{
mode = FileMode.Open;
}
tasker.SetStatus(mode == FileMode.Open ? Resources.FlashingNand : Resources.DumpingNand);
using (var file = new TrackableFileStream(nandDump, mode))
{
if (mode == FileMode.Open && file.Length > partitionSize)
{
throw new Exception(Resources.ImageTooLarge);
}
if (mode == FileMode.Create && task != NandTasks.DumpNandC)
{
file.SetLength(partitionSize);
}
if (task == NandTasks.DumpNandC)
{
file.OnProgress += (long position, long length) =>
{
tasker.OnProgress(Math.Min(position, partitionSize), partitionSize);
};
}
else
{
file.OnProgress += tasker.OnProgress;
}
switch (task)
{
case NandTasks.DumpNandB:
Shared.ShellPipe($"dd if=/dev/mapper/root-crypt bs=128K count={(partitionSize / 1024) / 4 }", null, file, throwOnNonZero: true);
break;
case NandTasks.FlashNandB:
Shared.ShellPipe("dd of=/dev/mapper/root-crypt bs=128K", file, throwOnNonZero: true);
hakchi.Shell.Execute("cryptsetup close root-crypt", throwOnNonZero: true);
break;
case NandTasks.DumpNandC:
Shared.ShellPipe($"tar -cvC /newroot/var/lib/ .", null, file, null, throwOnNonZero: true);
break;
case NandTasks.FlashNandC:
if (isTar)
{
hakchi.Shell.Execute("hakchi mount_base", null, null, null, 0, true);
hakchi.Shell.Execute("rm -rf /newroot/var/lib/*", null, null, null, 0, true);
hakchi.Shell.Execute("tar -xvC /newroot/var/lib/", file, throwOnNonZero: true);
}
else
{
Shared.ShellPipe("dd of=/dev/nandc bs=128K", file, throwOnNonZero: true);
}
break;
case NandTasks.DumpNand:
Shared.ShellPipe("sntool sunxi_flash phy_read 0 1000", null, file, throwOnNonZero: true);
break;
}
file.Close();
}
tasker.SetStatus(Resources.Done);
tasker.SetProgress(1, 1);
return Conclusion.Success;
});
}
public static FileStream Open(string path, FileMode mode, FileAccess access, FileShare share)
{
return(new FileStream(path, mode, access, share));
}
// ** ctor
public RawHtmlStream(string path, FileMode mode) : base(path, mode)
{
}
public static FileStream Open(string path, FileMode mode)
{
return(Open(path, mode, (mode == FileMode.Append ? FileAccess.Write : FileAccess.ReadWrite), FileShare.None));
}
public virtual Stream CreateFileStream(string filePath, FileMode mode)
{
return(new FileStream(filePath, mode));
}
/// <summary>
/// Opens a GridFS file with the specified mode.
/// </summary>
/// <param name="mode">The mode.</param>
/// <returns>A stream.</returns>
public MongoGridFSStream Open(
FileMode mode
)
{
return(Open(mode, FileAccess.ReadWrite));
}
/// <inheritdoc />
public IFileStream Open(string path, FileMode mode)
{
return(File.Open(path, mode).ToInterface());
}
public FileStream(string path, FileMode mode, FileAccess access)
{
OpenFile(path, access);
}
public override Stream Open(string path, FileMode mode)
{
return(AfsFile.Open(path, mode));
}
/// <inheritdoc />
public IFileStream Open(string path, FileMode mode, FileAccess access, FileShare share)
{
return(File.Open(path, mode, access, share).ToInterface());
}
public abstract Stream GetStream(string path, FileAccess access = FileAccess.Read, FileMode mode = FileMode.OpenOrCreate);
public override Stream Open(string path, FileMode mode, FileAccess access, FileShare share)
{
return(AfsFile.Open(path, mode, access, share));
}
public Stream OpenFileExclusively(string filePath, FileMode fileMode, FileAccess fileAccess)
{
return(File.Open(filePath, fileMode, fileAccess, FileShare.None));
}
public static Stream OpenPathUncached(string path, FileMode mode, System.IO.FileAccess access, FileShare share) => OpenPath(path, mode, access, share, FILE_FLAG_NO_BUFFERING | FILE_FLAG_SEQUENTIAL_SCAN | FILE_FLAG_WRITE_THROUGH);
/// <summary>
/// <span style="font-weight:bold;color:#a00;">(Extension Method)</span><br />
/// Opens an alternate data stream.
/// </summary>
/// <param name="file">
/// The <see cref="FileInfo"/> which contains the stream.
/// </param>
/// <param name="streamName">
/// The name of the stream to open.
/// </param>
/// <param name="mode">
/// One of the <see cref="FileMode"/> values, indicating how the stream is to be opened.
/// </param>
/// <returns>
/// An <see cref="AlternateDataStreamInfo"/> representing the stream.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="file"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="FileNotFoundException">
/// The specified <paramref name="file"/> was not found.
/// </exception>
/// <exception cref="ArgumentException">
/// <paramref name="streamName"/> contains invalid characters.
/// </exception>
/// <exception cref="NotSupportedException">
/// <paramref name="mode"/> is either <see cref="FileMode.Truncate"/> or <see cref="FileMode.Append"/>.
/// </exception>
/// <exception cref="IOException">
/// <para><paramref name="mode"/> is <see cref="FileMode.Open"/>, and the stream doesn't exist.</para>
/// <para>-or-</para>
/// <para><paramref name="mode"/> is <see cref="FileMode.CreateNew"/>, and the stream already exists.</para>
/// </exception>
/// <exception cref="SecurityException">
/// The caller does not have the required permission.
/// </exception>
/// <exception cref="UnauthorizedAccessException">
/// The caller does not have the required permission, or the file is read-only.
/// </exception>
public static AlternateDataStreamInfo GetAlternateDataStream(this FileSystemInfo file, string streamName, FileMode mode)
{
if (null == file)
{
throw new ArgumentNullException("file");
}
if (!file.Exists)
{
throw new FileNotFoundException(null, file.FullName);
}
SafeNativeMethods.ValidateStreamName(streamName);
if (FileMode.Truncate == mode || FileMode.Append == mode)
{
throw new NotSupportedException(string.Format(Resources.Culture,
Resources.Error_InvalidMode, mode));
}
FileIOPermissionAccess permAccess = (FileMode.Open == mode) ? FileIOPermissionAccess.Read : FileIOPermissionAccess.Read | FileIOPermissionAccess.Write;
new FileIOPermission(permAccess, file.FullName).Demand();
string path = SafeNativeMethods.BuildStreamPath(file.FullName, streamName);
bool exists = -1 != SafeNativeMethods.SafeGetFileAttributes(path);
if (!exists && FileMode.Open == mode)
{
throw new IOException(string.Format(Resources.Culture,
Resources.Error_StreamNotFound, streamName, file.Name));
}
if (exists && FileMode.CreateNew == mode)
{
throw new IOException(string.Format(Resources.Culture,
Resources.Error_StreamExists, streamName, file.Name));
}
return(new AlternateDataStreamInfo(file.FullName, streamName, path, exists));
}
/// <summary> /// Not used /// </summary> /// <param name="content">Not used</param> /// <param name="mode">Not used</param> /// <returns>The result of the write or original content</returns> public override byte[] Write(byte[] content, FileMode mode = FileMode.Create) => Write(content.ToString(Encoding.UTF8), mode).ToByteArray();
public override FileStreamBase Open(string fullPath, FileMode mode, FileAccess access, FileShare share, int bufferSize, FileOptions options, FileStream parent)
{
return(new UnixFileStream(fullPath, mode, access, share, bufferSize, options, parent));
}
/// <summary>
/// Opens an alternate data stream.
/// </summary>
/// <param name="filePath">
/// The path of the file which contains the stream.
/// </param>
/// <param name="streamName">
/// The name of the stream to open.
/// </param>
/// <param name="mode">
/// One of the <see cref="FileMode"/> values, indicating how the stream is to be opened.
/// </param>
/// <returns>
/// An <see cref="AlternateDataStreamInfo"/> representing the stream.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="filePath"/> is <see langword="null"/> or an empty string.
/// </exception>
/// <exception cref="FileNotFoundException">
/// The specified <paramref name="filePath"/> was not found.
/// </exception>
/// <exception cref="ArgumentException">
/// <para><paramref name="filePath"/> is not a valid file path.</para>
/// <para>-or-</para>
/// <para><paramref name="streamName"/> contains invalid characters.</para>
/// </exception>
/// <exception cref="NotSupportedException">
/// <paramref name="mode"/> is either <see cref="FileMode.Truncate"/> or <see cref="FileMode.Append"/>.
/// </exception>
/// <exception cref="IOException">
/// <para><paramref name="mode"/> is <see cref="FileMode.Open"/>, and the stream doesn't exist.</para>
/// <para>-or-</para>
/// <para><paramref name="mode"/> is <see cref="FileMode.CreateNew"/>, and the stream already exists.</para>
/// </exception>
/// <exception cref="SecurityException">
/// The caller does not have the required permission.
/// </exception>
/// <exception cref="UnauthorizedAccessException">
/// The caller does not have the required permission, or the file is read-only.
/// </exception>
public static AlternateDataStreamInfo GetAlternateDataStream(string filePath, string streamName, FileMode mode)
{
if (string.IsNullOrEmpty(filePath))
{
throw new ArgumentNullException("filePath");
}
return(CreateInfo(filePath).GetAlternateDataStream(streamName, mode));
}
public static OpenFlags ToOpenFlags(FileMode mode, FileAccess access)
{
OpenFlags flags = 0;
switch (mode)
{
case FileMode.CreateNew:
flags = OpenFlags.O_CREAT | OpenFlags.O_EXCL;
break;
case FileMode.Create:
flags = OpenFlags.O_CREAT | OpenFlags.O_TRUNC;
break;
case FileMode.Open:
// do nothing
break;
case FileMode.OpenOrCreate:
flags = OpenFlags.O_CREAT;
break;
case FileMode.Truncate:
flags = OpenFlags.O_TRUNC;
break;
case FileMode.Append:
flags = OpenFlags.O_APPEND;
break;
default:
throw new ArgumentException(Locale.GetText("Unsupported mode value"), "mode");
}
// Is O_LARGEFILE supported?
int _v;
if (TryFromOpenFlags(OpenFlags.O_LARGEFILE, out _v))
{
flags |= OpenFlags.O_LARGEFILE;
}
switch (access)
{
case FileAccess.Read:
flags |= OpenFlags.O_RDONLY;
break;
case FileAccess.Write:
flags |= OpenFlags.O_WRONLY;
break;
case FileAccess.ReadWrite:
flags |= OpenFlags.O_RDWR;
break;
default:
throw new ArgumentOutOfRangeException(Locale.GetText("Unsupported access value"), "access");
}
return(flags);
}
/// <summary>
/// Method to create the encryption cipher.
/// </summary>
/// <returns>The encryption cypher.</returns>
private RijndaelManaged CreateCipher()
{
RijndaelManaged aes = new RijndaelManaged();
IsolatedStorageFile isf = null;
try
{
isf = IsolatedStorageFile.GetUserStoreForAssembly();
}
catch (SecurityException)
{
isf = IsolatedStorageFile.GetMachineStoreForAssembly();
}
FileMode fm = FileMode.Open;
FileAccess fa = FileAccess.Read;
if (!isf.FileExists(Constants.CipherFile))
{
fm = FileMode.CreateNew;
fa = FileAccess.ReadWrite;
}
using (IsolatedStorageFileStream ifs = new IsolatedStorageFileStream(Constants.CipherFile, fm, fa, isf))
{
string cipherData = string.Empty;
if (fm == FileMode.Open)
{
using (StreamReader sr = new StreamReader(ifs))
{
cipherData = sr.ReadLine();
string[] cipherInit = cipherData.Split(new char[] { Constants.Pipe });
if (cipherInit.Length == 2)
{
aes.IV = this.rsa.Decrypt(Convert.FromBase64String(cipherInit[0]), true);
aes.Key = this.rsa.Decrypt(Convert.FromBase64String(cipherInit[1]), true);
}
else
{
throw new ArgumentException(Resources.ErrorInvalidCipherData);
}
sr.Close();
}
}
else
{
cipherData = Convert.ToBase64String(this.rsa.Encrypt(aes.IV, true))
+ Constants.Pipe + Convert.ToBase64String(this.rsa.Encrypt(aes.Key, true));
using (StreamWriter sw = new StreamWriter(ifs))
{
sw.WriteLine(cipherData);
sw.Flush();
sw.Close();
}
}
}
return(aes);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:SystemWrapper.IO.FileStreamWrap"/> class with the specified path and creation mode.
/// </summary>
/// <param name="path">A relative or absolute path for the file that the current FileStream object will encapsulate.</param>
/// <param name="mode">A FileMode constant that determines how to open or create the file.</param>
public void Initialize(string path, FileMode mode)
{
FileStreamInstance = new FileStream(path, mode);
}
public EndianIO(string FileLocation, EndianTypes EndianType, FileMode Mode = FileMode.Open, FileAccess Access = FileAccess.ReadWrite, FileShare Share = FileShare.Read) : this(new FileStream(FileLocation, Mode, Access, Share), EndianType)
{
this.FileLocation = FileLocation;
}