mcs/FileDescriptor.cc

   1 #include "FileDescriptor.h"
   2 #include "macros.h"
   3
   4 namespace remote { namespace mcs {
   5
   6 void FileDescriptor::serviceLoop()
   7 {
   8         unsigned int i, instanceCount;
   9         int f;
  10         filedescriptorsbyfd_t::iterator fileDescriptorIterator;
  11         // register the timeout handler
  12         signal( SIGALRM, timeoutHandler );
  13         ignoreBrokenPipeSignals();
  14
  15         do
  16         {
  17                 instanceCount = instances.size();
  18                 pollfd fdmap[instanceCount];
  19                 FileDescriptor::buildPollMap(fdmap);
  20                 if ( poll(fdmap,instanceCount,-1) < 0)
  21                 {
  22                         __THROW__("Error in poll!");
  23                 }
  24
  25                 try
  26                 {
  27                         // look for activity on any sockets
  28                         for ( i = 0; i < instanceCount; i++ )
  29                         {
  30                                 if ( fdmap[i].revents )
  31                                 {
  32                                         f = fdmap[i].fd;
  33                                         fileDescriptorIterator = instances.find(f);
  34                                         if (fileDescriptorIterator != instances.end())
  35                                         {
  36                                                 fileDescriptorIterator->second->handleEvent(fdmap[i].revents);
  37                                         }
  38                                 }
  39                         }
  40                 }
  41                 catch (remote::protocols::MMSException e)
  42                 {
  43                         clearTimeout();
  44                         log("Exception: %s\n",e.what());
  45                         fileDescriptorIterator->second->clearTimeout();
  46                         fileDescriptorIterator->second->destroy(false);
  47                 }
  48         }
  49         while( true );
  50 }
  51
  52 FileDescriptor::FileDescriptor(int p_fd)
  53 {
  54         clearTimeout();
  55         fd = p_fd;
  56         log("Opened fd %i\n",fd);
  57         instances[fd] = this;
  58 }
  59
  60 void FileDescriptor::buildPollMap(pollfd* map)
  61 {
  62         int j = 0;
  63         filedescriptorsbyfd_t::iterator i;
  64         for (i = instances.begin(); i != instances.end(); i++)
  65         {
  66                 map[j].fd = i->second->fd;
  67                 map[j].events = POLLMSG|POLLRDBAND|POLLRDNORM|POLLIN|POLLPRI|POLLERR|POLLHUP|POLLNVAL;
  68                 map[j].revents = 0;
  69                 j++;
  70         }
  71 }
  72
  73
  74 FileDescriptor::~FileDescriptor()
  75 {
  76         if (close(fd) != 0)
  77         {
  78                 int err = errno;
  79                 switch (err)
  80                 {
  81                         case EBADF:
  82                                 log("close(%i) - %i isn’t a valid open file descriptor.\n",fd,fd);
  83                                 break;
  84                         case EINTR:
  85                                 log("close(%i) - The close() call was interrupted by a signal.\n",fd);
  86                                 break;
  87                         case EIO:
  88                                 log("close(%i) - An I/O error occurred.\n",fd);
  89                                 break;
  90                         default:
  91                                 log("close(%i) - Unknown error %i occured\n",fd,err);
  92                 }
  93         }
  94         else
  95         {
  96                 log("Closed fd %i\n",fd);
  97         }
  98         instances.erase(fd);
  99 }
 100
 101 void FileDescriptor::destroy(bool silent)
 102 {
 103         delete this;
 104 }
 105
 106
 107 void FileDescriptor::setTimeout(int secs)
 108 {
 109                 itimerval timeout;
 110                 // stop the timer
 111                 timeout.it_interval.tv_sec = 0;
 112                 timeout.it_interval.tv_usec = 0;
 113                 timeout.it_value.tv_sec = secs;
 114                 timeout.it_value.tv_usec = 0;
 115                 if (setitimer(ITIMER_REAL, &timeout, NULL))
 116                 {
 117                         __THROW__ ("Timer set error\n");
 118                 };
 119                 currentFd = fd;
 120 }
 121
 122 void FileDescriptor::clearTimeout()
 123 {
 124                 itimerval timeout;
 125                 // stop the timer
 126                 timeout.it_interval.tv_sec = 0;
 127                 timeout.it_interval.tv_usec = 0;
 128                 timeout.it_value.tv_sec = 0;
 129                 timeout.it_value.tv_usec = 0;
 130                 if (setitimer(ITIMER_REAL, &timeout, NULL))
 131                 {
 132                         __THROW__ ("Timer clear error\n");
 133                 };
 134                 currentFd = -1;
 135 }
 136
 137
 138 RETSIGTYPE FileDescriptor::timeoutHandler(int sig)
 139 {
 140         log( "Timeout occured!\n");
 141         close(currentFd); // this should generate an exception
 142 }
 143
 144 void FileDescriptor::ignoreBrokenPipeSignals()
 145 {
 146         struct sigaction act;
 147         act.sa_handler = SIG_IGN;
 148         act.sa_flags = 0;
 149
 150         sigaction(SIGPIPE,&act,NULL);
 151 }
 152
 153 filedescriptorsbyfd_t FileDescriptor::instances;
 154 int FileDescriptor::currentFd = -1;
 155 }}