public void BlockData()
{
byte[] testData = new byte[(512 * 1024) + 21];
for (int i = 0; i < testData.Length; ++i)
{
testData[i] = (byte)(i % 33);
}
MemoryStream fsImage = new MemoryStream();
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
builder.AddFile(@"file", new MemoryStream(testData));
builder.Build(fsImage);
SquashFileSystemReader reader = new SquashFileSystemReader(fsImage);
using (Stream fs = reader.OpenFile("file", FileMode.Open))
{
byte[] buffer = new byte[(512 * 1024) + 1024];
int numRead = fs.Read(buffer, 0, buffer.Length);
Assert.Equal(testData.Length, numRead);
for (int i = 0; i < testData.Length; ++i)
{
Assert.Equal(testData[i], buffer[i] /*, "Data differs at index " + i*/);
}
}
}
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "Creating SquashFS file: '{0}'", FileName.ItemSpec);
try
{
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
foreach (var sourceFile in SourceFiles)
{
if (this.RemoveRoot != null)
{
string location = (sourceFile.GetMetadata("FullPath")).Replace(this.RemoveRoot.GetMetadata("FullPath"), string.Empty);
builder.AddFile(location, sourceFile.GetMetadata("FullPath"));
}
else
{
builder.AddFile(sourceFile.GetMetadata("Directory") + sourceFile.GetMetadata("FileName") + sourceFile.GetMetadata("Extension"), sourceFile.GetMetadata("FullPath"));
}
}
builder.Build(FileName.ItemSpec);
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return(false);
}
return(!Log.HasLoggedErrors);
}
public void Detect()
{
MemoryStream ms = new MemoryStream(new byte[1000]);
Assert.False(SquashFileSystemReader.Detect(ms));
ms = new MemoryStream(new byte[10]);
Assert.False(SquashFileSystemReader.Detect(ms));
MemoryStream emptyFs = new MemoryStream();
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
builder.Build(emptyFs);
Assert.True(SquashFileSystemReader.Detect(emptyFs));
}
public void CreateDirs()
{
MemoryStream fsImage = new MemoryStream();
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
builder.AddFile(@"\adir\anotherdir\file", new MemoryStream(new byte[] { 1, 2, 3, 4 }));
builder.Build(fsImage);
SquashFileSystemReader reader = new SquashFileSystemReader(fsImage);
Assert.True(reader.DirectoryExists(@"adir"));
Assert.True(reader.DirectoryExists(@"adir\anotherdir"));
Assert.True(reader.FileExists(@"adir\anotherdir\file"));
}
public void SingleFile()
{
MemoryStream fsImage = new MemoryStream();
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
builder.AddFile("file", new MemoryStream(new byte[] { 1, 2, 3, 4 }));
builder.Build(fsImage);
SquashFileSystemReader reader = new SquashFileSystemReader(fsImage);
Assert.Equal(1, reader.GetFileSystemEntries("\\").Length);
Assert.Equal(4, reader.GetFileLength("file"));
Assert.True(reader.FileExists("file"));
Assert.False(reader.DirectoryExists("file"));
Assert.False(reader.FileExists("otherfile"));
}
public void FragmentData()
{
MemoryStream fsImage = new MemoryStream();
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
builder.AddFile(@"file", new MemoryStream(new byte[] { 1, 2, 3, 4 }));
builder.Build(fsImage);
SquashFileSystemReader reader = new SquashFileSystemReader(fsImage);
using (Stream fs = reader.OpenFile("file", FileMode.Open))
{
byte[] buffer = new byte[100];
int numRead = fs.Read(buffer, 0, 100);
Assert.Equal(4, numRead);
Assert.Equal(1, buffer[0]);
Assert.Equal(2, buffer[1]);
Assert.Equal(3, buffer[2]);
Assert.Equal(4, buffer[3]);
}
}
public void Defaults()
{
MemoryStream fsImage = new MemoryStream();
SquashFileSystemBuilder builder = new SquashFileSystemBuilder();
builder.AddFile(@"file", new MemoryStream(new byte[] { 1, 2, 3, 4 }));
builder.AddDirectory(@"dir");
builder.DefaultUser = 1000;
builder.DefaultGroup = 1234;
builder.DefaultFilePermissions = UnixFilePermissions.OwnerAll;
builder.DefaultDirectoryPermissions = UnixFilePermissions.GroupAll;
builder.AddFile("file2", new MemoryStream());
builder.AddDirectory("dir2");
builder.Build(fsImage);
SquashFileSystemReader reader = new SquashFileSystemReader(fsImage);
Assert.Equal(0, reader.GetUnixFileInfo("file").UserId);
Assert.Equal(0, reader.GetUnixFileInfo("file").GroupId);
Assert.Equal(UnixFilePermissions.OwnerRead | UnixFilePermissions.OwnerWrite | UnixFilePermissions.GroupRead | UnixFilePermissions.GroupWrite, reader.GetUnixFileInfo("file").Permissions);
Assert.Equal(0, reader.GetUnixFileInfo("dir").UserId);
Assert.Equal(0, reader.GetUnixFileInfo("dir").GroupId);
Assert.Equal(UnixFilePermissions.OwnerAll | UnixFilePermissions.GroupRead | UnixFilePermissions.GroupExecute | UnixFilePermissions.OthersRead | UnixFilePermissions.OthersExecute, reader.GetUnixFileInfo("dir").Permissions);
Assert.Equal(1000, reader.GetUnixFileInfo("file2").UserId);
Assert.Equal(1234, reader.GetUnixFileInfo("file2").GroupId);
Assert.Equal(UnixFilePermissions.OwnerAll, reader.GetUnixFileInfo("file2").Permissions);
Assert.Equal(1000, reader.GetUnixFileInfo("dir2").UserId);
Assert.Equal(1234, reader.GetUnixFileInfo("dir2").GroupId);
Assert.Equal(UnixFilePermissions.GroupAll, reader.GetUnixFileInfo("dir2").Permissions);
}
public static int Run(Options opts)
{
RunHelpers(opts);
switch (opts.FileSystem)
{
case "SquashFS":
case "ISO":
break;
default:
Logger.Error("Requested file system is not supported (Requested {0}, supported: ISO, SquashFS)", opts.FileSystem);
WaitForUserExit();
return(INVALID_ARGUMENT);
}
Logger.Info("Gathering files image \"{0}\"", opts.Path);
var fileList = new LinkedList <FileInfo>();
var fileSize = 0L;
Action <DirectoryInfo> recursiveFileIndexer = null;
recursiveFileIndexer = new Action <DirectoryInfo>((parentDir) =>
{
try
{
foreach (var file in parentDir.GetFiles())
{
fileSize += file.Length + ((file.Length % 4096) == 0 ? 0 : 4096 - (file.Length % 4096));
fileList.AddLast(file);
}
}
catch (IOException) { }
catch (UnauthorizedAccessException) { }
try
{
foreach (var subDir in parentDir.GetDirectories())
{
Logger.Verbose("Advancing recursion into \"{0}\"", subDir.FullName);
recursiveFileIndexer(subDir);
}
}
catch (IOException) { }
catch (UnauthorizedAccessException) { }
});
recursiveFileIndexer(new DirectoryInfo(opts.Directory));
Logger.Info("Creating image \"{0}\"", opts.Path);
var imageStream = OpenPath(opts.Path,
FileMode.Create,
FileAccess.ReadWrite,
FileShare.None);
if (opts.Offset > 0)
{
imageStream = new OffsetableStream(imageStream, opts.Offset);
}
switch (opts.FileSystem)
{
case "SquashFS":
{
var builder = new SquashFileSystemBuilder();
LoopFiles((path, stream) => builder.AddFile(path, stream), opts.Directory, fileList);
Logger.Info("Finishing building SquashFS image...");
builder.Build(imageStream);
break;
}
case "ISO":
{
var builder = new CDBuilder();
LoopFiles((path, stream) => builder.AddFile(path, stream), opts.Directory, fileList);
Logger.Info("Finishing building ISO image...");
builder.Build(imageStream);
break;
}
default:
return(INVALID_ARGUMENT);
}
Logger.Info("Done!");
Cleanup(imageStream);
WaitForUserExit();
return(SUCCESS);
}
