/*******************************************************************************
* NetworkHttp.cc NetworkHttp class
* T.Barnaby, BEAM Ltd, 2006-08-01
*******************************************************************************
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <errno.h>
#include <sys/time.h>
#include <fcntl.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <sys/ioctl.h>
#include <math.h>
#include <BPoll.h>
#include <BFile.h>
#include <BHtmlPage.h>
#include <BNameValue.h>
#include <NetworkHttp.h>
#include <Debug.h>
#include <Control.h>
#include <TmsD.h>
#include <TmsC.h>
using namespace Tms;
using namespace std;
static const char* const suffixTable [] = {
".htm.html", "text/html",
".jpg.jpeg", "image/jpeg",
".gif", "image/gif",
".png", "image/png",
".txt.h.c.cc.cpp", "text/plain",
".css", "text/css",
".wav", "audio/wav",
".avi", "video/x-msvideo",
".qt.mov", "video/quicktime",
".mpe.mpeg", "video/mpeg",
".mid.midi", "audio/midi",
".mp3", "audio/mpeg",
#if 0 /* unpopular */
".au", "audio/basic",
".pac", "application/x-ns-proxy-autoconfig",
".vrml.wrl", "model/vrml",
#endif
0, "application/octet-stream" /* default */
};
typedef enum {
HTTP_OK = 200,
HTTP_MOVED_TEMPORARILY = 302,
HTTP_BAD_REQUEST = 400, /* malformed syntax */
HTTP_UNAUTHORIZED = 401, /* authentication needed, respond with auth hdr */
HTTP_NOT_FOUND = 404,
HTTP_FORBIDDEN = 403,
HTTP_REQUEST_TIMEOUT = 408,
HTTP_NOT_IMPLEMENTED = 501, /* used for unrecognized requests */
HTTP_INTERNAL_SERVER_ERROR = 500,
HTTP_CONTINUE = 100,
HTTP_SWITCHING_PROTOCOLS = 101,
HTTP_CREATED = 201,
HTTP_ACCEPTED = 202,
HTTP_NON_AUTHORITATIVE_INFO = 203,
HTTP_NO_CONTENT = 204,
HTTP_MULTIPLE_CHOICES = 300,
HTTP_MOVED_PERMANENTLY = 301,
HTTP_NOT_MODIFIED = 304,
HTTP_PAYMENT_REQUIRED = 402,
HTTP_BAD_GATEWAY = 502,
HTTP_SERVICE_UNAVAILABLE = 503, /* overload, maintenance */
HTTP_RESPONSE_SETSIZE = 0xffffffff
} HttpResponseNum;
typedef struct {
HttpResponseNum type;
const char* name;
const char* info;
} HttpEnumString;
static const HttpEnumString httpResponseNames[] = {
{ HTTP_OK, "OK", NULL },
{ HTTP_MOVED_TEMPORARILY, "Found", "Directories must end with a slash." },
{ HTTP_REQUEST_TIMEOUT, "Request Timeout",
"No request appeared within a reasonable time period." },
{ HTTP_NOT_IMPLEMENTED, "Not Implemented",
"The requested method is not recognized by this server." },
{ HTTP_UNAUTHORIZED, "Unauthorized", "" },
{ HTTP_NOT_FOUND, "Not Found",
"The requested URL was not found on this server." },
{ HTTP_BAD_REQUEST, "Bad Request", "Unsupported method." },
{ HTTP_FORBIDDEN, "Forbidden", "" },
{ HTTP_INTERNAL_SERVER_ERROR, "Internal Server Error",
"Internal Server Error" },
#if 0 /* not implemented */
{ HTTP_CREATED, "Created" },
{ HTTP_ACCEPTED, "Accepted" },
{ HTTP_NO_CONTENT, "No Content" },
{ HTTP_MULTIPLE_CHOICES, "Multiple Choices" },
{ HTTP_MOVED_PERMANENTLY, "Moved Permanently" },
{ HTTP_NOT_MODIFIED, "Not Modified" },
{ HTTP_BAD_GATEWAY, "Bad Gateway", "" },
{ HTTP_SERVICE_UNAVAILABLE, "Service Unavailable", "" },
#endif
};
static const char RFC1123FMT[] = "%a, %d %b %Y %H:%M:%S GMT";
NetworkHttpThread::NetworkHttpThread(NetworkHttp& netOutput) : onetOutput(netOutput){
}
void* NetworkHttpThread::function(){
dprintf(DBG_THREADS, "NetworkHttpThread: %d\n", gettid());
onetOutput.run();
return 0;
}
HttpConnection::HttpConnection(Control& control, int fd, BSocketAddressINET from)
: BSocket(fd), ocontrol(control), ofrom(from){
BString s;
if((s = ocontrol.oconfig.findValue("HtmlDir:")) != "")
ohtmlDir = s;
else
ohtmlDir = "html";
ofile = fdopen(fd, "rw");
}
HttpConnection::~HttpConnection(){
fclose(ofile);
}
BError HttpConnection::recvLine(BString& line){
BError err;
char buf[BufSize];
if(fgets(buf, sizeof(buf), ofile))
line = buf;
else
err.set(1);
return err;
}
BError HttpConnection::sendString(BString line){
BSize n;
return send(line, line.len(), n);
}
BString encodeString(BString str)
{
int n;
char* res = new char [str.len() * 6 + 1];
char* p = res;
BString rstr;
for(n = 0; n < str.len(); n++){
if(isalnum(str[n]))
*p++ = str[n];
else
p += sprintf(p, "&#%d;", (unsigned char)str[n]);
}
*p = '\0';
rstr = res;
delete[] res;
return rstr;
}
BString decodeString(BString str, int option)
{
const char* pin = str.retStr();
char* res = new char [str.len() + 1];
char* pout = res;
BString rstr;
char c;
while((c = *pin++) != '\0') {
unsigned value1, value2;
if(option && c == '+'){
*pout++ = ' ';
continue;
}
if(c != '%'){
*pout++ = c;
continue;
}
if(sscanf(pin, "%1X", &value1) != 1 || sscanf(pin+1, "%1X", &value2) != 1){
if(!option)
return "";
*pout++ = '%';
continue;
}
value1 = value1 * 16 + value2;
if(!option && (value1 == '/' || value1 == '\0')){
return pin + 1;
}
*pout++ = value1;
pin += 2;
}
*pout = '\0';
rstr = res;
delete[] res;
return rstr;
}
BError HttpConnection::sendHttpError(int num, BString str){
BError err;
sendString(BString("HTTP/1.0 ") + num + " " + str + "\r\n");
sendString("Content-type: text/html; charset=UTF-8\r\n");
sendString("Connection : close\r\n");
sendString("\r\n");
return err;
}
BError HttpConnection::sendHeader(int num, BString contentType){
unsigned i;
unsigned numNames = sizeof(httpResponseNames) / sizeof(httpResponseNames[0]);
BString responseString;
BString infoString;
time_t timer = time(0);
char timeStr[80];
BString header;
for(i = 0; i < numNames; i++) {
if(int(httpResponseNames[i].type) == num){
responseString = httpResponseNames[i].name;
infoString = httpResponseNames[i].info;
break;
}
}
strftime(timeStr, sizeof(timeStr), RFC1123FMT, gmtime(&timer));
header = BString("HTTP/1.0 ") + num + " " + responseString + "\r\n";
// header += BString("Content-type: ") + contentType + "\r\n";
header += BString("Content-type: ") + contentType + "; charset=UTF-8\r\n";
header += BString("Date: ") + timeStr + "\r\n";
header += BString("Connection: close\r\n");
#ifdef ZAP
strftime(timeStr, sizeof(timeStr), RFC1123FMT, gmtime(&timer));
header += BString("Last-Modified: ") + timeStr + "\r\n";
header += BString("Content-length: ") +contentLength + "\r\n";
#endif
header += BString("\r\n");
return sendString(header);
}
void HttpConnection::start(){
BThread::start();
}
void* HttpConnection::function(){
BError err;
dprintf(DBG_HTTP, "%s: Starting\n", __FUNCTION__);
while(1){
if(err = process()){
break;
}
}
dprintf(DBG_HTTP, "%s: Exiting\n", __FUNCTION__);
return 0;
}
BError HttpConnection::initTms(){
BError err;
BString hostName = "localhost";
// Connect to TMS control objects
if(err = otmsControl.connectService(BString("//") + hostName + "/tmsControl")){
cerr << "Error: cannot connect to tmsControl: " << err.getString() << "\n";
return err;
}
if(err = otmsProcess.connectService(BString("//") + hostName + "/tmsProcess")){
cerr << "Error: cannot connect to tmsProcess: " << err.getString() << "\n";
return err;
}
#ifdef ZAP
if(events){
if(err = tmsEventsProcess(tmsProcess, hostName)){
cerr << err.getString() + "\n";
return 1;
}
}
#endif
return err;
}
BError HttpConnection::process(){
BError err;
BString line;
char cmd[BufSize];
char url[BufSize];
dprintf(DBG_HTTP, "%s: Start\n", __FUNCTION__);
// Read command
if(err = recvLine(line))
return err;
dprintf(DBG_HTTP, "Received: %s\n", __FUNCTION__, line.retStr());
if(sscanf(line, "%[^ ] %[^ ] HTTP/%*d.%*d", cmd, url) != 2){
sendHeader(HTTP_BAD_REQUEST);
return err.set(1, "Invalid HTTP request");
}
dprintf(DBG_HTTP, "%s: Cmd: %s Url: %s\n", __FUNCTION__, cmd, url);
// Read header
while(! (err = recvLine(line))){
// printf("LenLen: %d\n", line.len()); hd8(line, line.len());
line.removeNL();
dprintf(DBG_HTTP, "%s: Received: %d %s\n", __FUNCTION__, line.len(), line.retStr());
if(line.len() == 1)
break;
}
if(strcasecmp(cmd, "GET")){
sendHeader(HTTP_NOT_IMPLEMENTED);
return err.set(1, "Invalid HTTP request");
}
if((BString(url) == "/")
|| (BString(url) == "index.html")
|| !strncmp(url, "/config.cgi", 11)
|| !strncmp(url, "/help.cgi", 9)
|| !strncmp(url, "/status.cgi", 9)
|| !strncmp(url, "/statistics.cgi", 9)
|| !strncmp(url, "/dataraw.cgi", 11)
){
err = processInternal(url);
}
else {
err = processFile(url);
}
fclose(ofile);
close();
err.set(1);
return err;
}
BError HttpConnection::createPage(BHtmlPage& page){
BError err;
BHtml h;
BHtml t;
h = BHtml("div");
h.append("a", "class='plain' href='/'", "Home")->append("br");
h.append("a", "class='plain' href='/config.cgi'", "Config")->append("br");
h.append("a", "class='plain' href='/status.cgi'", "Status")->append("br");
h.append("a", "class='plain' href='/statistics.cgi'", "Statistics")->append("br");
h.append("a", "class='plain' href='/help.cgi'", "Help")->append("br");
h.append("a", "class='plain' href='http://www.beam.ltd.uk'", "BEAM")->append("br");
h.append("a", "class='plain' href='http://www.alphadata.co.uk'", "Alpha Data")->append("br");
h.append("a", "class='plain' href='http://portal.beam.ltd.uk/support/cern'", "TMS Support")->append("br");
page.setLeftSide(h.render());
return err;
}
BError HttpConnection::processFile(BString url){
BError err;
BFile file;
BString ext;
int n;
const char* const* table;
const char* try_suffix;
BString mimeType;
BString s;
BString str;
BSize nsent;
BHtmlPage page;
dprintf(DBG_HTTP, "HttpConnection::processFile: Url: (%s)\n", url.retStr());
createPage(page);
if((url == "") || (url == "/"))
url = "index.html";
n = url.findReverse('.');
if(n >= 0)
ext = url.subString(n + 1, -1);
for(table = suffixTable; *table; table += 2){
if((try_suffix = strstr(*table, ext)) != 0){
try_suffix += strlen(ext);
if(*try_suffix == 0 || *try_suffix == '.')
break;
}
}
mimeType = table[1];
if(err = file.open(ohtmlDir + "/" + url, "r")){
sendHeader(HTTP_NOT_FOUND);
str = BString("Error: File not found.\r\n");
send(str, str.len(), nsent);
return err.set(1, "File not found");
}
dprintf(DBG_HTTP, "%s: Send Header Response\n", __FUNCTION__);
sendHeader(HTTP_OK, mimeType);
if(mimeType == "text/html"){
str = "";
while(file.readString(s) > 0){
str += s;
}
page.setTitle("TMS File");
page.setContent(htmlStrip(str));
str = page.render();
send(str, str.len(), nsent);
}
else {
dprintf(DBG_HTTP, "%s: SendFile\n", __FUNCTION__);
while(1){
char buf[1024];
int n;
BSize nw;
if((n = file.read(buf, 1024)) > 0)
send(buf, n, nw);
else
break;
}
}
return err;
}
BError HttpConnection::processInternal(BString url){
BError err;
BHtmlPage page;
BHtml h;
BHtml t;
BHtml* r;
BString str;
BSize nsent;
BList<BString> sl;
BList<BString> sl1;
BString urlBase;
BNameValueList<BString> args;
BIter i;
dprintf(DBG_HTTP, "%s: Start\n", __FUNCTION__);
createPage(page);
sl = url.getTokenList("?");
if(sl.number() >= 2){
urlBase = sl[0];
sl = sl[1].getTokenList("&");
for(sl.start(i); !sl.isEnd(i); sl.next(i)){
sl1 = sl[i].getTokenList("=");
if(sl1.number() == 1){
args.append(BNameValue<BString>("", sl1[0]));
}
else if(sl1.number() == 2){
args.append(BNameValue<BString>(sl1[0], sl1[1]));
}
}
}
else {
urlBase = url;
}
#ifndef ZAP
printf("Base: %s\n", urlBase.retStr());
printf("Args: ");
for(args.start(i); !args.isEnd(i); args.next(i)){
printf("%s=%s,", args[i].getName().retStr(), args[i].getValue().retStr());
}
printf("\n");
#endif
err = initTms();
if((urlBase == "/") || (urlBase == "/index.html")){
printf("DoIndex\n");
page.setTitle("TMS Main");
h = BHtml("div");
h.append("h1", "", "TMS Web Interface");
h.append("p", "", "This web interface provides information on the running TMS system ");
h.appendText("and provides the ability to fetch data and diagnostics information from the system.");
page.setContent(h.render());
str = page.render();
sendHeader(HTTP_OK, "text/html");
send(str, str.len(), nsent);
}
else if(urlBase == "/config.cgi"){
unsigned int n;
BIter i;
BError e;
ConfigInfo configInfo;
page.setTitle("TMS Configuration");
if(e = otmsControl.getConfiguration(configInfo)){
str = BString("TMS Access Error: ") + e.getString() + "\r\n";
sendHeader(HTTP_SERVICE_UNAVAILABLE);
send(str, str.len(), nsent);
}
else {
t = BHtml("table", "border=1");
r = t.append("tr");
r->append("th", "", "Channel");
r->append("th", "", "Module Number");
r->append("th", "", "Pupe Number");
r->append("th", "", "Pupe Channel");
for(n = 0; n < configInfo.puReferences.size(); n++){
r = t.append("tr");
r->append("td", "", n + 1);
r->append("td", "", configInfo.puReferences[n].moduleNum);
r->append("td", "", configInfo.puReferences[n].pupeNum);
r->append("td", "", configInfo.puReferences[n].pupeChan);
}
}
page.setContent(t.render());
str = page.render();
sendHeader(HTTP_OK, "text/html");
send(str, str.len(), nsent);
}
else if(urlBase == "/status.cgi"){
BIter i;
BError e;
BList<NameValue> list;
page.setTitle("TMS Status");
if(e = otmsControl.getStatus(list)){
str = BString("TMS Access Error: ") + e.getString() + "\r\n";
sendHeader(HTTP_SERVICE_UNAVAILABLE);
send(str, str.len(), nsent);
return err.set(1, "HTTP_SERVICE_UNAVAILABLE");
}
else {
t = BHtml("table", "border=1");
for(list.start(i); !list.isEnd(i); list.next(i)){
r = t.append("tr");
r->append("td", "", list[i].name);
r->append("td", "", list[i].value);
}
}
page.setContent(t.render());
str = page.render();
sendHeader(HTTP_OK, "text/html");
send(str, str.len(), nsent);
}
else if(urlBase == "/statistics.cgi"){
BIter i;
BError e;
BList<NameValue> list;
page.setTitle("TMS Statistics");
if(e = otmsControl.getStatistics(list)){
str = BString("TMS Access Error: ") + e.getString() + "\r\n";
sendHeader(HTTP_SERVICE_UNAVAILABLE);
send(str, str.len(), nsent);
return err.set(1, "HTTP_SERVICE_UNAVAILABLE");
}
else {
t = BHtml("table", "border=1");
for(list.start(i); !list.isEnd(i); list.next(i)){
r = t.append("tr");
r->append("td", "", list[i].name);
r->append("td", "", list[i].value);
}
}
page.setContent(t.render());
str = page.render();
sendHeader(HTTP_OK, "text/html");
send(str, str.len(), nsent);
}
else if(urlBase == "/dataraw.cgi"){
UInt32 i;
BError e;
DataInfo dataInfo;
Data data;
UInt32 cn = 0;
BString ct;
BString* v;
BString outputType;
// Set data require and wait for data
if(e = otmsProcess.getCycleInfo(cn, ct)){
str = BString("TMS Access Error: ") + e.getString() + "\r\n";
sendHeader(HTTP_SERVICE_UNAVAILABLE);
send(str, str.len(), nsent);
return err.set(1, "HTTP_SERVICE_UNAVAILABLE");
}
dataInfo.cycleNumber = cn;
dataInfo.channel = 1;
dataInfo.cyclePeriod = 0;
dataInfo.startTime = 0;
dataInfo.orbitNumber = 0;
dataInfo.bunchNumber = 0;
dataInfo.numValues = 0;
dataInfo.beyondPeriod = 0;
dataInfo.function = 0;
dataInfo.argument = 0;
if(v = args.find("channel"))
dataInfo.channel = v->retInt();
if(v = args.find("cyclePeriod"))
dataInfo.cyclePeriod = v->retInt();
if(v = args.find("startTime"))
dataInfo.startTime = v->retInt();
if(v = args.find("orbitNumber"))
dataInfo.orbitNumber = v->retInt();
if(v = args.find("bunchNumber"))
dataInfo.bunchNumber = v->retInt();
if(v = args.find("numValues"))
dataInfo.numValues = v->retInt();
if(v = args.find("function"))
dataInfo.function = v->retInt();
if(v = args.find("argument"))
dataInfo.argument = v->retInt();
if(v = args.find("outputType"))
outputType = *v;
if(e = otmsProcess.getData(dataInfo, data)){
str = BString("TMS Access Error: ") + e.getString() + "\r\n";
sendHeader(HTTP_SERVICE_UNAVAILABLE);
send(str, str.len(), nsent);
return err.set(1, "HTTP_SERVICE_UNAVAILABLE");
}
else {
str = "";
for(i = 0; i < data.dataValues.size(); i++){
str = str + data.dataValues[i].sigma + " " + data.dataValues[i].deltaX + " " + data.dataValues[i].deltaY + "\n";
}
}
if(outputType == "Graph"){
BFile df("/tmp/data.txt", "w");
BFile hf(ohtmlDir + "/data.html", "r");
BString s;
BString hstr;
df.writeString(str);
df.close();
plotData("/tmp/data.txt", 1, "Sigma", ohtmlDir + "/tmp/data0.png");
plotData("/tmp/data.txt", 2, "DeltaX", ohtmlDir + "/tmp/data1.png");
plotData("/tmp/data.txt", 3, "DeltaY", ohtmlDir + "/tmp/data2.png");
while(hf.readString(s) > 0){
hstr += s;
}
hstr = htmlStrip(hstr);
t = BHtml("table", "border=1");
r = t.append("tr");
r->append("td")->append("img", "src='tmp/data0.png'");
r = t.append("tr");
r->append("td")->append("img", "src='tmp/data1.png'");
r = t.append("tr");
r->append("td")->append("img", "src='tmp/data2.png'");
page.setTitle("TMS Data");
page.setContent(t.render() + hstr);
str = page.render();
sendHeader(HTTP_OK, "text/html");
send(str, str.len(), nsent);
}
else {
sendHeader(HTTP_OK, "text/plain");
send(str, str.len(), nsent);
}
}
else if(urlBase == "/help.cgi"){
page.setTitle("TMS Help");
t = BHtml("div");
t.append("li")->append("a", "href='/doc/index.html'", "Local Documentation");
t.append("li")->append("a", "href='http://portal.beam.ltd.uk/support/cern'", "BEAM TMS Support");
page.setContent(t.render());
str = page.render();
sendHeader(HTTP_OK, "text/html");
send(str, str.len(), nsent);
}
else {
sendHeader(HTTP_NOT_FOUND);
str = BString("Error: File not found.\r\n");
send(str, str.len(), nsent);
return err.set(1, "HTTP_NOT_FOUND");
}
return err;
}
BString HttpConnection::htmlStrip(BString str){
const char* s;
const char* e;
int start;
int num;
s = strcasestr(str, "<body>");
e = strcasestr(str, "</body>");
if(s && e){
start = s - str.retStr() + 6;
num = e - str.retStr() - start;
return str.subString(start, num);
}
else {
return str;
}
}
BError HttpConnection::plotData(BString dataFileName, int channel, BString name, BString outFileName){
BError err;
BString cmd;
FILE* f;
cmd = BString("set term png picsize 640 150; set output '") + outFileName + "';";
cmd = cmd + "set ylabel '" + name + "';";
cmd = cmd + "plot '" + dataFileName + "' using " + channel + " with lines;";
// printf("Cmd: %s\n", cmd.retStr());
f = popen("gnuplot -", "w");
fwrite(cmd, 1, cmd.len(), f);
pclose(f);
return err;
}
NetworkHttp::NetworkHttp(Control& control) :
BSocket(STREAM), ocontrol(control), orunThread(*this){
}
NetworkHttp::~NetworkHttp(){
BIter i;
for(oconnections.start(i); !oconnections.isEnd(i); ){
delete oconnections[i];
oconnections.del(i);
}
}
BError NetworkHttp::init(){
BError err;
BSocketAddressINET add;
int basePort = 80;
BString s;
dprintf(DBG_HTTP, "%s: Starting\n", __FUNCTION__);
if((s = ocontrol.oconfig.findValue("HttpPort:")) != "")
basePort = s.retInt();
// Create control socket
setReuseAddress(1);
// Connect up data socket
add.set("", basePort);
if(bind(add))
return BError(BString("Unable to bind to socket: ") + basePort + " " + strerror(errno));
listen();
// Don't let the threads have these sockets
fcntl(getFd(), F_SETFD, FD_CLOEXEC);
orunThread.start();
return err;
}
BError NetworkHttp::start(){
BError err;
return err;
}
BError NetworkHttp::stop(){
BError err;
return err;
}
BError NetworkHttp::run(){
BError err;
BIter i;
BPoll poll;
int fd;
int nfd;
HttpConnection* c;
BSocketAddressINET from;
dprintf(DBG_HTTP, "%s: Thread Started\n", __FUNCTION__);
poll.append(getFd());
while(1){
poll.doPoll(fd, 1000000);
if(fd == getFd()){
dprintf(DBG_HTTP, "%s: Accept connection\n", __FUNCTION__);
accept(nfd, from);
c = new HttpConnection(ocontrol, nfd, from);
oconnections.append(c);
c->start();
}
}
return err;
}
