mirror of
https://github.com/openhardwaremonitor/openhardwaremonitor
synced 2025-08-22 18:07:09 +00:00
372 lines
12 KiB
C#
372 lines
12 KiB
C#
/*
|
|
|
|
This Source Code Form is subject to the terms of the Mozilla Public
|
|
License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
Copyright (C) 2012 Prince Samuel <prince.samuel@gmail.com>
|
|
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Text;
|
|
using System.Net;
|
|
using System.Threading;
|
|
using System.IO;
|
|
using OpenHardwareMonitor.GUI;
|
|
using OpenHardwareMonitor.Hardware;
|
|
using System.Reflection;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
|
|
namespace OpenHardwareMonitor.Utilities
|
|
{
|
|
public class HttpServer
|
|
{
|
|
private HttpListener listener;
|
|
private int listenerPort, nodeCount;
|
|
private Thread listenerThread;
|
|
private Node root;
|
|
|
|
public HttpServer(Node r, int p)
|
|
{
|
|
root = r;
|
|
listenerPort = p;
|
|
//JSON node count.
|
|
nodeCount = 0;
|
|
listener = new HttpListener();
|
|
}
|
|
|
|
public Boolean startHTTPListener()
|
|
{
|
|
try
|
|
{
|
|
if (listener.IsListening)
|
|
return true;
|
|
|
|
string prefix = "http://+:" + listenerPort + "/";
|
|
listener.Prefixes.Clear();
|
|
listener.Prefixes.Add(prefix);
|
|
listener.Start();
|
|
|
|
if (listenerThread == null)
|
|
{
|
|
listenerThread = new Thread(HandleRequests);
|
|
listenerThread.Start();
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public Boolean stopHTTPListener()
|
|
{
|
|
try
|
|
{
|
|
listenerThread.Abort();
|
|
listener.Stop();
|
|
listenerThread = null;
|
|
}
|
|
catch (System.Net.HttpListenerException e)
|
|
{
|
|
}
|
|
catch (System.Threading.ThreadAbortException e)
|
|
{
|
|
}
|
|
catch (System.NullReferenceException e)
|
|
{
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void HandleRequests()
|
|
{
|
|
|
|
while (listener.IsListening)
|
|
{
|
|
var context = listener.BeginGetContext(new AsyncCallback(ListenerCallback), listener);
|
|
context.AsyncWaitHandle.WaitOne();
|
|
}
|
|
}
|
|
|
|
public void ListenerCallback(IAsyncResult result)
|
|
{
|
|
HttpListener listener = (HttpListener)result.AsyncState;
|
|
if (listener == null || !listener.IsListening)
|
|
return;
|
|
// Call EndGetContext to complete the asynchronous operation.
|
|
HttpListenerContext context = listener.EndGetContext(result);
|
|
HttpListenerRequest request = context.Request;
|
|
|
|
var requestedFile = request.RawUrl.Substring(1);
|
|
if (requestedFile == "data.json")
|
|
{
|
|
sendJSON(context);
|
|
return;
|
|
}
|
|
|
|
if (requestedFile.Contains("images_icon"))
|
|
{
|
|
serveResourceImage(context, requestedFile.Replace("images_icon/", ""));
|
|
return;
|
|
}
|
|
|
|
//default file to be served
|
|
if (string.IsNullOrEmpty(requestedFile))
|
|
requestedFile = "index.html";
|
|
|
|
string[] splits = requestedFile.Split('.');
|
|
string ext = splits[splits.Length - 1];
|
|
serveResourceFile(context, "Web." + requestedFile.Replace('/', '.'), ext);
|
|
}
|
|
|
|
private void serveResourceFile(HttpListenerContext context ,string name, string ext) {
|
|
|
|
//hack! resource names do not support the hyphen
|
|
name = "OpenHardwareMonitor.Resources." + name.Replace("custom-theme", "custom_theme");
|
|
|
|
string[] names =
|
|
Assembly.GetExecutingAssembly().GetManifestResourceNames();
|
|
for (int i = 0; i < names.Length; i++) {
|
|
if (names[i].Replace('\\', '.') == name) {
|
|
using (Stream stream = Assembly.GetExecutingAssembly().
|
|
GetManifestResourceStream(names[i])) {
|
|
context.Response.ContentType = getcontentType("." + ext);
|
|
context.Response.ContentLength64 = stream.Length;
|
|
byte[] buffer = new byte[512 * 1024];
|
|
int len;
|
|
while ((len = stream.Read(buffer, 0, buffer.Length)) > 0)
|
|
{
|
|
context.Response.OutputStream.Write(buffer, 0, len);
|
|
}
|
|
context.Response.OutputStream.Close();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
context.Response.OutputStream.Close();
|
|
context.Response.StatusCode = 404;
|
|
context.Response.Close();
|
|
}
|
|
|
|
private void serveResourceImage(HttpListenerContext context ,string name) {
|
|
name = "OpenHardwareMonitor.Resources." + name;
|
|
|
|
string[] names =
|
|
Assembly.GetExecutingAssembly().GetManifestResourceNames();
|
|
for (int i = 0; i < names.Length; i++) {
|
|
if (names[i].Replace('\\', '.') == name) {
|
|
using (Stream stream = Assembly.GetExecutingAssembly().
|
|
GetManifestResourceStream(names[i])) {
|
|
|
|
Image image = Image.FromStream(stream);
|
|
context.Response.ContentType = "image/png";
|
|
using (MemoryStream ms = new MemoryStream())
|
|
{
|
|
image.Save(ms, ImageFormat.Png);
|
|
ms.WriteTo(context.Response.OutputStream);
|
|
}
|
|
context.Response.OutputStream.Close();
|
|
image.Dispose();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
context.Response.OutputStream.Close();
|
|
context.Response.StatusCode = 404;
|
|
context.Response.Close();
|
|
}
|
|
|
|
private void sendJSON(HttpListenerContext context)
|
|
{
|
|
|
|
string JSON = "{\"id\": 0, \"Text\": \"Sensor\", \"Children\": [";
|
|
nodeCount = 1;
|
|
JSON += generateJSON(root);
|
|
JSON += "]";
|
|
JSON += ", \"Min\": \"Min\"";
|
|
JSON += ", \"Value\": \"Value\"";
|
|
JSON += ", \"Max\": \"Max\"";
|
|
JSON += ", \"ImageURL\": \"\"";
|
|
JSON += "}";
|
|
|
|
var responseContent = JSON;
|
|
byte[] buffer = Encoding.UTF8.GetBytes(responseContent);
|
|
|
|
context.Response.ContentLength64 = buffer.Length;
|
|
context.Response.ContentType = "application/json";
|
|
|
|
Stream outputStream = context.Response.OutputStream;
|
|
outputStream.Write(buffer, 0, buffer.Length);
|
|
outputStream.Close();
|
|
|
|
}
|
|
|
|
private string generateJSON(Node n)
|
|
{
|
|
string JSON = "{\"id\": " + nodeCount + ", \"Text\": \"" + n.Text + "\", \"Children\": [";
|
|
nodeCount++;
|
|
|
|
foreach (Node child in n.Nodes)
|
|
JSON += generateJSON(child) + ", ";
|
|
if (JSON.EndsWith(", "))
|
|
JSON = JSON.Remove(JSON.LastIndexOf(","));
|
|
JSON += "]";
|
|
|
|
if (n is SensorNode)
|
|
{
|
|
JSON += ", \"Min\": \"" + ((SensorNode)n).Min + "\"";
|
|
JSON += ", \"Value\": \"" + ((SensorNode)n).Value + "\"";
|
|
JSON += ", \"Max\": \"" + ((SensorNode)n).Max + "\"";
|
|
JSON += ", \"ImageURL\": \"images/transparent.png\"";
|
|
}
|
|
else if (n is HardwareNode)
|
|
{
|
|
JSON += ", \"Min\": \"\"";
|
|
JSON += ", \"Value\": \"\"";
|
|
JSON += ", \"Max\": \"\"";
|
|
JSON += ", \"ImageURL\": \"images_icon/" + getHardwareImageFile((HardwareNode)n) + "\"";
|
|
}
|
|
else if (n is TypeNode)
|
|
{
|
|
JSON += ", \"Min\": \"\"";
|
|
JSON += ", \"Value\": \"\"";
|
|
JSON += ", \"Max\": \"\"";
|
|
JSON += ", \"ImageURL\": \"images_icon/" + getTypeImageFile((TypeNode)n) + "\"";
|
|
}
|
|
else
|
|
{
|
|
JSON += ", \"Min\": \"\"";
|
|
JSON += ", \"Value\": \"\"";
|
|
JSON += ", \"Max\": \"\"";
|
|
JSON += ", \"ImageURL\": \"images_icon/computer.png\"";
|
|
}
|
|
|
|
JSON += "}";
|
|
return JSON;
|
|
}
|
|
|
|
private static void returnFile(HttpListenerContext context, string filePath)
|
|
{
|
|
context.Response.ContentType = getcontentType(Path.GetExtension(filePath));
|
|
const int bufferSize = 1024 * 512; //512KB
|
|
var buffer = new byte[bufferSize];
|
|
using (var fs = File.OpenRead(filePath))
|
|
{
|
|
|
|
context.Response.ContentLength64 = fs.Length;
|
|
int read;
|
|
while ((read = fs.Read(buffer, 0, buffer.Length)) > 0)
|
|
context.Response.OutputStream.Write(buffer, 0, read);
|
|
}
|
|
|
|
context.Response.OutputStream.Close();
|
|
}
|
|
|
|
private static string getcontentType(string extension)
|
|
{
|
|
switch (extension)
|
|
{
|
|
case ".avi": return "video/x-msvideo";
|
|
case ".css": return "text/css";
|
|
case ".doc": return "application/msword";
|
|
case ".gif": return "image/gif";
|
|
case ".htm":
|
|
case ".html": return "text/html";
|
|
case ".jpg":
|
|
case ".jpeg": return "image/jpeg";
|
|
case ".js": return "application/x-javascript";
|
|
case ".mp3": return "audio/mpeg";
|
|
case ".png": return "image/png";
|
|
case ".pdf": return "application/pdf";
|
|
case ".ppt": return "application/vnd.ms-powerpoint";
|
|
case ".zip": return "application/zip";
|
|
case ".txt": return "text/plain";
|
|
default: return "application/octet-stream";
|
|
}
|
|
}
|
|
|
|
private static string getHardwareImageFile(HardwareNode hn)
|
|
{
|
|
|
|
switch (hn.Hardware.HardwareType)
|
|
{
|
|
case HardwareType.CPU:
|
|
return "cpu.png";
|
|
case HardwareType.GpuNvidia:
|
|
return "nvidia.png";
|
|
case HardwareType.GpuAti:
|
|
return "ati.png";
|
|
case HardwareType.HDD:
|
|
return "hdd.png";
|
|
case HardwareType.Heatmaster:
|
|
return "bigng.png";
|
|
case HardwareType.Mainboard:
|
|
return "mainboard.png";
|
|
case HardwareType.SuperIO:
|
|
return "chip.png";
|
|
case HardwareType.TBalancer:
|
|
return "bigng.png";
|
|
default:
|
|
return "cpu.png";
|
|
}
|
|
|
|
}
|
|
|
|
private static string getTypeImageFile(TypeNode tn)
|
|
{
|
|
|
|
switch (tn.SensorType)
|
|
{
|
|
case SensorType.Voltage:
|
|
return "voltage.png";
|
|
case SensorType.Clock:
|
|
return "clock.png";
|
|
case SensorType.Load:
|
|
return "load.png";
|
|
case SensorType.Temperature:
|
|
return "temperature.png";
|
|
case SensorType.Fan:
|
|
return "fan.png";
|
|
case SensorType.Flow:
|
|
return "flow.png";
|
|
case SensorType.Control:
|
|
return "control.png";
|
|
case SensorType.Level:
|
|
return "level.png";
|
|
case SensorType.Power:
|
|
return "power.png";
|
|
default:
|
|
return "power.png";
|
|
}
|
|
|
|
}
|
|
|
|
public int ListenerPort
|
|
{
|
|
get { return listenerPort; }
|
|
set { listenerPort = value; }
|
|
}
|
|
|
|
~HttpServer()
|
|
{
|
|
stopHTTPListener();
|
|
listener.Abort();
|
|
}
|
|
|
|
public void Quit()
|
|
{
|
|
stopHTTPListener();
|
|
listener.Abort();
|
|
}
|
|
}
|
|
}
|