#include "server.h"
#include "logger.h"
#include "utils/signalHandling.h"

Include dependency graph for run.c:

Functions
int	serverPoll (Server)

int	serverHandleAccept (Server, unsigned int)

ssize_t	serverRead (Server, unsigned int)

ssize_t	serverWrite (Server, unsigned int)

void	serverCloseConn (Server, unsigned int)

void	serverRun (Server this)

Detailed Description

Author: Georg Hopp

Copyright: Copyright © 2012 Georg Hopp

This program 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 3 of the License, or (at your option) any later version.

This program 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 this program. If not, see http://www.gnu.org/licenses/.

Definition in file run.c.

Function Documentation

void serverCloseConn	(	Server	,
		unsigned	int
	)

Definition at line 31 of file close_conn.c.

Referenced by serverRun().

 {
     int    fd = (this->fds)[i].fd;
     Stream st = (this->conns[fd]).stream;
 
     delete((this->conns)[fd].sock);
     delete((this->conns)[fd].worker);
 
     if (NULL != st && STREAM_SSL == st->type) {
         SSL_shutdown((st->handle).ssl);
         SSL_free((st->handle).ssl);
         (st->handle).ssl = NULL;
     }
 
     delete(st);
 
     memset(&(this->fds[i]), 0, sizeof(struct pollfd));
 }

Here is the caller graph for this function:

int serverHandleAccept	(	Server	,
		unsigned	int
	)

Definition at line 36 of file handle_accept.c.

References clone, logger, LOGGER_DEBUG, loggerLog(), socketAccept(), socketNonblock(), STREAM_FD, and STREAM_SSL.

Referenced by serverRun().

 {
     char   remoteAddr[16] = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
     Sock   acc = NULL;
     Stream st;
 
     if (this->nfds >= this->max_fds) {
         return -1;
     }
 
     acc = socketAccept((0 == i)? this->sock : this->sockSSL, &remoteAddr);
 
     if (NULL != acc && -1 != acc->handle) {
         socketNonblock(acc);
 
         switch(i) {
             case 0:
                 // no SSL
                 st = new(Stream, STREAM_FD, acc->handle);
                 break;
 
             case 1:
                 // SSL
                 {
                     SSL * ssl = SSL_new(this->ctx);
                     SSL_set_fd(ssl, acc->handle);
                     SSL_accept(ssl);
                     st = new(Stream, STREAM_SSL, ssl);
                 }
                 break;
 
             default:
                 st = NULL;
                 break;
         }
 
         // save the socket handle
         (this->conns)[acc->handle].sock   = acc; 
 
         // clone worker
         (this->conns)[acc->handle].worker = clone(this->worker);
         (this->conns)[acc->handle].stream = st;
 
         (this->fds)[this->nfds].fd        = acc->handle;
         (this->fds)[this->nfds].events    = POLLIN;
         this->nfds++;
     } else {
         delete(acc);
 
         switch(errno) {
             case EAGAIN|EWOULDBLOCK:
             case EINTR:
                 loggerLog(this->logger,
                         LOGGER_DEBUG,
                         "server accept blocks");
                 return -1;
                 break;
 
             default:
                 loggerLog(this->logger,
                         LOGGER_DEBUG,
                         "server accept error");
                 return -2;
                 break;
         }
     }
 
     if (0 == this->nfds%200) {
         loggerLog(this->logger,
                 LOGGER_DEBUG, "paralel connections: %lu", this->nfds);
     }
 
     return acc->handle;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

int serverPoll ( Server )

put all closed fds to end of array in O(this->nfds)

Definition at line 34 of file poll.c.

References doShutdown, logger, LOGGER_CRIT, and loggerLog().

Referenced by serverRun().

                         {
     int events;
 
     /**
      * put all closed fds to end of array in O(this->nfds)
      */
     struct pollfd * fda = &(this->fds[2]);
     struct pollfd * fdb = &(this->fds[this->nfds-1]);
 
     while (fda <= fdb) {
         while (0 == fdb->fd && fda <= fdb) {
             fdb--;
             this->nfds--;
         }
 
         while (0 != fda->fd && fda <= fdb) fda++;
 
         if (fda < fdb) {
             memcpy(fda, fdb, sizeof(struct pollfd));
             fdb--;
             this->nfds--;
         }
     }
 
     /*
      * wait for handles to become ready
      */
     do {
         if (-1 == (events = poll(this->fds, this->nfds, -1))) {
             switch (errno) {
                 default:
                 case EBADF:
                 case EINVAL:
                 case ENOMEM:
                     doShutdown = 1;
                     // DROP THROUGH
 
                 case EINTR:
                     loggerLog(this->logger, LOGGER_CRIT,
                             "poll systemcall failed: [%s] - service terminated",
                             strerror(errno));
             }
         }
     } while (! doShutdown && 0 >= events);
 
     return events;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ssize_t serverRead	(	Server	,
		unsigned	int
	)

Definition at line 31 of file server/read.c.

References logger, LOGGER_INFO, loggerLog(), and streamReaderRead().

Referenced by serverRun().

 {
     int     fd = (this->fds)[i].fd;
 
     if (NULL == (this->conns)[fd].worker) {
         loggerLog(
                 this->logger,
                 LOGGER_INFO,
                 "initialization error: NULL reader");
         return -2;
     }
 
     return streamReaderRead(
             (this->conns)[fd].worker,
             (this->conns)[fd].stream);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void serverRun ( Server this )

until error or signal

handle accept

handle accept SSL

handle reads

handle writes

Definition at line 36 of file run.c.

References doShutdown, logger, LOGGER_INFO, loggerLog(), serverCloseConn(), serverHandleAccept(), serverPoll(), serverRead(), and serverWrite().

Referenced by main().

 {
     int events = 0;
 
     loggerLog(this->logger, LOGGER_INFO, "service started");
 
     while (!doShutdown) //! until error or signal 
     {
         unsigned int i;
 
         if (0 <= events) {
             /*
              * TODO check why sometimes events is less than 0
              * There is still a misshandling here.
              */
             events = serverPoll(this);
         }
 
         /**
          * handle accept
          */
         if (0 != ((this->fds)[0].revents & POLLIN)) {
             while (0 < serverHandleAccept(this, 0)) {}
             events--;
         }
 
         if (events == 0) {
             continue;
         }
 
         /**
          * handle accept SSL
          */
         if (0 != ((this->fds)[1].revents & POLLIN)) {
             while (0 < serverHandleAccept(this, 1)) {}
             events--;
         }
 
         if (events == 0) {
             continue;
         }
 
         for (i=2; i < this->nfds; i++) {
             /**
              * handle reads 
              */
             if (0 != ((this->fds)[i].revents & POLLIN)) {
                 ssize_t processed = serverRead(this, i);
 
                 if (0 > processed) {
                     events--;
 
                     switch (processed) {
                         case -2: // close me...
                             serverCloseConn(this, i);
 
                         case -1: // poll me again
                             break;
                     }
                 }
 
                 if (0 < processed) {
                     (this->fds)[i].events |= POLLOUT;
                 }
             }
 
             if (events == 0) {
                 break;
             }
 
             /**
              * handle writes
              */
             if (0 != ((this->fds)[i].revents & POLLOUT)) {
                 ssize_t remaining = serverWrite(this, i);
 
                 if (0 >= remaining) {
                     /*
                      * 0 means queue was empty...try again next
                      * time...no need to poll again.
                      * Anyway, most likely we need to read again
                      * so lets finish this event for now.
                      */
                     events--;
 
                     switch (remaining) {
                         case  0: // nothing more to write stop polling
                             (this->fds)[i].events &= ~POLLOUT;
                             break;
 
                         case -2: // close me...
                             serverCloseConn(this, i);
 
                         case -1: // poll me again
                             break;
                     }
                 }
             }
 
             if (events == 0) {
                 break; // no more events to handle
             }
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ssize_t serverWrite	(	Server	,
		unsigned	int
	)

Definition at line 30 of file server/write.c.

References logger, LOGGER_INFO, loggerLog(), and streamWriterWrite().

Referenced by serverRun().

 {
     int     fd = (this->fds)[i].fd;
 
     if (NULL == (this->conns)[fd].worker) {
         loggerLog(
                 this->logger,
                 LOGGER_INFO,
                 "initialization error: NULL worker");
         return -2;
     }
 
     return streamWriterWrite(
             (this->conns)[fd].worker,
             (this->conns)[fd].stream);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Detailed Description

Function Documentation