private static void SendHeader(Stream stream, HttpResponse response)
{
foreach (var(key, value) in response.Header)
{
stream.WriteLine($"{key}: {value}");
}
stream.WriteLine();
}
private static void SendHeader(Stream stream, HttpResponse response)
{
foreach (var kvp in response.Header)
{
stream.WriteLine($"{kvp.Key}: {kvp.Value}");
}
stream.WriteLine();
}
public void Encode(Stream memoryStream, UpnpPlaceHolder placeHolder = null, bool flushStream = true)
{
memoryStream.WriteLine($"{this.HttpVersion} {this.HttpCode} {this.HttpText}");
Array.ForEach(this.Headers.Items(), (singleHeader) => memoryStream.WriteLine(singleHeader.ToString()));
memoryStream.WriteLine("");
if (flushStream)
{
memoryStream.Flush();
}
}
public void Encode(Stream memoryStream, bool flushStream = true)
{
memoryStream.WriteLine($"{this.Method} {this.Url} {this.Text}");
Array.ForEach(this.Headers.Items(), (singleHeader) => memoryStream.WriteLine(singleHeader.ToString()));
memoryStream.WriteLine("");
if (flushStream)
{
memoryStream.Flush();
}
}
private static void WriteFinishTranscation(Stream stream, bool dryRun)
{
if (dryRun)
{
stream.WriteLine("ROLLBACK TRANSACTION DATAFACTORY;");
}
else
{
stream.WriteLine("COMMIT TRANSACTION DATAFACTORY;");
}
}
public Stream WriteTo(Stream stream)
{
stream.WriteLine((string)Name);
stream.WriteLine("{");
foreach (var property in Properties)
{
stream.WritePropertyVerbatim((string)property.Name, property.Value, indent: true);
}
stream.WriteLine("}");
return(stream);
}
internal System.IO.Stream GetSaveStream(HTTPResponse response)
{
if (!HTTPCacheService.IsSupported)
{
return(null);
}
LastAccess = DateTime.UtcNow;
string path = GetPath();
if (HTTPManager.IOService.FileExists(path))
{
Delete();
}
// Path name too long, we don't want to get exceptions
if (path.Length > HTTPManager.MaxPathLength)
{
return(null);
}
// First write out the headers
using (Stream writer = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Create) /*new FileStream(path, FileMode.Create)*/)
{
writer.WriteLine("HTTP/1.1 {0} {1}", response.StatusCode, response.Message);
foreach (var kvp in response.Headers)
{
for (int i = 0; i < kvp.Value.Count; ++i)
{
writer.WriteLine("{0}: {1}", kvp.Key, kvp.Value[i]);
}
}
writer.WriteLine();
}
// If caching is enabled and the response is from cache, and no content-length header set, then we set one to the response.
if (response.IsFromCache && !response.Headers.ContainsKey("content-length"))
{
response.Headers.Add("content-length", new List <string> {
BodyLength.ToString()
});
}
SetUpCachingValues(response);
// then create the stream with Append FileMode
return(HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Append)); //new FileStream(GetPath(), FileMode.Append);
}
public void Save(Stream stream)
{
_offsets.Clear();
var writtenObjects = new HashSet <PdfObject>();
BeforeWrite(_catalog);
AssignIds();
stream.WriteLine("%PDF-1.6");
stream.Write(_binaryMarker, 0, _binaryMarker.Length); // binary marker, just easier to always include
WriteObject(_catalog, stream, writtenObjects);
var xrefCount = _offsets.Count + 1; // to account for the required zero-id object
var xrefLoc = stream.Position;
stream.WriteLine("xref");
stream.WriteLine($"0 {xrefCount}");
stream.WriteLine($"0000000000 {ushort.MaxValue} f"); // said required zero-id free object
for (var i = 0; i < _offsets.Count; i++)
{
stream.WriteLine($"{_offsets[i].ToString().PadLeft(10, '0')} {(0).ToString().PadLeft(5, '0')} n");
}
stream.WriteLine($"trailer <</Size {xrefCount} /Root {_catalog.Id.AsObjectReference()}>>");
stream.WriteLine("startxref");
stream.Write(xrefLoc.ToString());
stream.WriteLine("");
stream.Write("%%EOF");
}
protected override void WriteXmlHeader(Stream streamToFill)
{
streamToFill.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
streamToFill.WriteLine("<feed xmlns=\"http://www.w3.org/2005/Atom\" xmlns:g=\"http://base.google.com/ns/1.0\">");
streamToFill.WriteLine(String.Format("<title>{0}</title>", _feedTitle));
streamToFill.WriteLine(String.Format("<link rel=\"self\" href=\"{0}\"/>", _feedLink));
streamToFill.WriteLine(String.Format("<updated>{0}</updated>", getFormatedDate(DateTime.Now)));
streamToFill.WriteLine("<author>");
streamToFill.WriteLine(String.Format("<name>{0}</name>", _feedAuthor));
streamToFill.WriteLine("</author>");
streamToFill.WriteLine(String.Format("<id>{0}</id>", _feedId));
}
protected override void WriteXmlHeader(Stream streamToFill)
{
streamToFill.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
streamToFill.WriteLine("<feed xmlns=\"http://www.w3.org/2005/Atom\" xmlns:g=\"http://base.google.com/ns/1.0\">");
streamToFill.WriteLine(String.Format("<title>{0}</title>", _feedTitle));
streamToFill.WriteLine(String.Format("<link rel=\"self\" href=\"{0}\"/>", _feedLink));
streamToFill.WriteLine(String.Format("<updated>{0}</updated>", getFormatedDate(DateTime.Now)));
streamToFill.WriteLine("<author>");
streamToFill.WriteLine(String.Format("<name>{0}</name>", _feedAuthor));
streamToFill.WriteLine("</author>");
streamToFill.WriteLine(String.Format("<id>{0}</id>", _feedId));
}
public void Log(LogCategory category, string text, params object[] parameters)
{
if ((EnabledCategories & category) != 0)
{
Stream.WriteLine(text, parameters);
}
}
public static void Write(Stream stream, HttpResponse response)
{
stream.WriteLine($"HTTP/1.1 {response.ResponseCode} {ResponseCodes.Get(response.ResponseCode)}");
response.Header ??= new Dictionary <string, string>();
response.Header["Connection"] = "close";
if (response.ResponseStream != null &&
!response.Header.ContainsKey("Content-Length"))
{
response.Header["Transfer-Encoding"] = "chunked";
}
SendHeader(stream, response);
if (response.ResponseStream == null)
{
return;
}
if (response.Header.ContainsKey("Content-Length"))
{
SendContent(stream, response, Convert.ToInt64(response.Header["Content-Length"]));
}
else
{
SendContent(stream, response);
}
}
private static void SendContent(Stream stream, HttpResponse response)
{
var buff = new byte[4096];
while (true)
{
var sz = response.ResponseStream.Read(buff, 0, 4096);
stream.WriteLine($"{sz:x}");
stream.Write(buff, 0, sz);
stream.WriteLine();
if (sz == 0)
{
break;
}
}
}
public override void RenderCommand(Stream stream)
{
var header = string.Format("data {0}", _Bytes.Length);
stream.WriteLine(header);
stream.Write(_Bytes, 0, _Bytes.Length);
stream.WriteLineFeed();
}
private static void WriteDisableTriggers(Stream stream, bool disableTriggers)
{
if (disableTriggers)
{
stream.WriteLine("DISABLE TRIGGER ALL ON DATABASE;");
}
}
public static void WriteLine(this Stream fs, string line)
{
var buff = line.GetASCIIBytes();
fs.Write(buff, 0, buff.Length);
fs.WriteLine();
BufferPool.Release(buff);
}
public override void RenderCommand(Stream stream)
{
var header = string.Format("data {0}", _Bytes.Length);
stream.WriteLine(header);
stream.Write(_Bytes, 0, _Bytes.Length);
stream.WriteLineFeed();
}
public static void WriteLine(this Stream fs, string format, params object[] values)
{
var buff = string.Format(format, values).GetASCIIBytes();
fs.Write(buff, 0, buff.Length);
fs.WriteLine();
BufferPool.Release(buff);
}
internal void Store(HTTPResponse response)
{
if (!HTTPCacheService.IsSupported)
{
return;
}
string path = GetPath();
// Path name too long, we don't want to get exceptions
if (path.Length > HTTPManager.MaxPathLength)
{
return;
}
// Don't delete and write the very same content to the disk if possible.
if (!AlreadyStored(response))
{
if (HTTPManager.IOService.FileExists(path))
{
Delete();
}
using (Stream writer = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Create))
{
writer.WriteLine("HTTP/1.1 {0} {1}", response.StatusCode, response.Message);
foreach (var kvp in response.Headers)
{
for (int i = 0; i < kvp.Value.Count; ++i)
{
writer.WriteLine("{0}: {1}", kvp.Key, kvp.Value[i]);
}
}
writer.WriteLine();
writer.Write(response.Data, 0, response.Data.Length);
}
BodyLength = response.Data.Length;
}
LastAccess = DateTime.UtcNow;
SetUpCachingValues(response);
}
public static void Write(this Stream stream, string value, bool includeNewLine = true)
{
stream.Write(Encoding.Default.GetBytes(value));
if (includeNewLine)
{
stream.WriteLine();
}
}
public void WriteTo(Stream stream)
{
var line = string.Format("{0} {1} {2}", Version, (int)StatusCode, StatusDescription);
//Debug.WriteLine(line);
stream.WriteLine(line);
foreach (var pair in Headers)
{
if (pair.Key.ToLowerInvariant() == "proxy-connection")
continue;
line = string.Format("{0}: {1}", pair.Key, pair.Value);
stream.WriteLine(line);
}
//Debug.WriteLine(null);
stream.WriteLine();
//stream.Flush();
}
public Stream WriteTo(Stream stream)
{
CheckSemanticValidity();
stream.WriteLine("vertex");
stream.WriteLine("{");
stream.WriteProperty("x", _x, indent: true);
stream.WriteProperty("y", _y, indent: true);
if (Comment != "")
{
stream.WriteProperty("comment", Comment, indent: true);
}
foreach (var property in UnknownProperties)
{
stream.WritePropertyVerbatim((string)property.Name, property.Value, indent: true);
}
stream.WriteLine("}");
return(stream);
}
public override void RenderCommand(Stream stream)
{
stream.WriteLine(string.Format("reset {0}", Reference));
if (From != null)
{
stream.WriteString("from ");
From.RenderMarkReference(stream);
stream.WriteLineFeed();
}
}
public override void RenderCommand(Stream stream)
{
stream.WriteLine(string.Format("reset {0}", Reference));
if (From != null)
{
stream.WriteString("from ");
From.RenderMarkReference(stream);
stream.WriteLineFeed();
}
}
protected void RenderMarkCommand(Stream stream)
{
if (MarkId != null)
{
var command = string.Format("mark :{0}", MarkId);
stream.WriteLine(command);
_HasBeenRendered = true;
}
}
public override void RenderCommand(Stream stream)
{
var command = CommandName;
if (!string.IsNullOrEmpty(Name))
command += " " + Name;
command += string.Format(" <{0}> ", Email);
command += FormatDate(Date);
stream.WriteLine(command);
}
protected void RenderMarkCommand(Stream stream)
{
if (MarkId != null)
{
var command = string.Format("mark :{0}", MarkId);
stream.WriteLine(command);
_HasBeenRendered = true;
}
}
internal void Store(HTTPResponse response)
{
if (!HTTPCacheService.IsSupported)
{
return;
}
string path = GetPath();
UnityEngine.Debug.Log($"Cache Store path => {path}");
// Path name too long, we don't want to get exceptions
if (path.Length > HTTPManager.MaxPathLength)
{
return;
}
if (HTTPManager.IOService.FileExists(path))
{
Delete();
}
using (Stream writer = HTTPManager.IOService.CreateFileStream(GetPath(), FileStreamModes.Create) /*new FileStream(path, FileMode.Create)*/)
{
writer.WriteLine("HTTP/1.1 {0} {1}", response.StatusCode, response.Message);
foreach (var kvp in response.Headers)
{
for (int i = 0; i < kvp.Value.Count; ++i)
{
writer.WriteLine("{0}: {1}", kvp.Key, kvp.Value[i]);
}
}
writer.WriteLine();
writer.Write(response.Data, 0, response.Data.Length);
}
BodyLength = response.Data.Length;
LastAccess = DateTime.UtcNow;
SetUpCachingValues(response);
}
public void WriteTo(Stream stream)
{
var line = string.Format("{0} {1} {2}", Version, (int)StatusCode, StatusDescription);
//Debug.WriteLine(line);
stream.WriteLine(line);
foreach (var pair in Headers)
{
if (pair.Key.ToLowerInvariant() == "proxy-connection")
{
continue;
}
line = string.Format("{0}: {1}", pair.Key, pair.Value);
stream.WriteLine(line);
}
//Debug.WriteLine(null);
stream.WriteLine();
//stream.Flush();
}
public override void RenderCommand(Stream stream)
{
if (!IsRendered)
{
IsRendered = true;
stream.WriteLine("blob");
base.RenderMarkCommand(stream);
stream.RenderCommand(DataCommand);
}
}
public void WriteDocElement(string element, string text)
{
if (string.IsNullOrWhiteSpace(text))
{
return;
}
WriteIndents();
Stream.WriteLine($"/// <{element}>");
WriteIndents();
Stream.WriteLine($"/// {text}");
WriteIndents();
Stream.WriteLine($"/// </{element}>");
}
public override void RenderCommand(Stream stream)
{
var command = CommandName;
if (!string.IsNullOrEmpty(Name))
{
command += " " + Name;
}
command += string.Format(" <{0}> ", Email);
command += FormatDate(Date);
stream.WriteLine(command);
}
private static void WriteInsertions(Stream stream, ISql sql, TableDescription[] tableDescriptions)
{
using var connection = sql.CreateConnection();
var server = new Server(new ServerConnection(connection));
var database = server.Databases[DEFAULT_DATABASENAME];
foreach (var tableDescription in tableDescriptions)
{
bool Match(Table table) => table.Schema == tableDescription.Schema &&
table.Name == tableDescription.Name;
var table = database
.Tables
.Cast <Table>()
.First(Match);
var tableName = tableDescription.TableName();
stream.WriteLine("SET IDENTITY_INSERT {0} ON;".FormatInvariant(tableName));
WriteInsertions(stream, table);
stream.WriteLine("SET IDENTITY_INSERT {0} OFF;".FormatInvariant(tableName));
}
}
public Stream WriteTo(Stream stream)
{
CheckSemanticValidity();
stream.WriteLine("sector");
stream.WriteLine("{");
stream.WriteProperty("textureFloor", _textureFloor, indent: true);
stream.WriteProperty("textureCeiling", _textureCeiling, indent: true);
if (HeightFloor != 0)
{
stream.WriteProperty("heightFloor", HeightFloor, indent: true);
}
if (HeightCeiling != 0)
{
stream.WriteProperty("heightCeiling", HeightCeiling, indent: true);
}
if (LightLevel != 160)
{
stream.WriteProperty("lightLevel", LightLevel, indent: true);
}
if (Special != 0)
{
stream.WriteProperty("special", Special, indent: true);
}
if (Id != 0)
{
stream.WriteProperty("id", Id, indent: true);
}
if (Comment != "")
{
stream.WriteProperty("comment", Comment, indent: true);
}
foreach (var property in UnknownProperties)
{
stream.WritePropertyVerbatim((string)property.Name, property.Value, indent: true);
}
stream.WriteLine("}");
return(stream);
}
protected override void WriteXmlHeader(Stream streamToFill)
{
streamToFill.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
streamToFill.WriteLine("<rss version =\"2.0\" xmlns:g=\"http://base.google.com/ns/1.0\">");
streamToFill.WriteLine("<channel>");
streamToFill.WriteLine(String.Format("<title>{0}</title>", _feedTitle));
streamToFill.WriteLine(String.Format("<description>{0}</description>", _feedDescription));
streamToFill.WriteLine(String.Format("<link>{0}</link>", _feedLink));
}
public Stream WriteTo(Stream stream)
{
CheckSemanticValidity();
stream.WriteLine("sidedef");
stream.WriteLine("{");
stream.WriteProperty("sector", _sector, indent: true);
if (OffsetX != 0)
{
stream.WriteProperty("offsetX", OffsetX, indent: true);
}
if (OffsetY != 0)
{
stream.WriteProperty("offsetY", OffsetY, indent: true);
}
if (TextureTop != "-")
{
stream.WriteProperty("textureTop", TextureTop, indent: true);
}
if (TextureBottom != "-")
{
stream.WriteProperty("textureBottom", TextureBottom, indent: true);
}
if (TextureMiddle != "-")
{
stream.WriteProperty("textureMiddle", TextureMiddle, indent: true);
}
if (Comment != "")
{
stream.WriteProperty("comment", Comment, indent: true);
}
foreach (var property in UnknownProperties)
{
stream.WritePropertyVerbatim((string)property.Name, property.Value, indent: true);
}
stream.WriteLine("}");
return(stream);
}
protected override void WriteXmlHeader(Stream streamToFill)
{
streamToFill.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
streamToFill.WriteLine("<rss version =\"2.0\" xmlns:g=\"http://base.google.com/ns/1.0\">");
streamToFill.WriteLine("<channel>");
streamToFill.WriteLine(String.Format("<title>{0}</title>", _feedTitle));
streamToFill.WriteLine(String.Format("<description>{0}</description>", _feedDescription));
streamToFill.WriteLine(String.Format("<link>{0}</link>", _feedLink));
}
public override void RenderCommand(Stream stream)
{
if (Blob != null)
{
stream.WriteString("M 644 ");
Blob.RenderMarkReference(stream);
stream.WriteString(string.Format(" \"{0}\"", Path));
stream.WriteLineFeed();
}
else
{
stream.WriteLine(string.Format("M 644 inline \"{0}\"", Path));
stream.RenderCommand(Data);
}
}
public override void RenderCommand(Stream stream)
{
foreach (var fc in FileCommands.OfType<FileModifyCommand>())
{
if (fc.Blob != null)
stream.RenderCommand(fc.Blob);
}
stream.WriteLine(string.Format("commit {0}", Reference));
base.RenderMarkCommand(stream);
if (Author != null)
stream.RenderCommand(Author);
stream.RenderCommand(Committer);
stream.RenderCommand(CommitInfo);
if (FromCommit != null)
{
stream.WriteString("from ");
FromCommit.RenderMarkReference(stream);
stream.WriteLineFeed();
}
foreach (var mc in MergeCommits)
{
stream.WriteString("merge ");
mc.RenderMarkReference(stream);
stream.WriteLineFeed();
}
foreach (var fc in FileCommands)
stream.RenderCommand(fc);
stream.WriteLineFeed();
}
private static bool CopyHttpStream(Stream fromStream, Stream toStream, string firstLine = "", string sslTunnelDomain="")
{
bool keepAlive = false;
var encoding = Encoding.UTF8;
string method;
string version;
string url;
using (var fromStreamReader = new BinaryReader(fromStream, encoding, true))
using (var toStreamWriter = new BinaryWriter(toStream, encoding, true))
{
if (String.IsNullOrEmpty(firstLine))
firstLine = fromStream.ReadLine();
if (!String.IsNullOrEmpty(sslTunnelDomain))
{
//modify the path in the http request to include the domain
ParseHttpCommand(firstLine, out method, out url, out version);
//modify the forward address so it has complete URL
firstLine = method + ' ' + "https://" + sslTunnelDomain + url + ' ' + version;
firstLine += "\r\n";
firstLine += "X-Forward-Secure: true";
}
LogMessage(string.Format(firstLine));
toStream.WriteLine(firstLine);
toStream.Flush();
string line;
int contentLength = 0;
bool chunked = false;
//copy the headers
while (!String.IsNullOrEmpty(line = fromStreamReader.ReadLine()))
{
if (line.StartsWith("Content-Length:", true, CultureInfo.CurrentCulture))
contentLength = int.Parse(line.Replace("Content-Length:", ""));
if (line.StartsWith("Transfer-Encoding: chunked", true, CultureInfo.CurrentCulture))
chunked = true;
if (line.StartsWith("Proxy-Connection: Keep-Alive", true, CultureInfo.CurrentCulture))
keepAlive = true;
toStreamWriter.WriteLine(line);
}
toStreamWriter.WriteLine();
if (contentLength > 0)
toStreamWriter.Write(fromStreamReader.ReadBytes(contentLength));
if(chunked)
{
while (!String.IsNullOrEmpty(line = fromStreamReader.ReadLine()))
{
contentLength = int.Parse(line, System.Globalization.NumberStyles.HexNumber);
toStreamWriter.Write(fromStreamReader.ReadBytes(contentLength));
fromStreamReader.ReadLine();
}
}
toStreamWriter.Flush();
}
return keepAlive;
}
public override void RenderCommand(Stream stream)
{
stream.WriteLine("deleteall");
}
public override void RenderCommand(Stream stream)
{
stream.WriteLine(string.Format("D {0}", Path));
}
protected virtual void WriteXmlFooter(Stream streamToFill)
{
streamToFill.WriteLine("</root>");
}
public override void RenderCommand(Stream stream)
{
stream.WriteLine(string.Format("R {0} {1}", this.Source, this.Path));
}
protected virtual void WriteXmlHeader(Stream streamToFill)
{
streamToFill.WriteLine("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
streamToFill.WriteLine("<root>");
}
protected override void WriteXmlFooter(Stream streamToFill)
{
streamToFill.WriteLine("</channel>");
streamToFill.WriteLine("</rss>");
}
protected override void WriteXmlFooter(Stream streamToFill)
{
streamToFill.WriteLine("</feed>");
}
