private void GetHostByNameSink(IAsyncResult result)
{
IPHostEntry e = null;
try
{
e = Dns.EndGetHostEntry(result);
}
catch (Exception ex)
{
// Could not resolve?
OpenSource.Utilities.EventLogger.Log(ex);
return;
}
object[] Args = (object[])result.AsyncState;
Uri Resource = (Uri)Args[0];
object Tag = (object)Args[1];
ContinueRequest(
new IPEndPoint(e.AddressList[0], Resource.Port),
HTTPMessage.UnEscapeString(Resource.PathAndQuery),
Tag,
null);
}
/// <summary>
/// Parses a URL
/// </summary>
/// <param name="ServiceURL">The URL to Parse</param>
/// <param name="WebIP">The IPAddress</param>
/// <param name="Port">The Port Number</param>
/// <param name="ServiceName">The Object</param>
static public void ParseURL(String ServiceURL, out String WebIP, out int Port, out String ServiceName)
{
Uri NewUri = new Uri(ServiceURL);
WebIP = NewUri.Host;
if (NewUri.HostNameType == UriHostNameType.Dns)
{
WebIP = Dns.GetHostEntry(WebIP).AddressList[0].ToString();
}
Port = NewUri.Port;
ServiceName = HTTPMessage.UnEscapeString(NewUri.PathAndQuery);
}
/// <summary>
/// Pipelines a Uri request
/// </summary>
/// <param name="Resource">Uri to GET</param>
/// <param name="Tag">State Data</param>
public void PipelineRequest(Uri Resource, object Tag)
{
object[] Args = new Object[2] {
Resource, Tag
};
string IP = Resource.Host;
if (Resource.HostNameType == UriHostNameType.Dns)
{
Dns.BeginGetHostEntry(IP, new AsyncCallback(GetHostByNameSink), (object)Args);
}
else
{
ContinueRequest(
new IPEndPoint(IPAddress.Parse(Resource.Host), Resource.Port),
HTTPMessage.UnEscapeString(Resource.PathAndQuery),
Tag,
null);
}
}
/// <summary>
/// Parses a Byte Array at a specific location, and builds a Packet.
/// </summary>
/// <param name="buffer">The Array of Bytes</param>
/// <param name="indx">The Start Index</param>
/// <param name="count">The number of Bytes to process</param>
/// <returns></returns>
static public HTTPMessage ParseByteArray(byte[] buffer, int indx, int count)
{
HTTPMessage TheMessage = new HTTPMessage();
UTF8Encoding UTF8 = new UTF8Encoding();
String TempData = UTF8.GetString(buffer, indx, count);
DText parser = new DText();
String TempString;
int idx = TempData.IndexOf("\r\n\r\n");
if (idx < 0)
{
return(null);
}
TempData = TempData.Substring(0, idx);
parser.ATTRMARK = "\r\n";
parser.MULTMARK = ":";
parser[0] = TempData;
string CurrentLine = parser[1];
DText HdrParser = new DText();
HdrParser.ATTRMARK = " ";
HdrParser.MULTMARK = "/";
HdrParser[0] = CurrentLine;
if (CurrentLine.ToUpper().StartsWith("HTTP/") == true)
{
TheMessage.ResponseCode = int.Parse(HdrParser[2]);
int s1 = CurrentLine.IndexOf(" ");
s1 = CurrentLine.IndexOf(" ", s1 + 1);
TheMessage.ResponseData = HTTPMessage.UnEscapeString(CurrentLine.Substring(s1));
try
{
TheMessage.Version = HdrParser[1, 2];
}
catch (Exception ex)
{
OpenSource.Utilities.EventLogger.Log(ex);
TheMessage.Version = "0.9";
}
}
else
{
TheMessage.Directive = HdrParser[1];
TempString = CurrentLine.Substring(CurrentLine.LastIndexOf(" ") + 1);
if (TempString.ToUpper().StartsWith("HTTP/") == false)
{
TheMessage.Version = "0.9";
TheMessage.DirectiveObj = HTTPMessage.UnEscapeString(TempString);
}
else
{
TheMessage.Version = TempString.Substring(TempString.IndexOf("/") + 1);
int fs = CurrentLine.IndexOf(" ") + 1;
TheMessage.DirectiveObj = HTTPMessage.UnEscapeString(CurrentLine.Substring(
fs,
CurrentLine.Length - fs - TempString.Length - 1));
}
}
String Tag = "";
String TagData = "";
for (int line = 2; line <= parser.DCOUNT(); ++line)
{
if (Tag != "" && parser[line, 1].StartsWith(" "))
{
TagData = parser[line, 1].Substring(1);
}
else
{
Tag = parser[line, 1];
TagData = "";
for (int i = 2; i <= parser.DCOUNT(line); ++i)
{
if (TagData == "")
{
TagData = parser[line, i];
}
else
{
TagData = TagData + parser.MULTMARK + parser[line, i];
}
}
}
TheMessage.AppendTag(Tag, TagData);
}
int cl = 0;
if (TheMessage.HasTag("Content-Length"))
{
try
{
cl = int.Parse(TheMessage.GetTag("Content-Length"));
}
catch (Exception ex)
{
OpenSource.Utilities.EventLogger.Log(ex);
cl = -1;
}
}
else
{
cl = -1;
}
byte[] tbuffer;
if (cl > 0)
{
tbuffer = new byte[cl];
if ((idx + 4 + cl) > count)
{
// NOP
}
else
{
Array.Copy(buffer, idx + 4, tbuffer, 0, cl);
TheMessage.DataBuffer = tbuffer;
}
}
if (cl == -1)
{
tbuffer = new Byte[count - (idx + 4)];
Array.Copy(buffer, idx + 4, tbuffer, 0, tbuffer.Length);
TheMessage.DataBuffer = tbuffer;
}
if (cl == 0)
{
TheMessage.DataBuffer = new byte[0];
}
return(TheMessage);
}
