ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/ircd-hybrid/trunk/modules/m_info.c
(Generate patch)

Comparing:
ircd-hybrid-7.2/modules/m_info.c (file contents), Revision 1011 by michael, Fri Sep 18 10:14:09 2009 UTC vs.
ircd-hybrid/trunk/modules/m_info.c (file contents), Revision 5022 by michael, Thu Dec 11 16:12:01 2014 UTC

# Line 1 | Line 1
1   /*
2 < *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3 < *  m_info.c: Sends information about the server.
2 > *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3   *
4 < *  Copyright (C) 2005 by the past and present ircd coders, and others.
4 > *  Copyright (c) 1997-2014 ircd-hybrid development team
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 16 | Line 15
15   *
16   *  You should have received a copy of the GNU General Public License
17   *  along with this program; if not, write to the Free Software
18 < *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18 > *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19   *  USA
20 < *
21 < *  $Id$
20 > */
21 >
22 > /*! \file m_info.c
23 > * \brief Includes required functions for processing the INFO command.
24 > * \version $Id$
25   */
26  
27   #include "stdinc.h"
28   #include "list.h"
27 – #include "m_info.h"
28 – #include "channel.h"
29   #include "client.h"
30 – #include "common.h"
31 – #include "irc_string.h"
30   #include "ircd.h"
33 – #include "hook.h"
31   #include "numeric.h"
32 < #include "s_log.h"
33 < #include "s_serv.h"
37 < #include "s_user.h"
32 > #include "misc.h"
33 > #include "server.h"
34   #include "send.h"
35 < #include "s_conf.h"
40 < #include "handlers.h"
41 < #include "msg.h"
35 > #include "conf.h"
36   #include "parse.h"
37   #include "modules.h"
38  
45 – static void send_conf_options(struct Client *);
46 – static void send_birthdate_online_time(struct Client *);
47 – static void send_info_text(struct Client *);
48 –
49 – static void m_info(struct Client *, struct Client *, int, char *[]);
50 – static void ms_info(struct Client *, struct Client *, int, char *[]);
51 – static void mo_info(struct Client *, struct Client *, int, char *[]);
52 –
53 – struct Message info_msgtab = {
54 –  "INFO", 0, 0, 0, 0, MFLG_SLOW, 0,
55 –  { m_unregistered, m_info, ms_info, m_ignore, mo_info, m_ignore }
56 – };
57 –
58 – #ifndef STATIC_MODULES
59 – const char *_version = "$Revision$";
60 – static struct Callback *info_cb;
61 –
62 – static void *
63 – va_send_info_text(va_list args)
64 – {
65 –  send_info_text(va_arg(args, struct Client *));
66 –  return NULL;
67 – }
68 –
69 – void
70 – _modinit(void)
71 – {
72 –  info_cb = register_callback("doing_info", va_send_info_text);
73 –  mod_add_cmd(&info_msgtab);
74 – }
39  
40 < void
41 < _moddeinit(void)
40 > /* Types for output_type in InfoStruct */
41 > enum
42   {
43 <  mod_del_cmd(&info_msgtab);
44 <  uninstall_hook(info_cb, va_send_info_text);
45 < }
46 < #endif
43 >  OUTPUT_STRING     = 1 << 0,  /* Output option as %s w/ dereference  */
44 >  OUTPUT_STRING_PTR = 1 << 1,  /* Output option as %s w/out deference */
45 >  OUTPUT_DECIMAL    = 1 << 2,  /* Output option as decimal (%d) */
46 >  OUTPUT_BOOLEAN    = 1 << 3,  /* Output option as "ON" or "OFF" */
47 >  OUTPUT_BOOLEAN_YN = 1 << 4,  /* Output option as "YES" or "NO" */
48 >  OUTPUT_BOOLEAN2   = 1 << 5   /* Output option as "YES/NO/MASKED" */
49 > };
50  
51   /*
52   * jdc -- Structure for our configuration value table
53   */
54   struct InfoStruct
55   {
56 <  const char *name;         /* Displayed variable name           */
57 <  unsigned int output_type; /* See below #defines                */
58 <  void *option;             /* Pointer reference to the value    */
59 <  const char *desc;         /* ASCII description of the variable */
56 >  const char *name;  /* Displayed variable name */
57 >  const unsigned int output_type;  /* Type of output. See enum above */
58 >  const void *option;  /* Pointer reference to the value */
59 >  const char *desc;  /* ASCII description of the variable */
60   };
61  
95 – /* Types for output_type in InfoStruct */
96 – #define OUTPUT_STRING     0x0001 /* Output option as %s w/ dereference  */
97 – #define OUTPUT_STRING_PTR 0x0002 /* Output option as %s w/out deference */
98 – #define OUTPUT_DECIMAL    0x0004 /* Output option as decimal (%d)       */
99 – #define OUTPUT_BOOLEAN    0x0008 /* Output option as "ON" or "OFF"      */
100 – #define OUTPUT_BOOLEAN_YN 0x0010 /* Output option as "YES" or "NO"      */
101 – #define OUTPUT_BOOLEAN2   0x0020 /* Output option as "YES/NO/MASKED"    */
102 –
62   static const struct InfoStruct info_table[] =
63   {
64    /* --[  START OF TABLE  ]-------------------------------------------- */
65 +
66    {
67 <    "network_name",
67 >    "DPATH",
68      OUTPUT_STRING,
69 <    &ServerInfo.network_name,
70 <    "Network name"
69 >    &ConfigGeneral.dpath,
70 >    "Root directory of installation"
71    },
72    {
73 <    "network_desc",
73 >    "SPATH",
74      OUTPUT_STRING,
75 <    &ServerInfo.network_desc,
76 <    "Network description"
75 >    &ConfigGeneral.spath,
76 >    "Path to server executable"
77    },
78    {
79 <    "hub",
80 <    OUTPUT_BOOLEAN_YN,
81 <    &ServerInfo.hub,
82 <    "Server is a hub"
79 >    "MPATH",
80 >    OUTPUT_STRING,
81 >    &ConfigGeneral.mpath,
82 >    "Path to main motd (Message of the Day) file"
83    },
84    {
85 <    "use_logging",
86 <    OUTPUT_BOOLEAN_YN,
87 <    &ConfigLoggingEntry.use_logging,
88 <    "Enable logging"
85 >    "CPATH",
86 >    OUTPUT_STRING,
87 >    &ConfigGeneral.configfile,
88 >    "Path to main configuration file"
89    },
90    {
91 <    "fuserlog",
92 <    OUTPUT_STRING_PTR,
93 <    &ConfigLoggingEntry.userlog,
94 <    "User log file"
91 >    "DLPATH",
92 >    OUTPUT_STRING,
93 >    &ConfigGeneral.dlinefile,
94 >    "Path to D-line database file"
95    },
96    {
97 <    "foperlog",
98 <    OUTPUT_STRING_PTR,
99 <    &ConfigLoggingEntry.operlog,
100 <    "Operator log file"
97 >    "KPATH",
98 >    OUTPUT_STRING,
99 >    &ConfigGeneral.klinefile,
100 >    "Path to K-line database file"
101    },
102    {
103 <    "fkilllog",
104 <    OUTPUT_STRING_PTR,
105 <    &ConfigLoggingEntry.killlog,
106 <    "Kill log file"
103 >    "GPATH",
104 >    OUTPUT_STRING,
105 >    &ConfigGeneral.glinefile,
106 >    "Path to G-line database file"
107    },
108    {
109 <    "fklinelog",
110 <    OUTPUT_STRING_PTR,
111 <    &ConfigLoggingEntry.klinelog,
112 <    "K-Line log file"
109 >    "XPATH",
110 >    OUTPUT_STRING,
111 >    &ConfigGeneral.xlinefile,
112 >    "Path to X-line database file"
113    },
114    {
115 <    "fglinelog",
116 <    OUTPUT_STRING_PTR,
117 <    &ConfigLoggingEntry.glinelog,
118 <    "G-Line log file"
115 >    "RESVPATH",
116 >    OUTPUT_STRING,
117 >    &ConfigGeneral.resvfile,
118 >    "Path to resv database file"
119    },
120    {
121 <    "restrict_channels",
122 <    OUTPUT_BOOLEAN_YN,
123 <    &ConfigChannel.restrict_channels,
124 <    "Only reserved channels are allowed"
121 >    "network_name",
122 >    OUTPUT_STRING,
123 >    &ConfigServerInfo.network_name,
124 >    "Network name"
125    },
126    {
127 <    "disable_local_channels",
128 <    OUTPUT_BOOLEAN_YN,
129 <    &ConfigChannel.disable_local_channels,
130 <    "Prevent users from joining &channels"
127 >    "network_desc",
128 >    OUTPUT_STRING,
129 >    &ConfigServerInfo.network_desc,
130 >    "Network description"
131    },
132 < {
133 <    "use_invex",
132 >  {
133 >    "hub",
134      OUTPUT_BOOLEAN_YN,
135 <    &ConfigChannel.use_invex,
136 <    "Enable chanmode +I (invite exceptions)"
135 >    &ConfigServerInfo.hub,
136 >    "Server is a hub"
137    },
138    {
139 <    "use_except",
139 >    "max_clients",
140 >    OUTPUT_DECIMAL,
141 >    &ConfigServerInfo.max_clients,
142 >    "Maximum number of clients permitted simultaneously on this server"
143 >  },
144 >  {
145 >    "max_nick_length",
146 >    OUTPUT_DECIMAL,
147 >    &ConfigServerInfo.max_nick_length,
148 >    "Maximum nickname length"
149 >  },
150 >  {
151 >    "max_topic_length",
152 >    OUTPUT_DECIMAL,
153 >    &ConfigServerInfo.max_topic_length,
154 >    "Maximum topic length"
155 >  },
156 >  {
157 >    "use_logging",
158      OUTPUT_BOOLEAN_YN,
159 <    &ConfigChannel.use_except,
160 <    "Enable chanmode +e (ban exceptions)"
159 >    &ConfigLog.use_logging,
160 >    "Enable logging"
161    },
162    {
163 <    "use_knock",
163 >    "disable_fake_channels",
164      OUTPUT_BOOLEAN_YN,
165 <    &ConfigChannel.use_knock,
166 <    "Enable /KNOCK"
165 >    &ConfigChannel.disable_fake_channels,
166 >    "Forbids channels with special ASCII characters in their name"
167    },
168    {
169 <    "knock_delay",
169 >    "invite_client_count",
170 >    OUTPUT_DECIMAL,
171 >    &ConfigChannel.invite_client_count,
172 >    "How many INVITE attempts are permitted in invite_client_time"
173 >  },
174 >
175 >  {
176 >    "invite_client_time",
177      OUTPUT_DECIMAL,
178 <    &ConfigChannel.knock_delay,
179 <    "Delay between a users KNOCK attempts"
178 >    &ConfigChannel.invite_client_time,
179 >    "How many invite_client_count invites are allowed in this time"
180 >  },
181 >  {
182 >    "knock_client_count",
183 >    OUTPUT_DECIMAL,
184 >    &ConfigChannel.knock_client_count,
185 >    "How many KNOCK attempts are permitted in knock_client_time"
186 >  },
187 >  {
188 >    "knock_client_time",
189 >    OUTPUT_DECIMAL,
190 >    &ConfigChannel.knock_client_time,
191 >    "How many knock_client_count knocks are allowed in this time"
192    },
193    {
194      "knock_delay_channel",
# Line 200 | Line 197 | static const struct InfoStruct info_tabl
197      "Delay between KNOCK attempts to a channel"
198    },
199    {
200 <    "max_chans_per_user",
200 >    "max_channels",
201      OUTPUT_DECIMAL,
202 <    &ConfigChannel.max_chans_per_user,
202 >    &ConfigChannel.max_channels,
203      "Maximum number of channels a user can join"
204    },
205    {
209 –    "quiet_on_ban",
210 –    OUTPUT_BOOLEAN_YN,
211 –    &ConfigChannel.quiet_on_ban,
212 –    "Banned users may not send text to a channel"
213 –  },
214 –  {
206      "max_bans",
207      OUTPUT_DECIMAL,
208      &ConfigChannel.max_bans,
# Line 242 | Line 233 | static const struct InfoStruct info_tabl
233      "Disallow joining channels when split"
234    },
235    {
245 –    "burst_topicwho",
246 –    OUTPUT_BOOLEAN_YN,
247 –    &ConfigChannel.burst_topicwho,
248 –    "Enable sending of who set topic on topicburst"
249 –  },
250 –  {
236      "flatten_links",
237      OUTPUT_BOOLEAN_YN,
238      &ConfigServerHide.flatten_links,
# Line 266 | Line 251 | static const struct InfoStruct info_tabl
251      "Hide this server from a flattened /links on remote servers"
252    },
253    {
269 –    "disable_hidden",
270 –    OUTPUT_BOOLEAN_YN,
271 –    &ConfigServerHide.disable_hidden,
272 –    "Prevent servers from hiding themselves from a flattened /links"
273 –  },
274 –  {
254      "hide_servers",
255      OUTPUT_BOOLEAN_YN,
256      &ConfigServerHide.hide_servers,
257      "Hide servernames from users"
258    },
259    {
260 +    "hide_services",
261 +    OUTPUT_BOOLEAN_YN,
262 +    &ConfigServerHide.hide_services,
263 +    "Hides the location of services server"
264 +  },
265 +  {
266      "hidden_name",
267      OUTPUT_STRING,
268      &ConfigServerHide.hidden_name,
# Line 287 | Line 272 | static const struct InfoStruct info_tabl
272      "hide_server_ips",
273      OUTPUT_BOOLEAN_YN,
274      &ConfigServerHide.hide_server_ips,
275 <    "Prevent people from seeing server IPs"
275 >    "Prevent people from seeing server IP addresses"
276 >  },
277 >  {
278 >    "away_count",
279 >    OUTPUT_DECIMAL,
280 >    &ConfigGeneral.away_count,
281 >    "How many AWAY attempts are permitted in away_time"
282 >  },
283 >  {
284 >    "away_time",
285 >    OUTPUT_DECIMAL,
286 >    &ConfigGeneral.away_time,
287 >    "How many away_count aways are allowed in this time"
288    },
289    {
290      "gline_min_cidr",
291      OUTPUT_DECIMAL,
292 <    &ConfigFileEntry.gline_min_cidr,
292 >    &ConfigGeneral.gline_min_cidr,
293      "Minimum required length of a CIDR bitmask for IPv4 G-Lines"
294    },
295    {
296      "gline_min_cidr6",
297      OUTPUT_DECIMAL,
298 <    &ConfigFileEntry.gline_min_cidr6,
298 >    &ConfigGeneral.gline_min_cidr6,
299      "Minimum required length of a CIDR bitmask for IPv6 G-Lines"
300    },
301    {
302      "invisible_on_connect",
303      OUTPUT_BOOLEAN_YN,
304 <    &ConfigFileEntry.invisible_on_connect,
304 >    &ConfigGeneral.invisible_on_connect,
305      "Automatically set mode +i on connecting users"
306    },
307    {
311 –    "burst_away",
312 –    OUTPUT_BOOLEAN_YN,
313 –    &ConfigFileEntry.burst_away,
314 –    "Send /away string that users have set on the server burst"
315 –  },
316 –  {
317 –    "use_whois_actually",
318 –    OUTPUT_BOOLEAN_YN,
319 –    &ConfigFileEntry.use_whois_actually,
320 –    "Show IP address on /WHOIS when possible"
321 –  },
322 –  {
308      "kill_chase_time_limit",
309      OUTPUT_DECIMAL,
310 <    &ConfigFileEntry.kill_chase_time_limit,
310 >    &ConfigGeneral.kill_chase_time_limit,
311      "Nick Change Tracker for KILL"
312    },
313    {
314 <    "hide_spoof_ips",
314 >    "ignore_bogus_ts",
315      OUTPUT_BOOLEAN_YN,
316 <    &ConfigFileEntry.hide_spoof_ips,
317 <    "Hide spoofed IP's"
316 >    &ConfigGeneral.ignore_bogus_ts,
317 >    "Ignore bogus timestamps from other servers"
318    },
319    {
320 <    "ignore_bogus_ts",
320 >    "cycle_on_host_change",
321      OUTPUT_BOOLEAN_YN,
322 <    &ConfigFileEntry.ignore_bogus_ts,
323 <    "Ignore bogus timestamps from other servers"
322 >    &ConfigGeneral.cycle_on_host_change,
323 >    "Send a fake QUIT/JOIN combination on host change"
324    },
325    {
326      "disable_auth",
327      OUTPUT_BOOLEAN_YN,
328 <    &ConfigFileEntry.disable_auth,
328 >    &ConfigGeneral.disable_auth,
329      "Completely disable ident lookups"
330    },
331    {
332      "disable_remote_commands",
333      OUTPUT_BOOLEAN_YN,
334 <    &ConfigFileEntry.disable_remote,
334 >    &ConfigServerHide.disable_remote_commands,
335      "Prevent users issuing commands on remote servers"
336    },
337    {
338      "tkline_expire_notices",
339      OUTPUT_BOOLEAN_YN,
340 <    &ConfigFileEntry.tkline_expire_notices,
340 >    &ConfigGeneral.tkline_expire_notices,
341      "Show temporary kline/xline expire notices"
342    },
343    {
344      "default_floodcount",
345      OUTPUT_DECIMAL,
346 <    &ConfigFileEntry.default_floodcount,
346 >    &ConfigGeneral.default_floodcount,
347      "Startup value of FLOODCOUNT"
348    },
349    {
350      "failed_oper_notice",
351 <    OUTPUT_BOOLEAN,
352 <    &ConfigFileEntry.failed_oper_notice,
353 <    "Inform opers if someone /oper's with the wrong password"
351 >    OUTPUT_BOOLEAN_YN,
352 >    &ConfigGeneral.failed_oper_notice,
353 >    "Inform opers if someone tries to /oper with the wrong password"
354    },
355    {
356      "dots_in_ident",
357      OUTPUT_DECIMAL,
358 <    &ConfigFileEntry.dots_in_ident,
358 >    &ConfigGeneral.dots_in_ident,
359      "Number of permissable dots in an ident"
360    },
361    {
377 –    "dot_in_ip6_addr",
378 –    OUTPUT_BOOLEAN,
379 –    &ConfigFileEntry.dot_in_ip6_addr,
380 –    "Suffix a . to ip6 addresses (for linked servers still running hybrid-6)"
381 –  },
382 –  {
362      "min_nonwildcard",
363      OUTPUT_DECIMAL,
364 <    &ConfigFileEntry.min_nonwildcard,
364 >    &ConfigGeneral.min_nonwildcard,
365      "Minimum non-wildcard chars in K/G lines"
366    },
367    {
368      "min_nonwildcard_simple",
369      OUTPUT_DECIMAL,
370 <    &ConfigFileEntry.min_nonwildcard_simple,
370 >    &ConfigGeneral.min_nonwildcard_simple,
371      "Minimum non-wildcards in gecos bans"
372    },
373    {
374      "max_accept",
375      OUTPUT_DECIMAL,
376 <    &ConfigFileEntry.max_accept,
376 >    &ConfigGeneral.max_accept,
377      "Maximum nicknames on accept list"
378    },
379    {
380      "anti_nick_flood",
381 <    OUTPUT_BOOLEAN,
382 <    &ConfigFileEntry.anti_nick_flood,
381 >    OUTPUT_BOOLEAN_YN,
382 >    &ConfigGeneral.anti_nick_flood,
383      "NICK flood protection"
384    },
385    {
386      "max_nick_time",
387      OUTPUT_DECIMAL,
388 <    &ConfigFileEntry.max_nick_time,
388 >    &ConfigGeneral.max_nick_time,
389      "NICK flood protection time interval"
390    },
391    {
392      "max_nick_changes",
393      OUTPUT_DECIMAL,
394 <    &ConfigFileEntry.max_nick_changes,
394 >    &ConfigGeneral.max_nick_changes,
395      "NICK change threshhold setting"
396    },
397    {
398      "anti_spam_exit_message_time",
399      OUTPUT_DECIMAL,
400 <    &ConfigFileEntry.anti_spam_exit_message_time,
400 >    &ConfigGeneral.anti_spam_exit_message_time,
401      "Duration a client must be connected for to have an exit message"
402    },
403    {
404      "ts_warn_delta",
405      OUTPUT_DECIMAL,
406 <    &ConfigFileEntry.ts_warn_delta,
406 >    &ConfigGeneral.ts_warn_delta,
407      "Maximum permitted TS delta before displaying a warning"
408    },
409    {
410      "ts_max_delta",
411      OUTPUT_DECIMAL,
412 <    &ConfigFileEntry.ts_max_delta,
412 >    &ConfigGeneral.ts_max_delta,
413      "Maximum permitted TS delta from another server"
414    },
415    {
416 <    "kline_with_reason",
416 >    "warn_no_connect_block",
417      OUTPUT_BOOLEAN_YN,
418 <    &ConfigFileEntry.kline_with_reason,
419 <    "Display K-line reason to client on disconnect"
418 >    &ConfigGeneral.warn_no_connect_block,
419 >    "Display warning if connecting server lacks a connect{} block"
420    },
421    {
422 <    "kline_reason",
423 <    OUTPUT_STRING,
424 <    &ConfigFileEntry.kline_reason,
425 <    "Reason given to K-lined clients on sign off"
447 <  },
448 <  {
449 <    "warn_no_nline",
450 <    OUTPUT_BOOLEAN,
451 <    &ConfigFileEntry.warn_no_nline,
452 <    "Display warning if connecting server lacks N-line"
422 >    "stats_e_disabled",
423 >    OUTPUT_BOOLEAN_YN,
424 >    &ConfigGeneral.stats_e_disabled,
425 >    "Whether or not STATS e is disabled"
426    },
427    {
428      "stats_o_oper_only",
429      OUTPUT_BOOLEAN_YN,
430 <    &ConfigFileEntry.stats_o_oper_only,
430 >    &ConfigGeneral.stats_o_oper_only,
431      "STATS O output is only shown to operators"
432    },
433    {
434      "stats_P_oper_only",
435      OUTPUT_BOOLEAN_YN,
436 <    &ConfigFileEntry.stats_P_oper_only,
436 >    &ConfigGeneral.stats_P_oper_only,
437      "STATS P is only shown to operators"
438    },
439    {
440 +    "stats_u_oper_only",
441 +    OUTPUT_BOOLEAN_YN,
442 +    &ConfigGeneral.stats_u_oper_only,
443 +    "STATS u is only shown to operators"
444 +  },
445 +  {
446      "stats_i_oper_only",
447      OUTPUT_BOOLEAN2,
448 <    &ConfigFileEntry.stats_i_oper_only,
448 >    &ConfigGeneral.stats_i_oper_only,
449      "STATS I output is only shown to operators"
450    },
451    {
452      "stats_k_oper_only",
453      OUTPUT_BOOLEAN2,
454 <    &ConfigFileEntry.stats_k_oper_only,
454 >    &ConfigGeneral.stats_k_oper_only,
455      "STATS K output is only shown to operators"
456    },
457    {
458      "caller_id_wait",
459      OUTPUT_DECIMAL,
460 <    &ConfigFileEntry.caller_id_wait,
460 >    &ConfigGeneral.caller_id_wait,
461      "Minimum delay between notifying UMODE +g users of messages"
462    },
463    {
464      "opers_bypass_callerid",
465      OUTPUT_BOOLEAN_YN,
466 <    &ConfigFileEntry.opers_bypass_callerid,
466 >    &ConfigGeneral.opers_bypass_callerid,
467      "Allows IRC operators to message users who are +g (callerid)"
468    },
469    {
470      "pace_wait_simple",
471      OUTPUT_DECIMAL,
472 <    &ConfigFileEntry.pace_wait_simple,
472 >    &ConfigGeneral.pace_wait_simple,
473      "Minimum delay between less intensive commands"
474    },
475    {
476      "pace_wait",
477      OUTPUT_DECIMAL,
478 <    &ConfigFileEntry.pace_wait,
478 >    &ConfigGeneral.pace_wait,
479      "Minimum delay between uses of certain commands"
480    },
481    {
482      "short_motd",
483      OUTPUT_BOOLEAN_YN,
484 <    &ConfigFileEntry.short_motd,
484 >    &ConfigGeneral.short_motd,
485      "Do not show MOTD; only tell clients they should read it"
486    },
487    {
488      "ping_cookie",
489 <    OUTPUT_BOOLEAN,
490 <    &ConfigFileEntry.ping_cookie,
489 >    OUTPUT_BOOLEAN_YN,
490 >    &ConfigGeneral.ping_cookie,
491      "Require ping cookies to connect"
492    },
493    {
494      "no_oper_flood",
495 <    OUTPUT_BOOLEAN,
496 <    &ConfigFileEntry.no_oper_flood,
495 >    OUTPUT_BOOLEAN_YN,
496 >    &ConfigGeneral.no_oper_flood,
497      "Reduce flood control for operators"
498    },
499    {
521 –    "true_no_oper_flood",
522 –    OUTPUT_BOOLEAN,
523 –    &ConfigFileEntry.true_no_oper_flood,
524 –    "Completely disable flood control for operators"
525 –  },
526 –  {
500      "oper_pass_resv",
501      OUTPUT_BOOLEAN_YN,
502 <    &ConfigFileEntry.oper_pass_resv,
502 >    &ConfigGeneral.oper_pass_resv,
503      "Opers can over-ride RESVs"
504    },
505    {
533 –    "idletime",
534 –    OUTPUT_DECIMAL,
535 –    &ConfigFileEntry.idletime,
536 –    "Number of seconds before a client is considered idle"
537 –  },
538 –  {
506      "max_targets",
507      OUTPUT_DECIMAL,
508 <    &ConfigFileEntry.max_targets,
508 >    &ConfigGeneral.max_targets,
509      "The maximum number of PRIVMSG/NOTICE targets"
510    },
511    {
512 <    "client_flood",
512 >    "throttle_count",
513      OUTPUT_DECIMAL,
514 <    &ConfigFileEntry.client_flood,
515 <    "Maximum amount of data in a client's queue before they are disconnected"
514 >    &ConfigGeneral.throttle_count,
515 >    "Number of connects in throttle_time before connections are blocked"
516    },
517    {
518      "throttle_time",
519      OUTPUT_DECIMAL,
520 <    &ConfigFileEntry.throttle_time,
520 >    &ConfigGeneral.throttle_time,
521      "Minimum time between client reconnects"
522    },
523    {
524 <    "glines",
525 <    OUTPUT_BOOLEAN,
526 <    &ConfigFileEntry.glines,
524 >    "gline_enable",
525 >    OUTPUT_BOOLEAN_YN,
526 >    &ConfigGeneral.glines,
527      "G-line (network-wide K-line) support"
528    },
529    {
530 <    "duration",
530 >    "gline_duration",
531      OUTPUT_DECIMAL,
532 <    &ConfigFileEntry.gline_time,
532 >    &ConfigGeneral.gline_time,
533      "Expiry time for G-lines"
534    },
535 +  {
536 +    "gline_request_duration",
537 +    OUTPUT_DECIMAL,
538 +    &ConfigGeneral.gline_request_time,
539 +    "Expiry time for pending G-lines"
540 +  },
541 +
542    /* --[  END OF TABLE  ]---------------------------------------------- */
543    {
544      NULL,
545      0,
546      NULL,
547 <    0
547 >    NULL
548    }
549   };
550  
577 – /*
578 – ** m_info()
579 – **  parv[0] = sender prefix
580 – **  parv[1] = servername
581 – */
582 – static void
583 – m_info(struct Client *client_p, struct Client *source_p,
584 –       int parc, char *parv[])
585 – {
586 –  static time_t last_used = 0;
587 –
588 –  if ((last_used + ConfigFileEntry.pace_wait) > CurrentTime)
589 –  {
590 –    /* safe enough to give this on a local connect only */
591 –    sendto_one(source_p, form_str(RPL_LOAD2HI),
592 –               me.name, source_p->name);
593 –    return;
594 –  }
595 –  else
596 –    last_used = CurrentTime;
597 –
598 –  if (!ConfigFileEntry.disable_remote)
599 –  {
600 –    if (hunt_server(client_p,source_p, ":%s INFO :%s",
601 –                    1, parc, parv) != HUNTED_ISME)
602 –    {
603 –      return;
604 –    }
605 –  }
606 –
607 – #ifdef STATIC_MODULES
608 –  send_info_text(source_p);
609 – #else
610 –  execute_callback(info_cb, source_p, parc, parv);
611 – #endif
612 – }
613 –
614 – /*
615 – ** mo_info()
616 – **  parv[0] = sender prefix
617 – **  parv[1] = servername
618 – */
619 – static void
620 – mo_info(struct Client *client_p, struct Client *source_p,
621 –        int parc, char *parv[])
622 – {
623 –  if (hunt_server(client_p, source_p, ":%s INFO :%s", 1,
624 –                  parc, parv) != HUNTED_ISME)
625 –    return;
626 –
627 – #ifdef STATIC_MODULES
628 –  send_info_text(source_p);
629 – #else
630 –  execute_callback(info_cb, source_p, parc, parv);
631 – #endif
632 – }
633 –
634 – /*
635 – ** ms_info()
636 – **  parv[0] = sender prefix
637 – **  parv[1] = servername
638 – */
639 – static void
640 – ms_info(struct Client *client_p, struct Client *source_p,
641 –        int parc, char *parv[])
642 – {
643 –  if (!IsClient(source_p))
644 –      return;
645 –
646 –  if (hunt_server(client_p, source_p, ":%s INFO :%s",
647 –                  1, parc, parv) != HUNTED_ISME)
648 –    return;
649 –
650 – #ifdef STATIC_MODULES
651 –  send_info_text(source_p);
652 – #else
653 –  execute_callback(info_cb, source_p, parc, parv);
654 – #endif
655 – }
656 –
657 – /* send_info_text()
658 – *
659 – * inputs       - client pointer to send info text to
660 – * output       - NONE
661 – * side effects - info text is sent to client
662 – */
663 – static void
664 – send_info_text(struct Client *source_p)
665 – {
666 –  const char **text = infotext;
667 –  char *source, *target;
668 –  
669 –  if (!MyClient(source_p) && IsCapable(source_p->from, CAP_TS6) &&
670 –      HasID(source_p))
671 –    source = me.id, target = source_p->id;
672 –  else
673 –    source = me.name, target = source_p->name;
674 –
675 –  while (*text)
676 –  {
677 –    const char *line = *text++;
678 –
679 –    if (*line == '\0')
680 –      line = " ";
681 –
682 –    sendto_one(source_p, form_str(RPL_INFO),
683 –               source, target, line);
684 –  }
685 –
686 –  if (IsOper(source_p))
687 –    send_conf_options(source_p);
688 –
689 –  send_birthdate_online_time(source_p);
690 –
691 –  sendto_one(source_p, form_str(RPL_ENDOFINFO),
692 –             me.name, source_p->name);
693 – }
694 –
551   /* send_birthdate_online_time()
552   *
553   * inputs       - client pointer to send to
# Line 701 | Line 557 | send_info_text(struct Client *source_p)
557   static void
558   send_birthdate_online_time(struct Client *source_p)
559   {
560 <  if (!MyClient(source_p) && IsCapable(source_p->from, CAP_TS6) && HasID(source_p))
561 <  {
562 <    sendto_one(source_p, ":%s %d %s :On-line since %s",
707 <               me.id, RPL_INFO, source_p->id,
708 <               myctime(me.firsttime));
709 <  }
710 <  else
711 <  {
712 <    sendto_one(source_p, ":%s %d %s :On-line since %s",
713 <               me.name, RPL_INFO, source_p->name,
714 <               myctime(me.firsttime));
715 <  }
560 >  sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
561 >                     ":On-line since %s",
562 >                     myctime(me.connection->firsttime));
563   }
564  
565   /* send_conf_options()
# Line 724 | Line 571 | send_birthdate_online_time(struct Client
571   static void
572   send_conf_options(struct Client *source_p)
573   {
727 –  Info *infoptr;
728 –  const char *from, *to;
729 –  const struct InfoStruct *iptr = NULL;
730 –
731 –  /* Now send them a list of all our configuration options
732 –   * (mostly from defaults.h and config.h)
733 –   */
734 –  if (!MyClient(source_p) && IsCapable(source_p->from, CAP_TS6) && HasID(source_p))
735 –  {
736 –    from = me.id;
737 –    to = source_p->id;
738 –  }
739 –  else
740 –  {
741 –    from = me.name;
742 –    to = source_p->name;
743 –  }
744 –
745 –  for (infoptr = MyInformation; infoptr->name; infoptr++)
746 –  {
747 –    if (infoptr->intvalue)
748 –    {
749 –      sendto_one(source_p, ":%s %d %s :%-30s %-5d [%-30s]",
750 –                 from, RPL_INFO, to, infoptr->name,
751 –                 infoptr->intvalue, infoptr->desc);
752 –    }
753 –    else
754 –    {
755 –      sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
756 –                 from, RPL_INFO, to, infoptr->name,
757 –                 infoptr->strvalue, infoptr->desc);
758 –    }
759 –  }
760 –
574    /*
575     * Parse the info_table[] and do the magic.
576     */
577 <  for (iptr = info_table; iptr->name; ++iptr)
577 >  for (const struct InfoStruct *iptr = info_table; iptr->name; ++iptr)
578    {
579      switch (iptr->output_type)
580      {
581        /* For "char *" references */
582        case OUTPUT_STRING:
583        {
584 <        const char *option = *((char **)iptr->option);
584 >        const char *option = *((const char *const *)iptr->option);
585  
586 <        sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
587 <                   from, RPL_INFO, to,
588 <                   iptr->name, option ? option : "NONE",
589 <                   iptr->desc ? iptr->desc : "<none>");
586 >        sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
587 >                           ":%-30s %-5s [%s]",
588 >                           iptr->name, option ? option : "NONE",
589 >                           iptr->desc ? iptr->desc : "<none>");
590          break;
591        }
592  
# Line 782 | Line 595 | send_conf_options(struct Client *source_
595        {
596          const char *option = iptr->option;
597  
598 <        sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
599 <                   from, RPL_INFO, to,
600 <                   iptr->name, option ? option : "NONE",
601 <                   iptr->desc ? iptr->desc : "<none>");
598 >        sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
599 >                           ":%-30s %-5s [%s]",
600 >                           iptr->name, option ? option : "NONE",
601 >                           iptr->desc ? iptr->desc : "<none>");
602          break;
603        }
604  
605        /* Output info_table[i].option as a decimal value. */
606        case OUTPUT_DECIMAL:
607        {
608 <        const int option = *((int *)iptr->option);
608 >        const int option = *((const int *const)iptr->option);
609  
610 <        sendto_one(source_p, ":%s %d %s :%-30s %-5d [%-30s]",
611 <                   from, RPL_INFO, to, iptr->name,
612 <                   option, iptr->desc ? iptr->desc : "<none>");
610 >        sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
611 >                           ":%-30s %-5d [%s]",
612 >                           iptr->name, option, iptr->desc ? iptr->desc : "<none>");
613          break;
614        }
615  
616        /* Output info_table[i].option as "ON" or "OFF" */
617        case OUTPUT_BOOLEAN:
618        {
619 <        const int option = *((int *)iptr->option);
619 >        const int option = *((const int *const)iptr->option);
620  
621 <        sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
622 <                   from, RPL_INFO, to,
623 <                   iptr->name, option ? "ON" : "OFF",
624 <                   iptr->desc ? iptr->desc : "<none>");
621 >        sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
622 >                           ":%-30s %-5s [%s]",
623 >                           iptr->name, option ? "ON" : "OFF",
624 >                           iptr->desc ? iptr->desc : "<none>");
625  
626          break;
627        }
# Line 816 | Line 629 | send_conf_options(struct Client *source_
629        /* Output info_table[i].option as "YES" or "NO" */
630        case OUTPUT_BOOLEAN_YN:
631        {
632 <        int option = *((int *)iptr->option);
632 >        const int option = *((const int *const)iptr->option);
633  
634 <        sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
635 <                   from, RPL_INFO, to,
636 <                   iptr->name, option ? "YES" : "NO",
637 <                   iptr->desc ? iptr->desc : "<none>");
634 >        sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
635 >                           ":%-30s %-5s [%s]",
636 >                           iptr->name, option ? "YES" : "NO",
637 >                           iptr->desc ? iptr->desc : "<none>");
638          break;
639        }
640  
641        case OUTPUT_BOOLEAN2:
642        {
643 <        int option = *((int *)iptr->option);
643 >        const int option = *((const int *const)iptr->option);
644  
645 <        sendto_one(source_p, ":%s %d %s :%-30s %-5s [%-30s]",
646 <                   from, RPL_INFO, to,
647 <                   iptr->name, option ? ((option == 1) ? "MASK" : "YES") : "NO",
648 <                   iptr->desc ? iptr->desc : "<none>");
645 >        sendto_one_numeric(source_p, &me, RPL_INFO|SND_EXPLICIT,
646 >                           ":%-30s %-5s [%s]",
647 >                           iptr->name, option ? ((option == 1) ? "MASK" : "YES") : "NO",
648 >                           iptr->desc ? iptr->desc : "<none>");
649          break;
650        }
651      }
652    }
653  
654 <  /* Don't send oper_only_umodes...it's a bit mask, we will have to decode it
842 <   * in order for it to show up properly to opers who issue INFO
843 <   */
844 < #ifndef EFNET
845 <  /* jdc -- Only send compile information to admins. */
846 <  if (IsAdmin(source_p))
847 <    sendto_one(source_p, ":%s %d %s :Running on [%s]",
848 <               from, RPL_INFO, to, ircd_platform);
849 < #endif
850 <  sendto_one(source_p, form_str(RPL_INFO),
851 <             from, to, "");
654 >  sendto_one_numeric(source_p, &me, RPL_INFO, "");
655   }
656 +
657 + /* send_info_text()
658 + *
659 + * inputs       - client pointer to send info text to
660 + * output       - NONE
661 + * side effects - info text is sent to client
662 + */
663 + static void
664 + send_info_text(struct Client *source_p)
665 + {
666 +  sendto_realops_flags(UMODE_SPY, L_ALL, SEND_NOTICE,
667 +                       "INFO requested by %s (%s@%s) [%s]",
668 +                       source_p->name, source_p->username,
669 +                       source_p->host, source_p->servptr->name);
670 +
671 +  for (const char **text = infotext; *text; ++text)
672 +  {
673 +    const char *line = *text;
674 +
675 +    if (*line == '\0')
676 +      line = " ";
677 +
678 +    sendto_one_numeric(source_p, &me, RPL_INFO, line);
679 +  }
680 +
681 +  if (HasUMode(source_p, UMODE_OPER))
682 +    send_conf_options(source_p);
683 +
684 +  send_birthdate_online_time(source_p);
685 +
686 +  sendto_one_numeric(source_p, &me, RPL_ENDOFINFO);
687 + }
688 +
689 + /*! \brief INFO command handler
690 + *
691 + * \param source_p Pointer to allocated Client struct from which the message
692 + *                 originally comes from.  This can be a local or remote client.
693 + * \param parc     Integer holding the number of supplied arguments.
694 + * \param parv     Argument vector where parv[0] .. parv[parc-1] are non-NULL
695 + *                 pointers.
696 + * \note Valid arguments for this command are:
697 + *      - parv[0] = command
698 + *      - parv[1] = nickname/servername
699 + */
700 + static int
701 + m_info(struct Client *source_p, int parc, char *parv[])
702 + {
703 +  static time_t last_used = 0;
704 +
705 +  if ((last_used + ConfigGeneral.pace_wait) > CurrentTime)
706 +  {
707 +    sendto_one_numeric(source_p, &me, RPL_LOAD2HI, "INFO");
708 +    return 0;
709 +  }
710 +
711 +  last_used = CurrentTime;
712 +
713 +  if (!ConfigServerHide.disable_remote_commands)
714 +    if (hunt_server(source_p, ":%s INFO :%s", 1, parc, parv) != HUNTED_ISME)
715 +      return 0;
716 +
717 +  send_info_text(source_p);
718 +  return 0;
719 + }
720 +
721 + /*! \brief INFO command handler
722 + *
723 + * \param source_p Pointer to allocated Client struct from which the message
724 + *                 originally comes from.  This can be a local or remote client.
725 + * \param parc     Integer holding the number of supplied arguments.
726 + * \param parv     Argument vector where parv[0] .. parv[parc-1] are non-NULL
727 + *                 pointers.
728 + * \note Valid arguments for this command are:
729 + *      - parv[0] = command
730 + *      - parv[1] = nickname/servername
731 + */
732 + static int
733 + ms_info(struct Client *source_p, int parc, char *parv[])
734 + {
735 +  if (hunt_server(source_p, ":%s INFO :%s", 1, parc, parv) != HUNTED_ISME)
736 +    return 0;
737 +
738 +  send_info_text(source_p);
739 +  return 0;
740 + }
741 +
742 + static struct Message info_msgtab =
743 + {
744 +  "INFO", NULL, 0, 0, 0, MAXPARA, MFLG_SLOW, 0,
745 +  { m_unregistered, m_info, ms_info, m_ignore, ms_info, m_ignore }
746 + };
747 +
748 + static void
749 + module_init(void)
750 + {
751 +  mod_add_cmd(&info_msgtab);
752 + }
753 +
754 + static void
755 + module_exit(void)
756 + {
757 +  mod_del_cmd(&info_msgtab);
758 + }
759 +
760 + struct module module_entry =
761 + {
762 +  .node    = { NULL, NULL, NULL },
763 +  .name    = NULL,
764 +  .version = "$Revision$",
765 +  .handle  = NULL,
766 +  .modinit = module_init,
767 +  .modexit = module_exit,
768 +  .flags   = 0
769 + };

Diff Legend

– Removed lines
+ Added lines
< Changed lines (old)
> Changed lines (new)