public override void Process(Command command)
{
var stream = ((RandomAccessRunLevel)this.Connection.RunLevel).Stream;
Connection.WriteOk("length", stream.Length.ToString());
Connection.Flush();
}
public override void Process(Command command)
{
Exception exception = null;
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
if (options.Length < 0)
{
Connection.WriteError(ErrorCodes.INVALID_PARAM, "LENGTH");
return;
}
if (inputBuffer == null)
{
inputBuffer = new byte[8192];
}
Connection.WriteOk();
Connection.Flush();
var stream = ((RandomAccessRunLevel)this.Connection.RunLevel).Stream;
var toread = options.Length;
using (Connection.AquireBinaryReadContext())
{
while (true)
{
if (toread == 0)
{
break;
}
var x = Connection.ReadStream.Read(inputBuffer, 0, Math.Min(inputBuffer.Length, toread));
if (x == 0)
{
throw new DisconnectedException();
}
try
{
stream.Write(inputBuffer, 0, x);
}
catch (IOException e)
{
exception = e;
}
toread -= x;
}
}
stream.Flush();
if (exception != null)
{
throw exception;
}
}
public override void Process(Command command)
{
var stream = ((RandomAccessRunLevel)Connection.RunLevel).Stream;
Connection.WriteOk("position", stream.Position.ToString());
Connection.Flush();
}
public override void Process(Command command)
{
Connection.WriteOk();
foreach (var s in ((TextCommandProcessorProvider)Connection.CommandProcessorProvider).GetCommandNames().Sorted())
{
Connection.WriteTextBlock(s);
}
}
public override void Process(Command command)
{
var options = this.LoadOptions<CommandOptions>((TextCommand)command);
if (options.Modulus != null && options.Exponent != null && options.Algorithm != null)
{
var symmetric = new RijndaelManaged();
symmetric.GenerateKey();
var modulus = TextConversion.FromBase64String(options.Modulus);
var exponent = TextConversion.FromBase64String(options.Exponent);
var rsaparameters = new RSAParameters();
rsaparameters.Modulus = modulus;
rsaparameters.Exponent = exponent;
var rsa = new RSACryptoServiceProvider();
rsa.ImportParameters(rsaparameters);
var myrsa = new RSACryptoServiceProvider();
rsaparameters = myrsa.ExportParameters(false);
Connection.WriteOk
(
"Modulus",
TextConversion.ToBase64String(rsaparameters.Modulus),
"Exponent",
TextConversion.ToBase64String(rsaparameters.Exponent),
"IV",
TextConversion.ToBase64String(new RSAPKCS1KeyExchangeFormatter(rsa).CreateKeyExchange(symmetric.IV)),
"KeyExchange",
TextConversion.ToBase64String(new RSAPKCS1KeyExchangeFormatter(rsa).CreateKeyExchange(symmetric.Key))
);
Connection.Flush();
if (options.WaitForReady)
{
Connection.ReadReady();
}
}
else if (options.Compress)
{
Connection.WriteOk();
Connection.Flush();
this.Connection.ReadStream = new InteractiveInflaterInputStream(this.Connection.RawReadStream, new Inflater(true));
this.Connection.WriteStream = new InteractiveDeflaterOutputStream(this.Connection.RawWriteStream, new Deflater(Deflater.DEFAULT_COMPRESSION, true), 512);
if (options.WaitForReady)
{
Connection.ReadReady();
}
}
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var stream = ((RandomAccessRunLevel)this.Connection.RunLevel).Stream;
stream.SetLength(options.Length);
Connection.WriteOk("position", stream.Position.ToString(), "length", stream.Length.ToString());
Connection.Flush();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var file = this.Connection.FileSystemManager.ResolveFile(options.Uri);
var ticket = new DownloadTicket(this.Connection, file, (FileShare)Enum.Parse(typeof(FileShare), options.Share, true), options.Offset, options.Length);
Connection.NetworkServer.AddTicket(ticket);
Connection.WriteTextBlock("OK TICKET={0}", ticket.TicketId);
Connection.Flush();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var nodeType = NodeType.FromName(options.NodeType);
var src = this.Connection.FileSystemManager.Resolve(options.Src, nodeType);
var des = this.Connection.FileSystemManager.Resolve(options.Des, nodeType);
src.MoveTo(des, options.Overwrite);
Connection.WriteOk();
Connection.Flush();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var stream = ((RandomAccessRunLevel)this.Connection.RunLevel).Stream;
var origin = (SeekOrigin)Enum.Parse(typeof(SeekOrigin), options.SeekOrigin, true);
stream.Seek(options.Position, origin);
Connection.WriteOk("position", stream.Position.ToString(), "length", stream.Length.ToString());
Connection.Flush();
}
public override void Process(Command command)
{
if (Interlocked.Increment(ref loginCount) % 8 == 0)
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
Connection.WriteOk("message", "LOGIN SUCCESSFUL");
Connection.RunLevel = NormalRunLevel.Default;
}
public override void Process(Command command)
{
Exception e = null;
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var nodeType = NodeType.FromName(options.NodeType);
var node = this.Connection.FileSystemManager.Resolve(options.Uri, nodeType);
node.Refresh();
if (!node.Exists)
{
throw new NodeNotFoundException(node.Address);
}
if (!NodeTypeSupported(node.NodeType))
{
Connection.WriteError(ErrorCodes.INVALID_PARAM);
return;
}
Connection.WriteOk();
Connection.Flush();
using (node.Attributes.AquireUpdateContext())
{
var lastLineRead = new ValueBox<string>();
foreach (var attribute in TextNetworkProtocol.ReadAttributes(Connection.ReadTextBlock, lastLineRead))
{
var attributeName = attribute.Name;
var attributeValue = attribute.Value;
if (!(attributeName.EqualsIgnoreCase("exists") || attributeName.EqualsIgnoreCase("length")))
{
e = ActionUtils.IgnoreExceptions(delegate
{
node.Attributes[attributeName] = attributeValue;
});
}
}
}
if (e != null)
{
throw e;
}
this.Connection.WriteOk();
}
public override void Process(Command command)
{
var list = new List<string>();
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
if (options.ConnectionCount)
{
list.Add("connectioncount");
list.Add(Connection.NetworkServer.ConnectionCount.ToString());
}
Connection.WriteOk(list.ToArray());
Connection.Flush();
}
public override void Process(Command command)
{
Ticket ticket;
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
if (!Connection.NetworkServer.TryGetTicket(options.Ticket, out ticket))
{
this.Connection.WriteError(ErrorCodes.INVALID_VALUE, "TICKET");
return;
}
Connection.NetworkServer.RemoveTicket(ticket.TicketId);
ticket.Claim(Connection);
}
public override void Process(Command command)
{
var options = this.LoadOptions<CommandOptions>((TextCommand)command);
if (StringUtils.IsNullOrEmpty(options.Uri))
{
Connection.WriteError(ErrorCodes.INVALID_VALUE, "uri");
}
var node = this.Connection.FileSystemManager.Resolve(options.Uri, NodeType.FromName(options.NodeType));
node.Create(options.CreateParent);
Connection.WriteOk();
Connection.Flush();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var nodeType = NodeType.FromName(options.NodeType);
var node = this.Connection.FileSystemManager.Resolve(options.Uri, nodeType);
if (node.NodeType.Equals(NodeType.Directory))
{
((IDirectory)node).Delete(options.Recursive);
}
else
{
node.Delete();
}
Connection.WriteOk();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
if (options.Position < 0)
{
Connection.WriteError(ErrorCodes.INVALID_PARAM, "POSITION");
return;
}
var stream = ((RandomAccessRunLevel)this.Connection.RunLevel).Stream;
stream.Position = options.Position;
Connection.WriteOk("position", stream.Position.ToString());
Connection.Flush();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var nodeType = NodeType.FromName(options.NodeType);
var node = this.Connection.FileSystemManager.Resolve(options.Uri, nodeType);
node.Refresh();
this.Connection.WriteOk();
foreach (Pair<string, object> attribute in node.Attributes)
{
if (attribute.Value != null)
{
Connection.WriteTextBlock(@"{0}=""{1}:{2}""", attribute.Name, ProtocolTypes.GetTypeName(attribute.Value.GetType()), ProtocolTypes.ToEscapedString(attribute.Value));
}
}
}
public override void Process(Command command)
{
var options = this.LoadOptions<CommandOptions>((TextCommand)command);
if (StringUtils.IsNullOrEmpty(options.Path))
{
Connection.WriteError(ErrorCodes.INVALID_VALUE, "sourceuri");
}
if (StringUtils.IsNullOrEmpty(options.Target))
{
Connection.WriteError(ErrorCodes.INVALID_VALUE, "targeturi");
}
var src = this.Connection.FileSystemManager.ResolveFile(options.Path);
var target = this.Connection.FileSystemManager.ResolveFile(options.Target);
src.CreateAsHardLink(target, options.Overwrite);
Connection.WriteOk();
Connection.Flush();
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
if (options.Length < 0)
{
Connection.WriteError(ErrorCodes.INVALID_VALUE, "LENGTH");
return;
}
var stream = ((RandomAccessRunLevel)this.Connection.RunLevel).Stream;
if (inputBuffer == null)
{
inputBuffer = new byte[Math.Max(1024 * 1024, options.Length)];
}
else if (inputBuffer.Length < options.Length
&& inputBuffer.Length < 1024 * 1024)
{
inputBuffer = new byte[Math.Max(1024 * 1024, options.Length)];
}
var x = stream.Read(inputBuffer, 0, Math.Min(options.Length, inputBuffer.Length));
Connection.WriteOk("length", x.ToString());
if (options.WaitForReady)
{
Connection.Flush();
Connection.ReadReady();
}
Connection.WriteStream.Write(inputBuffer, 0, x);
Connection.WriteStream.Flush();
Connection.Flush();
}
public override bool SupportsCommand(Command command)
{
if (!(command is TextCommand))
{
return false;
}
foreach (var attribute in attributes)
{
if (attribute.CommandName.EqualsIgnoreCase((command).Name))
{
foreach (string s in attribute.RunLevels)
{
if (AnyRunLevel.Default.Equals(s) || Connection.RunLevel.Equals(s))
{
return true;
}
}
}
}
return false;
}
public override void Process(Command command)
{
IHashingService service;
RandomAccessCommandOptions options;
Stream stream = null;
if (Connection.RunLevel is RandomAccessRunLevel)
{
IFile file;
options = (RandomAccessCommandOptions)LoadOptions(typeof(RandomAccessCommandOptions), (TextCommand)command);
RandomAccessRunLevel randomAccessRunLevel;
randomAccessRunLevel = ((RandomAccessRunLevel)Connection.RunLevel);
file = randomAccessRunLevel.FileNode;
stream = randomAccessRunLevel.Stream;
service = (IHashingService)file.GetService(new StreamHashingServiceType(stream, options.Algorithm));
}
else
{
INode node;
CommandOptions cmdOptions;
options = cmdOptions = (CommandOptions)LoadOptions((TextCommand)command);
var nodeType = TextNetworkProtocol.GetNodeType(options.NodeType);
if (nodeType == NodeType.File)
{
node = Connection.FileSystemManager.Resolve(cmdOptions.Uri, nodeType);
service = (IHashingService)node.GetService(new FileHashingServiceType(options.Algorithm));
}
else if (nodeType == NodeType.Directory)
{
DirectoryHashingServiceType serviceType;
node = Connection.FileSystemManager.Resolve(cmdOptions.Uri, nodeType);
serviceType = new DirectoryHashingServiceType(cmdOptions.Recursive, options.Algorithm);
string[] ss;
cmdOptions.DirAttribs = cmdOptions.DirAttribs.Trim();
if (cmdOptions.DirAttribs.Length > 0)
{
ss = cmdOptions.DirAttribs.Split(',');
if (ss.Length > 0)
{
serviceType.IncludedDirectoryAttributes = ss;
}
}
cmdOptions.FileAttribs = cmdOptions.FileAttribs.Trim();
if (cmdOptions.FileAttribs.Length > 0)
{
ss = cmdOptions.FileAttribs.Trim().Split(',');
if (ss.Length > 0)
{
serviceType.IncludedFileAttributes = ss;
}
}
service = (IHashingService)node.GetService(serviceType);
}
else
{
throw new NotSupportedException("ComputeHash_NodeType_" + options.NodeType);
}
}
var hashResult = service.ComputeHash(options.Offset, options.Length);
if (stream != null)
{
Connection.WriteOk
(
"hash", options.SerializeAsHex ? hashResult.TextValue : hashResult.Base64TextValue,
"offset", hashResult.Offset,
"length", hashResult.Length,
"stream-position", stream.Position
);
}
else
{
Connection.WriteOk
(
"hash", options.SerializeAsHex ? hashResult.TextValue : hashResult.Base64TextValue,
"offset", hashResult.Offset,
"length", hashResult.Length
);
}
Connection.Flush();
}
public override void Process(Command command)
{
var count = 0;
var options = this.LoadOptions<CommandOptions>((TextCommand)command);
var dir = this.Connection.FileSystemManager.ResolveDirectory(options.Uri);
dir.Refresh();
if (options.Regex != null)
{
options.Regex = TextConversion.FromEscapedHexString(options.Regex);
}
if (!dir.Exists)
{
throw new DirectoryNodeNotFoundException(dir.Address);
}
Connection.WriteOk();
if (options.IncludeAttributes)
{
Exception exception = null;
InvocationQueue queue;
if (t_InvocationQueue == null)
{
t_InvocationQueue = new InvocationQueue();
}
queue = t_InvocationQueue;
queue.TaskAsynchronisity = TaskAsynchronisity.AsyncWithSystemPoolThread;
queue.Start();
try
{
IEnumerable<INode> children = null;
if (String.IsNullOrEmpty(options.Regex))
{
children = dir.GetChildren();
}
else
{
children = dir.GetChildren(RegexBasedNodePredicateHelper.New(options.Regex));
}
foreach (var node in children)
{
var enclosedNode = node;
if (queue.TaskState == TaskState.Stopped)
{
break;
}
queue.Enqueue
(
delegate
{
try
{
if (enclosedNode.NodeType == NodeType.Directory)
{
Connection.WriteTextPartialBlock("d:");
}
else
{
Connection.WriteTextPartialBlock("f:");
}
Connection.WriteTextBlock(TextConversion.ToEscapedHexString(enclosedNode.Name, TextConversion.IsStandardUrlEscapedChar));
AttributesCommands.PrintAttributes(this.Connection, enclosedNode);
count++;
if (count % 15 == 0)
{
Connection.Flush();
}
}
catch (Exception e)
{
queue.Stop();
exception = e;
}
}
);
}
if (queue.TaskState == TaskState.Stopped)
{
throw exception;
}
}
finally
{
queue.Enqueue(queue.Stop);
queue.WaitForAnyTaskState(value => value != TaskState.Running);
queue.Reset();
Connection.Flush();
}
}
else
{
IEnumerable<string> children;
if (string.IsNullOrEmpty(options.Regex))
{
children = dir.GetChildNames(NodeType.Directory);
}
else
{
children = dir.GetChildNames(NodeType.Directory, PredicateUtils.NewRegex(options.Regex));
}
foreach (var name in children)
{
Connection.WriteTextPartialBlock("d:");
Connection.WriteTextBlock(TextConversion.ToEscapedHexString(name, TextConversion.IsStandardUrlEscapedChar));
count++;
if (count % 15 == 0)
{
Connection.Flush();
}
}
count = 0;
if (string.IsNullOrEmpty(options.Regex))
{
children = dir.GetChildNames(NodeType.File);
}
else
{
children = dir.GetChildNames(NodeType.File, PredicateUtils.NewRegex(options.Regex));
}
foreach (var name in children)
{
Connection.WriteTextPartialBlock("f:");
Connection.WriteTextBlock(TextConversion.ToEscapedHexString(name));
count++;
if (count % 15 == 0)
{
Connection.Flush();
}
}
}
Connection.Flush();
}
public override void Process(Command command)
{
Connection.WriteOk();
Connection.Flush();
Connection.RunLevel = NormalRunLevel.Default;
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var file = this.Connection.FileSystemManager.ResolveFile(options.Uri);
var content = file.GetContent();
Stream stream = null;
for (int i = 0; i < 16; i++)
{
try
{
stream =
content.OpenStream((FileMode) Enum.Parse(typeof(FileMode), options.Mode, true),
(FileAccess) Enum.Parse(typeof(FileAccess), options.Access, true),
(FileShare) Enum.Parse(typeof(FileShare), options.Share, true));
break;
}
catch (Exception)
{
if (i == 9)
{
throw;
}
System.Threading.Thread.Sleep(150);
}
}
EventHandler closeStream = (sender, eventArgs) => ActionUtils.IgnoreExceptions(delegate
{
if (stream != null)
{
stream.Close();
}
});
try
{
IList<object> list = new List<object>();
Connection.RunLevel = new RandomAccessRunLevel(file, stream);
this.Connection.Closed += closeStream;
list.Add("canread");
list.Add(stream.CanRead);
list.Add("canwrite");
list.Add(stream.CanWrite);
list.Add("canseek");
list.Add(stream.CanSeek);
list.Add("sharing");
list.Add(options.Share);
if (stream.CanSeek)
{
list.Add("length");
list.Add(stream.Length);
}
Connection.WriteOk
(
list.ToArray()
);
if (options.WaitForReady)
{
Connection.Flush();
Connection.ReadReady();
}
}
catch
{
throw;
}
}
public override void Process(Command command)
{
Connection.WriteOk();
Connection.RunLevel = DisconnectedRunLevel.Default;
}
public CommandNotSupportedException(Command command)
: base(command.ToString())
{
Command = command;
}
public override void Process(Command command)
{
TextReader reader;
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var file = this.Connection.FileSystemManager.ResolveFile(options.Uri);
if (!file.Exists)
{
throw new FileNodeNotFoundException(file.Address);
}
if (intputBuffer == null)
{
intputBuffer = new char[256];
}
var buffer = intputBuffer;
var encoding = Encoding.GetEncoding(options.TextEncoding);
Connection.WriteOk();
var noencoding = options.Encoding.Equals("none", StringComparison.CurrentCultureIgnoreCase);
Console.WriteLine("PRINT 1");
Console.WriteLine("file: " + file);
Console.WriteLine("content: " + file.GetContent().GetType());
Console.WriteLine("reader: " + file.GetContent().GetReader(FileShare.ReadWrite));
using (reader = file.GetContent().GetReader(FileShare.ReadWrite))
{
Console.WriteLine("PRINT 2");
while (true)
{
var x = reader.ReadBlock(buffer, 0, buffer.Length);
Console.WriteLine("PRINT 3 " + x);
if (x == 0)
{
break;
}
if (noencoding)
{
Connection.WriteTextPartialBlock(buffer, 0, x);
}
else
{
TextConversion.WriteEscapedHexString
(
new CharArrayReader(buffer, 0, x),
Connection.Writer,
c => c == '<' || c == '>' || c == '\r' || c == '\n'
);
}
Connection.Flush();
}
}
Console.WriteLine("PRINT END");
Connection.WriteTextBlock("");
}
public override void Process(Command command)
{
var options = (CommandOptions)this.LoadOptions((TextCommand)command);
var nodeType = NodeType.FromName(options.NodeType);
var src = this.Connection.FileSystemManager.Resolve(options.Src, nodeType);
var des = this.Connection.FileSystemManager.Resolve(options.Des, nodeType);
if (options.Monitor)
{
var x = 0;
var service = (INodeCopyingService)src.GetService(new NodeCopyingServiceType(des, options.Overwrite, options.BufferSize));
service.Progress.ValueChanged += delegate
{
Connection.WriteTextBlock("{0} {1}", service.Progress.CurrentValue, service.Progress.MaximumValue);
if (x % 8 == 0)
{
Connection.Flush();
}
x++;
};
int okwritten = 0;
Connection.WriteOk();
Action routine = delegate
{
service.Run();
this.Connection.Flush();
//
// Only write OK if the main thread hasn't printed OK/CANCEL
// in response to an a CANCEL request.
//
if (System.Threading.Interlocked.CompareExchange(ref okwritten, 1, 0) == 0)
{
this.Connection.WriteOk();
this.Connection.Flush();
}
};
var result = routine.BeginInvoke(null, null);
//
// Read the special CANCEL and READY commands.
//
var cancelled = false;
for (;;)
{
var line = this.Connection.ReadTextBlock();
if (line == null)
{
this.Connection.RunLevel = DisconnectedRunLevel.Default;
return;
}
if (line.StartsWith(ResponseCodes.READY, StringComparison.CurrentCultureIgnoreCase))
{
//
// READY tells us to process new commands.
//
break;
}
else if (line.StartsWith(ResponseCodes.CANCEL, StringComparison.CurrentCultureIgnoreCase))
{
//
// CANCEL tells us to cancel the operation.
//
// Cancel the operation
if (cancelled)
{
continue;
}
service.Stop();
// Write OK/CANCELED if the operation thread hasn't already
if (System.Threading.Interlocked.CompareExchange(ref okwritten, 1, 0) == 0)
{
if (service.TaskState == Platform.TaskState.Finished)
{
Connection.WriteOk();
}
else
{
Connection.WriteError(ErrorCodes.CANCELLED);
}
Connection.Flush();
}
// Wait for the operation thread to finish
routine.EndInvoke(result);
cancelled = true;
}
else
{
this.Connection.RunLevel = DisconnectedRunLevel.Default;
return;
}
}
Connection.Flush();
}
else
{
// Perform the operation
Connection.WriteOk();
src.CopyTo(des, options.Overwrite);
}
}
public override CommandProcessor GetCommandProcessor(Command command)
{
var list = (IList)commandProcessors[command.Name];
if (list != null)
{
foreach (TextCommandProcessor processor in list)
{
if (processor.SupportsCommand(command))
{
return processor;
}
}
}
throw new CommandNotSupportedException(command);
}
public override void Process(Command command)
{
Connection.WriteOk();
}
