xmlServer.cxx

Go to the documentation of this file.

/********************************************************************\
 
  Name:         xmlServer.cxx
  Created by:   Konstantin Olchanski
 
  Contents:     Serve XML-encoded ROOT objects through a TCP socket
 
  $Id$
 
\********************************************************************/
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
#include "xmlServer.h"
 
/*==== ROOT socket histo server ====================================*/
 
#if 1
#define THREADRETURN
#define THREADTYPE void
#endif
#if defined( OS_WINNT )
#define THREADRETURN 0
#define THREADTYPE DWORD WINAPI
#endif
#ifndef THREADTYPE
#define THREADTYPE int
#define THREADRETURN 0
#endif
 
#include <TROOT.h>
#include <TClass.h>
#include <TDirectory.h>
#include <TKey.h>
#include <TFolder.h>
#include <TSocket.h>
#include <TServerSocket.h>
#include <TThread.h>
#include <TMessage.h>
#include <TObjString.h>
#include <TH1.h>
#include <TCutG.h>
#include <TBufferXML.h>
 
#include <deque>
#include <map>
#include <string>
 
class XLockRootGuard
{
public:
   bool fIsLocked;
 
   XLockRootGuard() // ctor
   {
      TThread::Lock();
      fIsLocked = true;
   }
 
   ~XLockRootGuard() // dtor
   {
      if (fIsLocked)
         Unlock();
   }
 
   void Unlock()
   {
      fIsLocked = false;
      TThread::UnLock();
   };
};
 
static bool gVerbose = false;
 
static std::deque<std::string> gExports;
static std::map<std::string,std::string> gExportNames;
 
/*------------------------------------------------------------------*/
 
static std::string HtmlEncode(const char* s)
{
   std::string r;
   while (*s) {
      char c = *s;
      if (c == '<') {
         r += "&lt;";
      } else if (c == '>') {
         r += "&gt;";
      } else if (c == '&') {
         r += "&amp;";
      } else {
         r += c;
      }
      s++;
   }
   return r;
}
 
static std::string UrlEncode(const char* s)
{
   std::string r;
   while (*s) {
      char c = *s;
      if (isalpha(c)) {
         r += c;
      } else if (isdigit(c)) {
         r += c;
      } else {
         char buf[16];
         sprintf(buf, "%%%02x", c);
         r += buf;
      }
      s++;
   }
   return r;
}
 
static int atohex(int a)
{
   if (a>='0' && a<='9')
      return a-'0';
   if (a>='a' && a<='f')
      return a-'a'+10;
   if (a>='A' && a<='F')
      return a-'A'+10;
   return 0;
}
 
static std::string HtmlDecode(const char* s)
{
   std::string r;
   while (*s) {
      if (*s == '%') {
         s++;
         char c = 0;
         c = c*16 + atohex(s[0]);
         c = c*16 + atohex(s[1]);
         r += c;
 
         // be careful when incrementing "s" to not overrun the '\0' string terminator!
         if (*s)
            s++;
         if (*s)
            s++;
      } else {
         r += *s++;
      }
   }
   return r;
}
 
/*------------------------------------------------------------------*/
 
static TObject* FollowPath(TObject* container, char* path)
{
  if (0)
    printf("Follow path [%s] in container %p\n", path, container);
 
  while (1)
    {
      while (*path == '/')
        path++;
 
      char* s = strchr(path,'/');
 
      if (s)
        *s = 0;
 
      TObject *obj = NULL;
 
      std::string xpath = HtmlDecode(path);
      //printf("FindObject %s, decoded [%s]\n", path, xpath.c_str());
 
      if (container->InheritsFrom(TDirectory::Class()))
        obj = ((TDirectory*)container)->FindObject(xpath.c_str());
      else if (container->InheritsFrom(TFolder::Class()))
        obj = ((TFolder*)container)->FindObject(xpath.c_str());
      else if (container->InheritsFrom(TCollection::Class()))
        obj = ((TCollection*)container)->FindObject(xpath.c_str());
      else
        {
          fprintf(stderr, "XmlServer: ERROR: Container \'%s\' of type %s is not a TDirectory, TFolder or TCollection\n", container->GetName(), container->IsA()->GetName());
          return NULL;
        }
 
      if (!obj)
        return NULL;
 
      if (!s)
        return obj;
 
      container = obj;
 
      path = s+1;
    }
  /* NOT REACHED */
}
 
static TObject* FindTopLevelObject(const char* name)
{
   if (0)
      printf("FindTopLevelObject [%s]\n", name);
   if (strcmp(name, "root") == 0)
      return gROOT;
   TObject *obj = NULL;
   //gROOT->GetListOfFiles()->Print();
   obj = gROOT->GetListOfFiles()->FindObject(name);
   if (obj)
      return obj;
   obj = gROOT->FindObjectAny(name);
   if (obj)
      return obj;
   return NULL;
}
 
static TObject* TopLevel(char* path, char**opath)
{
  if (0)
    printf("Extract top level object from [%s]\n", path);
 
  while (*path == '/')
    path++;
 
  char* s = strchr(path,'/');
  
  if (s)
    {
      *s = 0;
      *opath = s+1;
    }
  else
    {
      *opath = NULL;
    }
 
  std::string xpath = HtmlDecode(path);
 
  TObject *obj = NULL;
 
  for (unsigned int i=0; i<gExports.size(); i++)
    {
      const char* ename = gExports[i].c_str();
      //printf("Compare [%s] and [%s]\n", xpath.c_str(), ename);
      if (strcmp(xpath.c_str(), ename) == 0)
        {
          const char* xname = gExportNames[ename].c_str();
          obj = FindTopLevelObject(xname);
          //printf("Lookup of [%s] returned %p\n", xname, obj);
          break;
        }
    }
 
  if (!obj)
    {
      fprintf(stderr, "XmlServer: ERROR: Top level object \'%s\' not found in exports list\n", xpath.c_str());
      return NULL;
    }
 
  return obj;
}
 
static TObject* FollowPath(char* path)
{
  if (0)
    printf("Follow path [%s]\n", path);
 
  char *s;
  TObject *obj = TopLevel(path, &s);
 
  if (!obj)
    return NULL;
 
  if (!s)
    return obj;
 
  return FollowPath(obj, s);
}
 
/*------------------------------------------------------------------*/
 
#if 0
static void ResetObject(TObject* obj)
{
  assert(obj!=NULL);
 
  if (gVerbose)
    printf("ResetObject object %p name [%s] type [%s]\n", obj, obj->GetName(), obj->IsA()->GetName());
 
  if (obj->InheritsFrom(TH1::Class()))
    {
      ((TH1*)obj)->Reset();
    }
  else if (obj->InheritsFrom(TDirectory::Class()))
    {
      TDirectory* dir = (TDirectory*)obj;
      TList* objs = dir->GetList();
 
      TIter next = objs;
      while(1)
        {
          TObject *obj = next();
          if (obj == NULL)
            break;
          ResetObject(obj);
        }
    }
}
#endif
 
/*------------------------------------------------------------------*/
 
static void SendString(TSocket* sock, const char* str)
{
   sock->SendRaw(str, strlen(str));
}
 
static void SendHttpReply(TSocket* sock, const char* mimetype, const char* message)
{
   char buf[256];
   int len = strlen(message);
   SendString(sock, "HTTP/1.1 200 OK\n");
   //SendString(sock, "Date: Tue, 15 May 2012 16:50:31 GMT\n");
   SendString(sock, "Server: ROOTANA xmlServer\n");
   sprintf(buf, "Content-Length: %d\n", len);
   SendString(sock, buf);
   //Connection: close\n
   sprintf(buf, "Content-Type: %s\n", mimetype);
   SendString(sock, buf);
   //charset=iso-8859-1\n
   SendString(sock, "\n");
   SendString(sock, message);
   printf("XmlServer: Reply content-length %d, content-type %s\n", len, mimetype);
}
 
static void SendHttpReply(TSocket* sock, const char* mimetype, const std::string& str)
{
   SendHttpReply(sock, mimetype, str.c_str());
}
 
/*------------------------------------------------------------------*/
 
static std::string HtmlTag(const char* tag, const char* contents)
{
   std::string s;
   s += "<";
   s += tag;
   s += ">";
   s += contents;
   s += "</";
   s += tag;
   s += ">";
   return s;
}
 
static std::string HtmlTag(const char* tag, const std::string& contents)
{
   std::string s;
   s += "<";
   s += tag;
   s += ">";
   s += contents;
   s += "</";
   s += tag;
   s += ">";
   return s;
}
 
/*------------------------------------------------------------------*/
 
std::string MakeXmlEntry(const TObject* obj)
{
   const char* objname = obj->GetName();
   const char* classname = obj->ClassName();
   bool isSubdir = false;
   std::string xkey = "";
 
   if (obj->InheritsFrom(TKey::Class())) {
      TKey* key = (TKey*)obj;
      classname = key->GetClassName();
      xkey = "<key/>";
   }
 
   const TClass *xclass = TClass::GetClass(classname);
 
   if (xclass->InheritsFrom(TDirectory::Class()))
      isSubdir = true;
 
   if (xclass->InheritsFrom(TFolder::Class()))
      isSubdir = true;
 
   if (xclass->InheritsFrom(TCollection::Class()))
      isSubdir = true;
 
   //printf("xclass %s, classname %s, subdir %d\n", xclass->GetName(), classname, isSubdir);
 
   if (isSubdir)
      return HtmlTag("subdir", HtmlTag("name", HtmlEncode(objname)) + HtmlTag("class", HtmlEncode(classname)) + xkey) + "\n";
   else
      return HtmlTag("object", HtmlTag("name", HtmlEncode(objname)) + HtmlTag("class", HtmlEncode(classname)) + xkey) + "\n";
}
 
std::string MakeHtmlEntry(const TObject* obj, const char* path)
{
   const char* objname = obj->GetName();
   const char* classname = obj->ClassName();
   bool isKey = false;
 
   if (obj->InheritsFrom(TKey::Class())) {
      TKey* key = (TKey*)obj;
      classname = key->GetClassName();
      isKey = true;
   }
 
   std::string s;
 
   s += "<a href=\"";
   s += path; //dir->GetName();
   s += "/";
   s += UrlEncode(objname);
   s += "\">";
   s += objname;
   s += "</a>\n";
   s += " (";
   s += classname;
   s += ")";
   if (isKey)
      s += "-KEY";
   s += " ";
   s += "<a href=\"";
   s += path; //dir->GetName();
   s += "/";
   s += UrlEncode(objname);
   s += ".xml";
   s += "\">";
   s += "XML</a>\n";
 
   return s;
}
   
/*------------------------------------------------------------------*/
 
static void SendFile(TSocket* sock, const char* filename, const char* mimetype)
{
   std::string f = filename;
   std::string reply;
   FILE *fp = fopen(f.c_str(), "r");
   if (!fp) {
      std::string home = getenv("HOME");
      f = home + "/packages/rootana/libXmlServer/" + filename;
      fp = fopen(f.c_str(), "r");
   }
   printf("sending file %s, fp %p\n", f.c_str(), fp);
   if (fp) {
      while (1) {
         char buf[1024+1];
         int rd = fread(buf, 1, sizeof(buf)-1, fp);
         if (rd <= 0)
            break;
         buf[rd] = 0;
         reply += buf;
      }
      fclose(fp);
   }
   SendHttpReply(sock, mimetype, reply);
}
 
/*------------------------------------------------------------------*/
 
static THREADTYPE xroot_server_thread(void *arg)
/*
  Serve histograms over TCP/IP socket link
*/
{
   char request[2560];
 
   TSocket *sock = (TSocket *) arg;
   //TMessage message(kMESS_OBJECT);
 
   do {
 
      /* close connection if client has disconnected */
      int rd = sock->RecvRaw(request, sizeof(request), kDontBlock); // (ESendRecvOptions)-1);
      if (rd <= 0)
        {
          if (gVerbose)
            fprintf(stderr, "XmlServer: connection from %s closed\n", sock->GetInetAddress().GetHostName());
          sock->Close();
          delete sock;
          return THREADRETURN;
        }
 
      if (1) {
         char *p;
         p = strchr(request, '\n');
         if (p)
            *p = 0;
         
         p = strchr(request, '\r');
         if (p)
            *p = 0;
      }
         
      if (gVerbose)
        printf("XmlServer: Request [%s] from %s\n", request, sock->GetInetAddress().GetHostName());
 
      if (0) {} 
      else if (strstr(request, "GET / "))
        {
          // enumerate top level exported directories
 
          XLockRootGuard lock;
          
          std::string reply;
 
          reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
          reply += HtmlTag("title", "Export list") + "\n";
          reply += "</head><body>\n";
          reply += HtmlTag("h1", "Export list") + "\n";
 
          for (unsigned int i=0; i<gExports.size(); i++) {
             const char* ename = gExports[i].c_str();
             const char* xname = gExportNames[ename].c_str();
             
             TObject* obj = FindTopLevelObject(xname);
             
             if (obj) {
                std::string s;
                s += " ";
                s += "<a href=\"";
                s += UrlEncode(ename);
                s += "\">";
                s += ename;
                s += "</a>\n";
                s += "<a href=\"";
                s += UrlEncode(ename);
                s += ".xml";
                s += "\">";
                s += "XML</a>\n";
                reply += HtmlTag("p", s) + "\n";
             } else {
                std::string s;
                s += ename;
                s += " (cannot be found. maybe deleted?)\n";
                reply += HtmlTag("p", s) + "\n";
             }
          }
          
          lock.Unlock();
 
          reply += "</body></html>\n";
          SendHttpReply(sock, "text/html", reply);
        }
      //else if (strstr(request, "GET /plot.html "))
      //  {
      //    SendFile(sock, "plot.html", "text/html");
      //  }
      else if (strstr(request, "js/jquery.min.js "))
        {
          SendFile(sock, "jquery.min.js", "text/javascript");
        }
      else if (strstr(request, "js/highcharts.js "))
        {
          SendFile(sock, "highcharts.js", "text/javascript");
        }
      else if (strstr(request, "js/exporting.js "))
        {
          SendFile(sock, "exporting.js", "text/javascript");
        }
      else if (strstr(request, "GET /favicon.ico "))
        {
          std::string reply;
 
          reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
          reply += HtmlTag("title", "No favicon") + "\n";
          reply += "</head><body>\n";
          reply += HtmlTag("h1", "No favicon") + "\n";
          reply += HtmlTag("p", "No favicon") + "\n";
          reply += "</body></html>\n";
          SendHttpReply(sock, "text/html", reply);
        }
      else if (strstr(request, "GET /index.xml "))
        {
          // enumerate top level exported directories
 
          XLockRootGuard lock;
 
          std::string xml;
 
          xml += "<xml>\n";
          xml += "<dir>\n";
          
          for (unsigned int i=0; i<gExports.size(); i++)
            {
              const char* ename = gExports[i].c_str();
              const char* xname = gExportNames[ename].c_str();
 
              TObject* obj = FindTopLevelObject(xname);
 
              if (!obj) {
                 xml += HtmlTag("subdir", HtmlTag("name", HtmlEncode(ename)) + "<deleted/>") + "\n";
                 continue;
              }
 
              const char* cname = obj->ClassName();
 
              xml += HtmlTag("subdir", HtmlTag("name", HtmlEncode(ename)) + HtmlTag("class", HtmlEncode(cname))) + "\n";
            }
          
          lock.Unlock();
 
          xml += "</dir>\n";
          xml += "</xml>\n";
 
          SendHttpReply(sock, "application/xml", xml);
        }
      else if (strncmp(request, "GET /", 5) == 0)
        {
          XLockRootGuard lock;
 
          char* dirname = request + 5;
 
          char* x = strstr(dirname, " HTTP");
          if (x)
             *x = 0;
 
          bool xmlOutput = false;
 
          x = strstr(dirname, ".xml");
          if (x) {
             *x = 0;
             xmlOutput = true;
          }
 
          std::string path;
          path += "/";
          path += dirname;
 
          std::string xpath = HtmlDecode(dirname);
 
      //printf("path [%s] dirname [%s] xpath [%s]\n", path.c_str(), dirname, xpath.c_str());
 
          TObject* obj = FollowPath(dirname);
 
          if (!obj) {
             std::string reply;
             std::string buf;
             
             reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
 
             buf = "Not found ";
             buf += xpath;
             reply += HtmlTag("title", buf) + "\n";
             reply += "</head><body>\n";
             reply += HtmlTag("h1", buf) + "\n";
             
             reply += HtmlTag("p", "Object not found");
 
             reply += "</body></html>\n";
             SendHttpReply(sock, "text/html", reply);
 
          } else if (obj && obj->InheritsFrom(TDirectory::Class())) {
             TDirectory* dir = (TDirectory*)obj;
 
             std::string reply;
             std::string buf;
             std::string xml;
 
             xml += "<xml>\n";
             xml += "<dir>\n";
             
             reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
 
             buf = "Dir ";
             buf += xpath;
             reply += HtmlTag("title", buf) + "\n";
             reply += "</head><body>\n";
             reply += HtmlTag("h1", buf) + "\n";
 
             //printf("Directory %p\n", dir);
             //dir->Print();
 
             std::map<std::string, std::string> alist;
 
             if (1) {
                TList* keys = dir->GetListOfKeys();
 
                //printf("Directory %p keys:\n", dir);
                //keys->Print();
             
                TIter next = keys;
                while(1) {
                   TObject *obj = next();
                   
                   //printf("object %p\n", obj);
                   
                   if (obj == NULL)
                      break;
 
                   std::string a = HtmlTag("p", MakeHtmlEntry(obj, path.c_str())) + "\n";
                   //alist[objname] = a;
                   reply += a;
                   
                   xml += MakeXmlEntry(obj);
                }
             }
 
             if (1) {
                TList* objs = dir->GetList();
             
                //printf("Directory %p objects:\n", dir);
                //objs->Print();
                
                TIter next = objs;
                while(1)
                   {
                      TObject *obj = next();
                      
                      //printf("object %p\n", obj);
                      
                      if (obj == NULL)
                         break;
                      
                      std::string a = HtmlTag("p", MakeHtmlEntry(obj, path.c_str())) + "\n";
                      //alist[objname] = a;
                      reply += a;
 
                      xml += MakeXmlEntry(obj);
                   }
             }
                
             lock.Unlock();
             
             if (1) {
                std::map<std::string, std::string>::iterator iter = alist.begin();
                for (; iter!=alist.end(); iter++) {
                   // iter->first is your key
                   // iter->second is it''s value
                   reply += iter->second;
                }
             }
              
             reply += "</body></html>\n";
 
             xml += "</dir></xml>\n";
 
             if (xmlOutput)
                SendHttpReply(sock, "application/xml", xml);
             else
                SendHttpReply(sock, "text/html", reply);
             
          } else if (obj && obj->InheritsFrom(TFolder::Class())) {
             TFolder* folder = (TFolder*)obj;
 
             //printf("Folder %p\n", folder);
             //folder->Print();
 
             std::string xml;
 
             xml += "<xml>\n";
             xml += "<dir>\n";
             
             std::string reply;
             std::string buf;
             
             reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
 
             buf = "Folder ";
             buf += xpath;
             reply += HtmlTag("title", buf) + "\n";
             reply += "</head><body>\n";
             reply += HtmlTag("h1", buf) + "\n";
             
             TIterator *iterator = folder->GetListOfFolders()->MakeIterator();
             
             while (1)
                {
                   TNamed *obj = (TNamed*)iterator->Next();
                   if (obj == NULL)
                      break;
                   
                   reply += HtmlTag("p", MakeHtmlEntry(obj, path.c_str())) + "\n";
                   xml += MakeXmlEntry(obj);
                }
             
             delete iterator;
 
             lock.Unlock();
 
             xml += "</dir></xml>\n";
             reply += "</body></html>\n";
 
             if (xmlOutput)
                SendHttpReply(sock, "application/xml", xml);
             else
                SendHttpReply(sock, "text/html", reply);
 
          } else if (obj && obj->InheritsFrom(TCollection::Class())) {
             TCollection* collection = (TCollection*)obj;
             
             //printf("Collection %p\n", collection);
             //collection->Print();
             //printf("Entries %d\n", collection->GetEntries());
             //printf("IsEmpty %d\n", collection->IsEmpty());
             
             std::string xml;
 
             xml += "<xml>\n";
             xml += "<dir>\n";
             
             std::string reply;
             std::string buf;
             
             reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
 
             buf = "Collection ";
             buf += xpath;
             reply += HtmlTag("title", buf) + "\n";
             reply += "</head><body>\n";
             reply += HtmlTag("h1", buf) + "\n";
             
             TIterator *iterator = collection->MakeIterator();
             
             while (1)
                {
                   TNamed *obj = (TNamed*)iterator->Next();
                   if (obj == NULL)
                      break;
                   
                   reply += HtmlTag("p", MakeHtmlEntry(obj, path.c_str())) + "\n";
                   xml += MakeXmlEntry(obj);
                }
             
             delete iterator;
 
             lock.Unlock();
             
             xml += "</dir></xml>\n";
             reply += "</body></html>\n";
 
             if (xmlOutput)
                SendHttpReply(sock, "application/xml", xml);
             else
                SendHttpReply(sock, "text/html", reply);
 
          } else {
             if (xmlOutput) {
                std::string xml;
                xml += "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n";
                xml += "<xml>\n";
                xml += "<ROOTobject>\n";
                TString msg = TBufferXML::ConvertToXML(obj);
                xml += msg;
                xml += "</ROOTobject>\n";
                xml += "</xml>\n";
                lock.Unlock();
                SendHttpReply(sock, "application/xml", xml);
             } else {
                SendFile(sock, "plot.html", "text/html");
                if (0) {
                std::string reply;
                std::string buf;
                
                reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
                
                buf = "Object ";
                buf += xpath;
                reply += HtmlTag("title", buf) + "\n";
                reply += "</head><body>\n";
                reply += HtmlTag("h1", buf) + "\n";
                
                reply += HtmlTag("p", obj->GetName());
                reply += HtmlTag("p", obj->ClassName());
                
                reply += "</body></html>\n";
                SendHttpReply(sock, "text/html", reply);
                }
             }
          }
        }
#if 0
      else if (strncmp(request, "ResetTH1 ", 9) == 0)
        {
          XLockRootGuard lock;
          
          char* path = request + 9;
 
          if (strlen(path) > 1)
            {
              TObject *obj = FollowPath(path);
 
              if (obj)
                ResetObject(obj);
            }
          else
            {
              for (unsigned int i=0; i<gExports.size(); i++)
                {
                  const char* ename = gExports[i].c_str();
                  const char* xname = gExportNames[ename].c_str();
 
                  TObject* obj = FindTopLevelObject(xname);
 
                  if (!obj)
                    {
                      fprintf(stderr, "XmlServer: ResetTH1: Exported name \'%s\' cannot be found!\n", xname);
                      continue;
                    }
 
                  ResetObject(obj);
                }
            }
          
          //TObjString s("Success");
 
          //message.Reset(kMESS_OBJECT);
          //message.WriteObject(&s);
          lock.Unlock();
          //sock->Send(message);
 
          const char *msg = "Success";
          sock->SendRaw(msg, strlen(msg) + 1);
        }
#endif
      else
        {
          fprintf(stderr, "XmlServer: Received unknown request \"%s\"\n", request);
 
          std::string reply;
          reply += "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n<html><head>\n";
          reply += HtmlTag("title", "Unknown request") + "\n";
          reply += "</head><body>\n";
          reply += HtmlTag("h1", "Unknown request") + "\n";
          reply += HtmlTag("p", request) + "\n";
          reply += "</body></html>\n";
          SendHttpReply(sock, "text/html", reply);
        }
   } while (1);
 
   return THREADRETURN;
}
 
/*------------------------------------------------------------------*/
 
static THREADTYPE xsocket_listener(void *arg)
{
  // Server loop listening for incoming network connections on specified port.
  // Starts a searver_thread for each connection.
 
  int port = *(int *) arg;
  
  fprintf(stderr, "XmlServer: Listening on port %d...\n", port);
  TServerSocket *lsock = new TServerSocket(port, kTRUE);
  
  while (1)
    {
      TSocket *sock = lsock->Accept();
      
      if (sock==NULL)
        {
          fprintf(stderr, "XmlServer: TSocket->Accept() error\n");
          break;
        }
      
      if (gVerbose)
        fprintf(stderr, "XmlServer: connection from %s\n", sock->GetInetAddress().GetHostName());
      
#if 1
      TThread *thread = new TThread("XmlServer", xroot_server_thread, sock);
      thread->Run();
#else
      LPDWORD lpThreadId = 0;
      CloseHandle(CreateThread(NULL, 1024, &xroot_server_thread, sock, 0, lpThreadId));
#endif
    }
  
  return THREADRETURN;
}
 
/*------------------------------------------------------------------*/
 
void XmlServer::SetVerbose(bool verbose)
{
  gVerbose = verbose;
}
 
/*------------------------------------------------------------------*/
 
void XmlServer::Export(TDirectory* dir, const char* exportName)
{
  if (gVerbose)
    printf("Export TDirectory %p named [%s] of type [%s] as [%s]\n", dir, dir->GetName(), dir->IsA()->GetName(), exportName);
 
  bool found = false;
  for (unsigned int i=0; i<gExports.size(); i++)
    {
      const char* ename = gExports[i].c_str();
      if (strcmp(ename, exportName) == 0)
        found = true;
    }
 
  if (!found)
    gExports.push_back(exportName);
  gExportNames[exportName] = dir->GetName();
}
 
void XmlServer::Export(TFolder* folder, const char* exportName)
{
  if (gVerbose)
    printf("Export TFolder %p named [%s] of type [%s] as [%s]\n", folder, folder->GetName(), folder->IsA()->GetName(), exportName);
 
  bool found = false;
  for (unsigned int i=0; i<gExports.size(); i++)
    {
      const char* ename = gExports[i].c_str();
      if (strcmp(ename, exportName) == 0)
        found = true;
    }
 
  if (!found)
    gExports.push_back(exportName);
  gExportNames[exportName] = folder->GetName();
}
 
void XmlServer::Export(TCollection* collection, const char* exportName)
{
  if (gVerbose)
    printf("Export TCollection %p named [%s] of type [%s] as [%s]\n", collection, collection->GetName(), collection->IsA()->GetName(), exportName);
 
  bool found = false;
  for (unsigned int i=0; i<gExports.size(); i++)
    {
      const char* ename = gExports[i].c_str();
      if (strcmp(ename, exportName) == 0)
        found = true;
    }
 
  if (!found)
    gExports.push_back(exportName);
  gExportNames[exportName] = collection->GetName();
}
 
void XmlServer::Start(int port)
{
  if (port==0)
    return;
 
  //printf("Here!\n");
 
  static int pport = port;
#if 1
  TThread *thread = new TThread("XmlServer", xsocket_listener, &pport);
  thread->Run();
#else
  LPDWORD lpThreadId = 0;
  CloseHandle(CreateThread(NULL, 1024, &xroot_socket_server, &pport, 0, lpThreadId));
#endif
}
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */