tevent: prefix types and defined with tevent_ and TEVENT_

This fixes the build warnings on some build-farm hosts.

metze

diff --git a/lib/tevent/tevent_signal.c b/lib/tevent/tevent_signal.c
index ab170a66cf75f38c5785e720e3c7ceff83419e79..0f3d83e8775db0d3338e1728ec309911b7d28564 100644 (file)
--- a/lib/tevent/tevent_signal.c
+++ b/lib/tevent/tevent_signal.c
@@ -30,23 +30,23 @@
 #include "tevent_internal.h"
 #include "tevent_util.h"
 
-#define NUM_SIGNALS 64
+#define TEVENT_NUM_SIGNALS 64
 
 /* maximum number of SA_SIGINFO signals to hold in the queue.
   NB. This *MUST* be a power of 2, in order for the ring buffer
   wrap to work correctly. Thanks to Petr Vandrovec <petr@vandrovec.name>
   for this. */
 
-#define SA_INFO_QUEUE_COUNT 64
+#define TEVENT_SA_INFO_QUEUE_COUNT 64
 
-struct sigcounter {
+struct tevent_sigcounter {
        uint32_t count;
        uint32_t seen;
 };
 
-#define SIG_INCREMENT(s) (s).count++
-#define SIG_SEEN(s, n) (s).seen += (n)
-#define SIG_PENDING(s) ((s).seen != (s).count)
+#define TEVENT_SIG_INCREMENT(s) (s).count++
+#define TEVENT_SIG_SEEN(s, n) (s).seen += (n)
+#define TEVENT_SIG_PENDING(s) ((s).seen != (s).count)
 
 struct tevent_common_signal_list {
        struct tevent_common_signal_list *prev, *next;
@@ -56,22 +56,22 @@ struct tevent_common_signal_list {
 /*
   the poor design of signals means that this table must be static global
 */
-static struct sig_state {
-       struct tevent_common_signal_list *sig_handlers[NUM_SIGNALS+1];
-       struct sigaction *oldact[NUM_SIGNALS+1];
-       struct sigcounter signal_count[NUM_SIGNALS+1];
-       struct sigcounter got_signal;
+static struct tevent_sig_state {
+       struct tevent_common_signal_list *sig_handlers[TEVENT_NUM_SIGNALS+1];
+       struct sigaction *oldact[TEVENT_NUM_SIGNALS+1];
+       struct tevent_sigcounter signal_count[TEVENT_NUM_SIGNALS+1];
+       struct tevent_sigcounter got_signal;
 #ifdef SA_SIGINFO
        /* with SA_SIGINFO we get quite a lot of info per signal */
-       siginfo_t *sig_info[NUM_SIGNALS+1];
-       struct sigcounter sig_blocked[NUM_SIGNALS+1];
+       siginfo_t *sig_info[TEVENT_NUM_SIGNALS+1];
+       struct tevent_sigcounter sig_blocked[TEVENT_NUM_SIGNALS+1];
 #endif
 } *sig_state;
 
 /*
   return number of sigcounter events not processed yet
 */
-static uint32_t sig_count(struct sigcounter s)
+static uint32_t tevent_sig_count(struct tevent_sigcounter s)
 {
        return s.count - s.seen;
 }
@@ -87,8 +87,8 @@ static void tevent_common_signal_handler(int signum)
        struct tevent_context *ev = NULL;
        int saved_errno = errno;
 
-       SIG_INCREMENT(sig_state->signal_count[signum]);
-       SIG_INCREMENT(sig_state->got_signal);
+       TEVENT_SIG_INCREMENT(sig_state->signal_count[signum]);
+       TEVENT_SIG_INCREMENT(sig_state->got_signal);
 
        /* Write to each unique event context. */
        for (sl = sig_state->sig_handlers[signum]; sl; sl = sl->next) {
@@ -109,24 +109,24 @@ static void tevent_common_signal_handler(int signum)
 static void tevent_common_signal_handler_info(int signum, siginfo_t *info,
                                              void *uctx)
 {
-       uint32_t count = sig_count(sig_state->signal_count[signum]);
-       /* sig_state->signal_count[signum].seen % SA_INFO_QUEUE_COUNT
+       uint32_t count = tevent_sig_count(sig_state->signal_count[signum]);
+       /* sig_state->signal_count[signum].seen % TEVENT_SA_INFO_QUEUE_COUNT
         * is the base of the unprocessed signals in the ringbuffer. */
        uint32_t ofs = (sig_state->signal_count[signum].seen + count) %
-                               SA_INFO_QUEUE_COUNT;
+                               TEVENT_SA_INFO_QUEUE_COUNT;
        sig_state->sig_info[signum][ofs] = *info;
 
        tevent_common_signal_handler(signum);
 
        /* handle SA_SIGINFO */
-       if (count+1 == SA_INFO_QUEUE_COUNT) {
+       if (count+1 == TEVENT_SA_INFO_QUEUE_COUNT) {
                /* we've filled the info array - block this signal until
                   these ones are delivered */
                sigset_t set;
                sigemptyset(&set);
                sigaddset(&set, signum);
                sigprocmask(SIG_BLOCK, &set, NULL);
-               SIG_INCREMENT(sig_state->sig_blocked[signum]);
+               TEVENT_SIG_INCREMENT(sig_state->sig_blocked[signum]);
        }
 }
 #endif
@@ -196,7 +196,7 @@ struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
        struct tevent_common_signal_list *sl;
        sigset_t set, oldset;
 
-       if (signum >= NUM_SIGNALS) {
+       if (signum >= TEVENT_NUM_SIGNALS) {
                errno = EINVAL;
                return NULL;
        }
@@ -204,7 +204,7 @@ struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
        /* the sig_state needs to be on a global context as it can last across
           multiple event contexts */
        if (sig_state == NULL) {
-               sig_state = talloc_zero(talloc_autofree_context(), struct sig_state);
+               sig_state = talloc_zero(talloc_autofree_context(), struct tevent_sig_state);
                if (sig_state == NULL) {
                        return NULL;
                }
@@ -267,7 +267,9 @@ struct tevent_signal *tevent_common_add_signal(struct tevent_context *ev,
                        act.sa_handler   = NULL;
                        act.sa_sigaction = tevent_common_signal_handler_info;
                        if (sig_state->sig_info[signum] == NULL) {
-                               sig_state->sig_info[signum] = talloc_zero_array(sig_state, siginfo_t, SA_INFO_QUEUE_COUNT);
+                               sig_state->sig_info[signum] =
+                                       talloc_zero_array(sig_state, siginfo_t,
+                                                         TEVENT_SA_INFO_QUEUE_COUNT);
                                if (sig_state->sig_info[signum] == NULL) {
                                        talloc_free(se);
                                        return NULL;
@@ -310,14 +312,14 @@ int tevent_common_check_signal(struct tevent_context *ev)
 {
        int i;
 
-       if (!sig_state || !SIG_PENDING(sig_state->got_signal)) {
+       if (!sig_state || !TEVENT_SIG_PENDING(sig_state->got_signal)) {
                return 0;
        }
        
-       for (i=0;i<NUM_SIGNALS+1;i++) {
+       for (i=0;i<TEVENT_NUM_SIGNALS+1;i++) {
                struct tevent_common_signal_list *sl, *next;
-               struct sigcounter counter = sig_state->signal_count[i];
-               uint32_t count = sig_count(counter);
+               struct tevent_sigcounter counter = sig_state->signal_count[i];
+               uint32_t count = tevent_sig_count(counter);
 #ifdef SA_SIGINFO
                /* Ensure we null out any stored siginfo_t entries
                 * after processing for debugging purposes. */
@@ -338,11 +340,11 @@ int tevent_common_check_signal(struct tevent_context *ev)
 
                                for (j=0;j<count;j++) {
                                        /* sig_state->signal_count[i].seen
-                                        * % SA_INFO_QUEUE_COUNT is
+                                        * % TEVENT_SA_INFO_QUEUE_COUNT is
                                         * the base position of the unprocessed
                                         * signals in the ringbuffer. */
                                        uint32_t ofs = (counter.seen + j)
-                                               % SA_INFO_QUEUE_COUNT;
+                                               % TEVENT_SA_INFO_QUEUE_COUNT;
                                        se->handler(ev, se, i, 1,
                                                    (void*)&sig_state->sig_info[i][ofs], 
                                                    se->private_data);
@@ -364,7 +366,7 @@ int tevent_common_check_signal(struct tevent_context *ev)
                        uint32_t j;
                        for (j=0;j<count;j++) {
                                uint32_t ofs = (counter.seen + j)
-                                       % SA_INFO_QUEUE_COUNT;
+                                       % TEVENT_SA_INFO_QUEUE_COUNT;
                                memset((void*)&sig_state->sig_info[i][ofs],
                                        '\0',
                                        sizeof(siginfo_t));
@@ -372,23 +374,23 @@ int tevent_common_check_signal(struct tevent_context *ev)
                }
 #endif
 
-               SIG_SEEN(sig_state->signal_count[i], count);
-               SIG_SEEN(sig_state->got_signal, count);
+               TEVENT_SIG_SEEN(sig_state->signal_count[i], count);
+               TEVENT_SIG_SEEN(sig_state->got_signal, count);
 
 #ifdef SA_SIGINFO
-               if (SIG_PENDING(sig_state->sig_blocked[i])) {
+               if (TEVENT_SIG_PENDING(sig_state->sig_blocked[i])) {
                        /* We'd filled the queue, unblock the
                           signal now the queue is empty again.
                           Note we MUST do this after the
-                          SIG_SEEN(sig_state->signal_count[i], count)
+                          TEVENT_SIG_SEEN(sig_state->signal_count[i], count)
                           call to prevent a new signal running
                           out of room in the sig_state->sig_info[i][]
                           ring buffer. */
                        sigset_t set;
                        sigemptyset(&set);
                        sigaddset(&set, i);
-                       SIG_SEEN(sig_state->sig_blocked[i],
-                                sig_count(sig_state->sig_blocked[i]));
+                       TEVENT_SIG_SEEN(sig_state->sig_blocked[i],
+                                tevent_sig_count(sig_state->sig_blocked[i]));
                        sigprocmask(SIG_UNBLOCK, &set, NULL);
                }
 #endif