generate bluescreens on fatal cpp errors (assertions to)
[enigma2.git] / lib / base / ebase.cpp
1 #include <lib/base/ebase.h>
2
3 #include <fcntl.h>
4 #include <unistd.h>
5 #include <errno.h>
6
7 #include <lib/base/eerror.h>
8 #include <lib/base/elock.h>
9
10 eSocketNotifier::eSocketNotifier(eMainloop *context, int fd, int requested, bool startnow): context(*context), fd(fd), state(0), requested(requested)
11 {
12         if (startnow)   
13                 start();
14 }
15
16 eSocketNotifier::~eSocketNotifier()
17 {
18         stop();
19 }
20
21 void eSocketNotifier::start()
22 {
23         if (state)
24                 stop();
25
26         context.addSocketNotifier(this);
27         state=2;  // running but not in poll yet
28 }
29
30 void eSocketNotifier::stop()
31 {
32         if (state)
33                 context.removeSocketNotifier(this);
34
35         state=0;
36 }
37
38                                         // timer
39 void eTimer::start(long msek, bool singleShot)
40 {
41         if (bActive)
42                 stop();
43
44         bActive = true;
45         bSingleShot = singleShot;
46         interval = msek;
47         gettimeofday(&nextActivation, 0);
48 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d msec", this, nextActivation.tv_sec, nextActivation.tv_usec, msek);
49         nextActivation += (msek<0 ? 0 : msek);
50 //      eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
51         context.addTimer(this);
52 }
53
54 void eTimer::startLongTimer( int seconds )
55 {
56         if (bActive)
57                 stop();
58
59         bActive = bSingleShot = true;
60         interval = 0;
61         gettimeofday(&nextActivation, 0);
62 //      eDebug("this = %p\nnow sec = %d, usec = %d\nadd %d sec", this, nextActivation.tv_sec, nextActivation.tv_usec, seconds);
63         if ( seconds > 0 )
64                 nextActivation.tv_sec += seconds;
65 //      eDebug("next Activation sec = %d, usec = %d", nextActivation.tv_sec, nextActivation.tv_usec );
66         context.addTimer(this);
67 }
68
69 void eTimer::stop()
70 {
71         if (bActive)
72         {
73                 bActive=false;
74                 context.removeTimer(this);
75         }
76 }
77
78 void eTimer::changeInterval(long msek)
79 {
80         if (bActive)  // Timer is running?
81         {
82                 context.removeTimer(this);       // then stop
83                 nextActivation -= interval;  // sub old interval
84         }
85         else
86                 bActive=true; // then activate Timer
87
88         interval = msek;                                                // set new Interval
89         nextActivation += interval;             // calc nextActivation
90
91         context.addTimer(this);                         // add Timer to context TimerList
92 }
93
94 void eTimer::activate()   // Internal Funktion... called from eApplication
95 {
96         context.removeTimer(this);
97
98         if (!bSingleShot)
99         {
100                 nextActivation += interval;
101                 context.addTimer(this);
102         }
103         else
104                 bActive=false;
105
106         /*emit*/ timeout();
107 }
108
109 void eTimer::addTimeOffset( int offset )
110 {
111         nextActivation.tv_sec += offset;
112 }
113
114 // mainloop
115 ePtrList<eMainloop> eMainloop::existing_loops;
116
117 void eMainloop::addSocketNotifier(eSocketNotifier *sn)
118 {
119         int fd = sn->getFD();
120         ASSERT(notifiers.find(fd) == notifiers.end());
121         notifiers[fd]=sn;
122 }
123
124 void eMainloop::removeSocketNotifier(eSocketNotifier *sn)
125 {
126         int fd = sn->getFD();
127         std::map<int,eSocketNotifier*>::iterator i(notifiers.find(fd));
128         if (i != notifiers.end())
129                 return notifiers.erase(i);
130         eFatal("removed socket notifier which is not present");
131 }
132
133 int eMainloop::processOneEvent(unsigned int user_timeout, PyObject **res, ePyObject additional)
134 {
135         int return_reason = 0;
136                 /* get current time */
137         timeval now;
138         gettimeofday(&now, 0);
139         m_now_is_invalid = 0;
140                 
141         if (additional && !PyDict_Check(additional))
142                 eFatal("additional, but it's not dict");
143                 
144         if (additional && !res)
145                 eFatal("additional, but no res");
146                 
147         int poll_timeout = -1; /* infinite in case of empty timer list */
148                 
149         if (m_timer_list)
150         {
151                 singleLock s(recalcLock);
152                 poll_timeout = timeval_to_usec(m_timer_list.begin()->getNextActivation() - now);
153                         /* if current timer already passed, don't delay infinite. */
154                 if (poll_timeout < 0)
155                         poll_timeout = 0;
156                         
157                         /* convert us to ms */
158                 poll_timeout /= 1000;
159         }
160         
161         if ((user_timeout > 0) && (poll_timeout > 0) && ((unsigned int)poll_timeout > user_timeout))
162         {
163                 poll_timeout = user_timeout;
164                 return_reason = 1;
165         }
166
167         int nativecount=notifiers.size(),
168                 fdcount=nativecount,
169                 ret=0;
170
171         if (additional)
172                 fdcount += PyDict_Size(additional);
173                 
174                 // build the poll aray
175         pollfd pfd[fdcount];  // make new pollfd array
176         std::map<int,eSocketNotifier*>::iterator it = notifiers.begin();
177         int i=0;
178         for (; i < nativecount; ++i, ++it)
179         {
180                 it->second->state = 1; // running and in poll
181                 pfd[i].fd = it->first;
182                 pfd[i].events = it->second->getRequested();
183         }
184         
185         if (additional)
186         {
187                 PyObject *key, *val;
188                 int pos=0;
189                 while (PyDict_Next(additional, &pos, &key, &val)) {
190                         pfd[i].fd = PyObject_AsFileDescriptor(key);
191                         pfd[i++].events = PyInt_AsLong(val);
192                 }
193         }
194
195         if (this == eApp)
196                 Py_BEGIN_ALLOW_THREADS
197                 ret = ::poll(pfd, fdcount, poll_timeout);
198                 Py_END_ALLOW_THREADS
199         else
200                 ret = ::poll(pfd, fdcount, poll_timeout);
201
202                         /* ret > 0 means that there are some active poll entries. */
203         if (ret > 0)
204         {
205                 int i=0;
206                 return_reason = 0;
207                 for (; i < nativecount; ++i)
208                 {
209                         if (pfd[i].revents)
210                         {
211                                 it = notifiers.find(pfd[i].fd);
212                                 if (it != notifiers.end()
213                                         && it->second->state == 1) // added and in poll
214                                 {
215                                         int req = it->second->getRequested();
216                                         if (pfd[i].revents & req)
217                                                 it->second->activate(pfd[i].revents & req);
218                                         pfd[i].revents &= ~req;
219                                 }
220                                 if (pfd[i].revents & (POLLERR|POLLHUP|POLLNVAL))
221                                         eDebug("poll: unhandled POLLERR/HUP/NVAL for fd %d(%d)", pfd[i].fd, pfd[i].revents);
222                         }
223                 }
224                 for (; i < fdcount; ++i)
225                 {
226                         if (pfd[i].revents)
227                         {
228                                 if (!*res)
229                                         *res = PyList_New(0);
230                                 ePyObject it = PyTuple_New(2);
231                                 PyTuple_SET_ITEM(it, 0, PyInt_FromLong(pfd[i].fd));
232                                 PyTuple_SET_ITEM(it, 1, PyInt_FromLong(pfd[i].revents));
233                                 PyList_Append(*res, it);
234                                 Py_DECREF(it);
235                         }
236                 }
237                         
238                 ret = 1; /* poll did not timeout. */
239         } else if (ret < 0)
240         {
241                         /* when we got a signal, we get EINTR. */
242                 if (errno != EINTR)
243                         eDebug("poll made error (%m)");
244                 else
245                 {
246                         return_reason = 2;
247                         ret = -1; /* don't assume the timeout has passed when we got a signal */
248                 }
249         }
250         
251                 /* when we not processed anything, check timers. */
252         if (!m_timer_list.empty())
253         {
254                         /* we know that this time has passed. */
255                 singleLock s(recalcLock);
256
257                 if (ret || m_now_is_invalid)
258                         gettimeofday(&now, 0);
259                 else
260                         now += poll_timeout;
261
262                         /* process all timers which are ready. first remove them out of the list. */
263                 while ((!m_timer_list.empty()) && (m_timer_list.begin()->getNextActivation() <= now))
264                         m_timer_list.begin()->activate();
265         }
266         
267         return return_reason;
268 }
269
270 void eMainloop::addTimer(eTimer* e)
271 {
272         m_timer_list.insert_in_order(e);
273 }
274
275 void eMainloop::removeTimer(eTimer* e)
276 {
277         m_timer_list.remove(e);
278 }
279
280 int eMainloop::iterate(unsigned int user_timeout, PyObject **res, ePyObject dict)
281 {
282         int ret = 0;
283         
284         timeval user_timer;
285         gettimeofday(&user_timer, 0);
286         user_timer += user_timeout;
287
288                 /* TODO: this code just became ugly. fix that. */
289         do
290         {
291                 if (m_interrupt_requested)
292                 {
293                         m_interrupt_requested = 0;
294                         return 0;
295                 }
296                 if (app_quit_now) return -1;
297                 timeval now, timeout;
298                 gettimeofday(&now, 0);
299                 timeout = user_timer - now;
300                 
301                 if (user_timeout && (user_timer <= now))
302                         return 0;
303                 
304                 int to = 0;
305                 if (user_timeout)
306                         to = timeout.tv_sec * 1000 + timeout.tv_usec / 1000;
307                 
308                 ret = processOneEvent(to, res, dict);
309                 if (res && *res)
310                         return ret;
311         } while (ret == 0);
312         
313         return ret;
314 }
315
316 int eMainloop::runLoop()
317 {
318         while (!app_quit_now)
319                 iterate();
320         return retval;
321 }
322
323 void eMainloop::reset()
324 {
325         app_quit_now=false;
326 }
327
328 PyObject *eMainloop::poll(ePyObject timeout, ePyObject dict)
329 {
330         PyObject *res=0;
331         
332         if (app_quit_now)
333                 Py_RETURN_NONE;
334         
335         int user_timeout = (timeout == Py_None) ? 0 : PyInt_AsLong(timeout);
336
337         iterate(user_timeout, &res, dict);
338         ePyObject ret(res);
339         
340         if (!ret) /* return empty list on timeout */
341                 return PyList_New(0);
342         
343         return ret;
344 }
345
346 void eMainloop::interruptPoll()
347 {
348         m_interrupt_requested = 1;
349 }
350
351 void eMainloop::quit(int ret)
352 {
353         retval = ret;
354         app_quit_now = true;
355 }
356
357 void eMainloop::addTimeOffset(int offset)
358 {
359         for (ePtrList<eMainloop>::iterator it(eMainloop::existing_loops)
360                 ;it != eMainloop::existing_loops.end(); ++it)
361         {
362                 singleLock s(it->recalcLock);
363                 it->m_now_is_invalid = 1;
364                 for (ePtrList<eTimer>::iterator tit = it->m_timer_list.begin(); tit != it->m_timer_list.end(); ++tit )
365                         tit->addTimeOffset(offset);
366         }
367 }
368
369 eApplication* eApp = 0;