mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-11-24 22:06:59 +01:00
278 lines
9.3 KiB
C#
278 lines
9.3 KiB
C#
/* Copyright (c) Citrix Systems, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms,
|
|
* with or without modification, are permitted provided
|
|
* that the following conditions are met:
|
|
*
|
|
* * Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the
|
|
* following disclaimer in the documentation and/or other
|
|
* materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
|
|
* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
namespace CommandLib
|
|
{
|
|
/// <summary>
|
|
/// Thrown if we fail to verify a tar header checksum
|
|
/// </summary>
|
|
public class HeaderChecksumFailed : ApplicationException
|
|
{
|
|
private uint expected;
|
|
private uint received;
|
|
|
|
public HeaderChecksumFailed(uint expected, uint received)
|
|
{
|
|
this.expected = expected;
|
|
this.received = received;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
string expected = Convert.ToString(this.expected);
|
|
string received = Convert.ToString(this.received);
|
|
|
|
return "Failed to verify the tar header checksum: received = " + received + "; expected = " + expected;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Thrown when we find the end of archive marker (two zero blocks)
|
|
/// </summary>
|
|
class EndOfArchive : ApplicationException
|
|
{
|
|
public EndOfArchive()
|
|
{
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return "End of tar archive";
|
|
}
|
|
}
|
|
|
|
public class Header
|
|
{
|
|
public string file_name;
|
|
public int file_mode;
|
|
public int user_id;
|
|
public int group_id;
|
|
public uint file_size;
|
|
public uint mod_time;
|
|
public bool link;
|
|
public int link_name;
|
|
|
|
/* Length of a header block */
|
|
public static uint length = 512;
|
|
|
|
/* http://en.wikipedia.org/w/index.php?title=Tar_%28file_format%29&oldid=83554041 */
|
|
private static int file_name_off = 0;
|
|
private static int file_name_len = 100;
|
|
private static int file_mode_off = 100;
|
|
private static int file_mode_len = 8;
|
|
private static int user_id_off = 108;
|
|
private static int user_id_len = 8;
|
|
private static int group_id_off = 116;
|
|
private static int group_id_len = 8;
|
|
private static int file_size_off = 124;
|
|
private static int file_size_len = 12;
|
|
private static int mod_time_off = 136;
|
|
private static int mod_time_len = 12;
|
|
private static int chksum_off = 148;
|
|
private static int chksum_len = 8;
|
|
private static int link_off = 156;
|
|
private static int link_len = 1;
|
|
private static int link_name_off = 156;
|
|
private static int link_name_len = 100;
|
|
|
|
/// <summary>
|
|
/// True if a buffer contains all zeroes
|
|
/// </summary>
|
|
public static bool all_zeroes(byte[] buffer)
|
|
{
|
|
bool zeroes = true;
|
|
for (int i = 0; i < buffer.Length && zeroes; i++)
|
|
{
|
|
if (buffer[i] != 0) zeroes = false;
|
|
}
|
|
|
|
return zeroes;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return a sub-array of bytes
|
|
/// </summary>
|
|
private byte[] slice(byte[] input, int offset, int length)
|
|
{
|
|
byte[] result = new byte[length];
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
result[i] = input[offset + i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Remove NULLs and spaces from the end of a string
|
|
/// </summary>
|
|
private string trim_trailing_stuff(string x)
|
|
{
|
|
char[] trimmed = {'\0', ' '};
|
|
return x.TrimEnd(trimmed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert the byte array into a string (assume UTF8)
|
|
/// </summary>
|
|
private string unmarshal_string(byte[] buffer)
|
|
{
|
|
Decoder decoder = Encoding.UTF8.GetDecoder();
|
|
char[] chars = new char[decoder.GetCharCount(buffer, 0, (int)buffer.Length)];
|
|
decoder.GetChars(buffer, 0, (int)buffer.Length, chars, 0);
|
|
return trim_trailing_stuff(new string(chars));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unmarshal an octal string into an int32
|
|
/// </summary>
|
|
private uint unmarshal_int32(byte[] buffer)
|
|
{
|
|
string octal = "0" + unmarshal_string(buffer);
|
|
return System.Convert.ToUInt32(octal, 8);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unmarshal an octal string into an int
|
|
/// </summary>
|
|
private int unmarshal_int(byte[] buffer)
|
|
{
|
|
string octal = "0" + unmarshal_string(buffer);
|
|
return System.Convert.ToInt32(octal, 8);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recompute the (weak) header checksum
|
|
/// </summary>
|
|
private uint compute_checksum(byte[] buffer)
|
|
{
|
|
uint total = 0;
|
|
for (int i = 0; i < buffer.Length; i++)
|
|
{
|
|
/* treat the checksum digits as ' ' */
|
|
if ((i >= chksum_off) && (i < (chksum_off + chksum_len)))
|
|
{
|
|
total += 32; /* ' ' */
|
|
}
|
|
else
|
|
{
|
|
total += buffer[i];
|
|
}
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Compute the required length of padding data to follow the data payload
|
|
/// </summary>
|
|
public uint paddingLength()
|
|
{
|
|
/* round up to the next whole number of blocks */
|
|
uint next_block_length = (file_size + length - 1) / length * length;
|
|
return next_block_length - file_size;
|
|
}
|
|
|
|
/// <summary>
|
|
/// pretty-print a header
|
|
/// </summary>
|
|
public override string ToString()
|
|
{
|
|
return String.Format("{0}/{1} {2:000000000000} {3:000000000000} {4}",
|
|
user_id, group_id, file_size, mod_time, file_name);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unmarshal a header from a buffer, throw an exception if the checksum doesn't validate
|
|
/// </summary>
|
|
public Header(byte[] buffer)
|
|
{
|
|
file_name = unmarshal_string(slice(buffer, file_name_off, file_name_len));
|
|
file_mode = unmarshal_int(slice(buffer, file_mode_off, file_mode_len));
|
|
user_id = unmarshal_int(slice(buffer, user_id_off, user_id_len));
|
|
group_id = unmarshal_int(slice(buffer, group_id_off, group_id_len));
|
|
file_size = unmarshal_int32(slice(buffer, file_size_off, file_size_len));
|
|
mod_time = unmarshal_int32(slice(buffer, mod_time_off, mod_time_len));
|
|
link = unmarshal_string(slice(buffer, link_off, link_len)) == "1";
|
|
link_name = unmarshal_int(slice(buffer, link_name_off, link_name_len));
|
|
|
|
uint chksum = unmarshal_int32(slice(buffer, chksum_off, chksum_len));
|
|
uint recomputed = compute_checksum(buffer);
|
|
if (chksum != recomputed)
|
|
throw new HeaderChecksumFailed(recomputed, chksum);
|
|
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read a tar header from a stream
|
|
/// </summary>
|
|
public static Header fromStream(Stream input)
|
|
{
|
|
byte[] one = IO.unmarshal_n(input, length);
|
|
if (all_zeroes(one))
|
|
{
|
|
byte[] two = IO.unmarshal_n(input, length);
|
|
if (all_zeroes(two))
|
|
throw new EndOfArchive();
|
|
return new Header(two);
|
|
}
|
|
|
|
return new Header(one);
|
|
}
|
|
}
|
|
|
|
public class Archive
|
|
{
|
|
public static void list(Stream stream)
|
|
{
|
|
try
|
|
{
|
|
while (true)
|
|
{
|
|
Header x = Header.fromStream(stream);
|
|
Console.WriteLine(x);
|
|
IO.skip(stream, x.file_size);
|
|
IO.skip(stream, x.paddingLength());
|
|
}
|
|
|
|
}
|
|
catch (EndOfArchive)
|
|
{
|
|
Console.WriteLine("EOF");
|
|
}
|
|
}
|
|
}
|
|
}
|