public Example_19()
{
try {
FileStream fos = new FileStream("Example_19.pdf", FileMode.Create);
BufferedStream bos = new BufferedStream(fos);
PDF pdf = new PDF( bos );
FileStream fis = new FileStream( "Example_03.pdf", FileMode.Open );
// FileInputStream fis = new FileInputStream( "PDF32000_2008.pdf" );
BufferedStream bis = new BufferedStream( fis );
List< PDFobj > objects = pdf.read(bis);
for ( int j = 0; j < objects.Count; j++ ) {
PDFobj obj = ( PDFobj ) objects[j];
for ( int i = 0; i < obj.dict.Count; i++ ) {
Console.WriteLine(obj.dict[i]);
}
Console.WriteLine();
}
bis.Close();
pdf.Flush();
bos.Close();
}
catch ( Exception e ) {
Console.WriteLine(e.StackTrace);
}
}
/**
* Writes a file from the contents of a String
* @param filename The name of the file.
* @return The String to write to the file.
*/
public static void writeFile(string filename, string contents)
{
FileStream fs = null;
BufferedStream bs = null;
StreamWriter sw = null;
try
{
fs = new FileStream(filename, FileMode.Open);
// Here BufferedInputStream is added for fast writing.
bs = new BufferedStream(fs);
sw = new StreamWriter(bs);
sw.Write(contents);
// dispose all the resources after using them.
fs.Close();
bs.Close();
sw.Close();
}
catch (FileNotFoundException e)
{
System.Console.WriteLine(e.ToString());
}
catch (IOException e)
{
System.Console.WriteLine(e.ToString());
}
}
public async Task ShouldNotFlushUnderlyingStreamIfReadOnly(bool underlyingCanSeek)
{
var underlying = new DelegateStream(
canReadFunc: () => true,
canWriteFunc: () => false,
canSeekFunc: () => underlyingCanSeek,
readFunc: (_, __, ___) => 123,
writeFunc: (_, __, ___) =>
{
throw new NotSupportedException();
},
seekFunc: (_, __) => 123L
);
var wrapper = new CallTrackingStream(underlying);
var buffered = new BufferedStream(wrapper);
buffered.ReadByte();
buffered.Flush();
Assert.Equal(0, wrapper.TimesCalled(nameof(wrapper.Flush)));
await buffered.FlushAsync();
Assert.Equal(0, wrapper.TimesCalled(nameof(wrapper.FlushAsync)));
}
public static void Main()
{
var bs = new BufferedStream(Console.OpenStandardInput());
StreamReader reader = new StreamReader(bs);
Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
string[] ss = reader.ReadLine().Split();
double t = double.Parse(ss[0]);
List<int> w = reader.ReadLine().Split().Select(x => int.Parse(x)).OrderBy(x => x).ToList();
int res = max_cuts + 47, left = int.Parse(ss[1]);
foreach (int q in w)
{
for (int i = 1; i <= max_cuts; i++)
{
double big = q / (double)i;
var cut = w.Select(x => new {Count = Math.Ceiling(x / big), Length = x});
if (cut.Min(y => y.Length / y.Count) >= t * big)
{
double cnt = cut.Sum(y => y.Count - 1);
if (cnt < res) res = (int)cnt;
}
}
left--;
}
Console.WriteLine(res);
}
public void TestBuffering(long length, int internalBufferCount, int clientBufferCount)
{
var random = new Random();
var remoteData = new byte[length];
random.NextBytes(remoteData);
var buffer = new byte[clientBufferCount];
var clientData = new List<byte>();
Func<long, byte[], int> reader = (remoteOffset, buff) =>
{
int toRead = Math.Min(buff.Length, (int)(length - remoteOffset));
Buffer.BlockCopy(remoteData, (int) remoteOffset, buff, 0, toRead);
return toRead;
};
var bufferedStream = new BufferedStream(length, reader, internalBufferCount);
while (true)
{
int read = bufferedStream.Read(buffer, 0, buffer.Length);
clientData.AddRange(buffer.Take(read));
if(read==0)
break;
}
Assert.Equal(remoteData, clientData);
}
protected string invokeGetRequest(string requestUrl, string contentType)
{
string completeUrl = requestUrl;
string responseString;
try
{
HttpWebRequest request1 = WebRequest.Create(completeUrl) as HttpWebRequest;
request1.ContentType = contentType;
request1.Method = @"GET";
HttpWebResponse httpWebResponse = (HttpWebResponse)request1.GetResponse();
using (BufferedStream buffer = new BufferedStream(httpWebResponse.GetResponseStream()))
{
using (StreamReader reader = new StreamReader(buffer))
{
responseString = reader.ReadToEnd();
}
}
//StreamReader reader = new StreamReader(httpWebResponse.GetResponseStream());
//string responseString = reader.ReadToEnd();
return responseString;
}
catch (WebException ex)
{
//reading the custom messages sent by the server
using (var reader = new StreamReader(ex.Response.GetResponseStream()))
{
return reader.ReadToEnd();
}
}
catch (Exception ex)
{
return "Failed with exception message:" + ex.Message;
}
}
public async Task ShouldAlwaysFlushUnderlyingStreamIfWritable(bool underlyingCanRead, bool underlyingCanSeek)
{
var underlying = new DelegateStream(
canReadFunc: () => underlyingCanRead,
canWriteFunc: () => true,
canSeekFunc: () => underlyingCanSeek,
readFunc: (_, __, ___) => 123,
writeFunc: (_, __, ___) => { },
seekFunc: (_, __) => 123L
);
var wrapper = new CallTrackingStream(underlying);
var buffered = new BufferedStream(wrapper);
buffered.Flush();
Assert.Equal(1, wrapper.TimesCalled(nameof(wrapper.Flush)));
await buffered.FlushAsync();
Assert.Equal(1, wrapper.TimesCalled(nameof(wrapper.FlushAsync)));
buffered.WriteByte(0);
buffered.Flush();
Assert.Equal(2, wrapper.TimesCalled(nameof(wrapper.Flush)));
await buffered.FlushAsync();
Assert.Equal(2, wrapper.TimesCalled(nameof(wrapper.FlushAsync)));
}
static void Main(string[] args)
{
using (FileStream fs = new FileStream(input, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (BufferedStream bs = new BufferedStream(fs))
{
using (StreamReader _in = new StreamReader(bs))
{
using (StreamWriter _out = new StreamWriter(output))
{
string line;
while ((line = _in.ReadLine()) != null)
{
if (wholeWordOnly)
{
_out.WriteLine(Regex.Replace(line, @"\bstart\b", "finish"));
}
else
{
_out.WriteLine(line.Replace("start", "finish"));
}
}
}
}
}
}
}
public static void SetPositionToNegativeValue_Throws_ArgumentOutOfRangeException()
{
using (BufferedStream stream = new BufferedStream(new MemoryStream()))
{
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Position = -1);
}
}
private void Connect()
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
SendTimeout = SendTimeout,
ReceiveTimeout = ReceiveTimeout
};
try
{
if (ConnectTimeout == 0)
{
socket.Connect(Host, Port);
}
else
{
var connectResult = socket.BeginConnect(Host, Port, null, null);
connectResult.AsyncWaitHandle.WaitOne(ConnectTimeout, true);
}
if (!socket.Connected)
{
socket.Close();
socket = null;
return;
}
Bstream = new BufferedStream(new NetworkStream(socket), 16 * 1024);
if (Password != null)
SendExpectSuccess(Commands.Auth, Password.ToUtf8Bytes());
db = 0;
var ipEndpoint = socket.LocalEndPoint as IPEndPoint;
clientPort = ipEndpoint != null ? ipEndpoint.Port : -1;
lastCommand = null;
lastSocketException = null;
LastConnectedAtTimestamp = Stopwatch.GetTimestamp();
if (isPreVersion1_26 == null)
{
isPreVersion1_26 = this.ServerVersion.CompareTo("1.2.6") <= 0;
}
if (ConnectionFilter != null)
{
ConnectionFilter(this);
}
}
catch (SocketException ex)
{
if (socket != null)
socket.Close();
socket = null;
HadExceptions = true;
var throwEx = new RedisException("could not connect to redis Instance at " + Host + ":" + Port, ex);
log.Error(throwEx.Message, ex);
throw throwEx;
}
}
public bool runTest()
{
Console.WriteLine(s_strTFPath + "\\" + s_strTFName + " , for " + s_strClassMethod + " , Source ver " + s_strDtTmVer);
int iCountErrors = 0;
int iCountTestcases = 0;
String strLoc = "Loc_000oo";
String strValue = String.Empty;
try
{
BinaryWriter sr2;
MemoryStream ms2;
FileStream fs2;
BufferedStream bs2;
String filName = s_strTFAbbrev+"Test.tmp";
if(File.Exists(filName))
File.Delete(filName);
strLoc = "Loc_98hg7";
ms2 = new MemoryStream();
sr2 = new BinaryWriter(ms2);
iCountTestcases++;
if(sr2.BaseStream != ms2) {
iCountErrors++;
printerr( "Error_g57hb! Incorrect basestream");
}
sr2.Close();
ms2 = new MemoryStream();
bs2 = new BufferedStream(ms2);
sr2 = new BinaryWriter(bs2);
iCountTestcases++;
if(sr2.BaseStream != bs2) {
iCountErrors++;
printerr( "Error_988hu! Incorrect basestream");
}
sr2.Close();
fs2 = new FileStream(filName, FileMode.Create);
sr2 = new BinaryWriter(fs2);
iCountTestcases++;
if(sr2.BaseStream != fs2) {
iCountErrors++;
printerr( "Error_29g87! Incorrect baseStream");
}
sr2.Close();
if(File.Exists(filName))
File.Delete(filName);
} catch (Exception exc_general ) {
++iCountErrors;
Console.WriteLine (s_strTFAbbrev + " : Error Err_8888yyy! strLoc=="+ strLoc +", exc_general=="+exc_general.ToString());
}
if ( iCountErrors == 0 )
{
Console.WriteLine( "paSs. "+s_strTFName+" ,iCountTestcases=="+iCountTestcases.ToString());
return true;
}
else
{
Console.WriteLine("FAiL! "+s_strTFName+" ,iCountErrors=="+iCountErrors.ToString()+" , BugNums?: "+s_strActiveBugNums );
return false;
}
}
public Example_01()
{
FileStream fos = new FileStream("Example_01.pdf", FileMode.Create);
BufferedStream bos = new BufferedStream(fos);
PDF pdf = new PDF(bos);
pdf.setCompressor(Compressor.ORIGINAL_ZLIB);
Page page = new Page(pdf, Letter.PORTRAIT);
Box flag = new Box();
flag.SetPosition(100.0, 100.0);
flag.SetSize(190.0, 100.0);
flag.SetColor(RGB.WHITE);
flag.DrawOn(page);
double sw = 7.69; // stripe width
Line stripe = new Line(0.0, sw/2, 190.0, sw/2);
stripe.SetWidth(sw);
stripe.SetColor(RGB.OLD_GLORY_RED);
for (int row = 0; row < 7; row++) {
stripe.PlaceIn(flag, 0.0, row * 2 * sw);
stripe.DrawOn(page);
}
Box union = new Box();
union.SetSize(76.0, 53.85);
union.SetColor(RGB.OLD_GLORY_BLUE);
union.SetFillShape(true);
union.PlaceIn(flag, 0.0, 0.0);
union.DrawOn(page);
double h_si = 12.6; // horizontal star interval
double v_si = 10.8; // vertical star interval
Point star = new Point(h_si/2, v_si/2);
star.SetShape(Point.STAR);
star.SetRadius(3.0);
star.SetColor(RGB.WHITE);
star.SetFillShape(true);
for (int row = 0; row < 6; row++) {
for (int col = 0; col < 5; col++) {
star.PlaceIn(union, row * h_si, col * v_si);
star.DrawOn(page);
}
}
star.SetPosition(h_si, v_si);
for (int row = 0; row < 5; row++) {
for (int col = 0; col < 4; col++) {
star.PlaceIn(union, row * h_si, col * v_si);
star.DrawOn(page);
}
}
pdf.Flush();
bos.Close();
}
private static void StartWavAnalyze(string strFileName,long nLength)
{
using (FileStream fs = new FileStream(strFileName,FileMode.Open,FileAccess.Read))
using (BufferedStream bs = new BufferedStream(fs,nBufferSize))
using (BinaryReader r = new BinaryReader(bs))
{
StartWavAnalyze(r,nLength);
}
}
public Example_04()
{
String fileName = "data/happy-new-year.txt";
FileStream fos = new FileStream("Example_04.pdf", FileMode.Create);
BufferedStream bos = new BufferedStream(fos);
PDF pdf = new PDF(bos);
pdf.setCompressor(Compressor.ORIGINAL_ZLIB);
Font f1 = new Font(
pdf,
"AdobeMingStd-Light", // Chinese (Traditional) font
CodePage.UNICODE);
Font f2 = new Font(
pdf,
"AdobeSongStd-Light", // Chinese (Simplified) font
CodePage.UNICODE);
Font f3 = new Font(
pdf,
"KozMinProVI-Regular", // Japanese font
CodePage.UNICODE);
Font f4 = new Font(
pdf,
"AdobeMyungjoStd-Medium", // Korean font
CodePage.UNICODE);
Page page = new Page(pdf, Letter.PORTRAIT);
f1.SetSize(14);
f2.SetSize(14);
f3.SetSize(14);
f4.SetSize(14);
double x_pos = 100.0;
double y_pos = 20.0;
StreamReader reader = new StreamReader(
new FileStream(fileName, FileMode.Open));
TextLine text = new TextLine(f1);
String line = null;
while ((line = reader.ReadLine()) != null) {
if (line.IndexOf("Simplified") != -1) {
text.SetFont(f2);
} else if (line.IndexOf("Japanese") != -1) {
text.SetFont(f3);
} else if (line.IndexOf("Korean") != -1) {
text.SetFont(f4);
}
text.SetText(line);
text.SetPosition(x_pos, y_pos += 24);
text.DrawOn(page);
}
reader.Close();
pdf.Flush();
bos.Close();
}
public static void StreamThroughWaveFile(string sFileName,IReadWaveData objCallback)
{
using (FileStream fs = new FileStream(sFileName,FileMode.Open,FileAccess.Read))
using (BufferedStream bs = new BufferedStream(fs, nBufferSize))
using (BinaryReader r = new BinaryReader(bs))
{
StreamThroughWaveFile(r, objCallback);
}
}
public static void Main()
{
var bs = new BufferedStream(Console.OpenStandardInput());
StreamReader reader = new StreamReader(bs);
string[] ss = reader.ReadLine().Split();
int n = int.Parse(ss[0]), k = int.Parse(ss[1]);
List<int> a = reader.ReadLine().Split().Select(x => int.Parse(x) - 1).ToList();
var cycles = Enumerable.Range(0, n).Select(x => new List<List<int>>()).ToArray();
bool[] seen = new bool[n];
foreach (int i in Enumerable.Range(0, n))
if (!seen[i])
{
List<int> cyc = new List<int> ();
int u = i;
do {
cyc.Add(u);
seen[u] = true;
u = a[u];
} while (u != i);
cycles[cyc.Count].Add(cyc);
}
Dictionary<int, int> pow = factor(k).ToDictionary(x => x.Prime, x => x.Power);
List<int> res = Enumerable.Repeat(-1, n).ToList();
foreach (var group in cycles.Where(x => x.Count > 0))
{
int len = group.First().Count;
int need = len == 1 ?
gcd(k, group.Count) : // we want to avoid self-loops
factor(len)
.Where(f => pow.ContainsKey(f.Prime))
.Select(f => pow[f.Prime])
.Aggregate(1, (x, y) => x * y);//multiply everything
if (group.Count % need == 0)
for (int i = 0; i < group.Count; i += need)
{
List<int> cyc = new List<int> ();
foreach (int l in Enumerable.Range(0, len))
foreach (int j in Enumerable.Range(0, need))
cyc.Add(group[i + j][l]);
int move = inverse(k / need % len, len);
foreach (int j in Enumerable.Range(0, cyc.Count))
res[cyc[j]] = cyc[(j + move) % cyc.Count];
}
}
if (res.Any(x => x == -1))
Console.WriteLine("Impossible");
else
Console.WriteLine(string.Join(" ", res.Select(x => x + 1)));
}
public List<string> GetAllData()
{
string line = "";
string input_file = "./Saved Data/characters.xml";
List<string> keyList = new List<string>();
List<string> elemList = new List<string>();
UnicodeEncoding encoding = new UnicodeEncoding();
byte[] key = null;
RijndaelManaged RMCrypto = new RijndaelManaged();
string tagID;
string tagIDend;
int indexStart = 0;
int indexEnd = 0;
key = encoding.GetBytes(Data_Handler_Key.keyvalue);
FileStream decrypted_file = new FileStream(input_file, FileMode.Open);
CryptoStream cryptography_stream = new CryptoStream(decrypted_file, RMCrypto.CreateDecryptor(key, key), CryptoStreamMode.Read);
using (MemoryStream msDecrypt = new MemoryStream())
{
using (BufferedStream readBuffer = new BufferedStream(cryptography_stream))
using (StreamReader srDecrypt = new StreamReader(readBuffer))
{
while ((line = srDecrypt.ReadLine()) != null)
{
elemList.Add(line);
}
}
}
cryptography_stream.Close();
decrypted_file.Close();
tagID = "<id>" + Character_Info.id + "</id>";
tagIDend = "<idend>" + Character_Info.id + "</idend>";
int i = 0;
foreach(var content in elemList)
{
if(content == tagID)
{
indexStart = i;
}
if(content == tagIDend)
{
indexEnd = i;
}
i++;
}
if (indexStart != indexEnd)
{
elemList.RemoveRange(indexStart, indexEnd - indexStart);
}
elemList.Remove("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
elemList.Remove("<savedcharacters>");
elemList.Remove("</savedcharacters>");
return elemList;
}
public static void Main()
{
string path = @"..\..\Files\Start.txt";
string pathResult = @"..\..\Files\Result.txt";
Console.WriteLine("Loading...");
try
{
if (File.Exists(path))
{
File.Delete(path);
}
int bufferSize = 10485760; //10MB buffer size
using (StreamWriter sw = new StreamWriter(path, true))
{
for (long i = 0; i < 5000000; i++) //if you want 100mb files make it 1 000 000
{
sw.WriteLine("This is some text to test");
sw.WriteLine("Reading repeated 500 time");
sw.WriteLine(" TEST TEXT:");
sw.WriteLine("testTextstart with startstart start");
}
}
using (FileStream fs = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (BufferedStream bs = new BufferedStream(fs, bufferSize))
{
using (StreamWriter result = new StreamWriter(pathResult, false))
{
using (StreamReader sr = new StreamReader(bs))
{
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
// result.WriteLine(line.Replace("start", "finish")); // ex. 07
result.WriteLine(Regex.Replace(line, @"\bstart\b", "finish")); //ex. 08
}
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine("Operation failed: \n {0}", e.ToString());
}
Console.WriteLine("Success -> check Files dir in project");
}
static void Main(string[] args)
{
// Check that an argument was specified when the
// program was invoked.
//if (args.Length == 0)
//{
// Console.WriteLine("Error: The name of the host computer" +
// " must be specified when the program is invoked.");
// return;
//}
// string remoteName = args[0];
// Create the underlying socket and connect to the server.
Console.WriteLine("OS {0} {1} processors count {2}\n", Environment.OSVersion, Environment.Is64BitOperatingSystem ? "x64" : "x32", Environment.ProcessorCount);
Socket clientSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
clientSocket.Connect(new IPEndPoint(
IPAddress.Parse("127.0.0.1"), 1800));
Console.WriteLine("Client is connected.\n");
// Create a NetworkStream that owns clientSocket and
// then create a BufferedStream on top of the NetworkStream.
// Both streams are disposed when execution exits the
// using statement.
using (Stream
netStream = new NetworkStream(clientSocket, true),
bufStream =
new BufferedStream(netStream, streamBufferSize))
{
// Check whether the underlying stream supports seeking.
Console.WriteLine("NetworkStream {0} seeking.\n",
bufStream.CanSeek ? "supports" : "does not support");
// Send and receive data.
if (bufStream.CanWrite)
{
SendData(netStream, bufStream);
}
if (bufStream.CanRead)
{
ReceiveData(netStream, bufStream);
}
// When bufStream is closed, netStream is in turn
// closed, which in turn shuts down the connection
// and closes clientSocket.
Console.WriteLine("\nShutting down the connection.");
bufStream.Close();
}
Console.ReadKey();
}
public void UnderlyingStreamThrowsExceptions()
{
var stream = new BufferedStream(new ThrowsExceptionFromAsyncOperationsStream());
Assert.Equal(TaskStatus.Faulted, stream.ReadAsync(new byte[1], 0, 1).Status);
Assert.Equal(TaskStatus.Faulted, stream.WriteAsync(new byte[10000], 0, 10000).Status);
stream.WriteByte(1);
Assert.Equal(TaskStatus.Faulted, stream.FlushAsync().Status);
}
public static void Main()
{
var bs = new BufferedStream(Console.OpenStandardInput());
StreamReader reader = new StreamReader(bs);
int n = int.Parse(reader.ReadLine());
List<int> a = reader.ReadLine().Split().Select(x => int.Parse(x))
.OrderByDescending(x => x).ToList();
Console.WriteLine(Enumerable.Range(0, n - 1).Max(i => i + a[i] + 2));
}
public static void Write_Arguments()
{
using (BufferedStream stream = new BufferedStream(new MemoryStream()))
{
byte[] array = new byte[10];
Assert.Throws<ArgumentNullException>("array", () => stream.Write(null, 1, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Write(array, -1, 1));
Assert.Throws<ArgumentOutOfRangeException>(() => stream.Write(array, 1, -1));
Assert.Throws<ArgumentException>(() => stream.Write(array, 9, 2));
}
}
public static void SetLength_NegativeValue()
{
using (MemoryStream underlying = new MemoryStream())
using (BufferedStream stream = new BufferedStream(underlying))
{
Assert.Throws<ArgumentOutOfRangeException>(() => stream.SetLength(-1));
stream.SetLength(1);
Assert.Equal(1, underlying.Length);
Assert.Equal(1, stream.Length);
}
}
public static void StreamThroughWave(string strFileName, long length)
{
if (!File.Exists(strFileName))
throw new Exception("File not found.");
using (FileStream fs = new FileStream(strFileName, FileMode.Open, FileAccess.Read))
using (BufferedStream bs = new BufferedStream(fs, 32768))
using (BinaryReader r = new BinaryReader(bs))
{
StreamThroughWave(r, length);
}
}
/// <summary>
/// Gets the chunk data.
/// </summary>
/// <returns>The chunk data.</returns>
/// <param name="x">The x coordinate.</param>
/// <param name="z">The z coordinate.</param>
/// <param name="width">Width.</param>
/// <param name="height">Height.</param>
/// <param name="depth">Depth.</param>
public CubicTerrainData GetChunkData(int x, int y, int z, int width, int height, int depth)
{
BufferedStream chunkDataStream = new BufferedStream (File.Open (this.chunkDataFile, FileMode.Open));
CubicTerrainData terrainData = new CubicTerrainData (width, height, depth);
// Get chunk starting position
chunkDataStream.Position = this.chunkLookupTable [new ListIndex<int>(x,y,z)];
terrainData.DeserializeChunk (chunkDataStream);
chunkDataStream.Close ();
return terrainData;
}
public static void Main()
{
Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
var bs = new BufferedStream(Console.OpenStandardInput());
StreamReader reader = new StreamReader(bs);
double x = double.Parse(reader.ReadLine());
List<int> res = Solve(x).ToList();
if (res.Count == 0)
Console.WriteLine("No solution");
else
foreach (int s in res)
Console.WriteLine(s);
}
static string CalculateChecksum(Stream stream)
{
using (var bs = new BufferedStream(stream))
using (var sha1 = new SHA1Managed())
{
var hash = sha1.ComputeHash(bs);
var formatted = new StringBuilder(2*hash.Length);
foreach (var b in hash)
{
formatted.AppendFormat("{0:X2}", b);
}
return formatted.ToString();
}
}
private void Connect()
{
socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)
{
SendTimeout = SendTimeout
};
try
{
socket = GetSocketCanConnect();
if (!socket.Connected)
{
socket.Shutdown(SocketShutdown.Both);
socket.Close();
socket = null;
return;
}
Bstream = new BufferedStream(new NetworkStream(socket), 16 * 1024);
if (Password != null)
SendExpectSuccess(Commands.Auth, Password.ToUtf8Bytes());
db = 0;
var ipEndpoint = socket.LocalEndPoint as IPEndPoint;
clientPort = ipEndpoint != null ? ipEndpoint.Port : -1;
lastCommand = null;
lastSocketException = null;
LastConnectedAtTimestamp = Stopwatch.GetTimestamp();
if (isPreVersion1_26 == null)
{
isPreVersion1_26 = this.ServerVersion.CompareTo("1.2.6") <= 0;
//force version reload
log.DebugFormat("redis-server Version: {0}", isPreVersion1_26);
}
}
catch (SocketException ex)
{
if (socket != null)
socket.Close();
socket = null;
HadExceptions = true;
var throwEx = new RedisException("could not connect to redis Instance at " + Host + ":" + Port, ex);
log.Error(throwEx.Message, ex);
throw throwEx;
}
}
public static string CalculateChecksum(string filename)
{
using (var fs = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var bs = new BufferedStream(fs))
using (var sha1 = new SHA1Managed())
{
var hash = sha1.ComputeHash(bs);
var formatted = new StringBuilder(2 * hash.Length);
foreach (var b in hash)
{
formatted.AppendFormat("{0:X2}", b);
}
return formatted.ToString();
}
}
public static void Main()
{
var bs = new BufferedStream(Console.OpenStandardInput());
StreamReader reader = new StreamReader(bs);
string[] ss = reader.ReadLine().Split();
int n = int.Parse(ss[0]), k = int.Parse(ss[1]);
List<int> a = reader.ReadLine().Split().Select(x => int.Parse(x) - 1).ToList();
var cycles = Enumerable.Range(0, n).Select(x => new List<List<int>>()).ToArray();
bool[] seen = new bool[n];
foreach (int i in Enumerable.Range(0, n)) if (!seen[i])
{
List<int> cyc = new List<int> ();
int u = i;
do {
cyc.Add(u);
seen[u] = true;
u = a[u];
} while (u != i);
cycles[cyc.Count].Add(cyc);
}
List<int> res = Enumerable.Repeat(-1, n).ToList();
foreach (var group in cycles) if (group.Count > 0)
{
int len = group.First().Count;
int need = gcd(len, k);
if (group.Count % need == 0)
for (int i = 0; i < group.Count; i += need)
{
List<int> cyc = new List<int> ();
foreach (int l in Enumerable.Range(0, len))
foreach (int j in Enumerable.Range(0, need))
cyc.Add(group[i + j][l]);
int move = inverse(k / need % len, len);
if (move != -1) foreach (int j in Enumerable.Range(0, cyc.Count))
res[cyc[j]] = cyc[(j + move) % cyc.Count];
}
}
if (res.Any(x => x == -1))
Console.WriteLine("Impossible");
else
Console.WriteLine(string.Join(" ", res.Select(x => x + 1)));
}
public PostscriptDSCTokenizer(string path)
{
_stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
_bufferedStream = new BufferedStream(_stream);
}
private void WriteHmuxLength(BufferedStream stream, int length)
{
stream.WriteByte((byte)(length >> 8));
stream.WriteByte((byte)length);
}
private bool TryMakeBrushesFromGeometryCache()
{
long begin = System.Environment.TickCount;
try
{
Action <object> loadBrush = new Action <object>(LoadBrush);
bool useIndex = false;
System.Runtime.Serialization.Formatters.Binary.BinaryFormatter f = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
int count = -1;
try
{
if (System.IO.File.Exists(geometryCacheIndexPath))
{
FileStream indexFile = new FileStream(geometryCacheIndexPath, FileMode.Open);
System.IO.Compression.GZipStream indexZip = new System.IO.Compression.GZipStream(indexFile, System.IO.Compression.CompressionMode.Decompress);
BufferedStream indexStream = new BufferedStream(indexZip);
index = (long[])f.Deserialize(indexStream);
indexStream.Close();
useIndex = true;
}
}
catch (Exception)
{
Debug.WriteLine("index deserialization failed");
}
bool geometryCacheExists = File.Exists(geometryCachePath);
if (geometryCacheExists == false)
{
System.Diagnostics.Trace.TraceWarning("No geometry cache found");
return(false);
}
// Load file to memory
FileStream file = new FileStream(geometryCachePath, FileMode.Open);
System.IO.Compression.GZipStream zip = new System.IO.Compression.GZipStream(file, System.IO.Compression.CompressionMode.Decompress);
BufferedStream bufferedStream = new BufferedStream(zip);
cacheData = ReadFully(bufferedStream, 0);
bufferedStream.Close();
MemoryStream stream = new MemoryStream(cacheData);
//stream.Write(cacheData, 0, cacheData.Length);
//stream.Seek(0, SeekOrigin.Begin);
count = (int)f.Deserialize(stream);
if ((index != null) && (index.Length == count))
{
stream.Close();
Debug.WriteLine("Valid index found, use multi threaded path for geometry cache loading");
threadInfo = new Dictionary <System.Threading.Thread, BrushLoadThreadInfo>();
for (int i = 0; i < count; ++i)
{
ThreadManager.Instance.AddTask(loadBrush, new BrushInfo(i));
}
ThreadManager.Instance.Execute();
cacheData = null;
threadInfo = null;
// \todo add interface
RenderStack.Graphics.BufferGL.FinalizeDeserializations();
}
else
{
// No valid index found, single threaded path
Debug.WriteLine("No valid index found, single threaded path for geometry cache loading");
index = new long[count];
useIndex = false;
// Create MemoryStream so we can access Position
for (int i = 0; i < count; ++i)
{
if (useIndex)
{
stream.Seek(index[i], SeekOrigin.Begin);
}
else
{
index[i] = stream.Position;
}
//Message("BrushManager: " + i.ToString() + "/" + count.ToString() + " GeometryMesh Deserialize");
string name = (string)f.Deserialize(stream);
GeometryMesh mesh = (GeometryMesh)f.Deserialize(stream);
Message("BrushManager: " + i.ToString() + "/" + count.ToString() + " MakeBrush " + name);
MakeBrush(name, mesh);
}
stream.Close();
}
UpdateGeometryCacheIndex();
long end = System.Environment.TickCount;
long duration = end - begin;
System.Diagnostics.Trace.WriteLine("Geometry cache load took " + duration.ToString() + " ticks");
return(true);
}
catch (Exception)
{
System.Diagnostics.Trace.TraceWarning("There was a problem with geometrycache");
return(false);
}
}
private int ReadHmuxLength(BufferedStream stream)
{
int length = (stream.ReadByte() << 8) + stream.ReadByte();
return(length);
}
private void DoHmux(HttpContext context)
{
HttpRequest request = context.Request;
HttpResponse response = context.Response;
String sessionId;
if (!_isStickySessions)
{
sessionId = null;
}
else
{
sessionId = GetRequestedSessionId(request);
}
TempBuffer tempBuf = TempBuffer.Allocate();
byte[] buf = tempBuf.GetBuffer();
try {
Stream is_ = request.InputStream;
int len = is_.Read(buf, 0, buf.Length);
bool isComplete;
if (len < 0)
{
isComplete = true;
}
else if (len < buf.Length)
{
int sublen = is_.Read(buf, len, 1);
if (sublen == 0) //.NET return 0 for Stream.EOF
{
isComplete = true;
}
else
{
len += sublen;
isComplete = false;
}
}
else
{
isComplete = false;
}
Server client = null;
int result = OK | EXIT;
HmuxConnection channel = _loadBalancer.OpenServer(sessionId, null);
// If everything fails, return an error
if (channel == null)
{
SendNotAvailable(response);
return;
}
client = channel.GetPool();
BufferedStream rs = channel.GetSocketStream();
BufferedStream ws = channel.GetSocketStream();
result = FAIL | EXIT;
long requestStartTime = Utils.CurrentTimeMillis();
try {
result = HandleRequest(context, request, response, channel, rs, ws,
buf, len, isComplete, isComplete);
if ((result & STATUS_MASK) == OK)
{
client.ClearBusy();
return;
}
else if ((result & STATUS_MASK) == BUSY)
{
client.Busy();
}
else
{
client.FailSocket();
}
} catch (ClientDisconnectException) {
_log.Info("Client disconnect detected for '{0}'", channel.GetTraceId());
return;
} catch (IOException e) {
client.FailSocket();
_log.Error("IOException '{0}': '{1}' {2}", channel.GetTraceId(), e.Message, e.StackTrace);
} finally {
if ((result & EXIT_MASK) == QUIT)
{
channel.Free(requestStartTime);
}
else
{
channel.Close();
}
}
// server/2675
if (isComplete && (result & STATUS_MASK) == BUSY ||
"GET".Equals(request.HttpMethod))
{
channel = _loadBalancer.OpenServer(sessionId, client);
// If everything fails, return an error
if (channel == null)
{
_log.Info("load-balance failed" + (client != null ? (" for " + client.GetDebugId()) : ""));
SendNotAvailable(response);
return;
}
Server client2 = channel.GetPool();
if (_log.IsLoggable(EventLogEntryType.Information))
{
_log.Info("load-balance failing over"
+ (client != null ? (" from " + client.GetDebugId()) : "")
+ " to " + client2.GetDebugId());
}
rs = channel.GetSocketStream();
ws = channel.GetSocketStream();
result = FAIL | EXIT;
requestStartTime = Utils.CurrentTimeMillis();
try {
result = HandleRequest(context, request, response, channel, rs, ws,
buf, len, isComplete, false);
if ((result & STATUS_MASK) == OK)
{
client2.ClearBusy();
return;
}
else if ((result & STATUS_MASK) == BUSY)
{
client2.Busy();
}
else
{
client2.FailSocket();
}
} catch (IOException e) {
client2.FailSocket();
_log.Info("Failover to '{0}' did not succeed '{1}', {2} ", client2.GetDebugId(), e.Message, e.StackTrace);
} finally {
if ((result & EXIT_MASK) == QUIT)
{
channel.Free(requestStartTime);
}
else
{
channel.Close();
}
}
}
SendNotAvailable(response);
} finally {
TempBuffer.Free(tempBuf);
tempBuf = null;
}
}
private Tuple <INatsConnection, IList <IOp> > EstablishConnection(Host host, ConnectionInfo connectionInfo, CancellationToken cancellationToken)
{
Socket socket = null;
BufferedStream writeStream = null;
BufferedStream readStream = null;
try
{
socket = _socketFactory.Create(connectionInfo.SocketOptions);
socket.Connect(
host,
connectionInfo.SocketOptions.ConnectTimeoutMs,
cancellationToken);
readStream = new BufferedStream(socket.CreateReadStream(), socket.ReceiveBufferSize);
var reader = new NatsOpStreamReader(readStream);
var consumedOps = new List <IOp>();
IOp ReadOne()
{
var op = reader.ReadOp().FirstOrDefault();
if (op != null)
{
consumedOps.Add(op);
}
return(op);
}
var serverInfo = VerifyConnection(host, connectionInfo, socket, ReadOne);
writeStream = new BufferedStream(socket.CreateWriteStream(), socket.SendBufferSize);
return(new Tuple <INatsConnection, IList <IOp> >(new NatsConnection(
serverInfo,
socket,
writeStream,
readStream,
reader,
cancellationToken), consumedOps));
}
catch
{
Swallow.Everything(
() =>
{
readStream?.Dispose();
readStream = null;
},
() =>
{
writeStream?.Dispose();
writeStream = null;
},
() =>
{
if (socket == null)
{
return;
}
if (socket.Connected)
{
socket.Shutdown(SocketShutdown.Both);
}
socket.Dispose();
socket = null;
});
throw;
}
}
private static PTable MergeTo2(IList <PTable> tables, long fileSize, int indexEntrySize, string outputFile,
Func <string, ulong, ulong> upgradeHash, Func <IndexEntry, bool> existsAt, Func <IndexEntry, Tuple <string, bool> > readRecord,
byte version, int cacheDepth)
{
Log.Trace("PTables merge started (specialized for <= 2 tables).");
var watch = Stopwatch.StartNew();
var enumerators = tables.Select(table => new EnumerableTable(version, table, upgradeHash, existsAt, readRecord)).ToList();
long dumpedEntryCount = 0;
using (var f = new FileStream(outputFile, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None,
DefaultSequentialBufferSize, FileOptions.SequentialScan))
{
f.SetLength(fileSize);
f.Seek(0, SeekOrigin.Begin);
using (var md5 = MD5.Create())
using (var cs = new CryptoStream(f, md5, CryptoStreamMode.Write))
using (var bs = new BufferedStream(cs, DefaultSequentialBufferSize))
{
// WRITE HEADER
var headerBytes = new PTableHeader(version).AsByteArray();
cs.Write(headerBytes, 0, headerBytes.Length);
// WRITE INDEX ENTRIES
var buffer = new byte[indexEntrySize];
var enum1 = enumerators[0];
var enum2 = enumerators[1];
bool available1 = enum1.MoveNext();
bool available2 = enum2.MoveNext();
IndexEntry current;
while (available1 || available2)
{
var entry1 = new IndexEntry(enum1.Current.Stream, enum1.Current.Version, enum1.Current.Position);
var entry2 = new IndexEntry(enum2.Current.Stream, enum2.Current.Version, enum2.Current.Position);
if (available1 && (!available2 || entry1.CompareTo(entry2) > 0))
{
current = entry1;
available1 = enum1.MoveNext();
}
else
{
current = entry2;
available2 = enum2.MoveNext();
}
if (existsAt(current))
{
AppendRecordTo(bs, buffer, version, current, indexEntrySize);
dumpedEntryCount += 1;
}
}
bs.Flush();
cs.FlushFinalBlock();
f.SetLength(f.Position + MD5Size);
// WRITE MD5
var hash = md5.Hash;
f.Write(hash, 0, hash.Length);
f.FlushToDisk();
}
}
Log.Trace("PTables merge finished in {0} ([{1}] entries merged into {2}).",
watch.Elapsed, string.Join(", ", tables.Select(x => x.Count)), dumpedEntryCount);
return(new PTable(outputFile, Guid.NewGuid(), version, depth: cacheDepth));
}
private async Task PerformPackageInstallation(IProgress <double> progress, PackageVersionInfo package, CancellationToken cancellationToken)
{
// Target based on if it is an archive or single assembly
// zip archives are assumed to contain directory structures relative to our ProgramDataPath
var extension = Path.GetExtension(package.targetFilename);
var isArchive = string.Equals(extension, ".zip", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".rar", StringComparison.OrdinalIgnoreCase) || string.Equals(extension, ".7z", StringComparison.OrdinalIgnoreCase);
var target = Path.Combine(isArchive ? _appPaths.TempUpdatePath : _appPaths.PluginsPath, package.targetFilename);
// Download to temporary file so that, if interrupted, it won't destroy the existing installation
var tempFile = await _httpClient.GetTempFile(new HttpRequestOptions
{
Url = package.sourceUrl,
CancellationToken = cancellationToken,
Progress = progress
}).ConfigureAwait(false);
cancellationToken.ThrowIfCancellationRequested();
// Validate with a checksum
var packageChecksum = string.IsNullOrWhiteSpace(package.checksum) ? Guid.Empty : new Guid(package.checksum);
if (packageChecksum != Guid.Empty) // support for legacy uploads for now
{
using (var crypto = new MD5CryptoServiceProvider())
using (var stream = new BufferedStream(File.OpenRead(tempFile), 100000))
{
var check = Guid.Parse(BitConverter.ToString(crypto.ComputeHash(stream)).Replace("-", String.Empty));
if (check != packageChecksum)
{
throw new ApplicationException(string.Format("Download validation failed for {0}. Probably corrupted during transfer.", package.name));
}
}
}
cancellationToken.ThrowIfCancellationRequested();
// Success - move it to the real target
try
{
Directory.CreateDirectory(Path.GetDirectoryName(target));
File.Copy(tempFile, target, true);
//If it is an archive - write out a version file so we know what it is
if (isArchive)
{
File.WriteAllText(target + ".ver", package.versionStr);
}
}
catch (IOException e)
{
_logger.ErrorException("Error attempting to move file from {0} to {1}", e, tempFile, target);
throw;
}
try
{
File.Delete(tempFile);
}
catch (IOException e)
{
// Don't fail because of this
_logger.ErrorException("Error deleting temp file {0]", e, tempFile);
}
}
private void mnuLoad_Click(object sender, EventArgs e)
{
clearLevel();
cmdSave.Enabled = false;
cmdClear.Enabled = false;
cmdReset.Enabled = false;
lstLevels.Items.Clear();
bool inLevel = false;
if (dgOpenMapData.ShowDialog() == DialogResult.OK)
{
mnuSave.Enabled = true;
mnuSaveAs.Enabled = true;
const string userRoot = "HKEY_CURRENT_USER";
const string subkey = "LodeRunner";
const string keyName = userRoot + "\\" + subkey;
Registry.SetValue(keyName, "PathName", Path.GetDirectoryName(dgOpenMapData.FileName));
// String[] lines = System.IO.File.ReadAllLines(dgOpenMapData.FileName);
using (FileStream fs = File.Open(dgOpenMapData.FileName, FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs, System.Text.ASCIIEncoding.Unicode.GetByteCount("g")))
using (StreamReader sr = new StreamReader(bs)) {
LevelDefinition levelDefinition = null;
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.StartsWith("#define GAME_NUMBER"))
{
gameNumber = line.Substring(@"#define GAME_NUMBER".Length + 1).Trim();
}
else if (line.StartsWith("#define NUMBER_OF_GAMES"))
{
numberOfGames = line.Substring(@"#define NUMBER_OF_GAMES".Length + 1).Trim();
}
else if (line.StartsWith("#if GAME_NUMBER"))
{
gameNumberId = Int16.Parse(line.Substring(line.IndexOf("==") + 3).Trim());
}
else if (line.StartsWith(" #define LEVEL_COUNT"))
{
Int16 gamesPerLevel = Int16.Parse(line.Substring(@" #define LEVEL_COUNT".Length + 1).Trim());
gamesPerLevels.Add(gamesPerLevel);
dgExport.Rows.Add(dgExport.Rows.Count, gamesPerLevel);
}
else if (line.StartsWith("const uint8_t PROGMEM"))
{
levelDefinition = new LevelDefinition();
levelDefinition.LevelName = line.Substring(line.IndexOf("PROGMEM ") + 8, line.Length - line.IndexOf("PROGMEM ") - 14);
inLevel = true;
}
else if (inLevel)
{
if (line == "};")
{
inLevel = false;
ListViewItem item = new ListViewItem();
item.Text = levelDefinition.LevelName;
item.Tag = levelDefinition;
lstLevels.Items.Add(item);
}
else
{
char[] splitchar = { ',' };
String[] strData = line.Trim().Split(splitchar);
int cursor = 0;
// Player start pos ..
CoordinateSet player = new CoordinateSet();
player.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
player.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.Player = player;
// Enemies
int numberOfEnemies = Convert.ToInt32(strData[cursor++].Trim(), 16);
for (int x = 0; x < numberOfEnemies; x++)
{
CoordinateSet enemy = new CoordinateSet();
enemy.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
enemy.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.Enemies.Add(enemy);
}
// Level Ladders
int numberOfLevelLadders = Convert.ToInt32(strData[cursor++].Trim(), 16);
for (int x = 0; x < numberOfLevelLadders; x++)
{
CoordinateSet levelLadder = new CoordinateSet();
levelLadder.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelLadder.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.Ladders.Add(levelLadder);
}
// Reentry points
for (int x = 0; x < 4; x++)
{
CoordinateSet reentryPoint = new CoordinateSet();
reentryPoint.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
reentryPoint.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.ReentryPoints.Add(reentryPoint);
}
// Encryption type ..
levelDefinition.EncryptionType = (EncryptionType)Convert.ToInt32(strData[cursor++].Trim(), 16);
int[] data = new int[strData.Length - cursor];
for (int count = cursor; count <= strData.Length - 2; count++)
{
data[count - cursor] = Convert.ToInt32(strData[count].Trim(), 16);
}
loadLevel(levelDefinition, data);
}
}
}
}
}
foreach (ListViewItem item in lstLevels.Items)
{
validate(item, (LevelDefinition)item.Tag);
}
MessageBox.Show("Level data loaded successfully.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
static void Main(string[] args)
{
/*-----------------------------------------------------------------------
* Title
* --------------------------------------------------------------------*/
string divider = new string('=', 100);
Console.WriteLine(divider);
Console.WriteLine("CLIENT");
Console.WriteLine(divider);
/*-----------------------------------------------------------------------
* Vars
* --------------------------------------------------------------------*/
int port = 43000;
TcpClient client;
byte count = 0;
/*-----------------------------------------------------------------------
* Send 3 messages (last one to close server)
* --------------------------------------------------------------------*/
try
{
while (count < 3)
{
// Pause for 1 second.
Thread.Sleep(1000);
// Create a new client
using (client = new TcpClient("localhost", port))
{
string msg = (count < 2) ? $"This is message {count + 1}" : "close";
// Create a new stream to send message
using (NetworkStream stream = client.GetStream())
{
using (BufferedStream writer = new BufferedStream(stream))
{
byte[] messageBytesToSend = Encoding.UTF8.GetBytes(msg);
writer.Write(messageBytesToSend, 0, messageBytesToSend.Length);
Console.WriteLine("Message sent...");
}
}
}
// Inc. counter
count++;
}
}
catch (Exception)
{
Console.WriteLine("Unable to connect to server");
}
/*-----------------------------------------------------------------------
* Finish up
* --------------------------------------------------------------------*/
Console.WriteLine("Client finished...");
Console.ReadKey();
}
public HttpBufferedStream(Stream stream)
{
this.innerStream = new BufferedStream(stream);
}
public void whois_info(string domainname)
{
Utils.Helper_Trace("XORCISM PROVIDER XINFO", "JobID:" + m_jobId + " whois on : " + domainname);
// http://reports.internic.net/cgi/whois?whois_nic=xorcism.org&type=domain
TcpClient tcpWhois = null;
NetworkStream nsWhois;
BufferedStream bfWhois = null;
StreamWriter swSend;
StreamReader srReceive;
try
{
// The TcpClient should connect to the who-is server, on port 43 (default who-is)
tcpWhois = new TcpClient("whois.internic.net", 43); //Hardcoded
// Set up the network stream
nsWhois = tcpWhois.GetStream();
// Hook up the buffered stream to the network stream
bfWhois = new BufferedStream(nsWhois);
}
catch (Exception ex)
{
Utils.Helper_Trace("XORCISM PROVIDER XINFO", "JobID:" + m_jobId + " WhoisError: Could not open a connection to the Who-Is server. " + ex.Message + " " + ex.InnerException);
}
// Send to the server the hostname that we want to get information on
swSend = new StreamWriter(bfWhois);
swSend.WriteLine(domainname);
swSend.Flush();
//TODO
/*
* try
* {
* srReceive = new StreamReader(bfWhois);
* string strResponse;
* // Read the response line by line
* //TODO: Review Update
* while ((strResponse = srReceive.ReadLine()) != null)
* {
* //txtResponse.Text += strResponse + "\r\n";
* if (strResponse.Contains("Domain Name:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Domain Name";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.INFORMATION.Add(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Registrar:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Registrar";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.INFORMATION.Add(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Whois Server:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Whois Server";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.INFORMATION.Add(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Referral URL:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Referral URL";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.AddToINFORMATION(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Name Server:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Name Server";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.AddToINFORMATION(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Status:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Status";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.AddToINFORMATION(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Updated Date:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Updated Date";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.AddToINFORMATION(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Creation Date:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Creation Date";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.AddToINFORMATION(newInfo);
* m_model.SaveChanges();
* }
* if (strResponse.Contains("Expiration Date:"))
* {
* INFORMATION newInfo = new INFORMATION();
* newInfo.Title = "Expiration Date";
* newInfo.Result = strResponse;
* newInfo.JobID = m_jobId;
* m_model.AddToINFORMATION(newInfo);
* m_model.SaveChanges();
* }
* }
* }
* catch(Exception ex)
* {
* Utils.Helper_Trace("XORCISM PROVIDER XINFO", "JobID:" + m_jobId + " WhoisError: Could not read data from the Who-Is server. " + ex.Message + " " + ex.InnerException);
* }
*/
// We're done with the connection
tcpWhois.Close();
}
static void _Start(object nothing)
{
try
{
var deadline = DateTime.Now.AddSeconds(20);
log.Info("_Start");
while (DateTime.Now < deadline)
{
try
{
TcpClient client = new TcpClient("127.0.0.1", OutputPort);
Console.WriteLine("Port open");
client.Close();
break;
}
catch (Exception)
{
Console.WriteLine("Port closed");
}
}
using (TcpClient client = new TcpClient("127.0.0.1", OutputPort))
{
client.ReceiveBufferSize = 1024 * 1024 * 5; // 5mb
using (MemoryStream ms = new MemoryStream())
{
using (var stream = new BufferedStream(client.GetStream(), 1024 * 1024 * 5))
{
DateTime lastdata = DateTime.Now;
while (client.Client.Connected)
{
int bytestoread = client.Available;
while (bytestoread > 0)
{
//bytestoread -= readRTPData(stream, ms);
bytestoread -= readJPGData(stream, ms);
lastdata = DateTime.Now;
}
// up to 100 fps or 50 with 10ms process time
System.Threading.Thread.Sleep(10);
if (lastdata.AddSeconds(5) < DateTime.Now)
{
client.Client.Send(new byte[0]);
}
}
//cleanup on disconnect
FlightData.myhud.bgimage = null;
}
}
}
}
catch (Exception ex)
{
FlightData.myhud.bgimage = null;
log.Error(ex);
}
}
protected TextBuffer(Stream str)
{
this.delta = 1;
this.bufferedStrm = new BufferedStream(str);
}
static int Main(string[] args)
{
try
{
// Default number of lines is 1
int numlines = 1;
#region Command Line Parsing
string filename = string.Empty;
bool redirected;
bool set_l = false;
bool set_input = false;
foreach (string arg in args)
{
if (arg[0] == '/')
{
if (arg.Length > 3)
{
if (arg.ToUpper( )[1] == 'L')
{
if (arg[2] != ':')
{
return(WriteError("Invalid argument: " + arg));
}
try
{
if (set_l)
{
return(WriteError("Duplicate /L argument"));
}
else
{
numlines = Convert.ToInt32(arg.Substring(3));
if (numlines < 1)
{
return(WriteError("Number of lines must be 1 or greater"));
}
set_l = true;
}
}
catch (FormatException)
{
return(WriteError("Invalid number of lines: " + arg));
}
}
}
else
{
if (arg == "/?")
{
return(WriteError( ));
}
else
{
return(WriteError("Invalid argument: " + arg));
}
}
}
else
{
if (set_input)
{
return(WriteError("Duplicate file argument"));
}
else
{
if (File.Exists(arg))
{
filename = arg;
}
else
{
return(WriteError("Invalid filename: " + arg));
}
set_input = true;
}
}
}
if (ConsoleEx.InputRedirected)
{
if (set_input)
{
return(WriteError("Use either file name or redirection, not both"));
}
else
{
set_input = true;
redirected = true;
}
}
else
{
if (args.Length == 0)
{
return(WriteError( ));
}
redirected = false;
}
#endregion Command Line Parsing
int index = 0;
string[] output = new string[numlines];
if (redirected)
{
// Read standard input and store the lines in a list
while (Console.In.Peek( ) > -1)
{
output.SetValue(Console.In.ReadLine( ), index);
index = (index + 1) % numlines;
}
}
else
{
// Read the file and store the lines in an array
Encoding enc = GetEncoding(filename);
using (FileStream fsi = File.Open(filename, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (BufferedStream bsi = new BufferedStream(fsi))
using (StreamReader sri = new StreamReader(bsi, enc))
{
while (sri.Peek( ) > -1)
{
output.SetValue(sri.ReadLine( ), index);
index = (index + 1) % numlines;
}
}
}
// Display the lines in the correct order
for (int i = index; i < output.Length; i++)
{
Console.WriteLine(output[i]);
}
if (index > 0)
{
for (int i = 0; i < index; i++)
{
Console.WriteLine(output[i]);
}
}
return(0);
}
catch (Exception e)
{
return(WriteError(e.Message));
}
}
// ReSharper restore UnusedMember.Local
private bool Load(ILoadMonitor loader)
{
IProgressStatus status =
new ProgressStatus(string.Format(Resources.BiblioSpecLibrary_Load_Loading__0__library,
Path.GetFileName(FilePath)));
loader.UpdateProgress(status);
long lenRead = 0;
// AdlerChecksum checksum = new AdlerChecksum();
try
{
// Use a buffered stream for initial read
BufferedStream stream = new BufferedStream(CreateStream(loader), 32 * 1024);
int countHeader = (int)LibHeaders.count * 4;
byte[] libHeader = new byte[countHeader];
if (stream.Read(libHeader, 0, countHeader) != countHeader)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_library_header_File_may_be_corrupted);
}
lenRead += countHeader;
// Check the first byte of the primary version number to determine
// whether the format is little- or big-endian. Little-endian will
// have the version number in this byte, while big-endian will have zero.
if (libHeader[(int)LibHeaders.version1 * 4] == 0)
{
_bigEndian = true;
}
int numSpectra = GetInt32(libHeader, (int)LibHeaders.num_spectra);
var dictLibrary = new Dictionary <LibKey, BiblioSpectrumInfo>(numSpectra);
var setSequences = new HashSet <LibSeqKey>();
string revStr = string.Format("{0}.{1}", // Not L10N
GetInt32(libHeader, (int)LibHeaders.version1),
GetInt32(libHeader, (int)LibHeaders.version2));
Revision = float.Parse(revStr, CultureInfo.InvariantCulture);
// checksum.MakeForBuff(libHeader, AdlerChecksum.ADLER_START);
countHeader = (int)SpectrumHeaders.count * 4;
byte[] specHeader = new byte[1024];
byte[] specSequence = new byte[1024];
for (int i = 0; i < numSpectra; i++)
{
int percent = i * 100 / numSpectra;
if (status.PercentComplete != percent)
{
// Check for cancellation after each integer change in percent loaded.
if (loader.IsCanceled)
{
loader.UpdateProgress(status.Cancel());
return(false);
}
// If not cancelled, update progress.
loader.UpdateProgress(status = status.ChangePercentComplete(percent));
}
// Read spectrum header
int bytesRead = stream.Read(specHeader, 0, countHeader);
if (bytesRead != countHeader)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_header_File_may_be_corrupted);
}
// If this is the first header, and the sequence length is zero,
// then this is a Linux format library. Switch to linux format,
// and start over.
if (i == 0 && GetInt32(specHeader, (int)SpectrumHeaders.seq_len) == 0)
{
_linuxFormat = true;
stream.Seek(lenRead, SeekOrigin.Begin);
// Re-ead spectrum header
countHeader = (int)SpectrumHeadersLinux.count * 4;
bytesRead = stream.Read(specHeader, 0, countHeader);
if (bytesRead != countHeader)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_header_File_may_be_corrupted);
}
}
lenRead += bytesRead;
// checksum.MakeForBuff(specHeader, checksum.ChecksumValue);
int charge = GetInt32(specHeader, (int)SpectrumHeaders.charge);
if (charge > TransitionGroup.MAX_PRECURSOR_CHARGE)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Invalid_precursor_charge_found_File_may_be_corrupted);
}
int numPeaks = GetInt32(specHeader, (int)SpectrumHeaders.num_peaks);
int seqLength = GetInt32(specHeader, (_linuxFormat ?
(int)SpectrumHeadersLinux.seq_len : (int)SpectrumHeaders.seq_len));
int copies = GetInt32(specHeader, (_linuxFormat ?
(int)SpectrumHeadersLinux.copies : (int)SpectrumHeaders.copies));
// Read sequence information
int countSeq = (seqLength + 1) * 2;
if (stream.Read(specSequence, 0, countSeq) != countSeq)
{
throw new InvalidDataException(Resources.BiblioSpecLibrary_Load_Data_truncation_in_spectrum_sequence_File_may_be_corrupted);
}
lenRead += countSeq;
// checksum.MakeForBuff(specSequence, checksum.ChecksumValue);
// Store in dictionary
if (IsUnmodified(specSequence, seqLength + 1, seqLength))
{
// These libraries should not have duplicates, but just in case.
// CONSIDER: Emit error about redundancy?
// These legacy libraries assume [+57.0] modified Cysteine
LibKey key = new LibKey(GetCModified(specSequence, ref seqLength), 0, seqLength, charge);
if (!dictLibrary.ContainsKey(key))
{
dictLibrary.Add(key, new BiblioSpectrumInfo((short)copies, (short)numPeaks, lenRead));
}
setSequences.Add(new LibSeqKey(key));
}
// Read over peaks
int countPeaks = 2 * sizeof(Single) * numPeaks;
stream.Seek(countPeaks, SeekOrigin.Current); // Skip spectrum
lenRead += countPeaks;
// checksum.MakeForBuff(specPeaks, checksum.ChecksumValue);
}
// Checksum = checksum.ChecksumValue;
_dictLibrary = dictLibrary;
_setSequences = setSequences;
loader.UpdateProgress(status.Complete());
return(true);
}
catch (InvalidDataException x)
{
loader.UpdateProgress(status.ChangeErrorException(x));
return(false);
}
catch (IOException x)
{
loader.UpdateProgress(status.ChangeErrorException(x));
return(false);
}
catch (Exception x)
{
x = new Exception(string.Format(Resources.BiblioSpecLibrary_Load_Failed_loading_library__0__, FilePath), x);
loader.UpdateProgress(status.ChangeErrorException(x));
return(false);
}
finally
{
if (ReadStream != null)
{
// Close the read stream to ensure we never leak it.
// This only costs on extra open, the first time the
// active document tries to read.
try { ReadStream.CloseStream(); }
catch (IOException) {}
}
}
}
public void Run()
{
IsRunning = true;
while (IsRunning)
{
Logger.Log("Broadcaster {0} waiting for connection...", Id);
TcpClient client = null;
try
{
client = Listener.AcceptTcpClient();
#if DEBUG == false
//timeouts affect debugging when stepping through code
client.ReceiveTimeout = 5000;
#endif
}
catch (Exception ex)
{
Logger.Log("Broadcaster {0} could not accept TCP client: {1}", Id, ex.Message);
continue;
}
Logger.Log("Broadcaster {0} accepting client: {1}", Id, client.Client.RemoteEndPoint);
BinaryReader reader = null;
BinaryWriter writer = null;
try
{
BufferedStream stream = new BufferedStream(client.GetStream());
reader = new BinaryReader(stream);
writer = new BinaryWriter(stream);
//grab auth key
int authKeyLength = IPAddress.NetworkToHostOrder(reader.ReadInt32());
byte[] authKeyBytes = reader.ReadBytes(authKeyLength);
string authKey = Encoding.UTF8.GetString(authKeyBytes);
if (Server.ActiveUsers.ContainsKey(authKey) == true)
{
while (true)
{
if (PendingMessages.Count > 0)
{
var message = PendingMessages.Dequeue();
byte[] userBytes = Encoding.UTF8.GetBytes(message.Key.Name);
writer.Write(IPAddress.HostToNetworkOrder(userBytes.Length));
writer.Write(userBytes);
byte[] messageBytes = Encoding.UTF8.GetBytes(message.Value);
writer.Write(IPAddress.HostToNetworkOrder(messageBytes.Length));
writer.Write(messageBytes);
stream.Flush();
}
else
{
Thread.Sleep(500);
}
}
}
}
catch (Exception ex)
{
Logger.Log("Broadcaster {0} exception handling client {1}, {2}: ", Id, client.Client.RemoteEndPoint, ex.Message);
}
finally
{
Logger.Log("Broadcaster {0} done handling client {1}", Id, client.Client.RemoteEndPoint);
reader.Close();
writer.Close();
if (client != null)
{
client.Close();
}
}
}
}
public async Task <HttpResponseMessage> DistributeDocument(string fileNameAndPath, string cloudDeploymentResourceUrl, string sourceDocumentId, string jwtToken)
{
string multiCloudMachineName = cloudDeploymentResourceUrl.TrimEnd('/') + "/api/v1/";
string qvDocName = Path.GetFileNameWithoutExtension(fileNameAndPath);
var l_FileStream = new FileStream(fileNameAndPath, FileMode.Open, FileAccess.Read);
var stream = new BufferedStream(l_FileStream, 8192);
var content = new StreamContent(stream, 65536);
try
{
content.Headers.Add("Content-Type", "binary/octet-stream");
using (HttpClient cloudClient = new HttpClient())
{
var request = new HttpRequestMessage(HttpMethod.Post, multiCloudMachineName + "apps/import?mode=autoreplace&appId=" + sourceDocumentId + "&fallbackName=" + qvDocName)
{
Content = content
};
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", jwtToken);
HttpResponseMessage autoReplaceDocResponse = await cloudClient.SendAsync(request);
switch (autoReplaceDocResponse.StatusCode)
{
case HttpStatusCode.RequestEntityTooLarge:
PrintMessage("Failure - Could not upload document to engine, since engine reported that the app exceeds the maximum size. statusCode= " + autoReplaceDocResponse.StatusCode + ", reason= " + autoReplaceDocResponse.ReasonPhrase, false);
throw new HttpAppSizeException("App size exceeds max size");
case HttpStatusCode.GatewayTimeout:
PrintMessage("Failure - Could not upload document in engine, API gateway in QSEfe/Multicloud reported that it timed out when waiting for a response. statusCode= " + autoReplaceDocResponse.StatusCode + ", reason= " + autoReplaceDocResponse.ReasonPhrase, false);
WorkflowExceptionStrategy.ThrowException(autoReplaceDocResponse);
break;
}
if (!autoReplaceDocResponse.IsSuccessStatusCode)
{
PrintMessage("Failure - Could not upload document " + qvDocName + "to engine. statusCode= " + autoReplaceDocResponse.StatusCode + ", reason= " + autoReplaceDocResponse.ReasonPhrase, false);
WorkflowExceptionStrategy.ThrowException(autoReplaceDocResponse);
}
else
{
Console.WriteLine("Success - Document " + qvDocName + " uploaded to engine");
}
var responseContent = await autoReplaceDocResponse.Content.ReadAsStringAsync() ?? "{}";
EngineDoc result = JsonConvert.DeserializeObject <EngineDoc>(responseContent);
HttpResponseMessage createItemResponse = await CreateItem(result, jwtToken, multiCloudMachineName, qvDocName);
return(createItemResponse);
}
}
catch (HttpAppSizeException)
{
PrintMessage("App " + qvDocName + " exceeds max size", false);
}
catch (WorkflowException e)
{
PrintMessage("Failure - Could not upload document " + qvDocName + " to engine, workflowException. Message =" + e.Message, false);
}
catch (TaskCanceledException e)
{
PrintMessage("Failure - Could not upload document " + qvDocName + " to engine, Connection timeout. Message =" + e.Message, false);
}
catch (Exception ex)
{
PrintMessage("Failure - Could not upload document " + qvDocName + " to engine, Other exception of unknown cause. Message =" + ex.Message, false);
}
finally
{
content.Dispose();
stream.Dispose();
l_FileStream.Dispose();
}
return(null);
}
public static PTable MergeTo(IList <PTable> tables, string outputFile, Func <string, ulong, ulong> upgradeHash, Func <IndexEntry, bool> existsAt, Func <IndexEntry, Tuple <string, bool> > readRecord, byte version, int cacheDepth = 16)
{
Ensure.NotNull(tables, "tables");
Ensure.NotNullOrEmpty(outputFile, "outputFile");
Ensure.Nonnegative(cacheDepth, "cacheDepth");
var indexEntrySize = version == PTableVersions.Index32Bit ? PTable.IndexEntry32Size : IndexEntry64Size;
var fileSize = GetFileSize(tables, indexEntrySize); // approximate file size
if (tables.Count == 2)
{
return(MergeTo2(tables, fileSize, indexEntrySize, outputFile, upgradeHash, existsAt, readRecord, version, cacheDepth)); // special case
}
Log.Trace("PTables merge started.");
var watch = Stopwatch.StartNew();
var enumerators = tables.Select(table => new EnumerableTable(version, table, upgradeHash, existsAt, readRecord)).ToList();
for (int i = 0; i < enumerators.Count; i++)
{
if (!enumerators[i].MoveNext())
{
enumerators[i].Dispose();
enumerators.RemoveAt(i);
i--;
}
}
long dumpedEntryCount = 0;
using (var f = new FileStream(outputFile, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None,
DefaultSequentialBufferSize, FileOptions.SequentialScan))
{
f.SetLength(fileSize);
f.Seek(0, SeekOrigin.Begin);
using (var md5 = MD5.Create())
using (var cs = new CryptoStream(f, md5, CryptoStreamMode.Write))
using (var bs = new BufferedStream(cs, DefaultSequentialBufferSize))
{
// WRITE HEADER
var headerBytes = new PTableHeader(version).AsByteArray();
cs.Write(headerBytes, 0, headerBytes.Length);
var buffer = new byte[indexEntrySize];
// WRITE INDEX ENTRIES
while (enumerators.Count > 0)
{
var idx = GetMaxOf(enumerators);
var current = enumerators[idx].Current;
if (existsAt(current))
{
AppendRecordTo(bs, buffer, version, current, indexEntrySize);
dumpedEntryCount += 1;
}
if (!enumerators[idx].MoveNext())
{
enumerators[idx].Dispose();
enumerators.RemoveAt(idx);
}
}
bs.Flush();
cs.FlushFinalBlock();
f.FlushToDisk();
f.SetLength(f.Position + MD5Size);
// WRITE MD5
var hash = md5.Hash;
f.Write(hash, 0, hash.Length);
f.FlushToDisk();
}
}
Log.Trace("PTables merge finished in {0} ([{1}] entries merged into {2}).",
watch.Elapsed, string.Join(", ", tables.Select(x => x.Count)), dumpedEntryCount);
return(new PTable(outputFile, Guid.NewGuid(), depth: cacheDepth));
}
public void CompleteTransaction(Guid txId, Action <DocumentInTransactionData> perDocumentModified)
{
Api.JetSetCurrentIndex(session, Transactions, "by_tx_id");
Api.MakeKey(session, Transactions, txId, MakeKeyGrbit.NewKey);
if (Api.TrySeek(session, Transactions, SeekGrbit.SeekEQ))
{
Api.JetDelete(session, Transactions);
}
Api.JetSetCurrentIndex(session, DocumentsModifiedByTransactions, "by_tx");
Api.MakeKey(session, DocumentsModifiedByTransactions, txId, MakeKeyGrbit.NewKey);
if (Api.TrySeek(session, DocumentsModifiedByTransactions, SeekGrbit.SeekEQ) == false)
{
return;
}
Api.MakeKey(session, DocumentsModifiedByTransactions, txId, MakeKeyGrbit.NewKey);
Api.JetSetIndexRange(session, DocumentsModifiedByTransactions, SetIndexRangeGrbit.RangeInclusive | SetIndexRangeGrbit.RangeUpperLimit);
var bookmarksToDelete = new List <byte[]>();
var documentsInTransaction = new List <DocumentInTransactionData>();
do
{
// esent index ranges are approximate, and we need to check them ourselves as well
if (
Api.RetrieveColumnAsGuid(session, DocumentsModifiedByTransactions,
tableColumnsCache.DocumentsModifiedByTransactionsColumns["locked_by_transaction"]) != txId)
{
continue;
}
var metadata = Api.RetrieveColumn(session, DocumentsModifiedByTransactions,
tableColumnsCache.DocumentsModifiedByTransactionsColumns["metadata"]);
var key = Api.RetrieveColumnAsString(session, DocumentsModifiedByTransactions,
tableColumnsCache.DocumentsModifiedByTransactionsColumns["key"],
Encoding.Unicode);
RavenJObject dataAsJson;
var metadataAsJson = metadata.ToJObject();
using (
Stream stream = new BufferedStream(new ColumnStream(session, DocumentsModifiedByTransactions,
tableColumnsCache.DocumentsModifiedByTransactionsColumns["data"])))
{
using (var data = documentCodecs
.Aggregate(stream, (dataStream, codec) => codec.Decode(key, metadataAsJson, dataStream)))
dataAsJson = data.ToJObject();
}
documentsInTransaction.Add(new DocumentInTransactionData
{
Data = dataAsJson,
Delete =
Api.RetrieveColumnAsBoolean(session, DocumentsModifiedByTransactions,
tableColumnsCache.DocumentsModifiedByTransactionsColumns["delete_document"]).Value,
Etag = Api.RetrieveColumn(session, DocumentsModifiedByTransactions,
tableColumnsCache.DocumentsModifiedByTransactionsColumns["etag"]).
TransfromToGuidWithProperSorting(),
Key = key,
Metadata = metadata.ToJObject(),
});
bookmarksToDelete.Add(Api.GetBookmark(session, DocumentsModifiedByTransactions));
} while (Api.TryMoveNext(session, DocumentsModifiedByTransactions));
foreach (var bookmark in bookmarksToDelete)
{
Api.JetGotoBookmark(session, DocumentsModifiedByTransactions, bookmark, bookmark.Length);
Api.JetDelete(session, DocumentsModifiedByTransactions);
}
foreach (var documentInTransactionData in documentsInTransaction)
{
perDocumentModified(documentInTransactionData);
}
}
public static bool VerifySteamHash(string executablePath)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
//Get Steam_api.dll from (parent)filepath\Among Us_Data\Plugins\x86\steam_api.dll and steam_api64.dll
var baseDllFolder = Path.Join(Directory.GetParent(executablePath).FullName, "/Among Us_Data/Plugins/x86/");
if (!Directory.Exists(baseDllFolder))
{
baseDllFolder = Path.Join(Directory.GetParent(executablePath).FullName, "/Among Us_Data/Plugins/x86_64/");
}
var steam_apiCert = AuthenticodeTools.IsTrusted(Path.Join(baseDllFolder, "steam_api.dll"));
var steam_api64Cert = AuthenticodeTools.IsTrusted(Path.Join(baseDllFolder, "steam_api64.dll"));
//Settings.conInterface.WriteModuleTextColored("GameVerifier",Color.Yellow,$"steam_apiCert: {steam_apiCert}");
//Settings.conInterface.WriteModuleTextColored("GameVerifier",Color.Yellow,$"steam_api64Cert: {steam_api64Cert}");
return((steam_apiCert) && (steam_api64Cert));
}
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
var baseDllFolder = Path.Join(Directory.GetParent(executablePath).FullName,
"/Among Us_Data/Plugins/x86/");
var steam_apiPath = Path.Join(baseDllFolder, "steam_api.dll");
var steam_api64Path = Path.Join(baseDllFolder, "steam_api64.dll");
var steam_apiHash = String.Empty;
var steam_api64Hash = String.Empty;
using (SHA1Managed sha1 = new SHA1Managed())
{
using (FileStream fs = new FileStream(steam_apiPath, FileMode.Open))
{
using (var bs = new BufferedStream(fs))
{
var hash = sha1.ComputeHash(bs);
StringBuilder steam_apihashSb = new StringBuilder(2 * hash.Length);
foreach (byte byt in hash)
{
steam_apihashSb.AppendFormat("{0:X2}", byt);
}
steam_apiHash = steam_apihashSb.ToString();
}
}
using (FileStream fs = new FileStream(steam_api64Path, FileMode.Open))
{
using (var bs = new BufferedStream(fs))
{
var hash = sha1.ComputeHash(bs);
StringBuilder steam_api64hashSb = new StringBuilder(2 * hash.Length);
foreach (byte byt in hash)
{
steam_api64hashSb.AppendFormat("{0:X2}", byt);
}
steam_api64Hash = steam_api64hashSb.ToString();
}
}
}
return(String.Equals(steamapi32_orig_hash.ToUpper(), steam_apiHash) &&
String.Equals(steamapi64_orig_hash.ToUpper(), steam_api64Hash));
}
throw new PlatformNotSupportedException();
}
/**
* Creates a CertPath of the specified type.
* This constructor is protected because most users should use
* a CertificateFactory to create CertPaths.
*
* @param type the standard name of the type of Certificatesin this path
**/
public PkixCertPath(
Stream inStream,
String encoding)
// : base("X.509")
{
try
{
if (encoding.ToUpper().Equals("PkiPath".ToUpper()))
{
Asn1InputStream derInStream = new Asn1InputStream(inStream);
Asn1Object derObject = derInStream.ReadObject();
if (!(derObject is Asn1Sequence))
{
throw new CertificateException(
"input stream does not contain a ASN1 SEQUENCE while reading PkiPath encoded data to load CertPath");
}
IEnumerator e = ((Asn1Sequence)derObject).GetEnumerator();
Stream certInStream;
MemoryStream outStream;
DerOutputStream derOutStream;
certificates = new ArrayList();
while (e.MoveNext())
{
outStream = new MemoryStream();
derOutStream = new DerOutputStream(outStream);
derOutStream.WriteObject((Asn1Encodable)e.Current);
derOutStream.Close();
certInStream = new MemoryStream(outStream.ToArray(), false);
certificates.Insert(0, new X509CertificateParser().ReadCertificate(certInStream));
}
}
else if (encoding.ToUpper().Equals("PKCS7") ||
encoding.ToUpper().Equals("PEM"))
{
inStream = new BufferedStream(inStream);
certificates = new ArrayList();
X509CertificateParser certParser = new X509CertificateParser();
X509Certificate cert = null;
while ((cert = certParser.ReadCertificate(inStream)) != null)
{
certificates.Add(cert);
}
}
else
{
throw new CertificateException("unsupported encoding: " + encoding);
}
}
catch (IOException ex)
{
throw new CertificateException(
"IOException throw while decoding CertPath:\n"
+ ex.ToString());
}
this.certificates = SortCerts(certificates);
}
private int HandleRequest(HttpContext context,
HttpRequest request,
HttpResponse response,
HmuxConnection hmuxChannel,
BufferedStream rs,
BufferedStream ws,
byte[] buf, int length, bool isComplete,
bool allowBusy)
{
Trace.TraceInformation("Handle request: length: {0}, complete: {1}, allowBusy {2}", length, isComplete, allowBusy);
String traceId = hmuxChannel.GetTraceId();
StringBuilder cb = new StringBuilder();
bool isDebugFiner = true;
String uri = request.Path;
uri = Uri.EscapeUriString(uri);
Trace.TraceInformation("Hmux[{0}] >>U:uri {1}->{2}", traceId, request.RawUrl, uri);
WriteRequestString(ws, HmuxConnection.HMUX_URI, uri, traceId);
String rawUri = request.RawUrl;
int queryIdx = rawUri.IndexOf('?');
if (queryIdx > -1 && queryIdx + 1 < rawUri.Length)
{
String query = rawUri.Substring(queryIdx + 1);
Trace.TraceInformation("Hmux[{0}] >>U:query {1}", traceId, query);
WriteRequestString(ws, HmuxConnection.CSE_QUERY_STRING, query, traceId);
}
Trace.TraceInformation("Hmux[{0}] >>m:method {1}", traceId, request.HttpMethod);
WriteRequestString(ws, HmuxConnection.HMUX_METHOD, request.HttpMethod, traceId);
Trace.TraceInformation("Hmux[{0}] >>u:server type {1}", traceId, "IIS");
WriteRequestString(ws, HmuxConnection.CSE_SERVER_TYPE, "IIS", traceId);
NameValueCollection serverVariables = request.ServerVariables;
String serverPort = serverVariables.Get("SERVER_PORT");
String serverName = serverVariables.Get("SERVER_NAME") + ':' + serverPort;
Trace.TraceInformation("Hmux[{0}] >>v:server name {1}", traceId, serverName);
WriteRequestString(ws, HmuxConnection.HMUX_SERVER_NAME, serverName, traceId);
Trace.TraceInformation("Hmux[{0}] >>g:server port {1}", traceId, serverPort);
WriteRequestString(ws, HmuxConnection.CSE_SERVER_PORT, serverPort, traceId);
String remoteAddr = serverVariables.Get("REMOTE_ADDR");
Trace.TraceInformation("Hmux[{0}] >>i:remote address {1}", traceId, remoteAddr);
WriteRequestString(ws, HmuxConnection.CSE_REMOTE_ADDR, remoteAddr, traceId);
String remoteHost = serverVariables.Get("REMOTE_HOST");
if (remoteHost == null)
{
remoteHost = remoteAddr;
}
Trace.TraceInformation("Hmux[{0}] >>h:remote host {1}", traceId, remoteHost);
WriteRequestString(ws, HmuxConnection.CSE_REMOTE_HOST, remoteHost, traceId);
String protocol = serverVariables.Get("HTTP_VERSION");
Trace.TraceInformation("Hmux[{0}] >>c:protocol {1}", traceId, protocol);
WriteRequestString(ws, HmuxConnection.CSE_PROTOCOL, protocol, traceId);
HttpClientCertificate clientCertificate = request.ClientCertificate;
if (request.IsSecureConnection)
{
Trace.TraceInformation("Hmux[{0}] >>r:secure", traceId);
WriteRequestString(ws, HmuxConnection.CSE_IS_SECURE, "", traceId);
WriteRequestHeader(ws, "HTTPS", "on", traceId);
WriteRequestHeader(ws, "SSL_SECRETKEYSIZE", clientCertificate.KeySize.ToString(), traceId);
}
if (clientCertificate.IsPresent)
{
Trace.TraceInformation("Hmux[{0}] >>r:certificate ({1})", traceId, clientCertificate.Certificate.Length);
ws.WriteByte(HmuxConnection.CSE_CLIENT_CERT);
WriteHmuxLength(ws, clientCertificate.Certificate.Length);
ws.Write(clientCertificate.Certificate, 0, clientCertificate.Certificate.Length);
}
if (request.IsAuthenticated)
{
/*
* String remoteUser = request.LogonUserIdentity.Name;
*/
String remoteUser = HttpContext.Current.User.Identity.Name;
WriteRequestString(ws, HmuxConnection.CSE_REMOTE_USER, remoteUser, traceId);
}
NameValueCollection headers = request.Headers;
foreach (String key in headers.AllKeys)
{
if ("Connection".Equals(key, StringComparison.OrdinalIgnoreCase))
{
continue;
}
String[] values = headers.GetValues(key);
foreach (String value in values)
{
WriteRequestHeader(ws, key, value, traceId);
}
}
if (_isDebug)
{
WriteRequestHeader(ws, "X-Resin-Debug", traceId, traceId);
}
Stream requestStream = request.InputStream;
Stream responseStream = null;
bool hasHeader = true;
bool hasStatus = false;
if (length > 0)
{
Trace.TraceInformation("Hmux[{0}] >>D: data ({1})", traceId, length);
WriteRequestData(ws, HmuxConnection.HMUX_DATA, buf, length, traceId);
}
int len;
int code;
while (!isComplete && (len = requestStream.Read(buf, 0, buf.Length)) > 0)
{
Trace.TraceInformation("Hmux[{0}] >>D: data ({1})", traceId, length);
WriteRequestData(ws, HmuxConnection.HMUX_DATA, buf, len, traceId);
Trace.TraceInformation("Hmux[{0}] >>Y: (yield)", traceId);
ws.WriteByte(HmuxConnection.HMUX_YIELD);
ws.Flush();
while (true)
{
code = rs.ReadByte();
if (code < 0)
{
Trace.TraceInformation("Hmux[{0}] <<w: end of file", traceId);
if (hasStatus)
{
return(OK | EXIT);
}
else
{
// Trace.TraceInformation("Hmux[{0}] <<w: unexpected end of file", traceId);
return(FAIL | EXIT);
}
}
else if (code == HmuxConnection.HMUX_QUIT)
{
Trace.TraceInformation("Hmux[{0}] <<Q: (keepalive)", traceId);
if (hasStatus)
{
return(OK | QUIT);
}
else
{
Trace.TraceInformation("Hmux[{0}] <<Q: unexpected quit file", traceId);
return(FAIL | QUIT);
}
}
else if (code == HmuxConnection.HMUX_EXIT)
{
Trace.TraceInformation("Hmux[{0}] <<X: (exit)", traceId);
if (hasStatus)
{
return(OK | EXIT);
}
else
{
Trace.TraceInformation("Hmux[{0}] <<X: unexpected exit", traceId);
return(FAIL | EXIT);
}
}
else if (code == HmuxConnection.HMUX_YIELD)
{
Trace.TraceInformation("Hmux[{0}] <<Y: (yield)", traceId);
continue;
}
int sublen = ReadHmuxLength(rs);
if (code == HmuxConnection.HMUX_ACK)
{
if (isDebugFiner)
{
Trace.TraceInformation("Hmux[{0}] <<A: (ack) ({1})", traceId, sublen);
}
break;
}
else if (code == HmuxConnection.HMUX_CHANNEL)
{
int channel = sublen;
Trace.TraceInformation("Hmux[{0}] <<C: (channel) ({1})", traceId, channel);
}
else if (code == HmuxConnection.HMUX_STATUS && hasHeader)
{
String status = ReadHmuxString(rs, sublen);
Trace.TraceInformation("Hmux[{0}] <<s: (status) ({1})", traceId, status);
int statusCode = 0;
for (int i = 0; i < 3; i++)
{
statusCode = 10 * statusCode + status[i] - '0';
}
if (statusCode != 200)
{
response.StatusCode = statusCode;
}
hasStatus = true;
}
else if (code == HmuxConnection.HMUX_HEADER && hasHeader)
{
String name = ReadHmuxString(rs, sublen);
rs.ReadByte();
sublen = ReadHmuxLength(rs);
String value = ReadHmuxString(rs, sublen);
Trace.TraceInformation("Hmux[{0}] <<H,S: (header) ({1}={2})", traceId, name, value);
RelayResponseHeader(response, name, value);
}
else if (code == HmuxConnection.HMUX_DATA)
{
Trace.TraceInformation("Hmux[{0}] <<D: (data)({1})", traceId, sublen);
if (responseStream == null)
{
responseStream = response.OutputStream;
}
RelayResponseData(rs, responseStream, sublen);
}
else if (code == HmuxConnection.HMUX_META_HEADER)
{
String name = ReadHmuxString(rs, sublen);
rs.ReadByte();
sublen = ReadHmuxLength(rs);
String value = ReadHmuxString(rs, sublen);
Trace.TraceInformation("Hmux[{0}] <<M,S: header ({1}={2})", traceId, name, value);
if ("cpu-load".Equals(name))
{
double loadAvg = 0.001 * long.Parse(value);
hmuxChannel.GetPool().SetCpuLoadAvg(loadAvg);
}
}
else
{
Skip(rs, sublen);
}
}
}
ws.WriteByte(HmuxConnection.HMUX_QUIT);
ws.Flush();
code = rs.ReadByte();
// #2369 - A slow modem can cause the app-tier and web-tier times
// to get out of sync, with the app-tier thinking it's completed
// (and starts the keepalive timeout) 30s before the web-tier reads
// its data.
// As a temporary measure, we start the idle time at the first data
// read (later we might mark the time it takes to read an app-tier
// packet. If it's short, e.g. 250ms, don't update the time.)
hmuxChannel.SetIdleStartTime(Utils.CurrentTimeMillis());
bool isBusy = false;
for (; code >= 0; code = rs.ReadByte())
{
if (code == HmuxConnection.HMUX_QUIT)
{
if (isDebugFiner)
{
Trace.TraceInformation("Hmux[{0}] <<Q: (keepalive)", traceId);
}
return(isBusy ? BUSY | QUIT : OK | QUIT);
}
else if (code == HmuxConnection.HMUX_EXIT)
{
Trace.TraceInformation("Hmux[{0}] <<X: (exit)", traceId);
return((isBusy || !hasStatus) ? BUSY | EXIT : OK | EXIT);
}
else if (code == HmuxConnection.HMUX_YIELD)
{
Trace.TraceInformation("Hmux[{0}] <<Y: (yield)", traceId);
continue;
}
int sublen = (rs.ReadByte() << 8) + rs.ReadByte();
if (code == HmuxConnection.HMUX_DATA)
{
if (responseStream == null)
{
responseStream = response.OutputStream;
}
Trace.TraceInformation("Hmux[{0}] <<D: (data)({1})", traceId, sublen);
if (!isBusy)
{
RelayResponseData(rs, responseStream, sublen);
}
else
{
Skip(rs, sublen);
}
}
else if (code == HmuxConnection.HMUX_STATUS && hasHeader)
{
hasStatus = true;
String status = ReadHmuxString(rs, sublen);
Trace.TraceInformation("Hmux[{0}] <<s: (status) ({1})", traceId, status);
int statusCode = 0;
for (int i = 0; i < 3; i++)
{
statusCode = 10 * statusCode + status[i] - '0';
}
if (statusCode == 503 && allowBusy)
{
isBusy = true;
}
else if (statusCode != 200)
{
response.StatusCode = statusCode;
}
}
else if (code == HmuxConnection.HMUX_HEADER && hasHeader)
{
String name = ReadHmuxString(rs, sublen);
rs.ReadByte();
sublen = ReadHmuxLength(rs);
String value = ReadHmuxString(rs, sublen);
Trace.TraceInformation("Hmux[{0}] <<H,S: (header) ({1}={2})", traceId, name, value);
if (!isBusy)
{
RelayResponseHeader(response, name, value);
}
}
else if (code == HmuxConnection.HMUX_META_HEADER)
{
String name = ReadHmuxString(rs, sublen);
rs.ReadByte();
sublen = ReadHmuxLength(rs);
String value = ReadHmuxString(rs, sublen);
Trace.TraceInformation("Hmux[{0}] <<M,S: header ({1}={2})", traceId, name, value);
if ("cpu-load".Equals(name))
{
double loadAvg = 0.001 * long.Parse(value);
hmuxChannel.GetPool().SetCpuLoadAvg(loadAvg);
}
}
else if (code == HmuxConnection.HMUX_CHANNEL)
{
int channel = sublen;
Trace.TraceInformation("Hmux[{0}] <<C: (channel) ({1})", traceId, channel);
}
else if (code == HmuxConnection.CSE_SEND_HEADER)
{
Trace.TraceInformation("Hmux[{0}] <<G: send headers", traceId);
Skip(rs, sublen);
}
else if (code == 0)
{
Trace.TraceInformation("Hmux[{0}] <<0: unknown code (0)", traceId);
return(FAIL | EXIT);
}
else
{
Trace.TraceInformation("Hmux[{0}] <<?: unknown code ({1})", traceId, code);
Skip(rs, sublen);
}
}
Trace.TraceInformation("Hmux[{0}] end of file", traceId);
// server/269q
if (hasStatus)
{
return(isBusy ? BUSY | EXIT : OK | EXIT);
}
else
{
// Trace.TraceInformation("Hmux[{0}] unexpected end of file", traceId, code);
return(FAIL | EXIT);
}
}
public DuplexBufferedStream(Stream stream, int bufferSize)
{
_readStream = new BufferedStream(stream, bufferSize);
_writeStream = new BufferedStream(stream, bufferSize);
_bufferSize = bufferSize;
}
private void WriteRequestData(BufferedStream stream, int code, byte[] data, int length, String traceId)
{
stream.WriteByte(HmuxConnection.HMUX_DATA);
WriteHmuxLength(stream, length);
stream.Write(data, 0, length);
}
public override void Action(TcpClient socket, string content, string[] Route)
{
if (Header.ContainsKey("Host"))
{
FFmpeg.Http = Http = "http://" + Header["Host"] + "/";
}
if (Route[1].ToLower() == "webapi")
{
#region 版本V2
if (Route[2].ToLower() == "iscs.wcs.vms" || string.IsNullOrEmpty(Route[2].ToLower()))
{
MergeResult NvrVideo = new MergeResult();
MergeResult CifsVideo = new MergeResult();
bool resgobal = false;
bool reslocal = false;
#region 合并
if (Route[3].ToLower() == "mergevideo")
{
List <object> para = JsonConvert.DeserializeObject <List <object> >(content);
ReuestInfo param = JsonConvert.DeserializeObject <ReuestInfo>(para[0].ToString());
if (param == null)
{
param = new ReuestInfo();
}
else
{
param.Hash = HashCode.GetHash(content);
resgobal = Strap.RequestGobal(param.Channels, param.PackageUkid + "_" + param.Hash);
NvrVideo = FFmpeg.MergeVideo(param.PackageUkid + "_" + param.Hash + "_gobal");
reslocal = Strap.RequestLocal(long.Parse(param.PackageUkid));
CifsVideo = FFmpeg.MergeVideo(param.PackageUkid.ToString() + "_local");
}
NvrVideo.PackageUkid = long.Parse(param.PackageUkid);
CifsVideo.PackageUkid = long.Parse(param.PackageUkid);
string id = Guid.NewGuid().ToString().Replace("-", "");
string result = new ReturnResult().Json(NvrVideo, CifsVideo, id);
SendCode(socket, result);
}
#endregion
#region 设置OSD
else if (Route[3].ToLower() == "osd")
{
// HttpRespone.RequestForm(content);
List <object> param = JsonConvert.DeserializeObject <List <object> >(content);
_log.Error(param[0] + "." + param[1] + "." + param[2]);
if (Strap.Device != null)
{
bool result = Strap.Device.IPCOSD(param[0].ToString(), param[1].ToString(), param[2].ToString());
if (result)
{
SendJson(socket, "{\"result\":\"ok\"}");
}
else
{
_log.Error(Strap.Device.ErrorMsg);
SendJson(socket, "{\"result\":\"fail\",\"msg\":\"" + Strap.Device.ErrorMsg + "\"}");
}
}
else
{
SendJson(socket, "{\"result\":\"ok\"}");
}
}
#endregion
#region 保存图片
else if (Route[3].ToLower() == "saveimage")
{
// HttpRespone.RequestForm(content);
string name = DateTime.Now.Ticks + ".jpg";
if (!Directory.Exists(FFmpeg.FileSavePath))
{
Directory.CreateDirectory(FFmpeg.FileSavePath);
}
string filename = FFmpeg.FileSavePath + name;
List <object> param = JsonConvert.DeserializeObject <List <object> >(content);
bool re = Strap.Device.SaveImage(param[0].ToString(), param[1].ToString(), filename);
_log.Debug(filename);
if (re)
{
SendJson(socket, "{\"result\":\"ok\",\"url\":\"http://" + _url + "/jpg/" + name + "\"}");
}
else
{
SendJson(socket, "{\"result\":\"fail\",\"msg\":\"" + Strap.Device.ErrorMsg + "\"}");
}
}
#endregion
#region 获取摄像头
else if (Route[3].ToLower() == "camera")
{
SendJson(socket, JsonConvert.SerializeObject(NVRInfos));
}
#endregion
#region 开始录像
else if (Route[3].ToLower() == "savevideo")
{
List <object> param = JsonConvert.DeserializeObject <List <object> >(content);
_log.Error(param[0] + "." + param[1] + "." + param[2]);
int id = Strap.Device.SaveVideo(param[0].ToString(), param[1].ToString(), long.Parse(param[2].ToString()));
if (id != 0)
{
SendJson(socket, "{\"result\":\"ok\",\"msg\":" + id + "}");
}
else
{
SendJson(socket, "{\"result\":\"fail\",\"msg\":" + Strap.Device.ErrorMsg + "}");
}
}
#endregion
#region 停止录像
else if (Route[3].ToLower() == "stopvideo")
{
List <object> param = JsonConvert.DeserializeObject <List <object> >(content);
bool result = Strap.Device.StopVideo(int.Parse(param[0].ToString()));
if (result)
{
SendJson(socket, "{\"result\":\"ok\"}");
}
else
{
SendJson(socket, "{\"result\":\"ok\",\"msg\":\"" + Strap.Device.ErrorMsg + "\"}");
}
}
#endregion
}
#endregion
}
else if (Route[1].ToLower() == "video")
{
string localfile = VirtualDirectory + "video\\" + Route[2].ToLower();
if (File.Exists(localfile))
{
FileStream fs = new FileStream(localfile, FileMode.Open, FileAccess.Read);
BufferedStream bs2 = new BufferedStream(fs);
HttpRespone.SendHeader(_httpversion, "application/octet-stream", bs2.Length, " 200 OK", ref socket);
byte[] bytes = new byte[4096];
int read;
while ((read = bs2.Read(bytes, 0, bytes.Length)) != 0)
{
HttpRespone.SendToBrowser(bytes, ref socket);
}
bs2.Close();
}
else
{
HttpRespone.SendError(_httpversion, "文件存在", ref socket);
}
}
else if (Route[1].ToLower() == "jpg")
{
string localfile = VirtualDirectory + "video\\" + Route[2].ToLower();
if (File.Exists(localfile))
{
FileStream fs = new FileStream(localfile, FileMode.Open, FileAccess.Read);
BufferedStream bs2 = new BufferedStream(fs);
HttpRespone.SendHeader(_httpversion, "image/jpeg", bs2.Length, " 200 OK", ref socket);
byte[] bytes = new byte[4096];
int read;
while ((read = bs2.Read(bytes, 0, bytes.Length)) != 0)
{
HttpRespone.SendToBrowser(bytes, ref socket);
}
bs2.Close();
}
else
{
HttpRespone.SendError(_httpversion, "文件存在", ref socket);
}
}
else
{
SendCode(socket, HtmlTemp.Html(new HttpCode().AppCode(Strap.Device.NVRInfos), 1));
}
}
public async Task <string> SendGetRequest(string url)
{
System.Net.ServicePointManager.Expect100Continue = false;
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; // set the TLS Protocol
// Create the web request
HttpWebRequest request = WebRequest.Create(new Uri(url)) as HttpWebRequest;
// request.ServicePoint.Expect100Continue = false;
// Set type to POST
request.Method = "GET";
request.KeepAlive = false;
request.ServicePoint.Expect100Continue = false;
request.ServicePoint.UseNagleAlgorithm = false;
// Сообщаем серверу, что умеем работать с zip
request.Headers.Add("Accept-Encoding", "gzip");
try
{
string result = null;
using (HttpWebResponse response = await request.GetResponseAsync() as HttpWebResponse)
{
Stream buffer = null;
if (response.ContentEncoding != "gzip")
{
buffer = new BufferedStream(response.GetResponseStream());
}
else
{
buffer = new GZipStream(response.GetResponseStream(), CompressionMode.Decompress);
}
using (StreamReader reader = new StreamReader(buffer))
result = await reader.ReadToEndAsync();
buffer.Dispose();
}
return(result);
}
catch (WebException wex)
{
string errorMessage = String.Format("Status Code: {0}; Message: {1}", wex.Status.ToString(), wex.Message);
if (wex.Response != null)
{
using (var sr = new StreamReader(wex.Response.GetResponseStream()))
{
Stream buffer = null;
if (wex.Response is HttpWebResponse && ((HttpWebResponse)wex.Response).ContentEncoding != "gzip")
{
buffer = new BufferedStream(wex.Response.GetResponseStream());
}
else
{
buffer = new GZipStream(wex.Response.GetResponseStream(), CompressionMode.Decompress);
}
using (StreamReader reader = new StreamReader(buffer))
errorMessage = await reader.ReadToEndAsync();
buffer.Dispose();
}
}
throw new Exception("Provider failed to process request: " + errorMessage);
}
}
internal SignerInfo ToSignerInfo(
DerObjectIdentifier contentType,
CmsProcessable content,
SecureRandom random)
{
AlgorithmIdentifier digAlgId = DigestAlgorithmID;
string digestName = Helper.GetDigestAlgName(digestOID);
string signatureName = digestName + "with" + Helper.GetEncryptionAlgName(encOID);
byte[] hash;
if (outer._digests.Contains(digestOID))
{
hash = (byte[])outer._digests[digestOID];
}
else
{
IDigest dig = Helper.GetDigestInstance(digestName);
if (content != null)
{
content.Write(new DigOutputStream(dig));
}
hash = DigestUtilities.DoFinal(dig);
outer._digests.Add(digestOID, hash.Clone());
}
IStreamCalculator calculator = sigCalc.CreateCalculator();
#if NETCF_1_0 || NETCF_2_0 || SILVERLIGHT || PORTABLE
Stream sigStr = calculator.Stream;
#else
Stream sigStr = new BufferedStream(calculator.Stream);
#endif
Asn1Set signedAttr = null;
if (sAttr != null)
{
IDictionary parameters = outer.GetBaseParameters(contentType, digAlgId, hash);
// Asn1.Cms.AttributeTable signed = sAttr.GetAttributes(Collections.unmodifiableMap(parameters));
Asn1.Cms.AttributeTable signed = sAttr.GetAttributes(parameters);
if (contentType == null) //counter signature
{
if (signed != null && signed[CmsAttributes.ContentType] != null)
{
IDictionary tmpSigned = signed.ToDictionary();
tmpSigned.Remove(CmsAttributes.ContentType);
signed = new Asn1.Cms.AttributeTable(tmpSigned);
}
}
// TODO Validate proposed signed attributes
signedAttr = outer.GetAttributeSet(signed);
// sig must be composed from the DER encoding.
new DerOutputStream(sigStr).WriteObject(signedAttr);
}
else if (content != null)
{
// TODO Use raw signature of the hash value instead
content.Write(sigStr);
}
Platform.Dispose(sigStr);
byte[] sigBytes = ((IBlockResult)calculator.GetResult()).Collect();
Asn1Set unsignedAttr = null;
if (unsAttr != null)
{
IDictionary baseParameters = outer.GetBaseParameters(contentType, digAlgId, hash);
baseParameters[CmsAttributeTableParameter.Signature] = sigBytes.Clone();
// Asn1.Cms.AttributeTable unsigned = unsAttr.GetAttributes(Collections.unmodifiableMap(baseParameters));
Asn1.Cms.AttributeTable unsigned = unsAttr.GetAttributes(baseParameters);
// TODO Validate proposed unsigned attributes
unsignedAttr = outer.GetAttributeSet(unsigned);
}
// TODO[RSAPSS] Need the ability to specify non-default parameters
Asn1Encodable sigX509Parameters = SignerUtilities.GetDefaultX509Parameters(signatureName);
AlgorithmIdentifier encAlgId = Helper.GetEncAlgorithmIdentifier(
new DerObjectIdentifier(encOID), sigX509Parameters);
return(new SignerInfo(signerIdentifier, digAlgId,
signedAttr, encAlgId, new DerOctetString(sigBytes), unsignedAttr));
}
public MessagesStreamReader(Stream stream)
{
this.stream = new BufferedStream(stream);
this.reader = new BinaryReader(this.stream);
}
private void DoGenerate(MmdModel model, MmdMotion motion, string savePath, float frameStepLength,
float timeAfterMotionFinish, float physicsStepLength)
{
try
{
_status = GenerateStatus.Preparing;
if (physicsStepLength > frameStepLength)
{
physicsStepLength = frameStepLength;
}
var poser = new Poser(model);
var motionPlayer = new MotionPlayer(motion, poser);
var physicsReactor = new BulletPyhsicsReactor();
var totalTimeLength = motion.Length / 30.0 + timeAfterMotionFinish;
var totalStepCount = (int)(totalTimeLength / frameStepLength) + 1;
var playPos = 0.0;
var maxSubSteps = (int)(frameStepLength / physicsStepLength) + 1;
using (var fileStream = new FileStream(savePath, FileMode.Create))
{
using (var bufferedStream = new BufferedStream(fileStream))
{
using (var binaryWriter = new BinaryWriter(bufferedStream))
{
WriteHeader(binaryWriter, model, totalStepCount + 1, frameStepLength);
_status = GenerateStatus.CalculatingFrames;
_totalFrames = totalStepCount + 1;
_calculatedFrames = 0;
physicsReactor.AddPoser(poser);
motionPlayer.SeekFrame(0);
poser.PrePhysicsPosing();
physicsReactor.Reset();
poser.PostPhysicsPosing();
WritePose(binaryWriter, poser);
_calculatedFrames = 1;
for (var i = 0; i < totalStepCount; ++i)
{
playPos += frameStepLength;
motionPlayer.SeekTime(playPos);
poser.PrePhysicsPosing();
physicsReactor.React(frameStepLength, maxSubSteps, physicsStepLength);
poser.PostPhysicsPosing();
WritePose(binaryWriter, poser);
_calculatedFrames = i + 2;
if (_canceled)
{
_status = GenerateStatus.Canceled;
return;
}
}
}
}
}
_status = GenerateStatus.Finished;
}
catch (Exception e)
{
_status = GenerateStatus.Failed;
Debug.LogException(e);
}
finally
{
if (_status != GenerateStatus.Finished)
{
try
{
File.Delete(savePath);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
}
