X-Git-Url: https://jfr.im/git/irc/evilnet/x3.git/blobdiff_plain/ff3b058ac51e9caf5cf1fd310b8a401a97a85582..ec8177c5c7b355a953871d6fded9ae77cf2a4a96:/src/global.c

diff --git a/src/global.c b/src/global.c
index ad325c5..c0a8e5f 100644
--- a/src/global.c
+++ b/src/global.c
@@ -33,6 +33,7 @@
 
 /* Global options */
 #define KEY_DB_BACKUP_FREQ	"db_backup_freq"
+#define KEY_ANNOUNCEMENTS_DEFAULT "announcements_default"
 #define KEY_NICK		"nick"
 
 /* Message data */
@@ -137,9 +138,14 @@ static struct log_type *G_LOG;
 static struct
 {
     unsigned long db_backup_frequency;
+    unsigned int announcements_default : 1;
 } global_conf;
 
-#define global_notice(target, format...) send_message(target , global , ## format)
+#if defined(GCC_VARMACROS)
+# define global_notice(target, ARGS...) send_message(target, global, ARGS)
+#elif defined(C99_VARMACROS)
+# define global_notice(target, ...) send_message(target, global, __VA_ARGS__)
+#endif
 
 void message_expire(void *data);
 
@@ -243,6 +249,8 @@ message_create(struct userNode *user, unsigned int argc, char *argv[])
 
 	    if(!irccasecmp(argv[i], "all")) {
 		flags |= MESSAGE_RECIPIENT_ALL;
+            } else if(!irccasecmp(argv[i], "authed")) {
+                flags |= MESSAGE_RECIPIENT_AUTHED;
 	    } else if(!irccasecmp(argv[i], "users")) {
 		flags |= MESSAGE_RECIPIENT_LUSERS;
 	    } else if(!irccasecmp(argv[i], "helpers")) {
@@ -253,6 +261,10 @@ message_create(struct userNode *user, unsigned int argc, char *argv[])
 		flags |= MESSAGE_RECIPIENT_STAFF;
 	    } else if(!irccasecmp(argv[i], "channels")) {
 		flags |= MESSAGE_RECIPIENT_CHANNELS;
+	    } else if(!irccasecmp(argv[i], "rchannels")) {
+		flags |= MESSAGE_RECIPIENT_RCHANNELS;
+            } else if(!irccasecmp(argv[i], "announcement") || !irccasecmp(argv[i], "announce")) {
+                flags |= MESSAGE_RECIPIENT_ANNOUNCE;
 	    } else {
 		global_notice(user, "GMSG_INVALID_TARGET", argv[i]);
 		return NULL;
@@ -291,6 +303,10 @@ messageType(const struct globalMessage *message)
     {
 	return "staff";
     }
+    else if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
+    {
+        return "announcement";
+    }
     else if(message->flags & MESSAGE_RECIPIENT_OPERS)
     {
 	return "opers";
@@ -303,6 +319,14 @@ messageType(const struct globalMessage *message)
     {
 	return "users";
     }
+    else if(message->flags & MESSAGE_RECIPIENT_AUTHED)
+    {
+        return "authed";
+    }
+    else if(message->flags & MESSAGE_RECIPIENT_RCHANNELS)
+    {
+        return "rchannels";
+    }
     else
     {
 	return "channels";
@@ -327,25 +351,34 @@ notice_target(const char *target, struct globalMessage *message)
     send_target_message(4, target, global, "%s", message->message);
 }
 
-static int
-notice_channel(const char *key, void *data, void *extra)
-{
-    struct chanNode *channel = data;
-    /* It should be safe to assume channel is not NULL. */
-    if(channel->channel_info)
- 	notice_target(key, extra);
-    return 0;
-}
-
 static void
 message_send(struct globalMessage *message)
 {
     struct userNode *user;
     unsigned long n;
+    dict_iterator_t it;
 
     if(message->flags & MESSAGE_RECIPIENT_CHANNELS)
     {
-	dict_foreach(channels, notice_channel, message);
+        dict_iterator_t it;
+
+        for (it = dict_first(channels); it; it = iter_next(it)) {
+            struct chanNode *chan = iter_data(it);
+
+            notice_target(chan->name, message);
+        }
+    }
+
+    if(message->flags & MESSAGE_RECIPIENT_RCHANNELS)
+    {
+        dict_iterator_t it;
+
+        for (it = dict_first(channels); it; it = iter_next(it)) {
+            struct chanNode *chan = iter_data(it);
+
+            if (chan->channel_info)
+                notice_target(chan->name, message);
+        }
     }
 
     if(message->flags & MESSAGE_RECIPIENT_LUSERS)
@@ -354,6 +387,20 @@ message_send(struct globalMessage *message)
 	return;
     }
 
+    if(message->flags & MESSAGE_RECIPIENT_ANNOUNCE)
+    {
+        char announce;
+
+        for (it = dict_first(clients); it; it = iter_next(it)) {
+            user = iter_data(it);
+            if (user->uplink == self) continue;
+            announce = user->handle_info ? user->handle_info->announcements : '?';
+            if (announce == 'n') continue;
+            if ((announce == '?') && !global_conf.announcements_default) continue;
+            notice_target(user->nick, message);
+        }
+    }
+
     if(message->flags & MESSAGE_RECIPIENT_OPERS)
     {
 	for(n = 0; n < curr_opers.used; n++)
@@ -377,6 +424,16 @@ message_send(struct globalMessage *message)
 	    notice_target(user->nick, message);
 	}
     }
+
+    if(message->flags & MESSAGE_RECIPIENT_AUTHED)
+    {
+        dict_iterator_t it;
+        for (it = dict_first(clients); it; it = iter_next(it)) {
+            struct userNode *luser = iter_data(it);
+            if (luser->handle_info)
+              notice_target(luser->nick, message);
+        }
+    }
 }
 
 void
@@ -415,7 +472,8 @@ global_message_args(long targets, const char *language_entry, ...)
             if(luser->uplink != self)
                 notice_target(luser->nick, message);
 
-            if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_HELPERS))
+            if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_HELPERS) || 
+                (message->flags & MESSAGE_RECIPIENT_AUTHED))
                 continue;
         }
 
@@ -423,13 +481,23 @@ global_message_args(long targets, const char *language_entry, ...)
         if (message->flags & MESSAGE_RECIPIENT_HELPERS && IsHelper(luser)) {
 	    notice_target(luser->nick, message);
 
-            if (message->flags & MESSAGE_RECIPIENT_LUSERS)
+            if ((message->flags & MESSAGE_RECIPIENT_LUSERS) || (message->flags & MESSAGE_RECIPIENT_AUTHED))
                 continue;
 	}
 
+        /* authed */
+        if ((message->flags & MESSAGE_RECIPIENT_AUTHED) && luser->handle_info) {
+            notice_target(luser->nick, message);
+
+            if (message->flags & MESSAGE_RECIPIENT_LUSERS)
+                continue;
+        }
+
         /* users */
-        if (message->flags & MESSAGE_RECIPIENT_LUSERS)
+        if (message->flags & MESSAGE_RECIPIENT_LUSERS) {
 	    notice_target(luser->nick, message);
+
+        }
     }
 
     message_del(message);
@@ -464,14 +532,20 @@ static GLOBAL_FUNC(cmd_notice)
 	target = MESSAGE_RECIPIENT_ALL;
     } else if(!irccasecmp(argv[1], "users")) {
 	target = MESSAGE_RECIPIENT_LUSERS;
+    } else if(!irccasecmp(argv[1], "authed")) {
+        target = MESSAGE_RECIPIENT_AUTHED;
     } else if(!irccasecmp(argv[1], "helpers")) {
 	target = MESSAGE_RECIPIENT_HELPERS;
     } else if(!irccasecmp(argv[1], "opers")) {
 	target = MESSAGE_RECIPIENT_OPERS;
     } else if(!irccasecmp(argv[1], "staff") || !irccasecmp(argv[1], "privileged")) {
 	target |= MESSAGE_RECIPIENT_HELPERS | MESSAGE_RECIPIENT_OPERS;
+    } else if(!irccasecmp(argv[1], "announcement") || !irccasecmp(argv[1], "announce")) {
+        target |= MESSAGE_RECIPIENT_ANNOUNCE;
     } else if(!irccasecmp(argv[1], "channels")) {
 	target = MESSAGE_RECIPIENT_CHANNELS;
+    } else if(!irccasecmp(argv[1], "rchannels")) {
+	target = MESSAGE_RECIPIENT_RCHANNELS;
     } else {
 	global_notice(user, "GMSG_INVALID_TARGET", argv[1]);
 	return 0;
@@ -625,7 +699,7 @@ send_messages(struct userNode *user, long mask, int obstreperize)
 
 static GLOBAL_FUNC(cmd_messages)
 {
-    long mask = MESSAGE_RECIPIENT_LUSERS | MESSAGE_RECIPIENT_CHANNELS;
+    long mask = MESSAGE_RECIPIENT_AUTHED | MESSAGE_RECIPIENT_LUSERS | MESSAGE_RECIPIENT_CHANNELS | MESSAGE_RECIPIENT_RCHANNELS;
     unsigned int count;
 
     if(IsOper(user))
@@ -644,7 +718,7 @@ static GLOBAL_FUNC(cmd_messages)
 }
 
 static int
-global_process_user(struct userNode *user)
+global_process_user(struct userNode *user, UNUSED_ARG(void *extra))
 {
     if(IsLocal(user) || self->uplink->burst || user->uplink->burst)
         return 0;
@@ -666,14 +740,14 @@ global_process_user(struct userNode *user)
 }
 
 static void
-global_process_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle))
+global_process_auth(struct userNode *user, UNUSED_ARG(struct handle_info *old_handle), UNUSED_ARG(void *extra))
 {
     if(IsHelper(user))
 	send_messages(user, MESSAGE_RECIPIENT_HELPERS, 0);
 }
 
 static void
-global_process_oper(struct userNode *user)
+global_process_oper(struct userNode *user, UNUSED_ARG(void *extra))
 {
     if(user->uplink->burst)
         return;
@@ -693,6 +767,8 @@ global_conf_read(void)
 
     str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
     global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
+    str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
+    global_conf.announcements_default = str ? enabled_string(str) : 1;
 
     str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
     if(global && str)
@@ -755,7 +831,7 @@ global_saxdb_write(struct saxdb_context *ctx)
 }
 
 static void
-global_db_cleanup(void)
+global_db_cleanup(UNUSED_ARG(void *extra))
 {
     while(messageList)
         message_del(messageList);
@@ -767,9 +843,9 @@ init_global(const char *nick)
     struct chanNode *chan;
     unsigned int i;
     G_LOG = log_register_type("Global", "file:global.log");
-    reg_new_user_func(global_process_user);
-    reg_auth_func(global_process_auth);
-    reg_oper_func(global_process_oper);
+    reg_new_user_func(global_process_user, NULL);
+    reg_auth_func(global_process_auth, NULL);
+    reg_oper_func(global_process_oper, NULL);
 
     conf_register_reload(global_conf_read);
 
@@ -795,6 +871,6 @@ init_global(const char *nick)
     }
 
     saxdb_register("Global", global_saxdb_read, global_saxdb_write);
-    reg_exit_func(global_db_cleanup);
+    reg_exit_func(global_db_cleanup, NULL);
     message_register_table(msgtab);
 }