mcs/FileDescriptor.cc

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