vss: Avoid read-overflowing the header buffer for ogg streams.

[paraslash.git] / sched.c

diff --git a/sched.c b/sched.c
index 8baed4962d9e5dfbf2cad170b1c38d2d42b123b3..66a17418027a5e9fa2d92bee412cf682561115b9 100644 (file)
--- a/sched.c
+++ b/sched.c
@@ -9,6 +9,7 @@
 #include <regex.h>
 #include <assert.h>
 #include <sys/time.h>
+#include <stdbool.h>
 
 #include "para.h"
 #include "ipc.h"
@@ -46,24 +47,25 @@ static void unregister_task(struct task *t)
                list_del(&t->post_select_node);
 }
 
+static inline bool timeout_is_zero(struct sched *s)
+{
+       struct timeval *tv = &s->select_timeout;
+       return tv->tv_sec == 0 && tv->tv_usec == 0;
+}
+
 static void sched_preselect(struct sched *s)
 {
        struct task *t, *tmp;
        list_for_each_entry_safe(t, tmp, &pre_select_list, pre_select_node) {
-               if (t->pre_select)
-                       t->pre_select(s, t);
-//             PARA_INFO_LOG("%s \n", t->status);
-               if (t->error >= 0)
+               if (t->error < 0) {
+                       unregister_task(t);
                        continue;
-               /*
-                * We have to check whether the list is empty because the call
-                * to ->pre_select() might have called sched_shutdown(). In
-                * this case t has been unregistered already, so we must not
-                * unregister it again.
-                */
-               if (list_empty(&pre_select_list))
-                       return;
-               unregister_task(t);
+               }
+               if (!t->pre_select)
+                       continue;
+               t->pre_select(s, t);
+               if (timeout_is_zero(s))
+                       break;
        }
 }
 
@@ -97,7 +99,12 @@ static void sched_post_select(struct sched *s)
 //             PARA_INFO_LOG("%s: %d\n", t->status, t->ret);
                if (t->error >= 0)
                        continue;
-               /* nec., see sched_preselect() */
+               /*
+                * We have to check whether the list is empty because the call
+                * to ->post_select() might have called sched_shutdown(). In
+                * this case t has been unregistered already, so we must not
+                * unregister it again.
+                */
                if (list_empty(&post_select_list))
                        return;
                unregister_task(t);
@@ -136,21 +143,26 @@ again:
        sched_preselect(s);
        if (list_empty(&pre_select_list) && list_empty(&post_select_list))
                return 0;
-       ret = s->select_function(s->max_fileno + 1, &s->rfds, &s->wfds,
-               &s->select_timeout);
-       if (ret < 0)
-               return ret;
-       if (ret == 0) {
-               /*
-                * APUE: Be careful not to check the descriptor sets on return
-                * unless the return value is greater than zero. The return
-                * state of the descriptor sets is implementation dependent if
-                * either a signal is caught or the timer expires.
-                */
+       if (!timeout_is_zero(s)) {
+               ret = s->select_function(s->max_fileno + 1, &s->rfds, &s->wfds,
+                       &s->select_timeout);
+               if (ret < 0)
+                       return ret;
+               if (ret == 0) {
+                       /*
+                        * APUE: Be careful not to check the descriptor sets on return
+                        * unless the return value is greater than zero. The return
+                        * state of the descriptor sets is implementation dependent if
+                        * either a signal is caught or the timer expires.
+                        */
+                       FD_ZERO(&s->rfds);
+                       FD_ZERO(&s->wfds);
+               }
+               gettimeofday(now, NULL);
+       } else {
                FD_ZERO(&s->rfds);
                FD_ZERO(&s->wfds);
        }
-       gettimeofday(now, NULL);
        sched_post_select(s);
        if (list_empty(&pre_select_list) && list_empty(&post_select_list))
                return 0;
@@ -197,7 +209,8 @@ void register_task(struct task *t)
  * Unregister all tasks.
  *
  * This will cause \a schedule() to return immediately because both the
- * \a pre_select_list and the \a post_select_list are empty.
+ * \a pre_select_list and the \a post_select_list are empty. This function
+ * must be called from the post_select (rather than the pre_select) method.
  */
 void sched_shutdown(void)
 {
@@ -258,8 +271,7 @@ char *get_task_list(void)
  */
 void sched_min_delay(struct sched *s)
 {
-       s->select_timeout.tv_sec = 0;
-       s->select_timeout.tv_usec = 1;
+       s->select_timeout.tv_sec = s->select_timeout.tv_usec = 0;
 }
 
 /**
@@ -302,17 +314,19 @@ void sched_request_timeout_ms(long unsigned ms, struct sched *s)
  * \param barrier Absolute time before select() should return.
  * \param s Pointer to the scheduler struct.
  *
- * If \a barrier is in the past, this function does nothing.
+ * \return If \a barrier is in the past, this function does nothing and returns
+ * zero. Otherwise it returns one.
  *
  * \sa sched_request_barrier_or_min_delay().
  */
-void sched_request_barrier(struct timeval *barrier, struct sched *s)
+int sched_request_barrier(struct timeval *barrier, struct sched *s)
 {
        struct timeval diff;
 
        if (tv_diff(now, barrier, &diff) > 0)
-               return;
+               return 0;
        sched_request_timeout(&diff, s);
+       return 1;
 }
 
 /**
@@ -321,15 +335,19 @@ void sched_request_barrier(struct timeval *barrier, struct sched *s)
  * \param barrier Absolute time before select() should return.
  * \param s Pointer to the scheduler struct.
  *
- * If \a barrier is in the past, this function requests a minimal timeout.
+ * \return If \a barrier is in the past, this function requests a minimal
+ * timeout and returns zero. Otherwise it returns one.
  *
  * \sa sched_min_delay(), sched_request_barrier().
  */
-void sched_request_barrier_or_min_delay(struct timeval *barrier, struct sched *s)
+int sched_request_barrier_or_min_delay(struct timeval *barrier, struct sched *s)
 {
        struct timeval diff;
 
-       if (tv_diff(now, barrier, &diff) > 0)
-               return sched_min_delay(s);
+       if (tv_diff(now, barrier, &diff) > 0) {
+               sched_min_delay(s);
+               return 0;
+       }
        sched_request_timeout(&diff, s);
+       return 1;
 }