private HTTPResponse createResponse(HTTPRequestParser parser)
{
var base64 = parser.GetHeader(HTTPRequestParser.Header_Uri);
base64 = HTTPProtocol.URLDecode(base64).TrimStart('/').Substring("b64_".Length).Replace('_', '=');
var filepathBytes = Convert.FromBase64String(base64);
var filepath = Encoding.UTF8.GetString(filepathBytes);
return HTTPResponse.FromFile(parser, filepath);
}
private HTTPResponse createResponse(HTTPRequestParser parser)
{
var soap = parser.GetHeader("SOAPACTION");
if (soap != null)
return createSoapResponse(parser, soap);
var alias = parser.GetHeader(HTTPRequestParser.Header_Uri);
alias = HTTPProtocol.URLDecode(alias);
var path = DLNA.Tree.GetFilePath(alias);
return HTTPResponse.FromFile(parser, path);
}
private HTTPResponse createSoapResponse(HTTPRequestParser parser, string soapAction)
{
if (!soapAction.Contains("Browse"))
return null;
soapAction = soapAction.Replace("\"", "");
var delim = soapAction.LastIndexOf('#');
var service = soapAction.Substring(0, delim - 1);
var action = soapAction.Substring(delim + 1);
var doc = new XmlDocument();
doc.LoadXml(parser.Body);
var id = doc.SelectSingleNode("//ObjectID").InnerText;
var start = int.Parse(doc.SelectSingleNode("//StartingIndex").InnerText);
var count = int.Parse(doc.SelectSingleNode("//RequestedCount").InnerText);
var browseFlag = doc.SelectSingleNode("//BrowseFlag").InnerText;
DIDLResult didl;
switch (browseFlag)
{
case "BrowseMetadata":
//need get object id metadata
didl = DLNA.Tree.ToDIDL_Lite_Meta(id);
break;
case "BrowseDirectChildren":
//browse all children
didl = DLNA.Tree.ToDIDL_Lite(id, start, count);
break;
default:
throw new NotSupportedException("BrowseFlag " + browseFlag + " is not supported");
}
if (id == "0")
//root
id = "";
var browsable = UpnpProtocol.GetBrowseResponse(didl);
ConsoleUtils.WriteLn(new Wr(ConsoleColor.DarkRed, parser.Body));
return HTTPResponse.FromData(parser, browsable);
// return HTTPResponse.FromFile(parser, "ContentDirDescription – TV OK.xml");
}
/// <summary>
/// Send appropriate response to parsed request
/// </summary>
/// <param name="parser"></param>
/// <param name="client"></param>
private void proceedRequest(HTTPRequestParser parser, TcpClient client)
{
var stream = client.GetStream();
var response = createResponse(parser);
if (response == null)
response = HTTPResponse.FromData(parser, "", 500);
stream.Write(response.Headers);
/* ConsoleUtils.WriteLn(
new Wr(ConsoleColor.Yellow, "{0} -> {1}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint),
new Wr(ConsoleColor.White, response.Headers)
);*/
var method = parser.GetHeader(HTTPRequestParser.Header_Method);
if (method != "HEAD")
stream.Write(response.Stream);
client.Close();
}
public static HTTPResponse FromFile(HTTPRequestParser request,string path)
{
var headers = createHeaders(request, 200);
var splited = path.Split('?');
path = splited[0];
var info = new FileInfo(path);
if (!info.Exists)
return FromData(request, "Path "+path+" is unavailable", 500);
var stream= new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
var respStream = createResponseStream(headers, request, stream, info.Length);
var mime = GetContentType(path);
headers.SetHeader("Content-Type",mime);
headers.SetHeader("Accept-Ranges","bytes");
headers.SetHeader("ContentFeatures.DLNA.ORG","DLNA.ORG_OP=01;DLNA.ORG_FLAGS=01500000000000000000000000000000");
headers.SetHeader("TransferMode.DLNA.ORG", "Streaming");
return new HTTPResponse(headers, respStream);
}
/// <summary>
/// Handle specified http client
/// </summary>
/// <param name="client">Client to be handled</param>
private void _handleClient(TcpClient client)
{
var stream = client.GetStream();
//parse incoming http request
var parser = new HTTPRequestParser();
while (!parser.IsComplete)
parser.AddData(stream.Read());
ConsoleUtils.WriteLn(
new Wr(ConsoleColor.Yellow, "{1} -> {0}", client.Client.LocalEndPoint, client.Client.RemoteEndPoint),
new Wr(ConsoleColor.Green, parser.HeaderPart.Replace("{", "{{").Replace("}","}}"))
);
proceedRequest(parser, client);
}
private HTTPRequestParser sendHTTP(string http, params object[] pars)
{
http = string.Format(http, pars);
var tv = new TcpClient();
var result = tv.BeginConnect(RemoteIP, RemotePort, null, null);
var success = result.AsyncWaitHandle.WaitOne(TimeSpan.FromSeconds(5));
if (!success)
{
return null;
}
// we have connected
tv.EndConnect(result);
var stream = tv.GetStream();
stream.Write(http);
var parser = new HTTPRequestParser();
while (!parser.IsComplete)
{
var data = stream.Read();
parser.AddData(data);
}
tv.Close();
return parser;
}
private static HTTPHeaders createHeaders(HTTPRequestParser request,int code, string codeDescription="")
{
var hasRange=request.GetHeader("Range") == null;
switch (code)
{
case 200:
case 206:
code = hasRange ? 200 : 206;
if(codeDescription=="")
codeDescription = hasRange ? "OK" : "Partial content";
break;
}
return HTTPHeaders.Response(code, codeDescription);
}
public static HTTPResponse NotFound(HTTPRequestParser request)
{
return fromData(request, "Page was not found", 404);
}
public static HTTPResponse FromData(HTTPRequestParser request, string data,int code=200)
{
return fromData(request, data, code);
}
private static HTTPResponse fromData(HTTPRequestParser request, string data, int code)
{
string description="";
switch (code)
{
case 500:
description = "Internal server error";
break;
case 404:
description = "Not found";
break;
}
var headers = createHeaders(request, code, description);
var respStream = createResponseStream(headers, request, createStream(data),Encoding.UTF8.GetByteCount(data));
return new HTTPResponse(headers, respStream);
}
/// <summary>
/// Create response stream according to data stream and range request. Also inject appropriate range and length headers
/// </summary>
/// <param name="headers"></param>
/// <param name="request"></param>
/// <param name="dataStream"></param>
/// <param name="dataTotalLength"></param>
/// <returns></returns>
private static ResponseStream createResponseStream(HTTPHeaders headers, HTTPRequestParser request,Stream dataStream ,long dataTotalLength)
{
var rangeSelector = request.GetHeader("Range");
var range=new HTTPRange(dataTotalLength,rangeSelector);
if (range.IsPartial)
//inject range header into response headers
headers.SetHeader("Content-Range", string.Format("bytes {0}-{1}/{2}",range.FromBytes,range.ToBytes,range.FileLength));
headers.SetHeader("Content-Length", range.ContentLength.ToString());
return new ResponseStream(dataStream, range.FromBytes, range.ToBytes);
}
/// <summary>
/// Listen on specified port, while _end is true
/// </summary>
private void _listen()
{
// _listener.Client.Listen(500);
lock (_listenHandShake)
Monitor.Pulse(_listenHandShake);
IPEndPoint clientEndPoint;
var processedClients = new Dictionary<string, HTTPRequestParser>();
_listener.EnableBroadcast = true;
_listener.MulticastLoopback = true;
var address = IPAddress.Parse("239.255.255.250");
_listener.JoinMulticastGroup(address);
while (!_end)
{
//handle incomming reqs
string data;
try
{
clientEndPoint = new IPEndPoint(IPAddress.Any, _port);
var buffer = _listener.Receive(ref clientEndPoint);
data = Encoding.ASCII.GetString(buffer);
}
catch (Exception ex)
{
ConsoleUtils.WriteLn(ex);
break;
}
var clientKey = clientEndPoint.ToString();
HTTPRequestParser parser;
if (!processedClients.TryGetValue(clientKey, out parser))
processedClients.Add(clientKey, parser = new HTTPRequestParser());
parser.AddData(data);
if (parser.IsComplete)
{
processedClients.Remove(clientKey);
onReqCompleted(parser, clientEndPoint);
}
}
_listener.Close();
}
private void onReqCompleted(HTTPRequestParser request, IPEndPoint endpoint)
{
ConsoleUtils.WriteLn(
new Wr(ConsoleColor.Yellow, "UHTTP recieved {0}", endpoint),
new Wr(ConsoleColor.Cyan, request.HeaderPart)
);
if (request.GetHeader(HTTPRequestParser.Header_Method).Contains("SEARCH"))
{
var search = request.GetHeader("ST");
if (search == "ssdp:all")
{
throw new NotImplementedException("response with all services");
}
string location;
if (_upnpServices.TryGetValue(search, out location))
{
var th = new Thread(() =>
{
//Positive replay to search
try
{
SendTo(endpoint, HTTPProtocol.Headers_SEARCH_ok, location, search, UpnpProtocol.GetUSN(UpnpProtocol.UUID, search));
}
catch (Exception ex)
{
ConsoleUtils.WriteLn(ex);
}
});
th.IsBackground = true;
th.Start();
}
}
}
