public List<String> StripLines(InputStream text) {
ByteArrayOutputStream out = new ByteArrayOutputStream();
byte[] chunk = new byte[8192];
int count = 0;
while ((count = text.read(chunk)) != -1) {
out.write(chunk, 0, count);
}
public override object Deserialize(Stream inputStream)
{
Initialize();
var input = new InputStream(inputStream);
var reader = new CompactBinaryReader<InputStream>(input);
return _deserializerStream.Deserialize(reader);
}
public static void Main(string[] args)
{
InputStream input = new InputStream("source.c");
BytecodeStream output = new BytecodeStream();
Compiler compiler = new Compiler();
compiler.Compile(input, output);
}
public void Init(IStreamHost host)
{
this.host = host;
this.image = host.CreateInputStream<ImageStream>("Stream In");
this.width = host.CreateOutput<int>("Output 1");
}
public void Init(IStreamHost host)
{
this.host = host;
this.i1 = host.CreateInputStream<DoubleStream>("Stream In");
this.o1 = host.CreateOutput<double>("Output 1");
}
public override object Deserialize(Stream stream)
{
var input = new InputStream(stream);
var reader = new CompactBinaryReader<InputStream>(input);
return Bond.Deserialize<object>.From(reader);
//return _deserializer.Deserialize(reader);
}
public void WriteData_NoWindowUpdate()
{
int invokeCount = 0;
InputStream input = new InputStream(100, delta => { invokeCount++; });
input.Write(new byte[50], 0, 50);
Assert.Equal(0, invokeCount);
}
private static string convertStreamToString(InputStream @is)
{
BufferedReader reader = new BufferedReader(new InputStreamReader(@is));
StringBuilder sb = new StringBuilder();
string line = null;
try
{
while ((line = reader.ReadLine()) != null)
{
sb.Append((line + "\n"));
}
}
catch (IOException e)
{
Log.W("LOG", e.GetMessage());
}
finally
{
try
{
@is.Close();
}
catch (IOException e)
{
Log.W("LOG", e.GetMessage());
}
}
return sb.ToString();
}
public SslTransportHandler(ITransportLayerHandler next, IServerParameters serverParameters)
{
_next = next;
_serverParameters = serverParameters;
_inputStream = new InputStream(this);
next.Callback = this;
}
public SslTransportHandler(ITransportLayerHandler next, X509Certificate serverCertificate)
{
_next = next;
_serverCertificate = serverCertificate;
_inputStream = new InputStream(this);
next.Callback = this;
}
public override object Deserialize(Stream inputStream)
{
Initialize();
inputStream.Seek(0, SeekOrigin.Begin);
var input = new InputStream(inputStream);
var reader = new FastBinaryReader<InputStream>(input);
return _deserializerStream.Deserialize(reader);
}
public void Init(IStreamHost host)
{
this.host = host;
this.image = host.CreateInputStream<ImageStream>("Stream In");
this.frm = new Form();
this.frm.Show();
frm.Paint += new PaintEventHandler(frm_Paint);
}
public SslTransportHandler(ITransportLayerHandler next, X509Certificate serverCertificate, SslProtocols protocols, bool clientCertificateRequired)
{
_protocols = protocols;
_clientCertificateRequired = clientCertificateRequired;
_next = next;
_serverCertificate = serverCertificate;
_inputStream = new InputStream(this);
next.Callback = this;
}
public void WriteMoreThanCreditedData_NoException()
{
int invokeCount = 0;
InputStream input = new InputStream(50, delta => { invokeCount++; });
input.Write(new byte[100], 0, 100);
Assert.Equal(0, invokeCount);
int read = input.Read(new byte[1000], 0, 1000);
Assert.Equal(100, read);
}
public void CreateGhostObject(InputStream input)
{
// Create Ghost
Transform p = (Transform)Instantiate(ghost, transform.localPosition, transform.localRotation);
p.parent = GameObject.Find("/Ghosts").transform;
p.gameObject.layer = LayerMask.NameToLayer("Ghost");
InputStreamReaderWriter control = p.GetComponent<InputStreamReaderWriter>();
control.input = input;
}
/// <summary>
/// Creates a <code>PushbackInputStream</code>
/// with a pushback buffer of the specified <code>size</code>,
/// and saves its argument, the input stream
/// <code>in</code>, for later use.
/// </summary>
/// <remarks>
/// Creates a <code>PushbackInputStream</code>
/// with a pushback buffer of the specified <code>size</code>,
/// and saves its argument, the input stream
/// <code>in</code>, for later use. Initially,
/// there is no pushed-back byte (the field
/// <code>pushBack</code> is initialized to
/// <code>-1</code>).
/// </remarks>
/// <param name="in">the input stream from which bytes will be read.</param>
/// <param name="size">the size of the pushback buffer.</param>
/// <exception>
/// IllegalArgumentException
/// if size is <= 0
/// </exception>
/// <since>JDK1.1</since>
public PushbackInputStream(InputStream @in, int size)
: base(@in)
{
if (size <= 0)
{
throw new System.ArgumentException("size <= 0");
}
this.buf = new byte[size];
this.pos = size;
}
private void AddGhostData(InputStream input)
{
if(input == null
|| input.Count == 0)
{
return;
}
input.Trim();
ghostData.Add(input);
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
Match match = regex.Match(stream.Content);
if (match.Success)
{
token = GetToken(match.Value);
return stream.Move(match.Value.Length);
}
return stream;
}
public void Init(IStreamHost host)
{
this.host = host;
this.testinputstream = host.CreateInputStream<IBaseStream>("Stream In");
this.testoutputstream = host.CreateOutputStream<IBaseStream>("Stream Out");
this.p1 = host.CreateParameter<double>("Param 1");
this.p2 = host.CreateParameter<double>("Param 2");
this.testoutdata = host.CreateOutput<double>("Out 1");
}
public void WriteAndReadData_WindowUpdate()
{
int invokeCount = 0;
int aggregate = 0;
InputStream input = new InputStream(100, delta => { invokeCount++; aggregate += delta; });
input.Write(new byte[50], 0, 50);
int read = input.Read(new byte[10], 0, 10);
Assert.Equal(1, invokeCount);
Assert.Equal(read, aggregate);
Assert.Equal(10, aggregate);
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
if (stream.Content.StartsWith(str))
{
token = this.token;
return stream.Move(str.Length);
}
return stream;
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
if (stream.Content[0] == c)
{
token = this.token;
return stream.Move(1);
}
return stream;
}
public void Lexer_returns_literals_and_skips_whitespace()
{
var inputStream = new InputStream<char, Token>(new Position<char>(0, new CharacterStream("1 2.3 'a' \"bef\"")), new TacoLexer().Produce);
var tokens = inputStream.Range(0, 5).ToArray();
Assert.That(tokens[0], Is.TypeOf<LiteralToken<int>>());
Assert.That(tokens[0], Has.Property("Value").EqualTo(1));
Assert.That(tokens[1], Is.TypeOf<LiteralToken<double>>());
Assert.That(tokens[1], Has.Property("Value").EqualTo(2.3));
Assert.That(tokens[2], Is.TypeOf<LiteralToken<char>>());
Assert.That(tokens[2], Has.Property("Value").EqualTo('a'));
Assert.That(tokens[3], Is.TypeOf<LiteralToken<string>>());
Assert.That(tokens[3], Has.Property("Value").EqualTo("bef"));
Assert.That(tokens[4], Is.Null);
}
public void StreamPositionLengthTest()
{
const int _50MB = 50*1024*1024;
var from1 = Random.Init<Containers>();
var from2 = Random.Init<Containers>();
var stream = new MemoryStream();
var output = new OutputStream(stream, 11);
var writer = new CompactBinaryWriter<OutputStream>(output);
Assert.IsTrue(output.Position == 0);
Serialize.To(writer, from1);
var pos = output.Position;
output.Flush();
Assert.IsTrue(output.Position == pos);
Assert.IsTrue(output.Position == stream.Length);
output.Position = _50MB;
Serialize.To(writer, from2);
output.Flush();
pos = output.Position;
stream.Position = 0;
var input = new InputStream(stream);
var reader = new CompactBinaryReader<InputStream>(input);
Assert.IsTrue(input.Position == stream.Position);
Assert.IsTrue(input.Length == stream.Length);
var to1 = Deserialize<Containers>.From(reader);
Assert.IsTrue(from1.IsEqual<Containers>(to1));
Assert.IsTrue(input.Length == stream.Length);
input.Position = _50MB;
var to2 = Deserialize<Containers>.From(reader);
Assert.IsTrue(from2.IsEqual<Containers>(to2));
Assert.IsTrue(input.Position == pos);
}
/// <summary>
/// Initializes a newly
/// created <code>SequenceInputStream</code>
/// by remembering the two arguments, which
/// will be read in order, first <code>s1</code>
/// and then <code>s2</code>, to provide the
/// bytes to be read from this <code>SequenceInputStream</code>.
/// </summary>
/// <remarks>
/// Initializes a newly
/// created <code>SequenceInputStream</code>
/// by remembering the two arguments, which
/// will be read in order, first <code>s1</code>
/// and then <code>s2</code>, to provide the
/// bytes to be read from this <code>SequenceInputStream</code>.
/// </remarks>
/// <param name="s1">the first input stream to read.</param>
/// <param name="s2">the second input stream to read.</param>
public SequenceInputStream(InputStream s1, InputStream s2)
{
System.Collections.Generic.List<InputStream> v = new System.Collections.Generic.List<InputStream>(2);
v.Add(s1);
v.Add(s2);
e = v.GetEnumerator();
try
{
nextStream();
}
catch (System.IO.IOException)
{
// This should never happen
throw new System.Exception("panic");
}
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
foreach (var function in Functions)
{
if (stream.Content.StartsWith(function.Name))
{
FunctionCallToken functionToken = new FunctionCallToken { Method = function.Method };
token = functionToken;
return stream.Move(function.Name.Length);
}
}
return stream;
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
foreach (var parameterName in parameterNames)
{
if (stream.Content.StartsWith(parameterName))
{
ParameterToken paramToken = new ParameterToken(parameterName);
token = paramToken;
return stream.Move(parameterName.Length);
}
}
return stream;
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
char firstChar = stream.Content[0];
if (firstChar == ' ' ||
firstChar == '\t' ||
firstChar == '\n' ||
firstChar == '\r')
{
token = new WhitespaceToken();
return stream.Move(1);
}
return stream;
}
public override InputStream TryRead(InputStream stream, out LexicToken token)
{
token = null;
foreach (var constant in Constants)
{
if (stream.Content.StartsWith(constant.Name))
{
NamedConstantToken constantToken = new NamedConstantToken(constant.Name, constant.Value);
token = constantToken;
return stream.Move(constant.Name.Length);
}
}
return stream;
}
public void Compile(InputStream input, BytecodeStream output)
{
// creating scanner from InputStream
Scanner scanner = new Scanner(input);
// creating builder for abstract syntax tree
ProgramNodeBuilder builder = new ProgramNodeBuilder();
// creating Parser
Parser parser = new Parser();
// parsing using scanner and builder, hence creating AST
parser.Parse(scanner, builder);
// creating target code generator
RISCCodeGenerator generator = new RISCCodeGenerator(output);
// retrieving abstract syntax tree from builder
ProgramNode parseTree = builder.GetRootNode();
// generating target code from AST and generator
parseTree.Traverse(generator);
Console.WriteLine("compilation complete");
}
/// <summary>Constructor.</summary>
public SimpleCharStream(InputStream dstream, int startline, int startcolumn, int buffersize)
: this(new InputStreamReader(dstream), startline, startcolumn, buffersize)
{
}
public IImage newImage(string fileName, ImageFormat format)
{
Bitmap.Config config = null;
if (format == ImageFormat.RGB565)
{
config = Bitmap.Config.RGB_565;
}
else if (format == ImageFormat.ARGB4444)
{
config = Bitmap.Config.ARGB_4444;
}
else
{
config = Bitmap.Config.ARGB_8888;
}
var options = new BitmapFactory.Options();
options.InPreferredConfig = config;
InputStream @in = null;
Bitmap bitmap;
try
{
@in = assets.Open(assetsPrefix + fileName);
bitmap = BitmapFactory.DecodeStream(@in, null, options);
if (bitmap == null)
{
throw new SystemException("Couldn't load bitmap from asset '" + fileName + "'");
}
}
catch (IOException e)
{
throw new SystemException("Couldn't load bitmap from asset '" + fileName + "'");
}
finally
{
if (@in != null)
{
try
{
@in.Close();
}
catch (IOException e)
{
}
}
}
if (bitmap.GetConfig() == Bitmap.Config.RGB_565)
{
format = ImageFormat.RGB565;
}
else if (bitmap.GetConfig() == Bitmap.Config.ARGB_4444)
{
format = ImageFormat.ARGB4444;
}
else
{
format = ImageFormat.ARGB8888;
}
return(new AndroidImage(bitmap, format));
}
public override bool EndOfBlock()
{
return(InputStream.PeekChar() == -1);
}
/// <summary>Constructor.</summary>
public SimpleCharStream(InputStream dstream)
: this(dstream, 1, 1, 4096)
{
}
public static long skipNative(InputStream @is, long howmuch)
{
return(@is.skip(howmuch));
}
public virtual TLObject <bridge> deserializeResponse(InputStream @is, TLContext tlc) => this.deserializeResponse(@is, tlc);
public override void deserializeBody(InputStream stream, TLContext context)
{
this.peer = StreamingUtils.readTLObject(stream, context);
this.randomId = StreamingUtils.readLong(stream);
this.data = StreamingUtils.readTLBytes(stream, context);
}
/// <summary>Reinitialise.</summary>
public virtual void ReInit(InputStream dstream)
{
ReInit(dstream, 1, 1, 4096);
}
/// <summary>Reinitialise.</summary>
/// <exception cref="Java.IO.UnsupportedEncodingException"/>
public virtual void ReInit(InputStream dstream, string encoding)
{
ReInit(dstream, encoding, 1, 1, 4096);
}
/// <exception cref="System.IO.IOException"></exception>
public override PackParser NewPackParser(InputStream @in)
{
throw new NotSupportedException();
}
public void InitStream(InputStream onlineSource)
{
_stream = onlineSource;
}
/// <summary>Creates an Append executor.</summary>
/// <param name="is">input stream to append.</param>
/// <param name="path">path of the file to append.</param>
public FSAppend(InputStream @is, string path)
{
this.@is = @is;
this.path = new Path(path);
}
/// <summary>Constructor.</summary>
public SimpleCharStream(InputStream dstream, int startline, int startcolumn)
: this(dstream, startline, startcolumn, 4096)
{
}
public override void deserializeBody(InputStream stream, TLContext context)
{
base.photos = StreamingUtils.readTLVector(stream, context);
base.users = StreamingUtils.readTLVector(stream, context);
}
public static int readBytesNative(InputStream @is, ref sbyte[] data, int offset, int length)
{
return(@is.read(data, offset, length));
}
/// <summary>Initialize a tee input stream.</summary>
/// <remarks>Initialize a tee input stream.</remarks>
/// <param name="src">source stream to consume.</param>
/// <param name="dst">
/// destination to copy the source to as it is consumed. Typically
/// this is a
/// <see cref="NGit.Util.TemporaryBuffer">NGit.Util.TemporaryBuffer</see>
/// .
/// </param>
public TeeInputStream(InputStream src, OutputStream dst)
{
this.src = src;
this.dst = dst;
}
public override void deserializeBody(InputStream stream, TLContext context)
{
this.session_id = Long.valueOf(StreamingUtils.readLong(stream));
}
/// <summary>Constructor.</summary>
/// <exception cref="Java.IO.UnsupportedEncodingException"/>
public SimpleCharStream(InputStream dstream, string encoding)
: this(dstream, encoding, 1, 1, 4096)
{
}
public static Lattice readSlf(InputStream stream)
{
Lattice lattice = new Lattice();
LineNumberReader lineNumberReader = new LineNumberReader(new InputStreamReader(stream));
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 1;
double num5 = 9.5;
string text;
while ((text = lineNumberReader.readLine()) != null)
{
string text2 = text;
object obj = "Node definitions";
CharSequence charSequence = CharSequence.Cast(obj);
if (String.instancehelper_contains(text2, charSequence))
{
num2 = 0;
num = 1;
}
else
{
string text3 = text;
obj = "Link definitions";
charSequence = CharSequence.Cast(obj);
if (String.instancehelper_contains(text3, charSequence))
{
num2 = 1;
num = 0;
}
else if (!String.instancehelper_startsWith(text, "#"))
{
if (num != 0)
{
string[] array = String.instancehelper_split(text, "\\s+");
if (array.Length != 3 || !String.instancehelper_startsWith(array[0], "I=") || !String.instancehelper_startsWith(array[1], "t=") || !String.instancehelper_startsWith(array[2], "W="))
{
lineNumberReader.close();
string text4 = new StringBuilder().append("Unknown node definition: ").append(text).toString();
throw new IOException(text4);
}
int num6 = Integer.parseInt(String.instancehelper_substring(array[0], 2));
long beginTime = ByteCodeHelper.d2l(Double.parseDouble(String.instancehelper_substring(array[1], 2)) * 1000.0);
string text5 = String.instancehelper_substring(array[2], 2);
int isFiller = 0;
if (num6 == num3 || String.instancehelper_equals(text5, "!ENTER"))
{
text5 = "<s>";
isFiller = 1;
}
if (num6 == num4 || String.instancehelper_equals(text5, "!EXIT"))
{
text5 = "</s>";
isFiller = 1;
}
if (String.instancehelper_equals(text5, "!NULL"))
{
text5 = "<sil>";
isFiller = 1;
}
if (String.instancehelper_startsWith(text5, "["))
{
isFiller = 1;
}
Word word = new Word(text5, new Pronunciation[0], isFiller != 0);
Node node = lattice.addNode(Integer.toString(num6), word, beginTime, -1L);
if (String.instancehelper_equals(text5, "<s>"))
{
lattice.setInitialNode(node);
}
if (String.instancehelper_equals(text5, "</s>"))
{
lattice.setTerminalNode(node);
}
}
else if (num2 != 0)
{
string[] array = String.instancehelper_split(text, "\\s+");
if (array.Length != 5 || !String.instancehelper_startsWith(array[1], "S=") || !String.instancehelper_startsWith(array[2], "E=") || !String.instancehelper_startsWith(array[3], "a=") || !String.instancehelper_startsWith(array[4], "l="))
{
lineNumberReader.close();
string text6 = new StringBuilder().append("Unknown edge definition: ").append(text).toString();
throw new IOException(text6);
}
string text7 = String.instancehelper_substring(array[1], 2);
string text8 = String.instancehelper_substring(array[2], 2);
double acousticScore = Double.parseDouble(String.instancehelper_substring(array[3], 2));
double lmScore = Double.parseDouble(String.instancehelper_substring(array[4], 2)) * num5;
lattice.addEdge((Node)lattice.nodes.get(text7), (Node)lattice.nodes.get(text8), acousticScore, lmScore);
}
else
{
if (String.instancehelper_startsWith(text, "start="))
{
string text9 = text;
object obj2 = "start=";
obj = "";
object obj3 = obj2;
charSequence = CharSequence.Cast(obj3);
CharSequence charSequence2 = charSequence;
obj3 = obj;
charSequence = CharSequence.Cast(obj3);
num3 = Integer.parseInt(String.instancehelper_replace(text9, charSequence2, charSequence));
}
if (String.instancehelper_startsWith(text, "end="))
{
string text10 = text;
object obj4 = "end=";
object obj3 = "";
obj = obj4;
charSequence = CharSequence.Cast(obj);
CharSequence charSequence3 = charSequence;
obj = obj3;
charSequence = CharSequence.Cast(obj);
num4 = Integer.parseInt(String.instancehelper_replace(text10, charSequence3, charSequence));
}
if (String.instancehelper_startsWith(text, "lmscale="))
{
string text11 = text;
object obj5 = "lmscale=";
obj = "";
object obj3 = obj5;
charSequence = CharSequence.Cast(obj3);
CharSequence charSequence4 = charSequence;
obj3 = obj;
charSequence = CharSequence.Cast(obj3);
num5 = Double.parseDouble(String.instancehelper_replace(text11, charSequence4, charSequence));
}
}
}
}
}
Iterator iterator = lattice.nodes.values().iterator();
while (iterator.hasNext())
{
Node node2 = (Node)iterator.next();
Iterator iterator2 = node2.getLeavingEdges().iterator();
while (iterator2.hasNext())
{
Edge edge = (Edge)iterator2.next();
if (node2.getEndTime() < 0L || node2.getEndTime() > edge.getToNode().getBeginTime())
{
node2.setEndTime(Math.max(edge.getToNode().getBeginTime(), node2.getBeginTime()));
}
}
}
return(lattice);
}
/// <param name="in">the patch to apply</param>
/// <returns>this instance</returns>
public virtual NGit.Api.ApplyCommand SetPatch(InputStream @in)
{
CheckCallable();
this.@in = @in;
return(this);
}
/// <summary>
/// Creates a new <code>JarInputStream</code> and reads the optional
/// manifest. If a manifest is present, also attempts to verify
/// the signatures if the JarInputStream is signed. </summary>
/// <param name="in"> the actual input stream </param>
/// <exception cref="IOException"> if an I/O error has occurred </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public JarInputStream(InputStream in) throws IOException
public JarInputStream(InputStream @in) : this(@in, true)
{
}
public RandomAccessStreamReader([NotNull] InputStream stream)
: this(stream, DefaultChunkLength)
{
}
public override void deserializeBody(InputStream stream, TLContext context)
{
this.title = StreamingUtils.readTLString(stream);
this.users = StreamingUtils.readTLIntVector(stream, context);
}
bool PerformHandshake(InputStream buffer, bool encrypted)
{
if (!ValidateClient(buffer))
{
if (encrypted || _pProtocolHandler.ValidateHandshake)
{
Logger.FATAL("Unable to validate client");
return(false);
}
else
{
Logger.WARN("Client not validated");
_validationScheme = 0;
}
}
_pOutputBuffer = Utils.GenerateRandomBytes(3072);
_pOutputBuffer.Write(0, (uint)DateTime.Now.SecondsFrom1970());
_pOutputBuffer.Write(0, (uint)0);
var serverBytes = Encoding.ASCII.GetBytes(Defines.HTTP_HEADERS_SERVER_US);
for (var i = 0; i < 10; i++)
{
var index = Utils.Random.Next(0, 3072 - Defines.HTTP_HEADERS_SERVER_US_LEN);
Buffer.BlockCopy(serverBytes, 0, _pOutputBuffer, index, serverBytes.Length);
}
var _pOutputBufferWithOffset = new BufferWithOffset(_pOutputBuffer);
var pInputBuffer = new BufferWithOffset(buffer);
var serverDHOffset = GetDHOffset(_pOutputBufferWithOffset, _validationScheme);
var clientDHOffset = GetDHOffset(pInputBuffer, _validationScheme);
var dhWrapper = new DHWrapper();
var pubKeyIn = new byte[128];
Buffer.BlockCopy(buffer.GetBuffer(), (int)(buffer.Position + clientDHOffset), pubKeyIn, 0, 128);
var sharedkey = dhWrapper.CreateSharedKey(pubKeyIn);
var pubKeyOut = dhWrapper.PublicKey;
Buffer.BlockCopy(pubKeyOut, 0, _pOutputBuffer, (int)serverDHOffset, 128);
if (encrypted)
{
_pKeyIn = new RC4_KEY();
_pKeyOut = new RC4_KEY();
Utils.InitRC4Encryption(sharedkey, pubKeyIn, pubKeyOut, _pKeyIn, _pKeyOut);
var data = new byte[1536];
Utils.RC4(data, _pKeyIn, 1536);
Utils.RC4(data, _pKeyOut, 1536);
}
var serverDigestOffset = GetDigestOffset(_pOutputBufferWithOffset, _validationScheme);
var pTempBuffer = new byte[1536 - 32];
Buffer.BlockCopy(_pOutputBuffer, 0, pTempBuffer, 0, (int)serverDigestOffset);
Buffer.BlockCopy(_pOutputBuffer, (int)serverDigestOffset + 32, pTempBuffer, (int)serverDigestOffset, (int)(1536 - serverDigestOffset - 32));
var pTempHash = HMACsha256(pTempBuffer, 1536 - 32, GenuineFmsKey, 36);
Buffer.BlockCopy(pTempHash, 0, _pOutputBuffer, (int)serverDigestOffset, 32);
var keyChallengeIndex = GetDigestOffset(pInputBuffer, _validationScheme);
pInputBuffer.Offset += (int)keyChallengeIndex;
pTempHash = HMACsha256(pInputBuffer, 32, GenuineFmsKey, 68);
Buffer.BlockCopy(_pOutputBuffer, 1536, pTempBuffer, 0, 1536 - 32);
pTempBuffer = new HMACSHA256(pTempHash).ComputeHash(pTempBuffer, 0, 1536 - 32);
Buffer.BlockCopy(pTempBuffer, 0, _pOutputBuffer, 1536 * 2 - 32, 32);
OutputBuffer.WriteByte((byte)(encrypted ? 6 : 3));
OutputBuffer.Write(_pOutputBuffer, 0, 3072);
buffer.Recycle(true);
if (!EnqueueForOutbound(OutputBuffer))
{
Logger.FATAL("Unable to signal outbound data");
return(false);
}
_rtmpState = RTMPState.RTMP_STATE_SERVER_RESPONSE_SENT;
return(true);
}
/// <summary>Create a new transport to fetch objects from a streamed bundle.</summary>
/// <remarks>
/// Create a new transport to fetch objects from a streamed bundle.
/// <p>
/// The stream can be unbuffered (buffering is automatically provided
/// internally to smooth out short reads) and unpositionable (the stream is
/// read from only once, sequentially).
/// <p>
/// When the FetchConnection or the this instance is closed the supplied
/// input stream is also automatically closed. This frees callers from
/// needing to keep track of the supplied stream.
/// </remarks>
/// <param name="db">repository the fetched objects will be loaded into.</param>
/// <param name="uri">
/// symbolic name of the source of the stream. The URI can
/// reference a non-existent resource. It is used only for
/// exception reporting.
/// </param>
/// <param name="in">the stream to read the bundle from.</param>
public TransportBundleStream(Repository db, URIish uri, InputStream @in) : base(db
, uri)
{
src = @in;
}
/// <summary>
/// Releases the unmanaged resources used by the <see cref="TnefReader"/> and
/// optionally releases the managed resources.
/// </summary>
/// <remarks>
/// Releases the unmanaged resources used by the <see cref="TnefReader"/> and
/// optionally releases the managed resources.
/// </remarks>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources;
/// <c>false</c> to release only the unmanaged resources.</param>
protected virtual void Dispose(bool disposing)
{
InputStream.Dispose();
}
/// <summary>Reinitialise.</summary>
/// <exception cref="Java.IO.UnsupportedEncodingException"/>
public virtual void ReInit(InputStream dstream, string encoding, int startline, int startcolumn, int buffersize)
{
ReInit(encoding == null ? new InputStreamReader(dstream) : new InputStreamReader(dstream, encoding), startline, startcolumn, buffersize);
}
/// <summary>Constructor.</summary>
/// <exception cref="Java.IO.UnsupportedEncodingException"/>
public SimpleCharStream(InputStream dstream, string encoding, int startline, int startcolumn, int buffersize)
: this(encoding == null ? new InputStreamReader(dstream) : new InputStreamReader(dstream, encoding), startline, startcolumn, buffersize)
{
}
/// <summary>Reinitialise.</summary>
public virtual void ReInit(InputStream dstream, int startline, int startcolumn, int buffersize)
{
ReInit(new InputStreamReader(dstream), startline, startcolumn, buffersize);
}
/// <exception cref="System.IO.IOException"></exception>
public override ObjectId Insert(int objectType, long length, InputStream @in)
{
throw new NotSupportedException();
}
