void ProcessStoreMessage()
{
RequestStoreMessage request = RequestStoreMessage.Deserialize(ProtocolParser.ReadBytes(input));
ReplyStoreMessage reply = new ReplyStoreMessage();
localRepo.StoreMessage(request.Prefix, ChunkHash.FromHashBytes(request.ChunkHash));
ProtocolParser.WriteBytes(output, ReplyStoreMessage.SerializeToBytes(reply));
}
public Chunk(byte[] buffer)
{
//Hash data
this.Data = buffer;
this.ClearHash = ClearHash.ComputeHash(buffer);
this.ChunkHash = ChunkHash.FromHashBytes(this.ClearHash.bytes);
}
void ProcessReadChunk()
{
RequestReadChunk request = RequestReadChunk.Deserialize(ProtocolParser.ReadBytes(input));
ReplyReadChunk reply = new ReplyReadChunk();
Chunk c = localRepo.ReadChunk(ChunkHash.FromHashBytes(request.ChunkHash));
reply.ChunkData = c.Data;
ProtocolParser.WriteBytes(output, ReplyReadChunk.SerializeToBytes(reply));
}
public override ChunkHash GetCustomHash(CustomID id)
{
string idPath = Path.Combine(idRoot, id.ToString() + ".id");
if (File.Exists(idPath) == false)
{
return(null);
}
byte[] hash = File.ReadAllBytes(idPath);
return(ChunkHash.FromHashBytes(hash));
}
public static void Main(string[] args, KeyStorage keyStorage)
{
if (args.Length != 4)
{
throw new HelpException("Missing arguments");
}
//Storage
Repo repo = Repo.Create(args [1]);
repo = new EncryptedRepo(repo, keyStorage);
//Find message
Chunk chunk = null;
if (args [2].Length == 64)
{
ChunkHash id = ChunkHash.FromHashBytes(Hash.FromString(args [2]).bytes);
chunk = repo.ReadChunk(id);
}
else
{
ICollection <ChunkHash> messages = repo.GetMessageList("file");
foreach (ChunkHash bh in messages)
{
if (bh.ToString().StartsWith(args [2]))
{
chunk = repo.ReadChunk(bh);
}
}
}
Message message = Message.FromChunk(chunk, keyStorage);
if (message == null)
{
Console.Error.WriteLine("Message not found");
return;
}
TreeMessage tm = message as TreeMessage;
if (tm == null)
{
Console.Error.WriteLine("Not a TreeMessage: " + message.GetType().Name);
return;
}
Console.WriteLine("Found TreeMessage " + tm.Name);
string targetPath = Path.Combine(args [3], tm.Name);
TreeChunk.Extract(repo, ChunkHash.FromHashBytes(tm.TreeChunkHash), targetPath);
}
public override List <ChunkHash> GetMessageList(string prefix)
{
RequestMessageList msg = new RequestMessageList(prefix);
SendMessage(msg);
ReplyMessageList reply = ReplyMessageList.Deserialize(ProtocolParser.ReadBytes(input));
List <ChunkHash> list = new List <ChunkHash> ();
foreach (byte[] hash in reply.ChunkHash)
{
list.Add(ChunkHash.FromHashBytes(hash));
}
return(list);
}
public override ChunkHash GetCustomHash(CustomID customID)
{
RequestCustomHash msg = new RequestCustomHash();
msg.CustomID = customID.bytes;
SendMessage(msg);
byte[] rbytes = ProtocolParser.ReadBytes(input);
//Console.WriteLine("Got reply " + rbytes.Length);
ReplyCustomHash reply = ReplyCustomHash.Deserialize(rbytes);
//Console.WriteLine("Got reply " + reply);
return(ChunkHash.FromHashBytes(reply.ChunkHash));
}
public static void Extract(Repo store, ChunkHash cid, string targetPath)
{
Directory.CreateDirectory(targetPath);
Chunk c = store.ReadChunk(cid);
TreeChunk tree = TreeChunk.Deserialize(c.Data);
foreach (TreeFile file in tree.Files)
{
StreamChunk.Extract(store, ChunkHash.FromHashBytes(file.TreeChunkHash), Path.Combine(targetPath, file.Name));
}
foreach (TreeFile subdir in tree.Directories)
{
TreeChunk.Extract(store, ChunkHash.FromHashBytes(subdir.TreeChunkHash), Path.Combine(targetPath, subdir.Name));
}
}
public static void Extract(Repo store, ChunkHash fileHash, string targetPath)
{
Chunk chunk = store.ReadChunk(fileHash);
StreamChunk streamChunk = StreamChunk.Deserialize <StreamChunk> (chunk.Data);
using (FileStream file = File.Open(targetPath, FileMode.Create)) {
foreach (byte[] hashBytes in streamChunk.Chunks)
{
Chunk fc = store.ReadChunk(ChunkHash.FromHashBytes(hashBytes));
file.Write(fc.Data, 0, fc.Data.Length);
}
//Verify length
if (file.Length != (long)streamChunk.Size)
{
throw new InvalidDataException("Invalid file length");
}
}
}
