/home/croftj/photogrotto/photogrotto.cpp

/*********************************************************************************
**
**   $Id: //depot/WorkInProgress/photogrotto/photogrotto.cpp#6 $
**   Copyright (c) 2007 Joe Croft joe@croftj.net
**   
**   This file is part of Photogrotto
**
**   Photogrotto is free software; you can redistribute it and/or modify
**   it under the terms of the GNU General Public License as published by
**   the Free Software Foundation; either version 2 of the License, or
**   (at your option) any later version.
**
**   Foobar is distributed in the hope that it will be useful,
**   but WITHOUT ANY WARRANTY; without even the implied warranty of
**   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**   GNU General Public License for more details.
**
**   You should have received a copy of the GNU General Public License
**   along with Foobar; if not, write to the Free Software
**   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
*********************************************************************************/

# include <errno.h>
# include <stdio.h>
# include <string.h>
# include <QFile>
# include "photogrotto.h"

FILE *logfp;

/*!
       \class PhotoGrotto
       
       \brief  Controlling  class  for  creating  a  http  server  for
       processing incomming connections and requests.
       
       This  class  functions as an  http server which accepts connections
       from   external  clients.  The  definition  of  the  server  is
       specified  in an XML file.
*/ 

/*!
       \fn PhotoGrotto::PhotoGrotto(QString confName, QObject *parent)
       
       This functioncreates a PhotoGrotto object. The  definition  of 
       the  server  is specified in an XML file. the file named by the
       parameter  \a  confName.  The Parameter \a parent points to the
       parent object of this one is any.
*/ 
PhotoGrotto::PhotoGrotto(QString confName, QObject *parent) :
      QTcpServer(parent)
{
   int line, col;

   logfp = stderr;

   /*
          Open the XML file for the application.
   */ 
   QFile file( confName );
   if ( !file.open( IO_ReadOnly ) )
   {
      error_str = "Could not open file: " + confName;
      return;
   }

   /*
          Try  parsing the file. If there are any erros, spit them out
          to stderr.
   */ 
   if ( !doc.setContent( &file, &err, &line, &col ) ) {
      file.close();
      error_str = "Error parsing xml doc: " + confName + "The error reported as: " + err + " found on line: " + QString::number(line) + ", column: " + QString::number(col);
      fprintf(stderr, "PhotoGrotto::PhotoGrotto(): Error in setContent file\n%s\n", qPrintable(error_str));
      return;
   }

   /*
          Set  up to listen on the address and port defined in the XML
          document. COmplain if you can't
   */ 
   getTcpParms();
   if ( ! listen(address, port) ) 
   {
      fprintf(logfp, "Error listening\n");
      return;
   }
}

/*!
      \fn void PhotoGrotto::incomingConnection(int sock)

       This   function  overloads  the  like  named  function  in  the
       QTcpServer class and is called whenever a new tcp connection is
       made.  It  creates  a new DbPhoto Object to handle the requests
       for the object and starts the thread for that object to run on.
       It   also  connects  the  appropriate  signals  and  slots  for
       controlling the thread.
*/ 
void PhotoGrotto::incomingConnection(int sock)
{
   fprintf(logfp, "PhotoGrotto::incomingConnection(): Enter, sock = %d\n", sock);
   fflush(logfp);

   /*
          Create   a   new   service  object  to  handle  this  socket
          connection.  Connect  the  appropriate  signals and slots to
          control it.
   */ 
   DbPhotoService *p = new DbPhotoService(sock, &doc, 120);
   connect(p, SIGNAL(send(QTcpSocket*, QByteArray)), this, SLOT(sendData(QTcpSocket*, QByteArray)));
   connect(p, SIGNAL(closeSocket(QTcpSocket*)), this, SLOT(haveCloseSocket(QTcpSocket*)));

   p->setMaxCache(2000);

   /*
          Start the thread to handle the requests.
   */ 
   p->start();
   fprintf(logfp, "PhotoGrotto::incomingConnection(): exit\n");
   fflush(logfp);
}

/*!
      \fn void PhotoGrotto::getTcpParms()

       This  function  retrieves the name of the log file and opens it
       for  logging.  It  also  retrieves the address and port for the
       server  to  listen  on  and  populates  the  class variables \a
       address and \a port with the defined information.
*/ 
void PhotoGrotto::getTcpParms()
{
   port = 80;
   address.setAddress(QHostAddress::Any);

   QDomElement docElem = doc.documentElement();
   QDomNode n = docElem.firstChild();
   while ( !n.isNull() ) 
   {
      QDomElement e = n.toElement();

      /*
             Have  a  logfile  tag,  get  the name and open the log if
             possible.
      */ 
      if ( e.tagName() == "logfile" ) 
      {
         if ( e.attribute("name").size() > 0 ) 
         {
            FILE *fp = fopen(qPrintable(e.attribute("name")), "a");
            if ( fp != 0 ) 
            {
               logfp = fp;
               stdout = fp;
               stderr = fp;
            }
            else
               fprintf(logfp, "Error opening logfile %s: %s\n", qPrintable(e.attribute("name")), strerror(errno));
         }
      }

      /*
             Have  the  listen tag. Get the address and port to listen
             on and save them for later.
      */ 
      else if ( e.tagName() == "listen" ) 
      {
         if ( e.attribute("addr").size() > 0 ) 
         {
            fprintf(logfp, "Listening on address: %s\n", qPrintable(e.attribute("addr")));
            address.setAddress(e.attribute("addr"));
         }
         else if ( e.attribute("address").size() > 0 ) 
         {
            fprintf(logfp, "Listening on address: %s\n", qPrintable(e.attribute("address")));
            address.setAddress(e.attribute("address"));
         }

         if ( e.attribute("port").size() > 0 ) 
            port = e.attribute("port").toInt();
         break;
      }
      n = n.nextSibling();
   }
   fprintf(logfp, "Listening on port: %d\n", port);
   fflush(logfp);
}        

/*!
       \fn  void  PhotoGrotto::sendData(QTcpSocket *sock, QByteArray  buf)
       
       This  function  writes the buffer \a buf of data to the socket \a sock.
       This  is  called  by  the  thread handling the requests for the
       socket.
*/ 
void PhotoGrotto::sendData(QTcpSocket *sock, QByteArray buf)
{
   fprintf(logfp, "PhotoGrotto::sendData(): Enter, sending %d bytes to sock %d\n", buf.count(), sock->socketDescriptor());
   fflush(logfp);
   sock->write(buf);
   fprintf(logfp, "PhotoGrotto::sendData(): Exit\n");
   fflush(logfp);
}

/*!
       \fn void PhotoGrotto::haveCloseSocket(QTcpSocket *sock)
       
       This function is called then the socket \a sock is closed. It cleans up the 
       socket object.
*/ 
void PhotoGrotto::haveCloseSocket(QTcpSocket *sock)
{
   fprintf(logfp, "PhotoGrotto::haveCloseSocket(): Enter, sock %d\n", sock->socketDescriptor());
   fflush(logfp);
   sock->disconnectFromHost();
   fprintf(logfp, "PhotoGrotto::haveClocseSocket(): Exit\n");
   fflush(logfp);
}

---