From cc05a230ac079fa15a2e43e6e68ef7126128cefd Mon Sep 17 00:00:00 2001 From: Joseph Bongaarts Date: Thu, 14 Feb 2002 00:20:45 +0000 Subject: [PATCH] Author: Ghostwolf Log message: Merged changes in 2.10.11 into .12 git-svn-id: file:///home/klmitch/undernet-ircu/undernet-ircu-svn/ircu2/trunk@634 c9e4aea6-c8fd-4c43-8297-357d70d61c8c --- ChangeLog | 4732 ++++++++++++++++++++++++++++++++++++++- RELEASE.NOTES | 7 +- configure | 170 +- configure.in | 6 +- doc/example.conf | 6 +- doc/p10.html | 21 +- doc/readme.features | 32 +- include/channel.h | 5 +- include/client.h | 10 +- include/fda.h | 4 +- include/handlers.h | 5 +- include/ircd_alloc.h | 6 +- include/ircd_defs.h | 13 +- include/ircd_events.h | 6 + include/ircd_features.h | 4 + include/msg.h | 4 + include/numeric.h | 12 +- include/s_user.h | 1 + include/send.h | 18 +- include/struct.h | 2 + include/supported.h | 14 +- include/whowas.h | 1 + ircd/IPcheck.c | 2 +- ircd/Makefile.in | 938 +++++++- ircd/channel.c | 79 +- ircd/client.c | 3 + ircd/engine_devpoll.c | 23 +- ircd/engine_kqueue.c | 21 +- ircd/engine_poll.c | 2 +- ircd/engine_select.c | 2 +- ircd/fda.c | 4 +- ircd/gline.c | 2 +- ircd/ircd.c | 4 +- ircd/ircd_alloc.c | 6 +- ircd/ircd_events.c | 94 +- ircd/ircd_features.c | 6 +- ircd/jupe.c | 1 - ircd/list.c | 46 + ircd/listener.c | 2 +- ircd/m_account.c | 130 ++ ircd/m_admin.c | 17 + ircd/m_away.c | 6 +- ircd/m_burst.c | 2 +- ircd/m_clearmode.c | 1 + ircd/m_kick.c | 4 +- ircd/m_mode.c | 2 +- ircd/m_quit.c | 16 +- ircd/m_squit.c | 7 +- ircd/m_stats.c | 6 +- ircd/m_topic.c | 4 +- ircd/m_userip.c | 1 + ircd/m_version.c | 18 + ircd/m_who.c | 9 +- ircd/m_whois.c | 7 + ircd/m_whowas.c | 5 +- ircd/motd.c | 3 + ircd/parse.c | 23 +- ircd/res.c | 24 +- ircd/s_auth.c | 12 +- ircd/s_bsd.c | 6 +- ircd/s_conf.c | 2 + ircd/s_debug.c | 6 +- ircd/s_err.c | 12 +- ircd/s_misc.c | 6 +- ircd/s_serv.c | 2 +- ircd/s_user.c | 89 +- ircd/send.c | 39 +- ircd/uping.c | 8 +- ircd/whocmds.c | 15 +- ircd/whowas.c | 5 + tools/ringlog.c | 341 +++ tools/ringlog.pl | 187 ++ 72 files changed, 6977 insertions(+), 352 deletions(-) create mode 100644 ircd/m_account.c create mode 100644 tools/ringlog.c create mode 100755 tools/ringlog.pl diff --git a/ChangeLog b/ChangeLog index 98c8013..7f2ded2 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,41 +1,4749 @@ +2002-02-08 Tim Vogelsang + + * ircd/m_quit.c: don't prefix user quits with "Quit:" unless a + reason is supplied. + +2002-02-06 Kevin L Mitchell + + * ircd/s_auth.c (read_auth_reply): left out an = in an + assertion--shouldn't have had any impact, though + + * ircd/Makefile.in: add a hook for using ringlog; run make depend + + * tools/ringlog.c: for the heck of it, add a comment including + rules for /etc/magic + +2002-02-05 Kevin L Mitchell + + * tools/ringlog.pl: perl script to take output from ringlog and + pass it to addr2line to get function, file, and line number + information + + * tools/ringlog.c: program/object to help in building function + trace information + +2002-02-04 Alex Badea + + * include/ircd_features.h: added new feature MOTD_BANNER + + * ircd/ircd_features.c: added new feature MOTD_BANNER + + * ircd/motd.c (motd_signon): send a one-line banner from + FEAT_MOTD_BANNER if it's not NULL and FEAT_NODEFAULTMOTD + is set + + * doc/example.conf: default value for MOTD_BANNER feature + + * doc/readme.features: documented the MOTD_BANNER feature + +2002-02-04 Kevin L Mitchell + + * ircd/s_debug.c (debug_serveropts): remove deprecated CHROOTDIR + check; added character 'A' to the server options string to + indicate when assertion checking is enabled + +2002-02-03 Kevin L Mitchell + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/engine_kqueue.c (set_or_clear): don't generate an ET_ERROR + event if the errno is EBADF, since the caller probably already + knows about it and just hasn't gotten around to processing it yet + + * ircd/ircd_events.c: set the GEN_ERROR flag if an ET_ERROR event + is generated; don't process socket_events() or socket_state() if + an error occurred; add GEN_ERROR to list of flags in gen_flags() + + * include/ircd_events.h: define new GEN_ERROR flag; add a macro to + clear it + +2002-02-01 Kevin L Mitchell + + * ircd/channel.c: change make_nick_user_{ip,host} to not use a + static buffer--instead, a buffer of the right size (NUH_BUFSIZE or + NUI_BUFSIZE--I confess they're not well-named) is allocated by the + caller + +2002-02-02 Alex Badea + + * include/client.h: added user flag FLAGS_HIDDENHOST + + * include/ircd_features.h: added FEAT_HOST_HIDING and + FEAT_HIDDEN_HOST + + * include/numeric.h: defined numeric 338 (RPL_WHOISACTUALLY) + to report real hostnames and IPs to opers + + * include/s_user.h: exported hide_hostmask() + + * include/send.h: changed sendcmdto_channel_butserv to + sendcmdto_channel_butserv_butone; ditto for + sendcmdto_common_channels + + * include/struct.h: added realhost to struct User + + * include/whowas.h: added realhost to struct Whowas + + * ircd/channel.c: match bans against both real and hidden + hostmasks; moved some calls to use sendcmdto_*_butone + + * ircd/gline.c: match glines agains real host + + * ircd/ircd_features.c: added FEAT_HOST_HIDING and + FEAT_HIDDEN_HOST + + * ircd/m_account.c: call hide_hostmask() for possibly + hiding the user's host + + * ircd/m_burst.c: moved some calls to use sendcmdto_*_butone + + * ircd/m_topic.c: moved some calls to use sendcmdto_*_butone + + * ircd/m_userip.c: report IP 127.0.0.1 if the user has a hidden + host + + * ircd/m_who.c: match real hosts, if the query comes from an oper + + * ircd/m_whois.c: report real hostname and IP to opers + + * ircd/m_whowas.c: report real hostname to opers + + * ircd/s_err.c: added user mode 'x' to the list of supported user + modes in RPL_MYINFO (004); added RPL_WHOISACTUALLY for reporting + real hostnames to opers + + * ircd/s_misc.c: moved some calls to use sendcmdto_*_butone + + * ircd/s_serv.c: send real hostname to servers + + * ircd/s_user.c: send real hostname to servers; added processing + of usermode 'x'; added hide_hostmask() which actually does the work + of hiding a user's host; moved some calls to use sendcmdto_*_butone + + * ircd/send.c: changed sendcmdto_channel_butserv to + sendcmdto_channel_butserv_butone; ditto for + sendcmdto_common_channels + + * ircd/whocmds.c: extra letter 'x' in WHO reply if the user has + it's host hidden + + * ircd/whowas.c: if needed, store a user's real host so we can + report it to opers later + + * doc/readme.features: documented HOST_HIDING and HIDDEN_HOST + features + + * doc/example.conf: default values for HOST_HIDING and + HIDDEN_HOST features + +2002-02-01 Tim Vogelsang + + * ircd/send.c (sendwallto_group_butone): don't sent wallops to + ordinary users + +2002-01-28 Kevin L Mitchell + + * ircd/jupe.c (jupe_activate): remove a bogus assertion + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/s_err.c: added new channel mode 'r' to list of supported + channel modes in RPL_MYINFO (004); migrated RPL_USERIP to use + numeric 340 instead of 307; add ERR_NEEDREGGEDNICK (477) for + informing users why they can't join a +r channel + + * ircd/m_clearmode.c (do_clearmode): add support for MODE_REGONLY + (+r) to do_clearmode(); note that it is *not* being added to the + default clearmode mask! + + * ircd/channel.c: don't allow non-+r users to send messages to +r + channels from off the channel; add support for MODE_REGONLY (+r) + to channel_modes(); don't allow non-+r users to join +r channels + without an invite; add support for MODE_REGONLY to the modebuf_*() + family of functions (changes in modebuf_flush_int(), + modebuf_mode(), and modebuf_extract()); add support for + MODE_REGONLY to mode_parse() + + * include/supported.h (FEATURESVALUES2): added the new channel + mode 'r' to the list of supported channel modes + + * include/numeric.h: move RPL_USERIP to 340 to avoid the 307 + conflict; add ERR_NEEDREGGEDNICK (477) for the new +r channels + + * include/channel.h: remove unused MODE_SENDTS; add new + MODE_REGONLY + + * ircd/s_bsd.c (read_packet): remove call to timer_verify() + + * ircd/list.c: remove calls to timer_verify() from + alloc_connection() and dealloc_connection() + + * ircd/ircd_events.c: turn off timer_verify(); remove calls to it + from timer_run() + +2002-01-27 Kevin L Mitchell + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/ircd_events.c (timer_run): why did I ever use a next + pointer when the algorithm guarantees that the head pointer will + always be the next pointer? + +2002-01-26 Kevin L Mitchell + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/s_bsd.c (read_packet): call timer_verify() after adding the + client process timer to catch any list corruption + + * ircd/list.c: surround alloc_connection() and + dealloc_connection() with calls to timer_verify() + + * ircd/ircd_events.c: add sledgehammer known as timer_verify() to + verify the timer list's structure; call it around timer_run() + +2002-01-22 Kevin L Mitchell + + * ircd/send.c (sendcmdto_common_channels): don't send message to a + channel that the source is a zombie on + +2002-01-13 Kevin L Mitchell + + * ircd/ircd_events.c (timer_enqueue): one more assertion--make + sure a timer has the ACTIVE flag set before enqueueing the timer + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/list.c (dealloc_connection): assert that the process timer + has been removed from the timer queue before dealloc_connection() + is called + +2002-01-12 Kevin L Mitchell + + * ircd/res.c: don't accept T_A when we're looking for T_PTR + + * ircd/channel.c (modebuf_flush_int): nuke the code that would + send a HACK DESYNCH notice on a HACK(2)--it would be far too + chatty + + * ircd/m_away.c (user_set_away): use AWAYLEN instead of TOPICLEN + + * include/supported.h: add AWAYLEN to the list of supported + features + + * include/ircd_defs.h: add AWAYLEN to specify the maximum length + of an away message + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/m_mode.c (m_mode): pass extra parameter to channel_modes() + + * ircd/channel.c: pass a buflen parameter to channel_modes() for + pbuf--we were using sizeof(pbuf), which would always be + sizeof(char*) before; change send_channel_modes() to pass extra + parameter to channel_modes() + + * include/channel.h: pass a buflen parameter to channel_modes() + for pbuf + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/uping.c (uping_start): initialize some timers + + * ircd/s_bsd.c (read_packet): use new t_onqueue() macro to figure + out when we need to re-add the process timer + + * ircd/s_auth.c (make_auth_request): initialize a timer + + * ircd/res.c (init_resolver): initialize some timers + + * ircd/list.c (alloc_connection): initialize the client process + timer + + * ircd/ircd_events.c: add a function, timer_init(), to initialize + a struct Timer; recast timer_add() to catch when adding a marked + timer and not re-enqueue it--but mark it for re-enqueuing; update + timer_del() to turn off the GEN_READD flag and to ignore reference + counts when destroying the timer--we're using GEN_MARKED as an + ersatz referance count; changed timer_run() to work with the new + way of doing things; add GEN_ACTIVE and GEN_READD to gen_flags()'s + map[] + + * ircd/ircd.c: initialize some timers + + * ircd/engine_select.c (engine_loop): initialize a timer + + * ircd/engine_poll.c (engine_loop): initialize a timer + + * ircd/engine_kqueue.c (engine_loop): initialize a timer + + * ircd/engine_devpoll.c (engine_loop): initialize a timer + + * ircd/IPcheck.c (IPcheck_init): initialize a timer + + * include/ircd_events.h: add GEN_READD flag for timers to indicate + that a timer must be readded; add t_onqueue() macro to check to + see if a timer is on the queue (this is a hack, though); added + timer_init() to initialize a struct Timer--we're no longer doing + the initialization in timer_add() + +2002-01-11 Kevin L Mitchell + + * ircd/engine_devpoll.c (engine_loop): relocate an assertion to + prevent a core bug *in* the assertion + + * doc/readme.features: document new POLLS_PER_LOOP feature; change + documentation to reflect that OPER_SET now defaults to FALSE + + * doc/p10.html: documented the new ACCOUNT stuff + + * doc/example.conf: document new POLLS_PER_LOOP default; change + default for OPER_SET + + * RELEASE.NOTES: changed documentation to reflect the fact that + assertions are now enabled by default and do not cause memory + leaks + + * ircd/res.c (make_cache): removed a bogus assertion we probably + never caught because assertions haven't been enabled on production + servers for any length of time before + + * ircd/engine_devpoll.c (engine_loop): ditto for POLLS_PER_DEVPOLL + + * ircd/engine_kqueue.c (engine_loop): stupid me forgot one + instance of POLLS_PER_KQUEUE + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/s_bsd.c (client_timer_callback): only clear the + FREEFLAG_TIMER flag when the timer is being destroyed + + * ircd/ircd_features.c: create a new feature, POLLS_PER_LOOP, and + default it to 200; turn OPER_SET off by default + + * ircd/engine_kqueue.c: dynamically allocate and reallocate the + array of events to obtain from the kernel + + * ircd/engine_devpoll.c: dynamically allocate and reallocate the + array of events to obtain from the kernel + + * include/ircd_features.h: add a new feature for tuning how many + events to get from the kernel, for engines that support that + + * ircd/Makefile.in: re-run make depend to correct dependancies + + * ircd/m_who.c: remove unneeded inclusion of list.h + + * ircd/ircd_events.c: remove unneeded inclusion of list.h + + * ircd/whocmds.c (do_who): hide server name in /who unless + requester is an operator; simplify hop count insertion + + * ircd/s_misc.c (exit_one_client): make sure client's snomask is + cleared + + * ircd/parse.c: use mo_version and mo_admin when opers do /version + or /admin + + * ircd/m_whowas.c (m_whowas): use HEAD_IN_SAND_SERVERNAME instead + of the static string "*.undernet.org" + + * ircd/m_version.c: only let ordinary users get version + information for the server they are on + + * ircd/m_admin.c: only let ordinary users get admin information + for the server they are on + + * ircd/channel.c (client_can_send_to_channel): check is_banned() + before letting the client speak on a channel s/he is not on + + * include/supported.h: add NETWORK to feature list + + * include/handlers.h: declare mo_admin() and mo_version() + +2002-01-10 Kevin L Mitchell + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/s_debug.c (count_memory): conditionalize on MDEBUG instead + of !NDEBUG + + * ircd/m_stats.c: conditionalize /stats M on MDEBUG instead of + !NDEBUG + + * ircd/ircd_alloc.c: conditionalize on MDEBUG instead of on + !NDEBUG + + * ircd/fda.c: conditionalize on MDEBUG instead of on !NDEBUG + + * ircd/Makefile.in: run make depend on chkconf.c as well + + * include/ircd_alloc.h: instead of conditionalizing on !NDEBUG, + conditionalize on MDEBUG + + * include/fda.h: instead of conditionalizing on !NDEBUG, + conditionalize on MDEBUG + + * configure: rebuild configure script + + * configure.in: enable assertion checking by default, since we + have now decoupled memory debugging from the NDEBUG macro + + * ircd/s_user.c (set_nick_name): remove calls to + verify_client_list() + + * ircd/s_misc.c (exit_one_client): remove calls to + verify_client_list() + + * ircd/s_conf.c (rehash): remove calls to verify_client_list() + + * ircd/m_who.c (m_who): remove calls to verify_client_list() + + * ircd/list.c: remove calls to verify_client_list(); keep + verify_client_list() around just in case we ever need it again, + but never compile it in + + * ircd/ircd_events.c (event_execute): remove calls to + verify_client_list() + + * ircd/client.c (client_get_ping): remove calls to + verify_client_list() + + * include/list.h (send_listinfo): remove temporary debugging + function verify_client_list() + + * ircd/uping.c: don't die if the event type is ET_ERROR in socket + callback functions + + * ircd/res.c (res_callback): don't die if the event type is + ET_ERROR + + * ircd/listener.c (accept_connection): don't die if the event type + is ET_ERROR + +2002-01-09 Kevin L Mitchell + + * ircd/s_user.c (set_nick_name): bracket call to + add_client_to_list() with calls to verify_client_list() + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel (again) + + * ircd/list.c (verify_client_list): add a probabilistic loop + detector: for every client added, there is a 2% probability that + it will be used to replace the value of sentinel; if at any time, + sentinel is found again, we know we're in a loop + + * ircd/ircd_events.c (event_execute): add verify_client_list() + calls wrapping event_execute; at the very least, I'll figure out + what event the corruption occurred in + + * ircd/list.c: moved verify_client_list() to try to keep it from + being inlined + + * ircd/Makefile.in (version.c): version.c wasn't dependant on + version.h and patchlevel.h, like it was supposed to be + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/s_auth.c (destroy_auth_request): overload send_reports + argument to also indicate whether or not to call + release_auth_client() and thereby enter the client into the linked + list + + * ircd/engine_devpoll.c (engine_loop): remove bogus assertion + + * include/patchlevel.h (PATCHLEVEL): bump patchlevel + + * ircd/list.c (free_client): verify that destroy_auth_request() + didn't automagically re-add us to the list; we might have to think + about this interaction more carefully, actually + + * ircd/s_auth.c (auth_kill_client): zero the auth pointer before + calling free_client(); otherwise, free_client() will try to free + the auth by calling destroy_auth_request(), which will call + add_client_to_list() + + * ircd/s_misc.c (exit_one_client): liberally sprinkle calls to + verify_client_list() around to catch any corruption that might + occur here + + * ircd/s_conf.c (rehash): liberally sprinkle calls to + verify_client_list() here, since this is about the only routine I + can think of that could cause the "core on kill -HUP" bug + + * ircd/m_who.c: sprinkle calls to verify_client_list() around + liberally, since we've seen crashes here; temporarily include the + otherwise unneeded list.h header + + * ircd/list.c: sprinkle calls to verify_client_list() around quite + liberally; add debugging asserts to list manipulation functions to + catch strange settings for next and prev pointers; define + verify_client_list(), which walks the client list and verifies + that everything is as it's supposed to be + + * ircd/client.c: wrap client_get_ping with calls to + verify_client_list() to see if that's where we're dying + + * include/patchlevel.h (PATCHLEVEL): bump to 03 + + * include/list.h: declare verify_client_list() if DEBUGMODE + enabled; otherwise, define it to be empty + +2002-01-08 Kevin L Mitchell + + * ircd/m_quit.c (m_quit): remove an unused variable + + * include/patchlevel.h (PATCHLEVEL): bump PATCHLEVEL to 2 + + * ircd/s_user.c: when building the user mode to send to the user, + don't include +r; add an extra set of parens to squelch a warning + + * ircd/m_quit.c (m_quit): use exit_client_msg() + + * include/patchlevel.h (PATCHLEVEL): bump patch level, so we can + keep track of who's running what version + + * ircd/m_squit.c (ms_squit): remove debugging calls to + protocol_violation() + + * Makefile.in: change MAKEFILES to IRCD_MAKEFILES to work around a + new gmake "feature" (pull-up from trunk) + + * ircd/m_quit.c (m_quit): prefix user quits with "Quit:" (pull-up + from trunk) + +2002-01-07 Kevin L Mitchell + + * ircd/s_user.c: add FLAGS_ACCOUNT, represented as 'r', to the + list of user modes; process account name as part of user mode in + NICK decoding (set_nick_name()); add account name to usermode when + building the usermode to incorporate in outgoing NICK messages + + * ircd/s_err.c: add RPL_WHOISACCOUNT for reporting what account a + user is logged in to + + * ircd/parse.c: define the new ACCOUNT command, usable only by + servers and ignored by everything else + + * ircd/m_whois.c: report what account name is associated with a + user, if any + + * ircd/m_account.c: implement the ACCOUNT command + + * ircd/Makefile.in: add m_account.c to the list of sources; ran + make depend + + * include/struct.h: add an account field to struct User + + * include/numeric.h: add a reply, RPL_WHOISACCOUNT, for reporting + what username a user is logged in under + + * include/msg.h: add ACCOUNT command and token (AC) + + * include/ircd_defs.h: define ACCOUNTLEN to be 12--this matches + the maximum length of a username for X + + * include/handlers.h: add declaration for ms_account() + + * include/client.h: add FLAGS_ACCOUNT to flag when a user account + name has been set; added FLAGS_ACCOUNT to SEND_UMODES; added + IsAccount() and SetAccount() to manipulate the flag + + * ircd/m_squit.c (ms_squit): if we call FindNServer() on a server + name like "Amsterdam2.NL.EU.undernet.org", we get the struct + Client for the server with numeric "Am", which happens to be + stockholm! To fix this, we look up the full name *first*; if that + doesn't get it, *then* we look up by numeric. + 2001-12-24 Perry Lorier * ircd/m_server.c: cleanups, maybe this will make the bug easier to find. * ircd/m_stats.c: display maximum number of connects in an I: +2001-11-22 Perry Lorier + * ircd/m_squit.c: Bug fix in squit + +2001-11-03 Greg Sikorski + * ircd/parse.c, include/handlers.h: Give remote whois the correct + handler. + 2001-11-01 Kevin L Mitchell * ircd/send.c: some minor white-space fiddling; recast selector test in sendwallto_group_butone() to remove a warning regarding - putting & within parentheses [forward-port from u2.10.11] + putting & within parentheses * ircd/m_create.c (ms_create): use time_t instead of int as a - declaration for rate [forward-port from u2.10.11] + declaration for rate * ircd/ircd_reply.c (protocol_violation): it's supposed to be WALL_DESYNCH, not CMD_DESYNCH, if I understand things right--no - wonder we weren't seeing any protocol violations! [forward-port - from u2.10.11] + wonder we weren't seeing any protocol violations! * include/send.h: include time.h for time_t; move WALL_* closer to the function they're used in; some white-space fiddling; add - declaration of sendto_opmask_butone_ratelimited() [forward-port - from u2.10.11] + declaration of sendto_opmask_butone_ratelimited() * ircd/m_squit.c (ms_squit): add protocol_violation() calls in the cases where we ignore a squit, so we aren't taken by surprise, at - least... [forward-port from u2.10.11] + least... * ircd/m_create.c (ms_create): Display origin server, not origin - user [forward-port from u2.10.11] + user -2001-11-02 Perry Lorier - * fixed TS drift message to use sptr, not cptr + * ircd/m_create.c (ms_create): Fix "Timestamp drift" server notice 2001-10-31 Perry Lorier - * fixed ping *bug* + * include/m_ping.c: Forward port ping bug 2001-10-31 Perry Lorier - * fixed hunt_server + * include/patchlevel.h: We're beta now + +2001-10-31 Perry Lorier + * ircd/s_user.c: fixed hunt_server + +2001-09-21 Perry Lorier + * ircd/send.c and various: replace sendcmdto_flag_butone with + sendwallto_group_butone + +2001-09-21 Vampire- + * ircd/ircd_string.c: unique_name_vector round II. + +2001-09-21 mbuna + * configure.in: Add support for darwin + +2001-09-21 Perry Lorier + * ircd/s_user.c I'm stupid, s/acptr/from/, Hektik pointed it out + +2001-09-20 Perry Lorier + + * Pullups from 2.10.10.pl16 + * Added some warnings, and the concept of rate limited snotices + +2001-08-31 Kevin L Mitchell + + * ircd/channel.c: use "%u" to format limit arguments; use + strtoul() to process limit arguments in a /mode command--note: + most clients seem to truncate the integer, probably because + they're using atoi, and perhaps signed ints + +2001-08-17 Kevin L Mitchell + + * ircd/numnicks.c: include stdlib.h for exit() + + * ircd/ircd_log.c: include stdlib.h for exit() + + * ircd/ircd_events.c: include stdlib.h for exit() + + * ircd/s_stats.c: remove description of /stats v, since it's gone + + * ircd/m_wallops.c (mo_wallops): add "*" to the beginning of + /wallops to distinguish wallops from wallusers + + * ircd/m_error.c (mr_error): ignore ERROR from clients that aren't + in the "handshake" or "connecting" states--I think the latter will + never happen, but... + + * doc/Authors: apply delete's Authors patch + + * RELEASE.NOTES: rewrite RELEASE.NOTES, basing it a little on + Braden's version + + * README: rewrite README + +2001-07-31 Kevin L. Mitchell + + * ircd/s_serv.c (server_estab): remove unused variable split + + * ircd/parse.c: add mr_error to the parse table + + * ircd/m_error.c (mr_error): add mr_error() to handle ERRORs from + unregistered connections--if IsUserPort() is true, the ERROR is + ignored, otherwise, the message is saved + +2001-07-28 Kevin L. Mitchell + + * ircd/m_kill.c (ms_kill): another minor typo *sigh* + + * ircd/s_user.c (send_supported): oops, minor typo... + + * ircd/s_user.c: implement send_supported() to send two ISUPPORT + messages containing our feature buffers; make register_user() use + send_supported() + + * ircd/s_misc.c (exit_client): make sure not to give away a remote + server in the ERROR message sent to the client; if the killer is a + server, we substitute our name in its place + + * ircd/m_version.c (m_version): use send_supported() to send the + ISUPPORT values to the user + + * ircd/m_nick.c: shave nick collision kills here a bit, too, for + the same reasons as for m_kill.c + + * ircd/m_kill.c: shave kills a bit so that the results look + exactly the same no matter where you are; if we didn't do this, it + would be possible to map the network by looking at the differences + between kills originating under various circumstances + + * include/supported.h: split the features into two, so as to not + bust the parameter count when sending the features list + + * include/s_user.h: declare new send_supported() function to send + the ISUPPORT information + +2001-07-27 Kevin L. Mitchell + + * ircd/s_bsd.c: disable IP (*not* TCP) options to prevent + source-routed spoofing attacks; this is only available under + u2.10.11, so don't even bother, since no one but testers are using + the source base + +2001-07-25 Kevin L. Mitchell + + * include/ircd_policy.h: enable HEAD_IN_SAND_REMOTE by default + + * ircd/s_err.c: put in a . for reporting link version on /trace, + to match what /version does + +2001-07-21 Kevin L. Mitchell + + * ircd/s_misc.c (exit_client): servers don't understand what the + numeric nick ERROR is supposed to mean, so they ignore error + messages, resulting in not knowing why we were rejected; use + sendcmdto_one for servers and sendrawto_one for clients + +2001-07-17 Kevin L. Mitchell + + * ircd/m_burst.c (ms_burst): in the case of a modeless channel and + a nick collide, a bare BURST may be propagated; adjust the + enforced parameter count to accept the bare BURST + +2001-07-12 Kevin L. Mitchell + + * ircd/s_bsd.c: mark a client as having been IP checked + + * ircd/IPcheck.c (ip_registry_check_remote): remove unneeded + second call to SetIPChecked() + +2001-07-11 Kevin L. Mitchell + + * ircd/engine_poll.c: deal with POLLHUP properly (hopefully) + + * ircd/engine_devpoll.c: deal with POLLHUP properly (hopefully) + +2001-07-09 Kevin L. Mitchell + + * ircd/os_bsd.c (os_get_rusage): move buf into the two ifdef'd + sections so that if neither is used, the declaration of buf will + not elicit an "unused variable" warning under NetBSD + + * ircd/m_map.c: include string.h to declare strcpy (fix warnings + on alpha) + + * ircd/m_away.c: include string.h to declare strcpy/strlen (fix + warnings on alpha) + + * ircd/ircd_log.c: include string.h to declare strcpy/strlen (fix + warnings on alpha) + + * ircd/client.c: include string.h to declare memset (fix warnings + on alpha) + + * ircd/channel.c: remove unused functions next_overlapped_ban, + del_banid, and is_deopped (fix warnings under -O1) + + * ircd/IPcheck.c: include string.h to declare memset/memcpy (fix + warnings on alpha) + +2001-06-29 Kevin L. Mitchell + + * ircd/s_user.c (set_user_mode): clear the snomask if the user + isn't supposed to receive server notices anymore + + * ircd/ircd_features.c: change CONFIG_OPERCMDS to default to FALSE + + * configure.in: use AC_MSG_CHECKING/AC_MSG_RESULT when checking + installation prefix; default devpoll and kqueue to on (they get + turned off if the required headers aren't present) + + * ircd/whocmds.c (do_who): use ircd_snprintf() instead of + sprintf_irc(); it's a bit hackish, but it'll do for now + + * ircd/support.c: remove unused #include + + * ircd/send.c: remove unused #include + + * ircd/s_user.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/s_serv.c: remove unused #include + + * ircd/s_misc.c: use ircd_snprintf() and friends instead of + sprintf_irc() and friends + + * ircd/s_err.c: moved atoi_tab[] from ircd/sprintf_irc.c to + ircd/s_err.c, which is the only other file to refer to it + + * ircd/s_conf.c (conf_add_deny): use ircd_snprintf() instead of + sprintf_irc() + + * ircd/s_bsd.c (connect_server): use ircd_snprintf() instead of + sprintf_irc() + + * ircd/s_auth.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/res.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/m_version.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/m_kill.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/listener.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/gline.c: use ircd_snprintf() instead of sprintf_irc() + + * ircd/channel.c: don't include sprintf_irc.h; use ircd_snprintf() + instead of sprintf_irc() + + * ircd/Makefile.in: remove sprintf_irc.c from sources list; run + make depend + + * include/ircd_string.h: remove declaration of sprintf_irc() (what + was it doing here anyway?) + + * include/sprintf_irc.h: removed unneeded source file + + * ircd/sprintf_irc.c: removed unneeded source file + + * ircd/s_debug.c (count_memory): remove some dead code + + * ircd/s_auth.c: remove some dead code + + * ircd/res.c (update_list): remove some dead code + + * ircd/m_whowas.c: remove some dead code + + * ircd/m_whois.c: remove some dead code + + * ircd/m_who.c: remove some dead code + + * ircd/m_wallusers.c: remove some dead code + + * ircd/m_wallops.c: remove some dead code + + * ircd/m_wallchops.c: remove some dead code + + * ircd/m_version.c: remove some dead code + + * ircd/m_userip.c: remove some dead code + + * ircd/m_userhost.c: remove some dead code + + * ircd/m_uping.c: remove some dead code + + * ircd/m_trace.c: remove some dead code + + * ircd/m_topic.c: remove some dead code + + * ircd/m_tmpl.c: remove some dead code + + * ircd/m_time.c: remove some dead code + + * ircd/m_squit.c: remove some dead code + + * ircd/m_silence.c: remove some dead code + + * ircd/m_settime.c: remove some dead code + + * ircd/m_set.c: remove some dead code + + * ircd/m_server.c: remove some dead code + + * ircd/m_rpong.c: remove some dead code + + * ircd/m_rping.c: remove some dead code + + * ircd/m_restart.c: remove some dead code + + * ircd/m_reset.c: remove some dead code + + * ircd/m_rehash.c: remove some dead code + + * ircd/m_quit.c: remove some dead code + + * ircd/m_proto.c: remove some dead code + + * ircd/m_privs.c: remove some dead code + + * ircd/m_privmsg.c: remove some dead code + + * ircd/m_pong.c: remove some dead code + + * ircd/m_ping.c: remove some dead code + + * ircd/m_pass.c: remove some dead code + + * ircd/m_part.c: remove some dead code + + * ircd/m_opmode.c: remove some dead code + + * ircd/m_oper.c: remove some dead code + + * ircd/m_notice.c: remove some dead code + + * ircd/m_nick.c: remove some dead code + + * ircd/m_map.c: remove some dead code + + * ircd/m_lusers.c: remove some dead code + + * ircd/m_list.c: remove some dead code + + * ircd/m_links.c: remove some dead code + + * ircd/m_kill.c: remove some dead code + + * ircd/m_kick.c: remove some dead code + + * ircd/m_jupe.c: remove some dead code + + * ircd/m_join.c: remove some dead code + + * ircd/m_ison.c: remove some dead code + + * ircd/m_invite.c: remove some dead code + + * ircd/m_info.c: remove some dead code + + * ircd/m_help.c: remove some dead code + + * ircd/m_gline.c: remove some dead code + + * ircd/m_get.c: remove some dead code + + * ircd/m_error.c: remove some dead code + + * ircd/m_endburst.c: remove some dead code + + * ircd/m_die.c: remove some dead code + + * ircd/m_desynch.c: remove some dead code + + * ircd/m_destruct.c: remove some dead code + + * ircd/m_defaults.c: remove some dead code + + * ircd/m_create.c: remove some dead code, along with an #if 1 + + * ircd/m_cprivmsg.c: remove some dead code + + * ircd/m_connect.c: remove some dead code + + * ircd/m_close.c: remove some dead code + + * ircd/m_clearmode.c: remove some dead code + + * ircd/m_burst.c: remove some dead code + + * ircd/m_away.c: remove some dead code + + * ircd/m_admin.c: remove some dead code + + * ircd/listener.c (accept_connection): remove some dead code + + * ircd/ircd_reply.c (need_more_params): remove some dead code + + * ircd/channel.c (add_banid): remove some dead code + + * include/support.h: remove some dead code + + * include/querycmds.h: remove some dead code + + * doc/readme.chroot: document how to do chroot operation + +2001-06-28 Kevin L. Mitchell + + * ircd/Makefile.in: tune for VPATH builds/installs; add a rule to + force bin directory to be created if necessary prior to + installation; run make depend + + * doc/Makefile.in (install): tune for VPATH installs by cd'ing to + the ${srcdir} + + * Makefile.in: tune to detect Makefile.in changes in + subdirectories and to create installation directory indicated by + ${prefix} + + * ircd/whocmds.c (count_users): routine to count the number of + users matching a given user@host mask + + * ircd/s_err.c: add error messages for ERR_LONGMASK, + ERR_TOOMANYUSERS, and ERR_MASKTOOWIDE + + * ircd/m_gline.c: look for and advance past '!' flag on G-lines + from operators; only set GLINE_OPERFORCE flag if oper has the + PRIV_WIDE_GLINE privilege + + * ircd/ircd_features.c: add GLINEMAXUSERCOUNT, which is the + maximum number of users a G-line can impact before it has to be + forced; OPER_WIDE_GLINE, to allow operators to use ! to force a + wide G-line to be set; and LOCOP_WIDE_GLINE, to allow local + operators to use ! to force a wide G-line to be set + + * ircd/gline.c: make make_gline() be called with separate user and + host arguments, and not call canon_userhost() directly; implement + gline_checkmask() to verify that a host mask is acceptable; move + BADCHAN check up in gline_add(), and check passed-in mask under + certain circumstances for acceptability; fix call to + sendto_opmask_butone() to handle separation of userhost into user + and host in gline_add(); update call to make_gline() + + * ircd/client.c: use FEAT_OPER_WIDE_GLINE and + FEAT_LOCOP_WIDE_GLINE to set PRIV_WIDE_GLINE for an operator; add + PRIV_WIDE_GLINE to privtab[] for client_report_privs() + + * include/whocmds.h (count_users): declare routine to count users + matching a given user@host mask + + * include/numeric.h: added three new error returns: ERR_LONGMASK + -- mask can't be formatted into a buffer; ERR_TOOMANYUSERS -- too + many users would be impacted by the mask; ERR_MASKTOOWIDE -- mask + contains wildcards in the wrong places + + * include/ircd_features.h: add FEAT_GLINEMAXUSERCOUNT, + FEAT_OPER_WIDE_GLINE, and FEAT_LOCOP_WIDE_GLINE + + * include/gline.h (GLINE_OPERFORCE): provides a way for m_gline() + to signal to gline_add() that the operator attempted to force the + G-line to be set + + * include/client.h (PRIV_WIDE_GLINE): new privilege for operators + + * doc/readme.gline: update to document new "!" prefix to a G-line + user@host mask + + * doc/readme.features: document GLINEMAXUSERCOUNT, + OPER_WIDE_GLINE, and LOCOP_WIDE_GLINE + + * doc/example.conf: update to mention new features along with + their defaults + +2001-06-27 Kevin L. Mitchell + + * doc/example.conf: updated example.conf from Braden + + + * include/supported.h: forward-port from pl15 + +2001-06-25 Kevin L. Mitchell + + * ircd/whocmds.c: include ircd_policy.h and implement + HEAD_IN_SAND_WHO_OPCOUNT--forward-port from pl15 + + * ircd/m_whois.c: forward-port of the idle-time hiding code from + pl15; this also required passing parc into do_whois(), which also + meant passing parc into do_wilds()--*sigh* + + * include/ircd_policy.h: add a couple more HEAD_IN_SAND + #define's--WHOIS_IDLETIME and WHO_HOPCOUNT + +2001-06-22 Kevin L. Mitchell + + * tools/wrapper.c: add a wrapper program that can be used to + adjust file descriptor limits and root directories; program must + be run as root--NOT SETUID!--and given appropriate -u arguments + + * doc/readme.log: documentation of how to configure logging + + * doc/readme.features: documentation of each feature (except for + logging) + +2001-06-21 Kevin L. Mitchell + + * Makefile.in (config): add a deprecation notice with a pointer to + tools/transition + + * tools/transition: shell script to convert old compile-time + options into new compile-time options and appropriate F-lines + + * tools/mkchroot: shell-script to prepare the chroot area by + copying over all the necessary libraries so they can be found + +2001-06-20 Kevin L. Mitchell + + * INSTALL: partial update of INSTALL for u2.10.11 release... + +2001-06-14 Kevin L. Mitchell + + * ircd/table_gen.c (makeTables): finally got tired of the + "overflow in implicit conversion" warning, so just got rid of it + by explicitly casting UCHAR_MAX to a (default) char; diffs show no + differences in the tables generated + +2001-06-11 Kevin L. Mitchell + + * ircd/send.c (sendcmdto_match_butone): don't let the server crash + if a client is in the STAT_CONNECTING status + +2001-06-10 Kevin L. Mitchell + + * ircd/send.c: remove unused vsendcmdto_one(), consolidating it + into sendcmdto_one(); define new sendcmdto_prio_one(), which + places the message into the priority queue + + * ircd/s_user.c (hunt_server_prio_cmd): definition of + hunt_server_prio_cmd(), which simply calls sendcmdto_prio_one() + instead of sendcmdto_one() + + * ircd/m_settime.c: use sendcmdto_prio_one() and + hunt_server_prio_cmd() to send SETTIME + + * ircd/m_server.c: use sendcmdto_prio_one() to send SETTIME + + * include/send.h: removed declaration for unused vsendcmdto_one(); + added a declaration for sendcmdto_prio_one() + + * include/s_user.h: declare hunt_server_prio_cmd(), which calls + sendcmdto_prio_one() + + * ircd/send.c (sendcmdto_flag_butone): oops; /wallops should be + put in the server's priority queue, too... + + * ircd/ircd.c: don't check LPATH for accessibility at all + +2001-06-08 Kevin L. Mitchell + + * ircd/s_serv.c (server_estab): send a +h flag in our SERVER + command if we're configured as a hub; send individual server flags + in SERVER commands + + * ircd/s_bsd.c (completed_connection): send a +h flag in our + SERVER command if we're configured as a hub + + * ircd/m_server.c: implement parv[7] as a mode-like string; +h + sets the FLAGS_HUB flag for a server; +s sets the FLAGS_SERVICE + flag for a server; +hs sets both flags; also modify CMD_SERVER + format string to send the flags + + * include/client.h: define two new flags, FLAGS_HUB and + FLAGS_SERVICE to mark services and hubs as such; define testing + macros, setting macros + + * ircd/s_user.c: remove deprecated struct Gline* argument to + register_user(); remove GLINE rebroadcast; do not send GLINE + acknowledgement parameter to NICK; do not look for GLINE + acknowledgement parameter to NICK while parsing + + * ircd/s_serv.c (server_estab): remove deprecated struct Jupe* + argument to server_estab(); do not send JUPE/GLINE acknowledgement + parameters for SERVER or NICK + + * ircd/m_user.c (m_user): remove deprecated argument to + register_user() + + * ircd/m_server.c: remove deprecated argument to server_estab(); + remove documentation comment regarding JUPE acknowledgement + parameter to SERVER; remove JUPE rebroadcast + + * ircd/m_pong.c (mr_pong): remove deprecated argument to + register_user() + + * ircd/m_nick.c: remove documentation comment regarding GLINE + acknowledgement parameter to NICK + + * ircd/jupe.c: use user's real name in JUPE server notices if + HEAD_IN_SAND_SNOTICES is defined + + * ircd/ircd.c: remove deprecated chroot() code; remove deprecated + setuid code; correct ancient DEBUG vs DEBUGMODE typo + + * ircd/gline.c: use user's real name in GLINE server notices if + HEAD_IN_SAND_SNOTICES is defined + + * ircd/channel.c (modebuf_flush_int): make apparent source be + local server, not oper's server; use user's real name in hack + notices and DESYNC notices if HEAD_IN_SAND_SNOTICES is defined + + * include/s_user.h: remove struct Gline pre-declaration; remove + deprecated struct Gline argument from register_user() + + * include/s_serv.h: remove struct Jupe pre-declaration; remove + deprecated struct Jupe argument from server_estab() + +2001-06-07 Kevin L. Mitchell + + * ircd/s_stats.c (hunt_stats): forward-port from pl15 of all the + changes required to control remote stats + + * ircd/s_numeric.c (do_numeric): rewrite numeric origins if + recipient is not an operator and HEAD_IN_SAND_REWRITE is defined + [forward-port from pl15] + + * ircd/m_whowas.c (m_whowas): report server name only if requester + is an operator [forward-port from pl15] + + * ircd/m_whois.c (do_whois): /whois now correctly reports + my server; if HEAD_IN_SAND_REMOTE is 1, ignore the middle argument + and obtain the report from the user's server [forward-port from + pl15] + + * ircd/m_who.c: add missing include for ircd_policy.h + [forward-port from pl15] + + * ircd/m_version.c (m_version): require oper access for remote + /version if HEAD_IN_SAND_REMOTE is 1 [forward-port from pl15] + + * ircd/m_time.c (m_time): require oper access for remote /time if + HEAD_IN_SAND_REMOTE is 1 [forward-port from pl15] + + * ircd/m_stats.c: pass extra argument to hunt_stats(); correct + missing semicolon [forward-port from pl15] + + * ircd/m_nick.c (ms_nick): hide the origin of certain collision + kills [forward-port from pl15] + + * ircd/m_motd.c (m_motd): require oper access for remote /motd if + HEAD_IN_SAND_REMOTE is 1 [forward-port from pl15] + + * ircd/m_lusers.c (m_lusers): require oper access for remote + /lusers if HEAD_IN_SAND_REMOTE is 1 [forward-port from pl15] + + * ircd/m_burst.c (ms_burst): server-added bans are stored using + local server name, to hide remote server names; modes also are to + originate from the local server [forward-port from pl15] + + * ircd/m_admin.c (m_admin): require oper access for remote /admin + if HEAD_IN_SAND_REMOTE is 1 [forward-port from pl15] + + * ircd/channel.c (add_banid): if a server is adding a ban, use my + server name to hide the remote server's name [forward-port from + pl15] + + * ircd/Makefile.in: ran make depend + + * include/s_stats.h: hunt_stats() has to have an extra argument to + support the forward-port from pl15 + + * include/ircd_policy.h: #define HEAD_IN_SAND_STATS_P; add + HEAD_IN_SAND_{BANWHO,REWRITE,REMOTE} [forward-port from pl15] + + * ircd/engine_poll.c (engine_loop): remove bogus assert that I + forgot to check in the events branch + +2001-06-06 Kevin L. Mitchell + + * ircd/res.c (init_resolver): don't start DNS expires with a 0 + relative timeout--if the server starts slow, timeouts could be + messy...there's probably a better solution, but this'll do for now + + * ircd/os_solaris.c: _XOPEN_SOURCE doesn't get along with Solaris + headers very well; include stropts.h; define an os_set_tos() + + * ircd/os_generic.c (os_set_tos): added an os_set_tos() for + os_generic.c + + * ircd/ircd.c: if there are no C-lines, we don't want to have a + timer that expires at the absolute time of 0--it kinda blocks all + the other timers! + + * ircd/engine_devpoll.c: some includes for open(); declare errcode + and codesize in engine_loop() + + * ircd/list.c (free_client): remove bogus check on timer active + flag + + * ircd/s_auth.c: pull out destruction code in + auth_timeout_request() into an externally-visible + destroy_auth_request(); manage cli_auth pointer in client + structure; use it for an extra assertion check + + * ircd/list.c: include s_auth.h for destroy_auth_request(); add + debugging notices to show flow when deallocating + connections/clients; call destroy_auth_request() when free'ing a + client that has an auth outstanding; don't free the connection if + the process timer is unmarked but still active + + * ircd/ircd_events.c: set GEN_ACTIVE when initializing a generator + and reset it before calling the event handler for an ET_DESTROY + event + + * include/s_auth.h (destroy_auth_request): declare + destroy_auth_request(), which can be used to destroy an + outstanding auth request if a client socket goes away before the + auth exchange is completed + + * include/ircd_events.h: add an active flag to keep track of + whether or not particular generators are active, for the + convenience of functions using the API + + * include/client.h: add a pointer for auth requests to struct + Connection so we can kill outstanding auth requests if a client + socket closes unexpectedly + + * ircd/s_bsd.c: cli_connect() could become 0 during the course of + the sock or timer callback; take that into account in the assert + + * ircd/list.c: add magic number checking and setting--magic + numbers are zero'd on frees to detect double-frees; add back + setting of cli_from() to 0 to break the back-link from the struct + Connection (duh) + + * ircd/ircd.c: set me's magic number correctly + + * include/client.h: define magic numbers and accessor/verifier + macros + + * ircd/list.c: assert that dealloc_client() is called with + cli_connect(cptr) == 0; set cli_connect(cptr) to 0 before calling + dealloc_client(); don't mess with cli_from(cptr) + + * ircd/s_bsd.c: only attempt to dealloc a connection if the + associated client has already been destroyed, or at least delinked + +2001-06-05 Kevin L. Mitchell + + * ircd/list.c (free_client): only try to delete the socket when + the fd hasn't already been closed, avoiding a double-free + + * ircd/list.c (free_connection): make sure the client is really + gone before doing away with the connection + + * ircd/s_bsd.c: record that socket has been added in con_freeflag + field; queue a socket_del() as soon as the socket is close()'d; + use con_freeflag & FREEFLAG_TIMER instead of con_timer; clear + FREEFLAG_SOCKET on ET_DESTROY event in client_sock_callback(), + then dealloc the connection if safe; mark socket as dead when + there's a read error or EOF; clear FREEFLAG_TIMER flag upon entry + to client_timer_callback(); dealloc connection if safe upon + ET_DESTROY event in client_timer_callback() + + * ircd/list.c: use con_freeflag instead of con_timer; only dealloc + the connection if both socket and timer have been destroyed; + destroy both socket and timer explicitly and carefully + + * include/client.h: replace the con_timer field with a + con_freeflag field, to indicate what still needs freeing; define + the freeflags + + * ircd/engine_select.c (engine_loop): duh...sockList[i] could + become 0 + + * ircd/engine_devpoll.c (engine_loop): duh...sockList[i] could + become 0 + + * ircd/s_bsd.c: add some extra assertions to try to track down a + corruption problem + + * ircd/engine_select.c (engine_loop): add an extra assert to try + to track down a corruption problem + + * ircd/engine_poll.c (engine_loop): add an extra assert to try to + track down a corruption problem + + * ircd/engine_kqueue.c (engine_loop): add an extra assert to try + to track down a corruption problem + + * ircd/engine_devpoll.c (engine_loop): skip slots that have become + empty during processing; add an extra assert to try to track down + a corruption problem + + * ircd/engine_kqueue.c (engine_delete): make sure to zero deleted + entries + +2001-06-04 Kevin L. Mitchell + + * ircd/s_bsd.c (client_sock_callback): client is no longer + blocked, so we must mark it as unblocked + + * ircd/engine_select.c: add Debug() calls galore; add handling for + SS_NOTSOCK; use a dummy sock variable to keep things from + disappearing on us; correct timeout calculation; update nfds for + efficiency + + * ircd/engine_poll.c: use new debugging level (DEBUG_ENGINE); + remove a spurious "if (sock)" which will always be true; update + nfds for efficiency + + * ircd/engine_kqueue.c: add Debug() calls galore; add handling for + SS_NOTSOCK (just in case); correct timeout calculation + + * ircd/engine_devpoll.c: add Debug() calls galore; add handling + for SS_NOTSOCK; correct timeout calculation; add EAGAIN handling + + * include/s_debug.h (DEBUG_ENGINE): add new debugging level; + pretty-indent numbers + + * ircd/engine_poll.c (engine_loop): break out SS_NOTSOCK + case--it's not a socket; the check for writability is most likely + not needed, but present for completeness + +2001-05-24 Kevin L. Mitchell + + * ircd/s_bsd.c: add Debug messages; call read_packet() even if the + no newline flag is set; call read_packet() when the timer expires, + regardless of what's in the buffer--read_packet() should be able + to deal properly + + * ircd/IPcheck.c (ip_registry_connect_succeeded): correct a NOTICE + sent to clients to include the client nickname (duh) + + * ircd/ircd_events.c: don't destroy a timer if it's already marked + for destruction; replace a missing ! in socket_del() + + * ircd/engine_poll.c (engine_loop): reference a temporary variable + so we don't have to worry about sockList[i] going away + + * ircd/s_bsd.c (client_sock_callback): add Debug messages + + * ircd/s_auth.c: add Debug messages all over the place + + * ircd/ircd_events.c: add and edit some Debug messages; add a list + of routines to convert some of the enums and flags from numbers + into human-readable strings for the Debug messages + + * ircd/engine_poll.c: hack some Debug messages to use the new name + conversion routines in ircd_events.c; add an extra assert for a + condition that shouldn't ever happen; apparently recv() can return + EAGAIN when poll() returns readable--I wonder why... + + * include/ircd_events.h: declare some helper routines under + DEBUGMODE + +2001-05-23 Kevin L. Mitchell + + * ircd/s_bsd.c (client_sock_callback): add an extra assertion + check + + * ircd/s_auth.c: add more Debug messages + + * ircd/list.c (make_client): add an extra assertion check + + * ircd/ircd_events.c (socket_events): don't call the engine events + changer if we haven't actually made any changes to the event mask + + * ircd/uping.c: add some Debug messages + + * ircd/s_stats.c: document new /STATS e + + * ircd/s_err.c: add RPL_STATSENGINE to report the engine name + + * ircd/s_bsd.c: remove static client_timer variable; in + read_packet(), if there's still data in the client's recvQ after + parsing, add a 2 second timer (con_proc); fix the ET_DESTROY case + of client_sock_callback to handle destroying the timer properly; + rewrote client_timer_callback from scratch to be called on an + individual client + + * ircd/m_stats.c: add /STATS e to report the engine name + + * ircd/list.c: deal with con_timer field in struct Connection + properly; correct a core-level bug in remove_client_from_list--if + the client is the only one in the list, we try to update + GlobalClientList's cli_prev pointer--not good + + * ircd/ircd.c: remove call to init_client_timer() + + * ircd/engine_poll.c: made Debug messages more uniform by + prepending "poll:" to them all; corrected an off-by-one error that + caused poll_count to be 1 less than the actual count and removed + my work-around; added Debug messages to indicate which socket is + being checked and what the results are + + * ircd/Makefile.in: ran a make depend + + * include/s_bsd.h: remove init_client_timer(), since we're doing + it differently now + + * include/numeric.h (RPL_STATSENGINE): a stats reply to report the + engine name + + * include/ircd_policy.h (HEAD_IN_SAND_STATS_E): turn off /stats e + reports for non-opers + + * include/client.h: add con_timer and con_proc fields to struct + Connection and define accessor macros--con_timer marks that + con_proc contains a valid timer, and con_proc is used to pace user + data + + * ircd/s_bsd.c (close_connection): let free_client() destroy the + socket + + * ircd/s_auth.c (start_auth): add a Debug call to indicate when + auth has begun on a client + + * ircd/ircd_events.c: ensure that event_execute() is called with a + non-NULL event; modify event_add() macro to properly zero list + bits; modify gen_dequeue() to not try to clip it out of a list + it's already been clipped out of; change signal socket + initialization to use state SS_NOTSOCK; permit timeout values of + 0 in add_timer(); add many Debug calls; change socket_del() and + timer_del() to always set the GEN_DESTROY flag; use GEN_MARKED in + timer_run() instead of GEN_DESTROY so that event_generate() will + pass on the events; remove the switch and replace with a simpler + if-then-else tree in timer_run(); don't allow destroyed sockets to + be destroyed again, nor their states or event masks to be changed + + * ircd/ircd.c: initialize "running" to 1 + + * ircd/engine_poll.c: deal with SS_NOTSOCK "sockets"; add Debug + messages all over the place; fix a counting problem in + engine_add(); turn wait into a signed integer and set it to -1 + only if timer_next() returns 0; adjust wait time to be relative; + don't call gen_ref_dec() if socket disappeared while we were + processing it + + * include/ircd_events.h: the pipe for signals is not a socket, so + we must mark it as such--added SS_NOTSOCK for that special socket; + events won't be generated if GEN_DESTROY is on, so add GEN_MARKED + for the benefit of timer_run() + + * configure.in: add --enable-pedantic and --enable-warnings to + turn on (and off) -Wall -pedantic in CFLAGS + +2001-05-21 Kevin L. Mitchell + + * ircd/s_conf.c: change "s_addr" element accesses to "address" + element accesses + + * include/s_conf.h: on some systems, "s_addr" is a macro; use + "address" instead + +2001-05-18 Kevin L. Mitchell + + * ircd/engine_kqueue.c: include ircd_alloc.h; set_or_clear returns + void in this file; add a missing semi-colon; declare errcode, + codesize + + * ircd/uping.c (uping_sender_callback): it's pptr, not uping + + * ircd/s_user.c (register_user): comment out spurious reference to + nextping + + * ircd/s_serv.c (server_estab): comment out spurious reference to + nextping + + * ircd/s_conf.c (read_configuration_file): comment out spurious + reference to nextping and nextconnect + + * ircd/s_bsd.c: comment out some spurious references to formerly + global (now non-existant) variables; correct a couple of typos + + * ircd/s_auth.c: pre-declare some functions referenced in the + callback; correct a typo + + * ircd/res.c (start_resolver): pass errno value of ENFILE + + * ircd/listener.c (accept_connection): you know your API is messed + up when...variables that shouldn't have been global crop up in + other files + + * ircd/list.c (free_client): substitution of == for = + + * ircd/ircd_signal.c: include assert.h for assertion checking; + check ev_data() to find out what signal generated event + + * ircd/ircd_events.c: some references to the variable "timer" + should have been references to the variable "ptr" + + * ircd/engine_select.c: it's struct fd_set, not struct fdset; + ev_timer(ev) is already a timer pointer; declare codesize as a + size_t to correct signedness issue; use timer_next(), not + time_next() + + * ircd/engine_poll.c: ev_timer(ev) is already a timer pointer; + select fd out of struct pollfd in assertion checking; declare + errcode and codesize; use timer_next(), not time_next() + + * ircd/engine_kqueue.c: ev_timer(ev) is already a timer pointer; + use function timer_next(), not time_next() + + * ircd/engine_devpoll.c: ev_timer(ev) is already a timer pointer; + use function timer_next(), not time_next() + + * ircd/Makefile.in (IRCD_SRC): add ircd_events.c to the list of + compiled sources; do make depend + + * include/list.h: pre-declare struct Connection + + * include/ircd_events.h (gen_ref_inc): cast to the right structure + name + + * include/s_auth.h: duh; missing */ + +2001-05-10 Kevin L. Mitchell + + * ircd/send.c: update write events status after sending data or + accumulating data to be sent + + * ircd/m_list.c (m_list): update write events status after + canceling a running /list + + * ircd/channel.c (list_next_channels): update write events status + after listing a few channels + + * ircd/s_bsd.c: extensive changes to update to new events model; + remove on_write_unblocked() and the two implementations of + read_message(), which have been deprecated by this change + + * ircd/s_auth.c: set the socket events we're interested in for + clients; simplify some logic that does the connect_nonb followed + by the socket_add + + * ircd/list.c: define free_connection() to free a connection + that's become freeable once the struct Socket has been + deallocated; fix up free_client() to take this new behavior into + account + + * ircd/ircd.c: call init_client_timer() + + * include/s_bsd.h: declare new REGISTER_ERROR_MESSAGE when unable + to register connect-in-progress with events system; declare + init_client_timer() (HACK!) to preserve rate-limiting behavior + + * include/list.h: declare new free_connection() + + * include/client.h: add a struct Socket to struct Connection + +2001-05-09 Kevin L. Mitchell + + * ircd/ircd_signal.c: massage the handlers for SIGHUP, SIGINT, and + SIGTERM into event callbacks; perform the actions in the + callbacks, since they're not called in the context of the signal; + set up the signal callbacks in the event engine + + * ircd/ircd_events.c (signal_callback): we're supposed to look for + a specific signal; don't generate an event if there is no signal + structure for it + + * ircd/ircd.c: nuke nextconnect and nextping and replace them with + connect_timer and ping_timer; massage try_connections() and + check_pings() into timer callbacks that re-add themselves at the + right time; remove ircd.c's "event_loop()"; initialize the event + system and the connect_timer and ping_timer + + * ircd/uping.c: correct a couple more typos + + * ircd/s_auth.c: rework to use new events system + + * ircd/os_solaris.c (os_connect_nonb): update to new interface + + * ircd/os_openbsd.c (os_connect_nonb): update to new interface + + * ircd/os_linux.c (os_connect_nonb): update to new interface + + * ircd/os_generic.c (os_connect_nonb): update to new interface + + * ircd/os_bsd.c (os_connect_nonb): update to new interface + + * include/s_auth.h: remove deprecated members of struct + AuthRequest, replacing them with struct Socket and struct Timer + structures; add flags to indicate when these structures have been + released by the event system; remove the deprecated + timeout_auth_queries() + + * include/ircd_osdep.h (os_connect_nonb): connect could complete + immediately, so change the interface to handle that possibility + + * ircd/uping.c (uping_server): noticed and corrected a typo + + * ircd/listener.c: set up to use ircd_event's struct Socket by + adding an socket_add() call to inetport(), replacing + free_listener() with socket_del() in close_listener(), and + reworking accept_connection to be called as the callback + + * ircd/ircd.c: add a call to IPcheck_init() + + * ircd/IPcheck.c: remove IPcheck_expire(); rework + ip_registry_expire() to be called from a timer; write + IPcheck_init() to set up the expiration timer (hard-coded for a + 60-second expiration time) + + * include/listener.h: add a struct Socket to the struct Listener; + remove accept_connection() + + * include/IPcheck.h: add IPcheck_init(), remove IPcheck_expire() + +2001-05-08 Kevin L. Mitchell + + * ircd/ircd_events.c: include config.h; use USE_KQUEUE and + USE_DEVPOLL instead of HAVE_KQUEUE and HAVE_DEVPOLL_H + + * ircd/engine_select.c: include config.h; set FD_SETSIZE to + MAXCONNECTIONS, not IRCD_FD_SETSIZE... + + * ircd/engine_poll.c: include config.h + + * ircd/engine_kqueue.c: include config.h + + * ircd/engine_devpoll.c: include config.h + + * ircd/Makefile.in: include engine sources in compilation and make + depend steps + + * configure.in: add checks for enabling the /dev/poll- and + kqueue-based engines + + * acconfig.h: add lines for USE_DEVPOLL and USE_KQUEUE + + * ircd/Makefile.in: work in the engine sources + +2001-05-07 Kevin L. Mitchell + + * ircd/m_settime.c: include ircd_snprintf.h + + * ircd/ircd_relay.c: stomp a couple of gcc warnings suggesting + parens around a construct that had both || and && + + * ircd/chkconf.c: #include "config.h" to get some important + definitions + + * ircd/Makefile.in: revamp ircd makefile for new build system + + * doc/Makefile.in: revamp doc makefile for new build system + + * config/*: Removed old build system files + + * stamp-h.in: a stamp file + + * install-sh: install-sh for new build system + + * configure.in: configure.in for new build system + + * configure: configure script for new build system (built by + autoconf) + + * config.sub: config.sub for new build system + + * config.h.in: config.h.in for new build system (built by + autoheader) + + * config.guess: config.guess for new build system + + * aclocal.m4: aclocal.m4 for new build system (built by aclocal + 1.4) + + * acinclude.m4: aclocal.m4 macros for new build system + + * acconfig.h: config.h skeleton for new build system + + * Makefile.in: modify for new build system + +2001-05-01 Kevin L. Mitchell + + * ircd/s_err.c: get rid of the last vestiges of TIME_T_FMT + + * ircd/m_settime.c: get rid of the last vestiges of TIME_T_FMT + + * ircd/m_server.c: get rid of the last vestiges of TIME_T_FMT + +2001-05-01 Perry Lorier + * doc/iauth.doc: Protocol for iauth server. (from hybrid). + * doc/linux-poll.patch: Patch to make Linux under 2.2 not deadlock + when you have far far too many sockets in use. + * {include,ircd}/iauth.c: A start on iauth support. + +2001-05-01 Perry Lorier + * ircd/s_err.c: Suggested wording change. + * ircd/s_user.c: Users aren't target limited against +k users. + * ircd/chkconf.c: Made it compile again, who knows if it works, but + now I can at least make install + * various: Cleanups on m_*.c files. + + +2001-04-23 Kevin L. Mitchell + + * ircd/s_misc.c (exit_client): make netsplit server notice say the + right thing + + * ircd/m_links.c (m_links_redirect): forward-port RPL_ENDOFLINKS + change to make Khaled happy... + + * ircd/m_whois.c (do_whois): pull-up of m_whois() fix + (do_whois): duh... + +2001-04-21 Kevin L. Mitchell + + * ircd/msgq.c: finally remove the msgq_integrity() hack, as it's + turned up no more bugs + + * ircd/ircd.c: use /* */ comments instead of // comments--all the + world's not gcc :( + + * ircd/s_conf.c (conf_add_server): use /* */ comments instead of + // comments--all the world's not gcc :( + + * ircd/runmalloc.c: finally garbage-collect unused file + + * include/runmalloc.h: finally garbage-collect unused file + + * ircd/: addition of '#include "config.h"' before + all other includes in most .c files + + * include/: remove includes of config.h, which are + now going into the raw .c files + +2001-04-20 Kevin L. Mitchell + + * ircd/m_whois.c (do_whois): display proper server name if the + user is looking up himself + + * ircd/m_who.c (m_who): disable match by servername or display of + server names by non-opers + + * include/ircd_policy.h: add define for + HEAD_IN_SAND_WHO_SERVERNAME to cover full intent of sub-motion 15 + of CFV 165 + +2001-04-18 Kevin L. Mitchell + + * ircd/s_conf.c: keep the $R in memory so we can see it clearly + when we do a /stats k + + * ircd/s_user.c (set_user_mode): pull-up of changes to prevent + users from turning on +s and +g + + * ircd/s_misc.c (exit_client): pull-up of changes to turn off + net.split notice + + * ircd/parse.c: pull-up of changes to disable /trace, /links, and + /map for users + + * ircd/m_whois.c (do_whois): pull-up of server name masking for + /whois + + * ircd/m_user.c (m_user): removal of umode and snomask defaulting + functions, pull-up + + * ircd/m_stats.c (m_stats): pull-up of stats-disabling stuff + + * ircd/m_map.c (m_map_redirect): pull-up of m_map_redirect() + + * ircd/m_links.c (m_links_redirect): pull-up of m_links_redirect() + + * ircd/channel.c (channel_modes): pull-up of channel key display + as * + + * include/ircd_policy.h: pull-up of ircd_policy.h + + * include/client.h: pull-up of Set/ClearServNotice() + + * ircd/gline.c (do_gline): report client name in G-line message + (pull-up) + + * ircd/s_user.c (register_user): pull-up--show IP address in some + server notices dealing only with users; report which connection + class has filled up + + * ircd/s_stats.c (report_deny_list): use conf->flags & + DENY_FLAGS_IP insteaf of conf->ip_kill + + * ircd/m_stats.c (report_klines): use conf->flags & DENY_FLAGS_IP + insteaf of conf->ip_kill + + * ircd/s_conf.c: use flags field in struct DenyConf; pull-up of + K-line by real name + + * include/s_conf.h: use a flags field in struct DenyConf; define + DENY_FLAGS_FILE, DENY_FLAGS_IP, and DENY_FLAGS_REALNAME for + pull-up of K-line by real name + + * ircd/m_trace.c: pull-up of IP show for user connections + + * doc/example.conf: pull-up of the realname K-line documentation + + * ircd/ircd.c: forward port of pid file advisory locking mechanism + +2001-04-16 Kevin L. Mitchell + + * ircd/send.c (sendcmdto_flag_butone): recast to just broadcast to + all servers, rather than to only servers that have +w/+g/whatever + users on them; among other things, this removes that atrocity + known as sentalong[] from this function + + * ircd/m_admin.c: must include ircd.h to declare "me"; must + include hash.h to declare FindUser() + + * ircd/m_wallusers.c: implementation of WALLUSERS + + * ircd/m_desynch.c (ms_desynch): only send DESYNCHs to opers + + * ircd/m_wallops.c: only send WALLOPS to opers + + * ircd/parse.c: add WALLUSERS command to parser table + + * include/handlers.h: declare wallusers handlers + + * include/msg.h: add WALLUSERS command + + * ircd/send.c (sendcmdto_flag_butone): if FLAGS_OPER is or'd with + flag, send only to appropriate opers + +2001-04-13 Kevin L. Mitchell + + * ircd/uping.c: refit to use the new events interface + + * ircd/res.c: refit to use the new events interface + + * ircd/ircd_events.c: create timer_chg(), which permits a + (non-periodic) timer's expire time to be modified; change the + logic in timer_run() so that timers that were re-added while the + event was being processed will not be destroyed prematurely + + * include/uping.h: include the events header, declare some extra + fields in struct UPing, remove timeout value, and define some + flags for marking which cleanup items have yet to be done + + * include/ircd_events.h: add a prototype for timer_chg() to change + the expire time of a running timer + +2001-03-13 Joseph Bongaarts + * ircd/os_openbsd.c: Tweaked the openbsd hack a bit. + +2001-03-07 Joseph Bongaarts + + * config/configure.in: Add check for OpenBSD + + * ircd/os_openbsd.c: Add seperate os dep file for openbsd which + differs from generic BSD, particularly in its handling of + _XOPEN_SOURCE. + +2001-02-12 Kevin L. Mitchell + + * ircd/m_gline.c (ms_gline): propagate a G-line that happened to + have been added by a U-lined server, rather than going through the + activate/deactivate logic; propagate G-line removals by U-lined + servers as well + + * ircd/gline.c: rename propagate_gline() to gline_propagate(); + make gline_propagate() return an int 0 (convenience return); only + update lastmod in gline_activate() and gline_deactivate() if the + current lastmod is non-zero, since 0 lastmod is our flag of a + U-lined server having added a G-line + + * include/gline.h (gline_propagate): exporting the G-line + propagation function + + * ircd/m_list.c (m_list): duh; permit explicit channel name + specification only when /list gets two arguments ("Kev + #wasteland") rather than when /list gets more than two + arguments--nice braino + +2001-01-29 Thomas Helvey + + * ircd/ircd_reply.c (need_more_params): fix bug that allowed + unregistered clients to spam opers with protocol violation + messages. Note: the bugfix may have eliminated some useful + protocol violation messages. + Please send protocol violation messages explicitly from the + functions they are discovered in, you have much better context + for the error there and it helps to document the behavior of the + server. This was also a design bug in that it violated the + "A function should do one thing" heuristic. Patching this one + would have resulted in a continuous spawning of other bugs over + the next 3 years, so I killed it. Check around for stuff this + broke and readd the calls to protocol_violation in the functions + that need to send the message. + +2001-01-29 Kevin L. Mitchell + + * ircd/channel.c (mode_parse_ban): stopper a tiny leak--if a ban + already existed, then the logic would (attempt to) skip it, but + would not free the ban string; now the ban string is free'd and + the ban count is decremented, releasing the ban for use + + * ircd/s_user.c: make send_umode_out() take a prop argument + instead of testing for the PRIV_PROPAGATE privilege itself; fix + set_umode() to use this new argument, calculating it before + calculating the new privileges for a -o'd user + + * ircd/m_oper.c (m_oper): pass the new prop argument to + send_umode_out() + + * ircd/channel.c (mode_parse_ban): turn off MODE_ADD bit in bans + that we're not actually going to add because they already exist; + test that particular bit before adding to the linked list + + * include/s_user.h: add a prop argument to send_umode_out() to + indicate whether or not to propagate the user mode + +2001-01-24 Kevin L. Mitchell + + * ircd/msgq.c: ircd_vsnprintf() returns the number of bytes that + it would have written; upper-bound the number to prevent overflows + by proxy; also, tune buffer size given to ircd_vsnprintf() to take + into account the fact that ircd_vsnprintf() already takes the + terminal \0 into account + +2001-01-22 Kevin L. Mitchell + + * ircd/msgq.c: add an incredibly ugly hack to attempt to track + down an apparent buffer overflow; remove msgq_map(), since it's no + longer used anywhere; slight tweaks to prevent off-by-one errors, + but these can't explain the problems we've seen + + * include/msgq.h: remove msgq_map(), since it's no longer used + anywhere + +2001-01-18 Kevin L. Mitchell + + * ircd/s_user.c (set_nick_name): call client_set_privs() after + parsing user modes + +2001-01-17 Kevin L. Mitchell + + * ircd/s_bsd.c (read_message): fix a typo in the select version of + read_message() + + * ircd/whowas.c (whowas_free): MyFree() is a macro that expects + its argument to be an lvalue, which means we can't use + whowas_clean()'s handy-dandy "return ww" feature + + * ircd/ircd_features.c: default LOCOP_KILL to TRUE--oops... + +2001-01-16 Kevin L. Mitchell + + * ircd/ircd_events.c (timer_run): it's possible that the timer got + deleted during the callback processing, so don't go to the bother + of requeuing it if the destroy flag is set + + * ircd/engine_select.c: define FD_SETSIZE to be IRCD_FD_SETSIZE + out of config.h if this is a *BSD; include errno.h (oops); + decrement error count after an hour using a timer; use FD_SETSIZE + constant instead of IRCD_FD_SETSIZE constant; fill in event + processing code + + * ircd/engine_poll.c: include errno.h (oops); decrement error + count after an hour using a timer; fill in event processing code + + * ircd/engine_kqueue.c: include errno.h (oops); decrement error + count after an hour using a timer; assert events filter is either + EVFILT_READ or EVFILT_WRITE; fill in event processing code + + * ircd/engine_devpoll.c: include errno.h (oops); decrement error + count after an hour using a timer; fill in event processing code + +2001-01-15 Kevin L. Mitchell + + * ircd/client.c: fixed feattab; basically, when I changed features + to use small integers specifying bit positions, instead of the + bits themselves, I forgot to update feattab to not | these + privileges together; also fixed a bug in the antiprivs masking + loop in client_set_privs()--last index wouldn't get parsed + +2001-01-11 Kevin L. Mitchell + + * ircd/ircd_events.c: call event_generate() with new data + argument; make it set that field in struct Event; make + socket_add() return the value of the eng_add callback + + * ircd/engine_select.c: make engine_add() return a + successful/unsuccessful status; add bounds-checking outside of an + assert; use accessor macros; use log_write(), not the deprecated + ircd_log(); add an assert to engine_loop() to double-check for + data structure corruption + + * ircd/engine_poll.c: make engine_add() return a + successful/unsuccessful status; add bounds-checking outside of an + assert; use accessor macros; use log_write(), not the deprecated + ircd_log(); add an assert to engine_loop() to double-check for + data structure corruption + + * ircd/engine_kqueue.c: implementation of an engine for kqueue() + + * ircd/engine_devpoll.c: implementation of an engine for /dev/poll + + * include/ircd_events.h: define some accessor macros; add ev_data + to struct Event for certain important data--errno values, for + instance; make EngineAdd callback tell us if it was successful or + not; add extra argument to event_generate(); make socket_add() + return the status from EngineAdd + +2001-01-10 Kevin L. Mitchell + + * ircd/ircd_events.c: pass initializer information about how many + total _filedescriptors_ may be opened at once + + * ircd/ircd.c: use exported "running" instead of unexported + thisServer.running + + * ircd/engine_select.c: implementation of an event engine based on + select() + + * ircd/engine_poll.c: implementation of an event engine based on + poll() + + * include/ircd_events.h: pass the engine initializer an integer + specifing how many _filedescriptors_ may be opened at once + + * include/ircd.h: running has to be exported for the engine_* + event loops + +2001-01-09 Kevin L. Mitchell + + * ircd/ircd_events.c: include some needed headers; add some + comments; make evEngines[] const; bundle sig_sock and sig_fd into + a struct named sigInfo; rework struct evInfo to have a queue of + _generators_, and only when threaded; added a gen_init() function + to centralize generator initialization; fix various compile-time + errors; rework event_add() for new queueing scheme and checked for + compile-time errors; add casts where needed; spell evEngines[] + correctly; make engine_name() return const char* + + * include/ircd_events.h: type EventCallBack depends on struct + Event, so pre-declare it; put _event_ queue into generators, and + only when threaded; give engine data a union to store both ints + and pointers; make engine name a const; fix gen_ref_dec() macro; + make engine_name() return a const char* + + * ircd/ircd_events.c: gen_dequeue() is now exported, so move it + down with the non-static functions; modify event_execute() to use + the new gen_ref_dec() to simplify code; make sure event_generate() + does not generate new events for generators marked for destruction + + * include/ircd_events.h: the engines, at least, may need to modify + reference counts to keep generators from going away while + something still points at them, so add reference counter + manipulators and export gen_dequeue() for them + + * ircd/ircd_events.c: set up the list of engines to try; set up + the signal struct Socket; rename netInfo to evInfo; move static + functions near the beginning of the file; do away with + signal_signal() (since we no longer keep a signal count ourselves) + and call event_generate() directly from signal_callback--also + renamed some functions; allow signal_callback() to read up to + SIGS_PER_SOCK at once from the signal pipe; add event_init() to + initialize the entire event system; add event_loop() to call the + engine's event loop; initialize new struct GenHeader member, + gh_engdata; remove timer_next(); add socket_add() function to add + a socket; add socket_del() to mark a socket for deletion; add + socket_state() to transition a socket between states; add + socket_events() to set what events we're interested in on the + socket; add engine_name() to retrieve event engine's name + + * include/ircd_events.h: add engine data field to struct + GenHeader; rename SOCK_ACTION_REMOVE to SOCK_ACTION_DEL; add a + note about states vs s_events; remove signal count; fold union + Generator back into struct Event; remove count members from struct + Generators; redefine engine callbacks to not take a struct + Engine*; add explanatory comments to callback definitions; add + some engine callbacks to handle operations; remove struct Engine + flag member--can detect single flag from eng_signal member; add + event_init(), event_loop(), engine_name(), and the socket_*() + functions; make timer_next() a macro to avoid a function call + +2001-01-08 Kevin L. Mitchell + + * include/ircd_events.h: rename to ircd_events.h, since it handles + events, not just networking stuff; add signal support; more + structural rearrangement + + * ircd/ircd_events.c: rename to ircd_events.c, since it handles + events, not just networking stuff; add signal support; more + structural rearrangement + +2001-01-07 Kevin L. Mitchell + + * ircd/ircd_network.c: implement timer API; add reference counts + appropriately + + * include/ircd_network.h: firm up some pieces of the interface; + split out members everything has into a separate structure; add + reference counts; add timer API + +2001-01-06 Kevin L. Mitchell + + * ircd/ircd_network.c: static data and event manipulation + functions for new event processing system + + * include/ircd_network.h: data structures for new event processing + system + +2001-01-03 Kevin L. Mitchell + + * ircd/whowas.c: Completely re-did the old allocation scheme by + turning it into a linked list, permitting the + NICKNAMEHISTORYLENGTH feature to be changed on the fly + + * ircd/s_debug.c (count_memory): use FEAT_NICKNAMEHISTORYLENGTH + feature instead of old #define + + * ircd/ircd_features.c: add NICKNAMEHISTORYLENGTH feature as an + integer feature with a notify callback (whowas_realloc) + + * ircd/client.c (client_set_privs): second memset was supposed to + be over antiprivs, not privs; thanks, Chris Behrens + for pointing that out... + + * include/whowas.h: new elements for an extra linked list in + struct Whowas; a notify function for feature value changes + + * include/ircd_features.h: new feature--FEAT_NICKNAMEHISTORYLENGTH + + * config/config-sh.in: NICKNAMEHISTORYLENGTH is now a feature + +2001-01-02 Kevin L. Mitchell + + * config/config-sh.in: get rid of DEFAULT_LIST_PARAMETER + compile-time option--now in features subsystem + + * ircd/motd.c (motd_init): rework motd_init() to be called as the + notify function for MPATH and RPATH features (should probably + split it up a bit, though...) + + * ircd/m_privs.c (mo_privs): if called with no parameters, return + privs of the caller, rather than an error + + * ircd/m_list.c: pull usage message into its own function; pull + list parameter processing into its own function that does not + modify the contents of the parameter; add list_set_default() to + set the default list parameter (uses the notify hook); rework + m_list() to make use of these functions; removed dead code + + * ircd/ircd_log.c (log_feature_mark): make sure to return 0, since + we have no notify handler + + * ircd/ircd_features.c: add notify callback for notification of + value changes; give mark callback an int return value to indicate + whether or not to call the notify callback; fix up feature macros + for new notify callback; add DEFAULT_LIST_PARAM feature; rewrite + string handling in feature_set() to deal with def_str being a null + pointer; wrote feature_init() to set up all defaults appropriately + + * ircd/ircd.c (main): call feature_init() instead of + feature_mark(), to avoid calling notify functions while setting up + defaults + + * ircd/client.c: updated to deal with new privileges structure + + * ircd/class.c: updated so init_class() can be called should one + of PINGFREQUENCY, CONNECTFREQUENCY, MAXIMUM_LINKS, or + DEFAULTMAXSENDQLENGTH be changed + + * include/ircd_log.h: log_feature_mark() updated to fit with new + API changes + + * include/ircd_features.h: added DEFAULT_LIST_PARAM feature and + feature_init() function (found necessary since adding the notify + stuff and notifying motd.c during start-up...before we defined + RPATH!) + + * include/client.h: move privs around to enable addition of more + bits if necessary; based on the FD_* macros + + * include/channel.h: declare list_set_default (actually located in + m_list.c *blanche*) + + * ircd/s_user.c: retrieve MAXSILES and MAXSILELENGTH (now + AVBANLEN*MAXSILES) from features subsystem + + * ircd/s_debug.c (debug_serveropts): CMDLINE_CONFIG doesn't go to + anything anymore + + * ircd/s_bsd.c: retrieve HANGONGOODLINK and HANGONRETRYDELAY from + the features subsystem + + * ircd/s_auth.c (start_auth): NODNS migrated to the features + subsystem + + * ircd/random.c: created random_seed_set() function to set seed + value, along with some stuff to make ircrandom() a little more + random--state preserving, xor of time instead of direct usage, + etc.; it's still a pseudo-random number generator, though, and + hopefully I haven't broken the randomness + + * ircd/m_version.c: FEATUREVALUES makes use of feature_int() calls + + * ircd/m_join.c: use features interface to retrieve + MAXCHANNELSPERUSER + + * ircd/ircd_features.c: add NODISP flag for super-secret features; + add a whole bunch of new features migrated over from make config + + * ircd/ircd.c: use features interface to retrieve PINGFREQUENCY, + CONNECTTIMEOUT, and TIMESEC + + * ircd/client.c (client_get_ping): use features interface to + retrieve PINGFREQUENCY + + * ircd/class.c: use features interface to retrieve PINGFREQUENCY, + CONNECTFREQUENCY, MAXIMUM_LINKS, and DEFAULTMAXSENDQLENGTH + + * ircd/chkconf.c (DEFAULTMAXSENDQLENGTH): since it's now in the + features subsystem, we have to add something explicit + + * ircd/channel.c: use features interface to retrieve + KILLCHASETIMELIMIT, MAXBANLENGTH, MAXBANS, and MAXCHANNELSPERUSER; + note that MAXBANLENGTH is now calculated dynamically from MAXBANS + and AVBANLEN + + * ircd/Makefile.in: run make depend + + * include/supported.h (FEATURESVALUES): update to reference + feature settings + + * include/random.h: add prototype for random_seed_set + + * include/ircd_features.h: add several more features + + * include/channel.h: move MAXBANS and MAXBANLENGTH into feature + subsystem + + * config/config-sh.in: feature-ized some more stuff + + * include/motd.h: some new elements in motd.h for motd.c changes + + * ircd/motd.c: motd_cache() now searches a list of already cached + MOTD files; saves us from having duplicate caches in memory if + there are two identical T-lines for two different sites... + +2001-01-02 Perry Lorier + * ircd/motd.c: don't core if the motd isn't found. Bug found by + Amarande. + +2001-01-02 Perry Lorier + * ircd/s_err.c: Added third param to 004 - the channel modes that tage params. Used by hybrid/epic. + * ircd/s_channels.c: Added fix for msg'ing a -n+m channel - thanks + to guppy for noticing, and hektik for providing the fix. + * misc others: Minor cleanups, added more protocol_violations, ripped + out more P09 stuffs, bit more protocol neg stuff. + +2000-12-19 Kevin L. Mitchell + + * ircd/m_ison.c (m_ison): Dianora says that ISON has to end with a + space (*sigh* stupid clients...) + + * ircd/s_user.c: make WALLOPS_OPER_ONLY a feature managed through + ircd_features.[ch] + + * ircd/s_err.c: get rid of GODMODE conditionals + + * ircd/s_debug.c (debug_serveropts): switch to using appropriate + calls into the features subsystem for various serveropts + characters + + * ircd/s_conf.c (find_conf_entry): get rid of USEONE conditional + + * ircd/s_bsd.c: remove GODMODE conditional; use features subsystem + to get value of VIRTUAL_HOST and CLIENT_FLOOD; remove + NOFLOWCONTROL conditional + + * ircd/s_auth.c: use features subsystem to determine value of + KILL_IPMISMATCH + + * ircd/parse.c: get rid of NOOPER and GODMODE conditionals; use + features subsystem to determine the setting of IDLE_FROM_MSG + + * ircd/numnicks.c: get rid of EXTENDED_NUMERICS conditionals + + * ircd/motd.c: get value of NODEFAULTMOTD from features subsystem; + use features subsystem to get motd file names + + * ircd/m_settime.c: get value of RELIABLE_CLOCK from features + subsystem + + * ircd/m_server.c: get rid of CRYPT_LINK_PASSWORD, since it does + us no good; use features subsystem to figure out if we need to do + HUB-type stuff; make TESTNET debugging sendto_opmask_butone's use + the Debug(()) macro instead; get value of RELIABLE_CLOCK from + features subsystem + + * ircd/m_privmsg.c: get IDLE_FROM_MSG from the features subsystem + + * ircd/m_oper.c: get CRYPT_OPER_PASSWORD from the features + subsystem + + * ircd/m_connect.c: get SERVER_PORT from the features subsystem + + * ircd/ircd_log.c (log_set_file): fix a bug that kept log files + from getting marked if they were already set to something... + + * ircd/ircd_features.c: add a flag to indicates read-only access; + add several new features that used to be compile-time selected + + * ircd/ircd.c: grab pidfile out of feature subsystem; don't check + access to motd files (what the heck?); make sure to initialize the + feature subsystem before trying to write the config file + + * ircd/dbuf.c: use feature_int() to retrieve BUFFERPOOL settings; + use feature_bool() to figure out if we're using the FERGUSON + flusher + + * ircd/Makefile.in: MPATH and RPATH are now done differently, so + remove the clause that creates empty files of that name; also ran + make depend + + * include/sys.h: CLIENT_FLOOD is now a feature; unfortunately, + there is no easy way to bounds-check it at present + + * include/querycmds.h: make sure ircd_features.h is included; use + feature_str(FEAT_DOMAINNAME) in calls to match() + + * include/ircd_features.h: many new features that used to be + compile-time selected + + * config/config-sh.in: add * to DOMAINNAME; try also using first + argument to search in /etc/resolv.conf; removed many compile-time + options that now can be configured through the features system + +2000-12-18 Kevin L. Mitchell + + * doc/api/log.txt: how to use the logging API + + * doc/api/features.txt: how to use the features API + + * doc/api/api.txt: how to write API documentation + + * include/ircd_features.h: rearranged a couple of features for + neatness purposes + + * ircd/ircd_features.c: cleaned up the macros some; rearranged + some code to all go into the switch; rearranged a couple of + features for neatness purposes + +2000-12-16 Greg Sikorski + * ircd/os_bsd.c: Added os_set_tos for BSD users. + +2000-12-16 Kevin L. Mitchell + + * ircd/ircd_features.c: Isomer almost got it right; you need to + use F_I(), since it's an integer value, not a boolean value. The + asserts in feature_int would catch you out... Also made the F_* + macros take flags + + * ircd/s_err.c: define RPL_PRIVS reply + + * ircd/parse.c: put new PRIVS command into command table + + * ircd/m_privs.c (mo_privs): message handler to report operator + privileges + + * ircd/ircd_features.c: declare new features OPER_SET and + LOCOP_SET; redo boolean testing routine to accept TRUE, YES, and + ON for boolean TRUE, and FALSE, NO, and OFF for boolean FALSE + + * ircd/client.c: simplify client_set_privs() with a table that + defines what features to test for; add new client_report_privs() + + * ircd/Makefile.in: compile new m_privs.c; run make depend + + * include/numeric.h (RPL_PRIVS): new reply numeric for displaying + an operator's privileges + + * include/msg.h: define new command: PRIVS + + * include/ircd_features.h: create new features OPER_SET and + LOCOP_SET for controlling access to /set + + * include/handlers.h (mo_privs): declare message handler for + reporting oper privileges + + * include/client.h (client_report_privs): declare function to + report what privileges an oper has + + * ircd/m_whois.c (do_whois): fix a bug that caused /whois to + report that a user is an oper if the oper doing the /whois had + PRIV_SEE_OPERS + +2000-12-17 Isomer + * ircd/listener.c: added support for TOS twiddling as a 'feature'. + +2000-12-17 Isomer + * ircd/os_linux.c: add TOS stuffs + + * ircd/listener.c: add TOS stuffs + +2000-12-16 Kevin L. Mitchell + + * ircd/whocmds.c (do_who): use HasPriv to determine whether or not + to indicate a user is an oper + + * ircd/s_user.c: clear privileges setting when deopping; don't + propagate +o unless user has PRIV_PROPAGATE privilege + + * ircd/s_debug.c (debug_serveropts): created debug_serveropts() + function and replaced how the server option string is generated + + * ircd/parse.c: remove conditional on CONFIG_OPERCMDS + + * ircd/m_whois.c (do_whois): use HasPriv to determine whether or + not to indicate the user is an operator + + * ircd/m_who.c: use HasPriv to determine whether or not a user + should be displayed in the list of opers + + * ircd/m_version.c: call debug_serveropts() to get server option + string + + * ircd/m_userip.c (userip_formatter): use HasPriv to determine + whether or not to show oper status + + * ircd/m_userhost.c (userhost_formatter): use HasPriv to determine + whether or not to show oper status + + * ircd/m_restart.c (mo_restart): replace ugly #ifdef conditional + checks with HasPriv check; remove dead code + + * ircd/m_rehash.c (mo_rehash): replace ugly #ifdef conditional + checks with HasPriv check + + * ircd/m_opmode.c (mo_opmode): use HasPriv to check permissions; + use feature_bool to check if disabled + + * ircd/m_oper.c (m_oper): set oper priviliges + + * ircd/m_mode.c (m_mode): replace #ifdef conditional with HasPriv + check + + * ircd/m_kill.c (mo_kill): use HasPriv checks to determine if we + can kill + + * ircd/m_kick.c (m_kick): replace #ifdef conditional with HasPriv + check + + * ircd/m_jupe.c (mo_jupe): rework permissions checking structure; + use feature_bool to check if disabled + + * ircd/m_join.c (m_join): remove BADCHAN conditional; replace + #ifdef conditional with a HasPriv check + + * ircd/m_gline.c (mo_gline): rework permissions checking + structure; use feature_bool to check if any part is disabled + + * ircd/m_die.c: replace ugly #ifdef conditionals with HasPriv + check; remove dead code + + * ircd/m_clearmode.c: use feature_bool() to detect if we're + disabled; use HasPriv to figure out what we're permitted to do; + only allow clearmode on moded channels + + * ircd/ircd_features.c: define various features; use HasPriv to + verify permissions to set/reset + + * ircd/gline.c (gline_add): use HasPriv instead of #ifdef + conditionals + + * ircd/client.c (client_set_privs): function to set an oper's + privileges + + * ircd/channel.c: use HasPriv calls instead of #ifdef conditionals + + * include/whocmds.h: deconditionalize several macros and + substitute appropriate calls to HasPriv() + + * include/s_debug.h: get rid of global serveropts[]; define new + function debug_serveropts() to build that string on the fly + + * include/ircd_features.h: define some features + + * include/client.h: add privs member to struct Connection; define + various priviledges + + * include/channel.h: no longer using IsOperOnLocalChannel; remove + conditional of MAGIC_OPER_OVERRIDE on OPER_WALK_THROUGH_LMODES + + * doc/Configure.help: remove help information for deprecated + options + + * config/config-sh.in: remove certain deprecated options having to + do with what opers can and cannot do--first stage in moving + compile-time constants into the .conf + +2000-12-16 Isomer + * ircd/parse.c: detect if the prefix is missing and try and recover + instead of coring. + +2000-12-15 Kevin L. Mitchell + + * ircd/ircd_log.c: found and fixed some bugs in the debug logging + code that would sometimes result in the log file not being + reopened--which meant that a user could connect and get the + logging output--oops + + * ircd/Makefile.in: run make depend... + + * ircd/s_stats.c: get rid of report_feature_list() + + * ircd/s_err.c: add the 'bad value' error message, shift error + messages over somewhat + + * ircd/s_debug.c (debug_init): call log_debug_init with the + use_tty flag + + * ircd/s_conf.c (read_configuration_file): unmark features before + reading the config file, then reset unmarked features after + reading the config file + + * ircd/m_stats.c: use feature_report() instead of + report_feature_list() + + * ircd/ircd_log.c: fix log_debug_file (bogus assertion); add + special 'mark' flags and use them; add the stuff needed by the + features API + + * ircd/ircd_features.c: rework the features API and add gobs of + comments to try to explain what some of these complex functions + are actually doing + + * include/s_stats.h: get rid of report_feature_list(); use + feature_report() instead + + * include/numeric.h: added a new error message and shifted old + values over some--this is, after all, an alpha + + * include/ircd_log.h: log_debug_init now takes an integer to tell + it if it should be using the tty; added a couple of functions + required by the features API + + * include/ircd_features.h: add an enum and some more functions to + flesh out the feature API--it should now be possible to put all + those compile-time constants in the config file! + + * ircd/send.c: got the direction of the assert incorrect... + + * ircd/send.c: implement the efficiency of flush_connections by + creating a linked list of struct Connection's with queued data; + also get rid of flush_sendq_except and make sure to yank + connections out of the list when their sendQs become empty (notice + the assertion in flush_connections!) + + * ircd/s_bsd.c (close_connection): must yank the Connection out of + the sendq list + + * ircd/list.c (dealloc_connection): must yank the Connection out + of the sendq list + + * ircd/dbuf.c (dbuf_put): call flush_connections instead of the + deprecated flush_sendq_except + + * ircd/client.c: define a couple new helper functions for sendq + threading--this will make the flush_connections function in send.c + considerably more efficient by creating a linked list of + Connections that have queued data to send + + * include/send.h: remove flush_sendq_except, as it's not used + anymore + + * include/client.h: declare a couple new helper functions for the + sendq threading system + +2000-12-14 Kevin L. Mitchell + + * ircd/m_ison.c (m_ison): Apply Diane Bruce's patch to make ISON + parse all arguments + + * ircd/s_debug.c (count_memory): modify to report for clients and + connections, not local clients and remote clients + + * ircd/list.c: fiddle with the client-fiddling functions to take + into account the divorce of struct Connection from struct Client + + * ircd/ircd.c: define a struct Connection for me, initialize it, + and link it into the right place (ewww, globals!) + + * include/client.h: remove CLIENT_{LOCAL,REMOTE}_SIZE; split + struct Client into struct Client and struct Connection; redefine + local-portion accessor macros to go through struct Client to the + struct Connection; define struct Connection accessor macros + +2000-12-13 Kevin L. Mitchell + + * ircd/whowas.c: missed a couple of accesses to a struct Client + + * ircd/uping.c: missed a couple of accesses to a struct Client + + * ircd/send.c: missed a couple of accesses to a struct Client + + * ircd/s_user.c: missed a couple of accesses to a struct Client + + * ircd/s_misc.c: missed a couple of accesses to a struct Client + + * ircd/s_conf.c: missed a couple of accesses to a struct Client + + * ircd/s_bsd.c: missed a couple of accesses to a struct Client + + * ircd/s_auth.c: missed a couple of accesses to a struct Client + + * ircd/res.c: missed a couple of accesses to a struct Client + + * ircd/parse.c: missed a couple of accesses to a struct Client + + * ircd/m_whois.c: use new accessor macros for struct Client + + * ircd/m_who.c: use new accessor macros for struct Client + + * ircd/m_wallchops.c: use new accessor macros for struct Client + + * ircd/m_version.c: use new accessor macros for struct Client + + * ircd/m_userip.c: use new accessor macros for struct Client + + * ircd/m_userhost.c: use new accessor macros for struct Client + + * ircd/m_user.c: use new accessor macros for struct Client + + * ircd/m_uping.c: use new accessor macros for struct Client + + * ircd/m_trace.c: use new accessor macros for struct Client + + * ircd/m_topic.c: use new accessor macros for struct Client + + * ircd/m_time.c: use new accessor macros for struct Client + + * ircd/m_stats.c: use new accessor macros for struct Client + + * ircd/m_squit.c: use new accessor macros for struct Client + + * ircd/m_silence.c: use new accessor macros for struct Client + + * ircd/m_server.c: use new accessor macros for struct Client; + remove dead code + + * ircd/m_rpong.c: use new accessor macros for struct Client + + * ircd/m_rping.c: use new accessor macros for struct Client + + * ircd/m_quit.c: use new accessor macros for struct Client + + * ircd/m_privmsg.c: use new accessor macros for struct Client + + * ircd/m_pong.c: use new accessor macros for struct Client; remove + dead code + + * ircd/m_ping.c: use new accessor macros for struct Client + + * ircd/m_pass.c: use new accessor macros for struct Client + + * ircd/m_part.c: use new accessor macros for struct Client + + * ircd/m_oper.c: use new accessor macros for struct Client + + * ircd/m_notice.c: use new accessor macros for struct Client + + * ircd/m_nick.c: use new accessor macros for struct Client + + * ircd/m_names.c: use new accessor macros for struct Client + + * ircd/m_mode.c: use new accessor macros for struct Client + + * ircd/m_map.c: use new accessor macros for struct Client + + * ircd/m_list.c: use new accessor macros for struct Client + + * ircd/m_links.c: use new accessor macros for struct Client; + remove some dead code + + * ircd/m_kill.c: use new accessor macros for struct Client; remove + some dead code + + * ircd/m_kick.c: use new accessor macros for struct Client + + * ircd/m_join.c: use new accessor macros for struct Client; remove + some dead code + + * ircd/m_ison.c: use new accessor macros for struct Client + + * ircd/m_invite.c: use new accessor macros for struct Client + + * ircd/m_info.c: use new accessor macros for struct Client + + * ircd/m_gline.c: use new accessor macros for struct Client + + * ircd/m_error.c: use new accessor macros for struct Client + + * ircd/m_create.c: use new accessor macros for struct Client + + * ircd/m_connect.c: use new accessor macros for struct Client; + removed some dead code + + * ircd/m_burst.c: use new accessor macros for struct Client + + * ircd/m_away.c: use new accessor macros for struct Client + + * ircd/m_admin.c: use new accessor macros for struct Client + + * ircd/hash.c: missed a couple of accesses to a struct Client + + * ircd/gline.c: missed a couple of accesses to a struct Client + + * ircd/crule.c: missed a couple of accesses to a struct Client + + * ircd/class.c: missed an access to a struct Client + + * ircd/channel.c: missed a couple of accesses to a struct Client + + * ircd/IPcheck.c: missed an access to a struct Client + + * include/querycmds.h: fix a couple of stats macros to use + structure accessor macros + + * include/client.h: change structure member names to highlight any + places in the code I've missed + +2000-12-12 Kevin L. Mitchell + + * ircd/whowas.c: use new struct Client accessor macros + + * ircd/whocmds.c: use new struct Client accessor macros + + * ircd/send.c: use new struct Client accessor macros + + * ircd/s_user.c: use new struct Client accessor macros; removed + some dead code + + * ircd/s_serv.c: use new struct Client accessor macros; removed + some dead code + + * ircd/s_numeric.c: use new struct Client accessor macros + + * ircd/s_misc.c: use new struct Client accessor macros + + * ircd/s_debug.c: use new struct Client accessor macros + + * ircd/s_conf.c: use new struct Client accessor macros + + * ircd/s_bsd.c: use new struct Client accessor macros + + * ircd/s_auth.c: use new struct Client accessor macros + + * ircd/parse.c: use new struct Client accessor macros + + * ircd/packet.c: use new struct Client accessor macros + + * ircd/numnicks.c: use new struct Client accessor macros + + * ircd/motd.c: use new struct Client accessor macros + + * ircd/listener.c: use new struct Client accessor macros + + * ircd/list.c: use new struct Client accessor macros + + * ircd/jupe.c: use new struct Client accessor macros + + * ircd/ircd_snprintf.c: use new struct Client accessor macros + + * ircd/ircd_reply.c: use new struct Client accessor macros + + * ircd/ircd_relay.c: use new struct Client accessor macros + + * ircd/ircd.c: use new struct Client accessor macros + + * ircd/gline.c: catch some instances of me. I missed + previously + + * ircd/client.c: use cli_ instead of con_ + + * ircd/class.c: use cli_ instead of con_ + + * ircd/channel.c: use cli_ instead of con_ + + * ircd/IPcheck.c: use cli_ instead of con_; catch some instances + of me. I missed previously + + * include/client.h: use cli_ instead of con_...seemed like a good + idea at the time *shrug* + +2000-12-11 Kevin L. Mitchell + + * ircd/hash.c: use struct Client accessor macros + + * ircd/gline.c: use struct Client accessor macros + + * ircd/crule.c: use struct Client accessor macros + + * ircd/client.c: use struct Client accessor macros; remove some + dead code + + * ircd/class.c: use struct Client accessor macros + + * ircd/channel.c: use struct Client accessor macros; remove some + dead code + + * ircd/IPcheck.c: use struct Client accessor macros + + * include/numnicks.h: use struct Client accessor macros + + * include/client.h: first step to divorcing struct Client and + struct Connection--define accessor macros and use them + + * ircd/gline.c: When Uworld removed Uworld-set G-lines, only the + uplink would remove them. This is because the removal protocol + message wasn't being sent to the uplinks. This is fixed by fixing + propagate_gline() to send the proper number of arguments depending + on whether or not we're adding or deleting the Uworld gline, and + by having gline_deactivate() make sure to turn off the active bit + and call propagate_gline() if it's a Uworld gline + +2000-12-10 Kevin L. Mitchell + + * ircd/os_generic.c: make sure IOV_MAX gets defined, just in case + + * ircd/os_bsd.c: apparently BSD doesn't have IOV_MAX defined + anywhere intelligent... + +2000-12-09 Kevin L. Mitchell + + * ircd/send.c (send_queued): call deliver_it with appropriate + arguments + + * ircd/s_serv.c: reorder a couple of headers--cosmetic + + * ircd/s_bsd.c (deliver_it): make deliver_it work with a struct + MsgQ + + * ircd/os_solaris.c (os_sendv_nonb): function for calling writev + with appropriate iovec + + * ircd/os_linux.c (os_sendv_nonb): function for calling writev + with appropriate iovec + + * ircd/os_generic.c (os_sendv_nonb): function for calling writev + with appropriate iovec + + * ircd/os_bsd.c (os_sendv_nonb): function for calling writev with + appropriate iovec + + * ircd/msgq.c (msgq_mapiov): add a len_p argument for totalling up + exactly how much we're trying to write out to the fd + + * include/s_bsd.h: make deliver_it take a struct MsgQ + + * include/msgq.h: add a len_p argument to msgq_mapiov to help + detect short writes that indicate possible socket blocking + + * include/ircd_osdep.h: declare os_sendv_nonb() + + * ircd/channel.c (modebuf_mode): don't add empty modes... + +2000-12-08 Kevin L. Mitchell + + * include/send.h: add prio argument to send_buffer to select + between normal and priority queues + + * ircd/s_user.c (send_user_info): add prio argument to send_buffer + call + + * ircd/m_ison.c (m_ison): add prio argument to send_buffer call + + * ircd/ircd_reply.c (send_reply): add prio argument to send_buffer + call + + * ircd/channel.c (send_channel_modes): add prio argument to + send_buffer call + + * ircd/send.c (send_buffer): add a prio argument to select the + priority queue; update send.c functions to use it + + * ircd/msgq.c (msgq_add): remove msgq_prio; fold msgq_link and + msgq_add; add a prio argument to msgq_add to select the priority + queue + + * include/msgq.h: remove msgq_prio; add a prio argument to + msgq_add + + * ircd/send.c: remove sendbuf; remove GODMODE code; switch to + using msgq functions instead of dbuf functions; remove old, dead + sendto_* functions; redo send_buffer to take a struct MsgBuf; + rework sendcmdto_* functions to make use of the new struct MsgBuf + + * ircd/s_user.c: remove hunt_server; restructure send_user_info to + make appropriate use of struct MsgBuf + + * ircd/s_debug.c (count_memory): count memory used by the MsgQ + system and report it + + * ircd/s_conf.c (read_configuration_file): use + sendto_opmask_butone instead of the now dead sendto_op_mask + + * ircd/s_bsd.c: switch to using appropriate MsgQLength and other + calls on sendQ + + * ircd/parse.c (parse_server): get rid of a piece of GODMODE code + + * ircd/msgq.c: add msgq_append and msgq_bufleft; fix a bug in + msgq_clean + + * ircd/m_version.c: fix spelling in comments marking dead code + + * ircd/m_userip.c (userip_formatter): restructure to make use of + struct MsgBuf + + * ircd/m_userhost.c (userhost_formatter): restructure to make use + of struct MsgBuf + + * ircd/m_stats.c: use MsgQLength on a sendQ + + * ircd/m_settime.c: use MsgQLength instead of DBufLength on a + sendQ; mark a piece of dead code + + * ircd/m_names.c: use send_reply instead of sendto_one + + * ircd/m_mode.c: use new mode; remove old dead code + + * ircd/m_ison.c (m_ison): restructure to make use of struct MsgBuf + + * ircd/m_burst.c: use BUFSIZE instead of IRC_BUFSIZE; remove old + dead code + + * ircd/listener.c (accept_connection): use sendto_opmask_butone + instead of sendto_op_mask + + * ircd/list.c (free_client): use MsgQClear to clear sendQ + + * ircd/ircd_reply.c: remove send_error_to_client; restructure + send_reply to make use of struct MsgBuf + + * ircd/dbuf.c (dbuf_put): remove argument to flush_sendq_except, + since its no longer used (at least currently) + + * ircd/channel.c: restructure send_channel_modes to make use of + struct MsgBuf; remove set_mode, add_token_to_sendbuf, cancel_mode, + and send_hack_notice; use BUFSIZE instead of IRC_BUFSIZE + + * ircd/Makefile.in: add msgq.c to list of sources; run make depend + + * ircd/IPcheck.c: use sendcmdto_one instead of sendto_one + + * include/send.h: send_buffer now takes a struct MsgBuf * instead + of a char *; flush_sendq_except now takes no arguments, as sendq + flushing currently only happens in dbuf.h and sendQ is a struct + MsgQ; remove prototypes for a lot of old sendto_* functions that + aren't used anymore; remove sendbuf and IRC_BUFSIZE--the former is + no longer needed, and the latter is identical to BUFSIZE in + ircd_defs.h + + * include/s_user.h: make InfoFormatter take a struct MsgBuf* + instead of a char *; also make it return void, instead of char * + + * include/msgq.h: add msgq_append and msgq_bufleft functions + + * include/client.h: use a struct MsgQ instead of a struct DBuf for + sendq + + * doc/Configure.help: Remove help for compile-time options that + have gone away + + * config/config-sh.in: remove CONFIG_NEWMODE + + * ircd/m_server.c (mr_server): don't send server IPs in any server + notices + + * ircd/msgq.c (msgq_vmake): add \r\n to messages + +2000-12-07 Kevin L. Mitchell + + * include/msgq.h: declare the MsgQ API + + * ircd/msgq.c: implementation of new MsgQ system + +2000-12-06 Kevin L. Mitchell + + * ircd/ircd_features.c: #include was supposed to be for + ircd_features.h, not features.h--missed when I had to do a + rename because of namespace collision + +2000-12-05 Greg Sikorski + * ircd/m_topic.c: Added missing braces that caused all remote + topics to be ignored. + +2000-12-04 Kevin L. Mitchell + + * ircd/m_create.c: I'm tired of the exit_client warning :) + (ms_create): discovered that exit_client() was being called with + too few arguments + + * ircd/s_misc.c (exit_client): remove all dependance on + FNAME_USERLOG, since that's now gone; log only to LS_USER + + * ircd/s_debug.c: USE_SYSLOG no longer means anything + + * ircd/m_oper.c (m_oper): no longer log to LS_OPERLOG--we already + log to LS_OPER + + * ircd/m_kill.c: no longer conditionalize on SYSLOG_KILL + + * ircd/ircd_log.c: remove LS_OPERLOG, LS_USERLOG + + * include/ircd_log.h: remove LS_OPERLOG, LS_USERLOG--they serve + the same purpose as LS_USER and LS_OPER + + * config/config-sh.in: remove no longer relevant log config + variables + + * ircd/uping.c (uping_init): use log_write instead of ircd_log + + * ircd/s_misc.c (exit_client): use log_write instead of ircd_log + + * ircd/s_conf.c: use log_write instead of ircd_log + + * ircd/s_bsd.c (report_error): use log_write instead of ircd_log + + * ircd/s_auth.c (timeout_auth_queries): use log_write instead of + ircd_log + + * ircd/res.c (send_res_msg): use log_write instead of ircd_log + + * ircd/m_who.c: use log_write instead of write_log; no longer + conditionalize on WPATH; mark dead ircd_log calls + + * ircd/m_uping.c: mark dead ircd_log call + + * ircd/m_server.c (mr_server): use log_write instead of ircd_log + + * ircd/m_restart.c: use log_write instead of ircd_log; mark dead + ircd_log calls + + * ircd/m_rehash.c (mo_rehash): use log_write instead of ircd_log + + * ircd/m_oper.c: use log_write instead of ircd_log; no longer + conditionalize on FNAME_OPERLOG; mark dead ircd_log calls + + * ircd/m_kill.c: mark dead ircd_log calls + + * ircd/m_connect.c: use log_write instead of ircd_log; mark dead + ircd_log + + * ircd/m_clearmode.c: use log_write instead of write_log; no + longer conditionalize on OPATH + + * ircd/jupe.c: use log_write instead of write_log; no longer + conditionalize on JPATH + + * ircd/ircd_log.c: add USER subsystem; remove ircd_log() compat + function; fix a couple of bugs + + * ircd/ircd_alloc.c: fixed a comment + + * ircd/ircd.c: use log_write instead of ircd_log; fold server + notice generation in a couple of cases + + * ircd/gline.c: use log_write instead of write_log; no longer + conditionalize on GPATH + + * ircd/channel.c (modebuf_flush_int): use log_write instead of + write_log; no longer conditionalize on OPATH + + * ircd/Makefile.in: run make depend, since dependencies have + changed + + * doc/example.conf: add system USER to documentation + + * include/ircd_log.h: add system USER; remove old ircd_log() + declarations + +2000-12-04 Isomer + * ircd/m_names.c: Add NAMES_EON to do_names to say add a + 'end_of_names' reply when done. + * ircd/m_join.c: use NAMES_EON as mentioned above + +2000-12-01 net + + * ircd/motd.c: add a freelist for struct Motds + +2000-11-30 Kevin L. Mitchell + + * ircd/s_stats.c (report_feature_list): report features--only + local opers can see logging configuration, since it doesn't really + mean anything to users + + * ircd/s_err.c: add reply messages for new feature subsystem + + * ircd/s_conf.c: add F lines to .conf + + * ircd/parse.c: add the message descriptions for /set, /reset, and + /get + + * ircd/m_stats.c: add /stats f + + * ircd/m_set.c (mo_set): implement /set + + * ircd/m_reset.c (mo_reset): implement /reset + + * ircd/m_rehash.c: /rehash m now flushes MOTD cache, and /rehash l + reopens log files (for log file rotation) + + * ircd/m_get.c (mo_get): implement /get + + * ircd/ircd_log.c: use int instead of void return value; add + log_report_features() and log_canon(); fix a function that + disappears if DEBUGMODE not #define'd + + * ircd/ircd_features.c: functions to manipulate feature settings + either from the config file or with the new /set, /reset, and /get + commands + + * ircd/Makefile.in: add new .c files, run make depend + + * include/s_stats.h: declare report_feature_list() (/stats f + handler) + + * include/numeric.h: add RPL_STATSFLINE, RPL_FEATURE, + ERR_NOFEATURE, ERR_BADLOGTYPE, ERR_BADLOGSYS, and ERR_BADLOGVALUE + reply numerics + + * include/msg.h: add defines for SET, RESET, and GET + + * include/ircd_log.h: add a function to canonicalize subsystem + names; change some void return values to int + + * include/ircd_features.h: new features subsystem handles all the + manipulation of special features, like log files + + * include/handlers.h: declare new mo_{s,res,g}et message handlers + for fiddling with features run-time + + * include/client.h (SNO_DEFAULT): don't set SNO_DEBUG by default; + seemed like a good idea at the time... + + * doc/example.conf: document new F lines + +2000-11-29 Kevin L. Mitchell + + * ircd/s_debug.c: rewrite debug_init() and vdebug() in terms of + new logging functions, which have special support for the debug + log; added loop detection to vdebug(), so that I can + sendto_opmask_butone() from log_vwrite() without incurring another + call to vdebug() + + * ircd/s_conf.c (rehash): call log_reopen() from rehash routine; + this allows log file rotations + + * ircd/m_kill.c: call log_write_kill() instead of ircd_log_kill() + + * ircd/ircd_log.c: much more work fleshing out the interface; + removed old interface; included backwards-compat ircd_log() + function that logs to subsystem LS_OLDLOG + + * ircd/ircd.c: switch to new log_init()/log_close()/log_reopen() + functions + + * include/ircd_log.h: include stdarg.h for va_list; move ordering + warning to top of file; fill out LogSys enum; declare new + log_debug_init(), log_vwrite(), log_write_kill(), and + log_[sg]et_*() functions; add flags argument to log_write(); + defined flags to inhibit various logging actions + + * include/client.h: added support for new SNO_DEBUG, enabled only + if DEBUGMODE is defined + +2000-11-28 Kevin L. Mitchell + + * ircd/ircd_log.c: make sure the various LOG_* constants are + defined (probably not needed, since #include isn't + conditional); various static data needed for the new logging + functions; definitions of new logging functions + + * include/ircd_log.h: new LogSys enum, declarations for part of + new logging API + + * ircd/motd.c: we were setting type to MOTD_CLASS unconditionally, + which was of course stupid; switched to using switch/case in + initialization in motd_create(); zero the MotdList.other pointer + from motd_clear() + + * ircd/ircd.c (main): motd_init() has to come before init_conf(), + or we overwrite init_conf()'s hard work with respect to T-lines + +2000-11-27 Kevin L. Mitchell + + * ircd/s_stats.c: comment out report_motd_list and include a + reference to motd_report() + + * ircd/s_conf.c: rip out the old MOTD manipulation functions; call + motd_add() from the conf parser; call motd_clear() from the rehash + routine; remove the no longer needed memory clearing and reloading + stuff from the rehash service routine + + * ircd/motd.c: loads new API, including static internal functions + to do allocation/deallocation, etc. + + * ircd/m_stats.c: use new motd_report() instead of + report_motd_list() + + * ircd/m_motd.c: use new syntax for motd_send() + + * ircd/ircd.c: use new motd_init() function + + * ircd/Makefile.in (SRC): forgot to add motd.c to SRC in + Makefile.(in); also ran make depend + + * include/motd.h: don't need config.h, but now do need time.h; + define new structures and constants; redefine old API and define + new functions + +2000-11-22 Kevin L. Mitchell + + * ircd/s_user.c (register_user): use motd_signon() instead of + calling m_motd; much cleaner this way + + * ircd/motd.c: write the new motd_* stuff to make MOTD handling + less of a crock + + * ircd/m_motd.c: rewrite m{,s}_motd to call out to new motd_* + functions + + * include/motd.h: define new MOTD API stuff + +2000-11-20 Kevin L. Mitchell + + * ircd/ircd_reply.c (protocol_violation): rewrite + protocol_violation so it'll actually work + + oh, yeah, use %s -> cptr->name, instead of %c -> cptr, so we get + the client's real name in there. + + * ircd/m_motd.c (m_motd): Iso's addition of get_client_class(sptr) + resulted in core dumps if NODEFAULTMOTD is defined, because m_motd + gets called from register_user with a NULL sptr. This is probably + a design problem, but this bandaid will do for now... + +2000-11-19 Isomer + * ircd/ircd_reply.c: added 'protocol_violation', thus alerting us + to problems in the server<->server protocol. + + * ircd/m_connect.c: allow remote connects with a port of '0' + meaning to use the port in the config file. + + * ircd/m_create.c: Enable hacking protection, lets see how far we + get. + + * ircd/m_error.c: The RFC says never accept ERROR from unreg'd + clients, so we don't any more. + + * ircd/m_kill.c: The kill path is now made up of numnicks of servers, + and the user@host is displayed of the victim. + + * ircd/m_map.c: reloaded 'dump_map'. + + * ircd/m_trace.c: allow per class T: + + * ircd/m_stats.c: allow local opers /remote stats anywhere on the 'net. + +2000-11-17 Isomer + + * ircd/m_topic.c: Fixed bug where we'd only send to clients topics + that were the *same* instead of different. Oh the embarrasment! + + * ircd/IPcheck.c: Merged net's fix. + +2000-11-02 Kevin L. Mitchell + + * ircd/m_whois.c: remove compiler warning by adding a newline to + end of file + + * ircd/m_names.c: moved the flags up to s_user.h + + * ircd/m_join.c: call do_names instead of m_names; restructure + ms_join to never transmute a JOIN into a CREATE, but use the TS in + the JOIN (if present) to timestamp the channel + + * ircd/channel.c: send JOINs individually, instead of grouping + them, so that we can send the channel's creation time + + * include/s_user.h: declare do_names() + +2000-10-30 Isomer + * ircd/m_oper.c: Fixed warning + +2000-10-30 Isomer + * ircd/m_oper.c: Fixed over agressive cut and no paste + +2000-10-30 Isomer + + * ircd/m_topic.c: Restructured, fixed bug where topics on local + channels are propergated (I forget who pointed this out to me, but + thanks anyway). Also to save bandwidth don't send the topic to + users if the topic is already the same on the server (but still + propergate to other servers). X/W's "autotopic" feature must + chew a lot of bandwidth, hopefully this will help reduce this. + + * doc/rfc1459.rfc: Updated documentation on /topic. + + * ircd/listener.c: snotice warnings about failed accept()'s + potentially warning admins that they're running out of fd's. + + * ircd/stats.c, ircd/class.c: Removed /stats v, added number of + people in a class in /stats y + + * ircd/m_create.c: Checks for timewarp hacking and squit's + evil servers. (currently disabled) + + +2000-10-30 net + + * ircd/gline.c: Fixed various bugs Isomer left behind. + +2000-10-26 Kevin L. Mitchell + + * ircd/m_join.c (m_join): reply on attempt to join a BADCHANed + channel is now ERR_BANNEDFROMCHAN instead of ERR_BADCHANNAME + +2000-10-24 Kevin L. Mitchell + + * ircd/channel.c: ok, now last mode rules; mode +ps will always + result in +s (and won't send a mode if the channel is already +s); + mode +sp will always result in +p; -n+n on a +n channel results in + no mode change; -n+n on a -n channel results in a +n mode change; + etc. + +2000-10-23 Kevin L. Mitchell + + * ircd/channel.c: add "add" and "del" elements to ParseState to + avoid not-too-pretty -p+s when +s is sufficient; fix a bug in + mode_parse_limit that caused it to clear all channel modes + prematurely; restructure mode_parse_mode to avoid calling + modebuf_mode too early (ties in with first mentioned change); + better logic for +p/+s mutual exclusivity; initialize "add" and + "del" elements in mode_parse; send simple modes down to + modebuf_mode after the loop in mode_parse + +2000-09-28 Greg Sikorski + * ircd/m_names.c: Fixed a non-lethal logic error that + triggers an assert() in find_member_link while debugging. + (Spotted by Maniac-). +2000-09-19 Thomas Helvey + * ircd/s_conf.c: move K:lines to their own list and data + structures, add supporting code. + * ircd/m_stats.c: cleanup stats processing a bit move + kline listing code to a new function, haven't figured + out where it goes yet tho' + * ircd/s_stats.c: added K:line bulk lister + * include/s_conf.h: added new DenyConf struct + * *[ch]: fixeup code that depended on changes + +2000-09-17 Thomas Helvey + * ircd/class.c: encapsulate class list + * include/class.h: clean up classes + * * fixup code that depended on changes + +2000-09-17 Thomas Helvey + * ircd/s_conf.c: add me to local conf + * include/s_conf.h: move CONF_ME macro to chkconf.c + * ircd/s_bsd.c: cleanup initialization, allow virtual host + to be changed by rehash + +2000-09-17 Thomas Helvey + * include/class.h: add missing prototype + * ircd/class.c: make argument to get_conf_class const + +2000-09-17 Thomas Helvey + * ircd/*.c: merged in changes from 2.10.10.pl12, cleanup + merge conflicts. + * ircd/*.h: merged in changes from 2.10.10.pl12, cleanup + merge conflicts + +2000-09-16 Thomas Helvey + * ircd/s_conf.c: add code for server struct + * ircd/client.c: copy of class.c sort of, new file for client + specific operations, will move things here as appropriate, + currently only one function is exported from here. + * ircd/*.c: general logic cleanups, convert negatives to + positives in places. + +2000-09-16 Thomas Helvey + * ircd/s_conf.c: add code for new crule data structs, strip quotes + * ircd/crule.c: clean up scary casting a bit, type safety stuff + * include/s_conf.h: add CRuleConf struct and support, remove + unused constants + * include/crule.h: type safety cleanups + * ircd/*.c: fixup code that depended on stuff I changed + +2000-09-15 Thomas Helvey + * ircd/s_conf.c: start adding code for new conf data structs, changed + listeners, admin line, motd lines, class lines. Move validate_hostent + to resolver. General mayhem. + * include/s_conf.h: new data structs and accessors + * ircd/res.c: move validate_hostent here, rewrite, use regular + expression for validation. + * doc/example.conf: update docs for port + +2000-09-14 Thomas Helvey + * ircd/s_conf.c (conf_init): rewrite conf file parser, start to break + up conf_init into managable chunks. + * ircd/listener.c (set_listener_mask): fix logic bug core dump. + * include/s_conf.h: add new data struct for local info (unwinding the mess). + +2000-09-13 Thomas Helvey + * ircd/list.c: put Clients in free lists, pre-allocate MAXCONNECTIONS + local clients. + * ircd/list.c: put SLinks in free lists + * ircd/channel.c: put Memberships in free lists + * ircd/ircd.c: rearrange initializations a bit in main + Note: With these changes, ircd NEVER frees Clients, SLinks or + Memberships. It will also rarely need to allocate new + ones during net bursts and other disruptions. This should + cut down on memory fragmentation a bit as well. + +2000-08-30 Kevin L. Mitchell + + * ircd/m_names.c (do_names): pull-up from do_names fix in + u2.10.10.pl11 + +2000-07-15 Perry Lorier + * various: IP only k:'s and G:'s now do bit tests instead of two(!) + match()'s. Major Major cpu savings. Also speed up the + other case slightly. As a side effect you can now + k/Gline *@10.0.0.0/8. I'll do bans tomorrow, it's nearing + 3am. + +2000-07-15 Perry Lorier + * various: Fixed warnings after compiling on an alpha. +2000-07-09 Perry Lorier + * doc/ircd.8: Applied grammitical changes by Liandrin, applied + changes suggested by various other people. + * ircd/IPcheck.c: More bug fixes. Current problem appears to be + that it gets a corrupt entry somehow. +2000-07-09 Greg Sikorski + * ircd/m_oper.c: Clean up compiler warning. + +2000-07-08 Perry Lorier + * doc/ircd.8: Updated the documentation, it was slightly out of date + being updated around 1989. + * ircd/m_whois.c: Rewrote for clarity, and probably a bit more speed. + fixed a few minor glitches. + * doc/rfc1459.unet: Updated. + * ircd/IPcheck.c: Fixed more bugs. + * ircd/s_bsd.c: We now keep track of servers we've conected. + +2000-07-02 Perry Lorier + * ircd/s_misc.c: Fixed remote IPcheck bug. Ok, I'm a moron, so sue + me. Thanks to Hektik, thanks thanks thanks thanks + thanks thanks thanks thanks thank thanks thank thanks + +2000-07-01 Perry Lorier + * ircd/s_conf.c: "Fixed" the "bug" where people would "evade" K:'s. + * ircd/s_conf.c, include/IPcheck.h: Fixed compile warnings. + +2000-06-22 Perry Lorier + * ircd/IPcheck.c: Large chunks redone. + * ircd/s_conf.c: Changes due to IPcheck - ONE nolonger supported, + single AND double digit limits are allowed now. + * misc other: Changes to IPcheck. + +2000-06-30 Perry Lorier + * ircd/ircd.c: Fix command line parameter bugs. + +2000-06-30 Perry Lorier + * ircd/m_kill.c: Fixed bug with LOCAL_KILL_ONLY + * ircd/m_nick.c: Tidied things up. + +2000-06-12 Joseph Bongaarts + * ircd/m_stats.c: Iso forgot mo_stats when he added /stats v + +2000-05-29 Perry Lorier + * ircd/m_stats.c: add /stats v to do only the last part of the /trace + * ircd/IPcheck.c: Cosmetic change, if we meddle with it enough do + you think it'll get bored and fix itself? + +2000-06-09 Greg Sikorski + + * ircd/m_names.c: Clean up compiler warnings. + +2000-06-09 Kevin L. Mitchell + + * ircd/channel.c (mode_parse_client): don't send warning if + there's not enough arguments for a +/-o/v; means the habit of + doing "/mode #channel +oooooo bob" doesn't result in a bunch of + error messages + +2000-06-04 Greg Sikorski + + * ircd/m_names.c: Re-factor code to remove unneccessary + GlobalChannelList iteration every time someone joins a channel. + +2000-06-02 Kevin L. Mitchell + + * ircd/s_user.c: add struct Gline * argument to register_user; + look up global glines and repropagate them if necessary; send + acknowledgement of gline to remote servers when registering users + + * ircd/s_serv.c (server_estab): don't send acknowledgement of + local glines to remote servers; do send gline acknowledgement of + bursted users + + * ircd/m_user.c (m_user): pass new struct Gline * argument to + register_user + + * ircd/m_pong.c: pass new struct Gline * argument to register_user + + * ircd/m_nick.c (ms_nick): document protocol change + + * ircd/gline.c: support GLINE_LASTMOD + + * include/s_user.h: add struct Gline * argument to register_user + + * include/gline.h: add GLINE_LASTMOD to look up non-zero lastmods + + * ircd/s_conf.c (find_kill): add unsigned int argument to + gline_lookup() + + * ircd/gline.c: add GLINE_GLOBAL to lookup or find only global + glines; add unsigned int argument to gline_lookup() + + * include/gline.h: add GLINE_GLOBAL flag; add unsigned int + argument to gline_lookup() + + * ircd/m_server.c: Resend jupe only when there is no % + parameter, or when it falls out of bounds: see comments prior to + call to jupe_resend(); call server_estab with struct Jupe + parameter, so that we place the appropriate % in the + appropriate place. + + * ircd/s_serv.c (server_estab): send % for introduced + server, as well as for servers when we're sending the BURST + + * include/s_serv.h: add a struct Jupe * to the arguments for + server_estab() so that we can send the appropriate lastmod + parameter + + * ircd/m_gline.c (ms_gline): actually, this should be the + slightest bit more efficient... + + * ircd/m_jupe.c (ms_jupe): actually, this should be the slightest + bit more efficient... + + * ircd/m_gline.c (ms_gline): inhibit GLINE processing resends + during netburst + + * ircd/m_jupe.c (ms_jupe): inhibit JUPE processing resends during + netburst + + * ircd/channel.c (joinbuf_join): really remove user from local + channels + +2000-05-29 Perry Lorier + * ircd/m_names.c: Removed redundant space. + * ircd/s_bsd.c: Fixed incorrect syntax on ERROR line. + +2000-05-18 Kevin L. Mitchell + + * ircd/m_burst.c (ms_burst): er...that should have been a ",", not + a " " + +2000-05-04 Kevin L. Mitchell + + * ircd/channel.c: replace bogus assertions with returns, which is + logically correct; only wipe out limit/key if they were originally + set in the first place; remove user from channel when doing a + PARTALL; only send MODE +o for user CREATEing channel if user is + not MyUser--CREATE will only be used if the channel did not + originally exist, therefore we can assume no one local is on the + channel anyway, and we don't exactly need for the user to see an + explicit +o for themselves + + * doc/readme.gline: describe the syntax of the GLINE command + + * doc/readme.jupe: update to reflect a couple of changes to JUPE + + * ircd/gline.c: don't propagate local changes + + * ircd/jupe.c: don't propagate local changes + + * ircd/m_gline.c (mo_gline): force local flag when deactivating + glines with 0 lastmod + + * ircd/gline.c (gline_deactivate): G-lines with zero lastmod time + are now removed instead of being deactivated + + * ircd/m_gline.c (ms_gline): make G-lines of the form "GLINE * + -" be accepted + + * ircd/channel.c (send_channel_modes): deal with one of the last + vestiges of sendbuf + + * ircd/m_burst.c (ms_burst): debugged ban processing; removed + debugging hooks + + * ircd/channel.c (modebuf_extract): remove debugging + sendto_opmask_butone calls + +2000-05-03 Kevin L. Mitchell + + * ircd/channel.c: support a couple of new flags to support using + mode_parse; fix some bugs with 0 struct ModeBuf *; implementation + of modebuf_extract to extract added flags for use by ms_burst + + * include/channel.h: a couple of new flags to support using + mode_parse inside ms_burst + + * ircd/m_burst.c (ms_burst): brand new implementation of BURST + + * ircd/m_endburst.c: add loop to processing of end_of_burst to + free empty channels after the BURST is over. + + * ircd/m_server.c: convert to use new send.c functions--I wanted + to rewrite it from scratch, but the logic's pretty complex; I may + still rewrite it, though... + +2000-05-02 Thomas Helvey + + * ircd/ircd.c: fix broken header include ordering + +2000-05-02 Thomas Helvey + + * ircd/IPcheck.c: cleanups for ZenShadow's cleanups + review emailed privately + + * include/IPcheck.h: removed unneeded include + +2000-05-02 Kevin L. Mitchell + + * ircd/s_user.c (hunt_server): throw in a comment so I know what + the sendto_one is for + + * include/querycmds.h (Count_unknownbecomesclient): convert to + sendto_opmask_butone + + * ircd/send.c: start removing dead code + + * include/send.h: start removing dead code + + * ircd/m_rping.c: convert to sendcmdto_one / send_reply / + hunt_server_cmd + + * ircd/m_rpong.c: convert to sendcmdto_one / send_reply + +2000-05-01 Kevin L. Mitchell + + * ircd/m_stats.c: convert to sendcmdto_one / send_reply + + * ircd/m_kick.c: Completely reimplement m_kick + + * ircd/channel.c: send_user_joins removed; it was dead code, + anyway... + +2000-05-01 Perry Lorier + * ircd/m_invite.c: Fix for the rest of m_invite.c, and again. + * ircd/channels.c: My fix for the part problem. Untested, probably + won't work. Can't be much worse than the current problem. + it'll either work or core, take your pick. + + +2000-04-30 Perry Lorier + * config/config-sh.in: Fix for CONNEXIT + * ircd/s_{user,misc}.c: Fix for CONNEXIT + * ircd/m_invite.c: Fix for incorrectly numnickified invite. + (Kev: Want to come talk to me about this?) + +2000-04-30 Steven M. Doyle + * ircd/ircd.c + - general cleanups and readability enhancements + - rewrite of setuid/chroot code. + - server will no longer run as root + - -DPROFIL compile option removed + - Fixed IPcheck API calls + + * config/config-sh.in + - Fixed up chroot compile options + - Added options for debug and profile compiles + + * config/gen.ircd.Makefile + - Support for new debug/profile options + + * ircd/Makefile.in + - Support for new debug/profile options + + * ircd/ircd_signal.c + - Removed -DPROFIL + + * include/IPcheck.h + - Removed old API prototypes, added new ones + + * ircd/IPcheck.c + - Readability cleanups (well, I -think-...) + - Changed IPRegistryEntry.last_connect to a time_t. The previously + used unsigned short was probably causing interesting things after + a client had been connected longer than about 65,535 seconds... + - Removed old API functions. + + * ircd/whocmds.c + - Removed IPcheck.h include + + * Additionally modified IPcheck API calls in: + - ircd/m_nick.c + - ircd/m_auth.c + - ircd/s_bsd.c + - ircd/s_conf.c + - ircd/s_misc.c + - ircd/s_serv.c + - ircd/s_user.c + + +2000-04-30 Perry Lorier + * ircd/s_bsd.c: Sigh. :) + * ircd/m_mode.c: fix for modeless channels by poptix. + +2000-04-29 Kevin L. Mitchell + + * ircd/m_join.c: reimplement JOIN in terms of struct JoinBuf + + * ircd/channel.c (clean_channelname): make clean_channelname also + truncate long channel names + +2000-04-28 Kevin L. Mitchell + + * ircd/m_create.c: reimplement CREATE in terms of struct JoinBuf + + * ircd/channel.c: implemented joinbuf_init, joinbuf_join, + joinbuf_flush + + * include/channel.h: definitions and declarations for the struct + JoinBuf abstraction + +2000-04-29 Perry Lorier + * ircd/s_bsd.c: Ok, so I thought I compiled and tested this... + +2000-04-29 Perry Lorier + * ircd/s_bsd.c: Add debugging code to IPcheck + +2000-04-28 Kevin L. Mitchell + + * include/ircd_reply.h (SND_EXPLICIT): use instead of RPL_EXPLICIT + + * ircd/ircd_reply.c (send_reply): use SND_EXPLICIT instead of + RPL_EXPLICIT + + * ircd/m_userhost.c (m_userhost): add a dead code comment + + * ircd/m_desynch.c: forgot one... + + * ircd/m_rehash.c (mo_rehash): er, duplicates :) + + * ircd/m_proto.c (proto_send_supported): just change a comment so + it doesn't show up in my scans + + * ircd/ircd_reply.c (send_reply): fix a slight bug... + + * ircd/s_numeric.c (do_numeric): use new sendcmdto_* functions, + kinda hackish... + + * ircd/parse.c (parse_server): argument wrangling to make + processing in do_numeric a little easier to deal with + + * ircd/s_serv.c (server_estab): SERVER should come from + acptr->serv->up, not &me + + * ircd/m_lusers.c: accidentally left out sptr for a %C + + * ircd/send.c: hack to support doing wallchops... + + * ircd/m_whowas.c: convert to new send functions + + * ircd/m_whois.c: convert to new send functions + + * ircd/m_who.c: convert to new send functions + + * ircd/m_wallops.c: convert to new send functions + + * ircd/m_wallchops.c: convert to new send functions + + * ircd/m_version.c: convert to new send functions + + * ircd/m_userip.c: convert to new send functions + + * ircd/m_userhost.c: convert to new send functions + + * ircd/m_uping.c: convert to new send functions + + * ircd/m_trace.c: convert to new send functions + + * ircd/m_topic.c: convert to new send functions + + * ircd/m_time.c: convert to new send functions + + * ircd/m_squit.c: convert to new send functions + + * ircd/m_silence.c: convert to new send functions + + * ircd/m_settime.c: convert to new send functions + + * ircd/m_restart.c: convert to new send functions + + * ircd/m_rehash.c: convert to new send functions + + * ircd/m_privmsg.c: convert to new send functions + + * ircd/m_pong.c: convert to new send functions + + * ircd/m_ping.c: convert to new send functions + + * ircd/m_pass.c: convert to new send functions + + * ircd/m_opmode.c: convert to new send functions + + * ircd/m_oper.c: convert to new send functions + + * ircd/m_notice.c: convert to new send functions + + * ircd/m_nick.c: convert to new send functions + + * ircd/m_names.c: convert to new send functions + + * ircd/m_motd.c: convert to new send functions + + * ircd/m_mode.c: convert to new send functions + + * ircd/m_map.c: convert to new send functions + + * ircd/m_lusers.c: convert to new send functions + + * ircd/m_list.c: convert to new send functions + + * ircd/m_links.c: convert to new send functions + + * ircd/m_kill.c: convert to new send functions + + * ircd/m_jupe.c: convert to new send functions + + * ircd/m_invite.c: convert to new send functions + + * ircd/m_info.c: convert to new send functions + + * ircd/m_help.c: convert to new send functions + + * ircd/m_gline.c: convert to new send functions + + * ircd/m_error.c: convert to new send functions + + * ircd/m_endburst.c: convert to new send functions + + * ircd/m_die.c: convert to new send functions + + * ircd/m_destruct.c: convert to new send functions + + * ircd/m_defaults.c: convert to new send functions + + * ircd/m_connect.c: convert to new send functions + +2000-04-28 Perry Lorier + * RELEASE.NOTES: Describe a few more undocumented features. + * config/config-sh.in: change the default paths for logging + and the recommended number of channels. + * include/supported.h: Rearrange slightly, added CHANTYPE's + +2000-04-27 Kevin L. Mitchell + + * ircd/m_close.c: convert to send_reply + + * ircd/m_clearmode.c: convert to send_reply, sendcmdto_serv_butone + + * ircd/m_away.c: convert to send_reply and sendcmdto_serv_butone + + * ircd/m_admin.c: convert to send_reply and hunt_server_cmd + + * ircd/s_user.c (hunt_server_cmd): new hunt_server replacement + that takes cmd and tok arguments, etc. NOTE: THIS IMPLEMENTATION + HAS A MAJOR HACK!!! The whole hunt_server architecture should be + carefully rethought... + + * ircd/s_stats.c (hunt_stats): use new hunt_server_cmd + + * include/s_user.h: hunt_server_cmd -- replacement for hunt_server + + * ircd/s_misc.c: *sigh* 2.10.10 doesn't support squitting by + numeric nick; therefore, we have to use the server name + + * ircd/m_squit.c (ms_squit): allow to squit by server numeric nick + + * ircd/send.c: fix minor bugs + + * ircd/s_user.c (check_target_limit): mark dead code so I filter + it when I grep + + * ircd/s_serv.c (exit_new_server): mark dead code so I filter it + when I grep + + * ircd/parse.c: mark dead code so I filter it when I grep + + * ircd/map.c: mark dead code so I filter it when I grep + + * ircd/ircd.c: mark dead code so I filter it when I grep + + * ircd/ircd_relay.c: convert over to new sendcmdto_*, send_reply + functions + + * ircd/channel.c: mark dead code so I filter it when I grep + + * ircd/s_stats.c: use send_reply instead of sendto_one w/rpl_str; + hope I'm not stepping on toes... + + * ircd/s_conf.c: more sendto_opmask_butone / send_reply + conversions; use ircd_snprintf in a couple of cases to negate the + possibility of buffer overflow + +2000-04-26 Kevin L. Mitchell + + * ircd/channel.c: convert as much as possible to new send + semantics + + * ircd/send.c (sendcmdto_common_channels): fix a subtle bug -- + test member->user->from->fd, not from->fd + + * ircd/gline.c (gline_add): go ahead and add badchans; we just + won't look for them in m_gline; this way, they always work... + + * ircd/jupe.c: use ircd_vsnprintf conversion specifiers + + * ircd/gline.c: since write_log now uses ircd_vsnprintf, use + ircd_vsnprintf conversion specifiers + + * ircd/support.c (write_log): use ircd_vsnprintf for write_log, so + I have my conversion specifiers + + * ircd/gline.c (do_gline): use send_reply for ERR_YOUREBANNEDCREEP + + * ircd/send.c (sendcmdto_flag_butone): explicitly send WALLOPS to + local users + + * ircd/s_serv.c (exit_new_server): rewrite exit_new_server to be a + little less brain-dead + + * ircd/s_misc.c: use sendcmdto_one, sendrawto_one, and send_reply + + * ircd/s_debug.c: use send_reply with RPL_EXPLICIT for + RPL_STATSDEBUG + + * ircd/res.c (cres_mem): use send_reply with RPL_EXPLICIT for + RPL_STATSDEBUG + + * ircd/list.c (send_listinfo): use send_reply with RPL_EXPLICIT + for RPL_STATSDEBUG + + * ircd/m_pong.c: use RPL_EXPLICIT for ERR_BADPING + + * ircd/ircd.c: use RPL_EXPLICIT for ERR_BADPING + + * ircd/s_user.c (register_user): use RPL_EXPLICIT for + ERR_INVALIDUSERNAME + + * ircd/ircd_reply.c (send_reply): support RPL_EXPLICIT + + * include/ircd_reply.h (RPL_EXPLICIT): somewhat of a hack to mark + a numeric as needing to use an explicit pattern, which will be the + first argument in the variable argument list + + * ircd/s_user.c: use sendrawto_one instead of sendto_one to send + non-prefixed nospoof PING + + * ircd/s_bsd.c: use sendrawto_one instead of sendto_one to send + non-prefixed SERVER login + + * ircd/ircd.c (check_pings): fix last sendto_one calls (except for + a numeric usage further up) + + * include/send.h: declare sendrawto_one + + * ircd/send.c (sendrawto_one): new function to use ONLY for + non-prefixed commands, like PING to client, or PASS/SERVER on + server registration + +2000-04-25 Kevin L. Mitchell + + * ircd/ircd_snprintf.c (doprintf): implement %H for possible + future expansion (channel numerics?) + + * include/ircd_snprintf.h: added documentation to # to explain use + with %C; added documentation for : to explain use with %C; added + documentation for %H for channels + + * ircd/whocmds.c: use send_reply + + * ircd/userload.c: use sendcmdto_one + + * ircd/uping.c: use sendcmdto_one + + * ircd/send.c: use new flags to %C format string; ':' prefixes + client name with a colon for local connects, '#' uses + nick!user@host form for local connects + + * ircd/s_user.c: use send_reply, sendto_opmask_butone, + sendcmdto_one, sendcmdto_serv_butone, sendcmdto_flag_butone + + * ircd/s_serv.c: use sendcmdto_one, sendto_opmask_butone + + * ircd/s_bsd.c: use sendto_opmask_butone, send_reply, + sendcmdto_one + + * ircd/s_auth.c: use sendto_opmask_butone + + * ircd/res.c: use sendcmdto_one + + * ircd/ircd_snprintf.c (doprintf): minor bug fixes and some + debugging assertions + +2000-04-24 Kevin L. Mitchell + + * ircd/support.c: dumpcore is no longer used, so get rid of it + + * ircd/parse.c: use send_reply, sendcmdto_one + + * ircd/map.c: use send_reply + + * ircd/listener.c: use send_reply + + * ircd/jupe.c: use sendto_opmask_butone, send_reply + + * ircd/ircd_reply.c: use send_reply + + * ircd/ircd.c: use sendto_opmask_butone + + * ircd/gline.c: use sendto_opmask_butone, send_reply + + * ircd/ircd_snprintf.c (doprintf): make it deal with incompletely + registered clients; make FLAG_ALT print nick!user@host; make + FLAG_COLON print :blah + + * ircd/class.c (report_classes): use send_reply instead of + sendto_one + + * ircd/hash.c (m_hash): replace sendto_one with sendcmdto_one + + * ircd/IPcheck.c (ip_registry_connect_succeeded): replace + sendto_one with sendcmdto_one + +2000-04-21 Kevin L. Mitchell + + * ircd/send.c: clean up logic in sendcmdto_channel_butone; use + MyConnect() instead of IsServer() in sendcmdto_flag_butone; define + sendcmdto_match_butone + + * include/send.h: declare sendcmdto_match_butone + +2000-04-20 Kevin L. Mitchell + + * ircd/jupe.c: update to use send_reply() + + * ircd/gline.c: update to use send_reply() + + * include/ircd_reply.h: declare send_reply + + * ircd/ircd_reply.c (send_reply): send_error_to_client, but for + replies; uses ircd_snprintf + + * ircd/send.c: added comments to redirect searchers to appropriate + sendcmdto_* function; moved new functions to end of file; added + explanatory comments; reordered arguments; defined new functions + mentioned below + + * ircd/m_jupe.c: reorder arguments to sendcmdto_* functions + + * ircd/m_gline.c: reorder arguments to sendcmdto_* functions + + * ircd/jupe.c: reorder arguments to sendcmdto_* functions + + * ircd/gline.c: reorder arguments to sendcmdto_* functions + + * include/send.h: reorder arguments, add explanatory comments, + declare new functions sendcmdto_flag_butone, sendto_opmask_butone, + and vsendto_opmask_butone + +2000-04-19 Kevin L. Mitchell + + * ircd/send.c: define sendcmdto_channel_butone, wrote a simplified + vsendto_op_mask that uses '*' instead of the receiving client + nickname + + * include/send.h: declare sendcmdto_channel_butone; takes a skip + argument that allows you to skip (or not to skip) deaf users, + users behind bursting servers, and non channel operators + +2000-04-17 Kevin L. Mitchell + + * ircd/send.c: new sendcmdto_channel_butserv -- note that old + sendto_channel_butserv has a subtle bug; also wrote + sendcmdto_common_channels. + + * include/send.h: declare new sendcmdto_* functions + + * ircd/jupe.c: support local deactivations of jupes + + * ircd/gline.c: support local deactivations of glines + + * include/jupe.h: JUPE_LDEACT allows jupes to be locally + deactivated; if they aren't locally deactivated, then it slaves to + the net-wide activation status; JupeIsRemActive() tests only + whether the jupe is active everywhere else + + * include/gline.h: GLINE_LDEACT allows glines to be locally + deactivated; if they aren't locally deactivated, then it slaves to + the net-wide activation status; GlineIsRemActive() tests only + whether the gline is active everywhere else + + * ircd/gline.c: detect overlapping G-lines; if an existing, wider + gline expires after the new one will, we drop the new one, + otherwise we add the G-line after that one (so the wide one will + apply first); if the new one contains an existing G-line and if it + will expire after the existing one, we drop the existing one to + save memory + + * ircd/m_gline.c (mo_gline): opers could issue remote local + glines when CONFIG_OPERCMDS was off; fixed + +2000-04-16 Kevin L. Mitchell + + * ircd/m_jupe.c (mo_jupe): allow target argument to be dropped if + this is a local JUPE + + * ircd/gline.c: add flags argument to gline_activate and + gline_deactivate for future expansion + + * ircd/m_gline.c: pass flags to gline_activate and + gline_deactivate + + * include/gline.h: add flags argument to gline_activate and + gline_deactivate + + * ircd/jupe.c: add flags argument to jupe_activate and + jupe_deactivate for future expansion + + * include/jupe.h: add flags argument to jupe_activate and + jupe_deactivate + + * ircd/m_jupe.c: pass a flags argument to jupe_add instead of + local, active; pass flags to jupe_activate and jupe_deactivate + + * include/gline.h: remove dead code + + * ircd/gline.c: make gline expire times relative to CurrentTime, + since that should be monotonically increasing, instead of + TStime(), which can be set backwards, and which can therefore + cause an expire time to increase; make local glines be removed + instead of just deactivated; don't let gline_find() look for + user@host glines if the mask being looked up is a channel mask + + * ircd/send.c (vsendcmdto_one): forgot to account for the case + where origin is a server and destination is a user + + * ircd/jupe.c: make jupe expire times relative to CurrentTime, + since that should be monotonically increasing, instead of + TStime(), which can be set backwards, and which can therefore + cause an expire time to increase; make local jupes be removed + instead of just deactivated + + * ircd/ircd_snprintf.c: d'oh, thanks for catching that; short for + limit is fine. any other warnings I should know about? + +2000-04-15 Thomas Helvey + + * ircd/*.c: const correctness and type safety cleanups to + get code to compile with C++ compiler. Still has + signed/unsigned comparison warnings. + +2000-04-15 Greg Sikorski + + * ircd/userload.c: change include to for + portability. + +2000-04-14 Kevin L. Mitchell + + * ircd/m_gline.c (mo_gline): d'oh, target isn't a numeric; use %C + and convert acptr... + + * ircd/s_user.c: move gline_lookup function call into + register_user, where it'll have a username to lookup! + + * ircd/m_gline.c: modify to utilize new sendcmdto_* series of + functions; also stuff send_error_to_client into return clauses + + * ircd/m_jupe.c: modify to utilize new sendcmdto_* series of + functions; also use send_error_to_client where that makes sense + + * ircd/jupe.c: modify to utilize new sendcmdto_* series of + functions; also use send_error_to_client where that makes sense + + * ircd/gline.c: modify to utilize new sendcmdto_* series of + functions; also fix gline_lookup() to deal properly with remote + clients--boy, do struct Client and struct User need to be cleaned + up! + + * ircd/ircd_snprintf.c (doprintf): a dest of &me is a server, + too... + + * ircd/send.c: wrote sendcmdto_one(), vsendcmdto_one(), and + sendcmdto_serv_butone(), all utilizing the %v conversion of + ircd_snprintf() + + * include/send.h: define IRC_BUFSIZE, max size of a message; + declare sendcmdto_one(), vsendcmdto_one(), and + sendcmdto_serv_butone() + + * include/msg.h: define all the CMD_* constants needed to utilize + the new sendcmdto_* series of functions + + * ircd/Makefile.in (SRC): list ircd_snprintf.c; run make depend + + * ircd/gline.c: remove old, dead code. + + * ircd/m_gline.c (mo_gline): disallow setting of global G-lines + unless CONFIG_OPERCMDS is enabled; disallow listing of all G-lines + (don't advertise proxies); remove dead code + + * ircd/parse.c: oper handler for JUPE only lists jupes unless + CONFIG_OPERCMDS is enabled + + * ircd/m_jupe.c (mo_jupe): don't compile mo_jupe() if + CONFIG_OPERCMDS is not enabled; we'll disable it in parse.c + + * ircd/m_opmode.c (mo_opmode): if CONFIG_OPERCMDS is not enabled, + always return ERR_DISABLED + + * ircd/m_clearmode.c (mo_clearmode): if CONFIG_OPERCMDS is not + enabled, always return ERR_DISABLED + + * ircd/s_err.c: add error message to indicate disabled commands + + * include/numeric.h (ERR_DISABLED): to indicate disabled commands + + * doc/Configure.help: add documentation for CONFIG_OPERCMDS + + * config/config-sh.in: add CONFIG_OPERCMDS, default both it and + CONFIG_NEW_MODE to 'y' for now + + * ircd/gline.c (gline_list): fix a minor formatting bogon + + * BUGS: since I fixed that bug, might as well mark it fixed. + + * ircd/m_join.c: look up badchans with GLINE_EXACT + + * ircd/m_gline.c: fix parc count problems; look up existing + G-lines with GLINE_EXACT; only set new lastmod when + activating/deactivating existing glines if old lastmod was not 0 + + * ircd/gline.c: forgot to copy the gline reason over; don't + propagate a gline with 0 lastmod if origin is user; add + GLINE_EXACT to force exact matching of gline mask + + * ircd/ircd_snprintf.c (doprintf): forgot to deal with the zero + flag properly + + * ircd/s_conf.c (find_kill): gline_find() takes a char *userhost, + but gline_lookup() actually takes a client--d'oh. + +2000-04-13 Thomas Helvey + * ircd/IPcheck.c: Back port BLMet's bugfix from 2.10.10 + +2000-04-13 Greg Sikorski + + * ircd/whocmds.c: Don't make idle flag default in /who, to prevent: + "/who * x" + "Gte3 H*iwg Gte@212.49.240.217 :1 :0 I am the one that was." + (Found by Plexus). + + * ircd/whocmds.c: Change idle time calc from socket idle to user + idle. + +2000-04-13 Kevin L. Mitchell + + * config/aclocal.m4 (unet_CHECK_TYPE_SIZES): check size of void *, + too, for ircd_snprintf.c + + * include/ircd_snprintf.h: documentation for ircd_(v)snprintf, in + comments; mostly descended from the Linux manpage for printf, but + also documenting the extensions. + + * ircd/ircd_snprintf.c: NULL dest is equivalent to going to a + client; make 'q' be the same as 'L'; remove __inline__; only + define EXTENSION if HAVE_LONG_LONG is defined + + * include/handlers.h: declare m_gline() + + * ircd/parse.c: gline can be called by users, but it only lists + the glines. + + * ircd/s_user.c (set_nick_name): resend gline if a remote server + introduces a glined client + + * ircd/s_serv.c (server_estab): burst glines, too + + * ircd/gline.c: fix up all the expire times to be offsets; + simplify gline_resend() + + * ircd/m_gline.c: begin coding replacements for ms_gline(), + mo_gline(), and m_gline() + + * ircd/gline.c (gline_add): allow *@#channel to work correctly; + also, prohibit local BADCHANs if LOCAL_BADCHAN not defined + +2000-04-13 Greg Sikorski + + * tools/Bouncer/*: Add comments/documentation/tags. + * tools/Bouncer/*: Add debug defines, make task fork(). + +2000-04-12 Thomas Helvey + * ircd/s_err.c: Cleanup s_err.c make one table so we + don't have to do anything tricky to get an error string. + +2000-04-12 Greg Sikorski + * Add port bouncer for http (x/w) + +2000-04-12 Kevin L. Mitchell + + * ircd/s_conf.c (find_kill): replaced call to find_gline() with a + call to gline_find(); also used GlineReason() instead of direct + reference to structure member + + * ircd/m_join.c (m_join): replace bad_channel() calls with calls + to gline_find(name, GLINE_BADCHAN), and also check to see if gline + is active + + * ircd/channel.c: nothing seems to be called anywhere... + + * ircd/s_err.c: update a couple of replies to dovetail with new + semantics + + * ircd/gline.c: begin complete re-implementation of gline.c along + the lines of the final design of jupe.c + + * include/gline.h: begin complete re-implementation of gline.c + along the lines of the final design of jupe.c + + * ircd/channel.c (mode_process_clients): fix "Deop of +k user on + %s by %s" message... + + * ircd/ircd_snprintf.c: my new snprintf()-like functions + + * include/ircd_snprintf.h: my new snprintf()-like functions + +2000-04-11 Thomas Helvey + * ircd/IPcheck.c: removed old dead code + * ircd/s_user.c (send_user_info): removed non-standard + user not found message for userhost/userip + +2000-04-11 Greg Sikorski + + * ircd/s_err.c: Added missing quotes to ERR_DONTCHEAT numeric. + * doc/p10.html: Work on chapter 4. + +2000-04-10 Kevin L. Mitchell + + * ircd/channel.c (mode_parse_client): fix coredump on /mode + #foobar +o nosuchnick + +2000-04-10 Perry Lorier + * BUGS: Added bug. + +2000-04-09 Thomas Helvey + * include/IPcheck.h: fix prototype + * ircd/s_user.c: fix usage of IPcheck_remote_connect + * ircd/IPcheck.c: removed unused args + +2000-04-09 Thomas Helvey + * include/IPcheck.h: add proto for IPcheck_expire + + * ircd/IPcheck.c: Rewrote + + * ircd/ircd.c: Add IPcheck_expire to main message loop + + * ircd/s_user.c: Redo target hashing, refactor target code + + * include/numeric.h: Cleaned up numerics, added which ones are + in use by other networks and what they are in use for. + + * ircd/channel.c: cleaned can_join(), allow anyone through anything + if /invited, simplified the function. Opers overusing OPEROVERRIDE + will get a message explaining to them not to cheat. + + * ircd/m_join.c: cleaned up the various join functions, should be + a lot more efficient. Still needs work. Now assumes that s<->s + won't send it a JOIN 0. Service coders - note this and tread with + care. + + * ircd/m_stats.c: added Gte-'s stats doc patch. + + * ircd/m_version.c: /version now returns the 005 numeric as well. + as requested by Liandrin. + + +2000-04-07 Kevin L. Mitchell + + * ircd/m_clearmode.c: add include for support.h for write_log() + + * configure: move ircd/crypt/* to tools/* + +2000-04-06 Thomas Helvey + * ircd/s_auth.c: Shorten auth connect timeout to 60 seconds + set client host to server alias if connection from localhost + +2000-04-06 Perry Lorier + * ircd/ircd.c: Fix core during pinging (oops) + +2000-04-06 Perry Lorier + * ircd/send.c: fixed wrong ident being sent to channels bug. + * include/numerics.h: Updated some of the numerics from other + networks. Flagged some as 'unused' by undernet. + +2000-03-30 Perry Lorier + * ircd/ircd.c: Lets see if this helps the ping problem at all. + * ircd/whocmds.c, /doc/readme.who: Added %l specifier to get idle + time for local clients. (as requested), extended who now returns all + the flags (@+!) so you can tell the complete state of a client. + +2000-03-30 Thomas Helvey + * m_rping.c m_rpong.c: add Gte's rping/rpong fixes + +2000-03-30 Perry Lorier + * ircd/parse.c: oops, missed opers. + +2000-03-30 Perry Lorier + * ircd/parse.c: fixed mystifying ping bug thats been plaguing us + for so long. Remember: m_ping MUST be in the parse array. :) + +2000-03-30 Perry Lorier + * ircd/ircd.c: test in check_pings was wrong. I move that we + disallow cvs commit after 10pm localtime.... + +2000-03-30 Perry Lorier + * ircd/m_pong.c: Fix it for servers too. + +2000-03-30 Perry Lorier + * ircd/m_pong.c: Fix ping timeout bugs + +2000-03-30 Perry Lorier + * ircd/channel.c: Bans had CurrentTime in their when field instead + of TStime() + +2000-03-31 Thomas Helvey + * ircd/numnicks.c (SetXYYCapacity): fix for extended + numerics. + +2000-03-30 Perry Lorier + * ircd/m_nick.c: send kills both ways so when we add nick change + on collision we don't desync the network. + + * ircd/map.c: Fixup the map a bit more. + +2000-03-31 Kevin L. Mitchell + + * ircd/m_clearmode.c (do_clearmode): Log the CLEARMODE to OPATH + + * ircd/m_opmode.c: Log the mode changes to OPATH + + * ircd/channel.c (modebuf_flush_int): Log the mode changes to + OPATH + + * include/channel.h (MODEBUF_DEST_LOG): Log the mode changes to + OPATH + + * doc/Configure.help: help text for CONFIG_LOG_OPMODE / OPATH + + * config/config-sh.in: added OPATH for opmode log file + + * ircd/m_clearmode.c (do_clearmode): updated uses of + modebuf_mode_string() for the new usage + + * ircd/channel.c: added flag MODE_FREE and an int argument to + modebuf_mode_string() to indicate that the string must be free'd; + updated calls to modebuf_mode_string() for the new usage; called + collapse(pretty_mask()) on the ban string and use allocated memory + for it; added ban list length accounting; fixed a number of small + bugs in ban processing + + * include/channel.h: added flag MODE_FREE and an int argument to + modebuf_mode_string() to indicate that the string must be free'd + + * ircd/m_clearmode.c (do_clearmode): made sure clearmode removed + keys and limits that are set + +2000-03-30 Perry Lorier + * ircd/ircd.c: rewrote check_pings() for maintainability + and speed. Also changed quit msg's so they don't have + redundant nick[host] info in them. + + * ircd/send.c: Changed write errors to report what error + occured (if possible). + + * ircd/gline.c: added gline comment to the quit. + + * ircd/m_server.c: Added suggestions to server quits mentioning + what went wrong so the admin can fix it earlier instead of asking + questions... + + * ircd/map.c: Changed m_map() to hide numerics, show a * beside + servers that aren't fully burst yet. And show '(--s)' for servers + where its not sure. + + * doc/example.conf: Fixed wrapped U: + +2000-03-30 Kevin L. Mitchell + + * ircd/m_mode.c (ms_mode): implemented a new m_mode in terms of + mode_parse() (version selectable at compile time) + + * ircd/m_clearmode.c (mo_clearmode): clean_channelname(parv[1]) + + * ircd/m_opmode.c (mo_opmode): clean_channelname(parv[1]) + + * config/config-sh.in: add new config option to enable new m_mode + implementation + + * doc/Configure.help: add documentation for new config option + CONFIG_NEW_MODE + + * ircd/channel.c (mode_parse_client): /opmode #foobar -o -- 461 + MODE -v : Not enough parameters + + * ircd/m_clearmode.c (do_clearmode): do_clearmode() would remove + +k and +l even if they weren't set... + + * ircd/m_opmode.c: implement the OPMODE command using mode_parse() + + * ircd/channel.c: make mode_process_clients() clear the DEOPPED + flag; fix +s+p exclusivity; add MODE_ADD/MODE_DEL to flag list + for; test the 0-th member, not the i-th member, of the client + change state stuff + + * ircd/m_clearmode.c (do_clearmode): use the new + mode_invite_clear() function + + * ircd/channel.c: cleared up all the compile-time warnings and + errors + + * include/channel.h: added declarations for mode_ban_invalidate() + and mode_invite_clear() + + * ircd/channel.c: finished mode_parse(), then broke it up into a + dozen or so helper functions to make the code easier to read + +2000-03-29 Thomas Helvey + * ircd/ircd.c: refactor server initialization a bit, use + getopt for parsing command line, refactor init_sys, main, + and other bits. + + * ircd/s_bsd.c: add functions for initialization to clean + up logic a bit and remove duplicated code. + + * include/ircd.h: add struct for server process related + variables. + +2000-03-29 Kevin L. Mitchell + + * ircd/channel.c: initial definition of mode_parse(); flags to + prevent doing the same thing multiple times; helper method + send_notoper() to send a "Not oper"/"Not on channel" notice + + * include/channel.h: declare mode_parse() and helper flags + + * ircd/channel.c (modebuf_flush_int): fiddled with timestamp + sending to match the current action of set_mode() closely enough + that hopefully there won't be major conflicts + + * ircd/channel.c (modebuf_flush_int): consolidated the mode string + building logic, reversed the order of the arguments to mode + commands to have '-' preceed '+' + +2000-03-29 Thomas Helvey + * ircd/s_bsd.c (add_connection): don't disable socket options + let OS tune itself and allow important performance tweaks to + work. + +2000-03-28 Kevin L. Mitchell + + * ircd/channel.c (modebuf_flush_int): use %d, not %-15d; I got + confused by set_mode, which is doing some really weird logic; + guess what I'm going to rewrite next? ;) + +2000-03-28 Kevin L. Mitchell + + * include/channel.h: added MODE_SAVE for the bounds checking stuff + in modebuf_flush + + * ircd/channel.c: make modebuf_flush into modebuf_flush_int and + make it do bounds checking on the buffer; all modes are sent only + if the all parameter is 1; modebuf_flush is the exported wrapper + + * include/channel.h: add BOUNCE, renumber flags to get a little + more space + + * ircd/channel.c (modebuf_flush): don't overload HACK2, add + BOUNCE; send DESYNCH message + +2000-03-27 Kevin L. Mitchell + + * ircd/m_clearmode.c (do_clearmode): only mark the modes the + channel actually has in effect for deletion + + * ircd/channel.c: added explanatory comments to all added + functions; made flushing take place at the correct place even if + the MODEBUF_DEST_DEOP flag is set; rewrote build_string() helper + to bash some stupid bugs; made modebuf_flush() return if ModeBuf + is empty, fixed the apparent source, removed some bogus string + termination code, properly terminate the mode strings, add support + for HACK2 and HACK3, made limit strings not be sent if the limit + is being removed, changed where '+' and '-' come from in sent + strings, added support for DEOP flag, set up bouncing code for + HACK2 + + * ircd/Makefile.in: ran make depend + + * include/channel.h: added new defines for future functionality, + made modebuf_flush() return int so I can use tail recursion + + * ircd/m_clearmode.c: add msg.h to includes; other misc cleanups + to make it all compile + + * ircd/m_opmode.c: add msg.h to includes... + + * ircd/m_clearmode.c: implemented mo_clearchan()/ms_clearchan() + + * ircd/channel.c (modebuf_flush): realized I forgot to + nul-terminate addbuf/rembuf properly... + + * ircd/m_clearmode.c (do_clearmode): wrote do_clearmode()... + + * ircd/channel.c (modebuf_flush): correct sendto_server_butone to + sendto_serv_butone--blah^2 + + * ircd/send.c (sendto_serv_butone): stupid comments confused me + + * ircd/channel.c (modebuf_flush): if there are no mode changes to + propagate, we're done... + + * ircd/channel.c (modebuf_flush): duh; it's sendto_server_butone, + not sendto_all_butone + + * ircd/m_clearmode.c: define skeleton for m{o,s}_clearmode + + * ircd/m_opmode.c: define skeleton for m{o,s}_opmode + + * ircd/Makefile.in (SRC): added m_opmode() and m_clearmode() to + the list + + * ircd/parse.c: added messages for opmode and clearmode + + * include/handlers.h: added declarations for mo_opmode(), + ms_opmode(), mo_clearmode(), and ms_clearmode() + + * include/msg.h: define MSG_OPMODE, TOK_OPMODE, MSG_CLEARMODE, and + TOK_CLEARMODE + + * include/channel.h (MODEBUF_DEST_OPMODE): Define the + MODEBUF_DEST_OPMODE flag + + * ircd/channel.c (modebuf_flush): added new flag, + MODEBUF_DEST_OPMODE; causes channel MODE/HACK(4) notice to appear + to originate from source's server (or source itself, if + IsServer(source)); also causes a server-level MODE to be sent as + OPMODE instead + + * include/channel.h: defined MODEBUF_DEST_SERVER, + MODEBUF_DEST_HACK4 + + * ircd/channel.c: Add another argument to build_string() to handle + numeric nicks; implemented MODEBUF_DEST_SERVER to send MODEs to + servers; implemented MODEBUF_DEST_HACK4 to cause HACK(4) notices + to be sent out + +2000-03-27 Perry Lorier + + * ircd/s_bsd.c: fixed missing 'u' typo. + +2000-03-26 Kevin L. Mitchell + + * ircd/channel.c: implement modebuf_init(), _mode(), _mode_uint(), + _mode_string(), _mode_client(), _flush(); also implemented a + simple build_string() + + * include/channel.h: added definition of ModeBuf, modebuf_* + manipulation functions, and a couple of helper macros +>>>>>>> 1.290.2.46 diff --git a/RELEASE.NOTES b/RELEASE.NOTES index 77911a9..2b6dfc8 100644 --- a/RELEASE.NOTES +++ b/RELEASE.NOTES @@ -99,12 +99,9 @@ systems where ./configure does not detect that it is a system call. debugging the server. THIS FEATURE SHOULD NOT BE USED ON A PRODUCTION NETWORK; it represents a severe privacy risk. ---enable-asserts +--disable-asserts Assertions are a means of checking that certain underlying -assumptions are met. This option enables those assertions. Note: -This option should not be activated on production servers due to -debugging code in the server's MyMalloc() implementation which will -cause the server to leak memory. +assumptions are met. This option disables those assertions. --disable-symbols By default, the -g compiler option is used to enable symbols on the diff --git a/configure b/configure index 462c1c3..b9a7725 100755 --- a/configure +++ b/configure @@ -18,7 +18,7 @@ ac_help="$ac_help ac_help="$ac_help --enable-debug Turn on debugging mode" ac_help="$ac_help - --enable-asserts Enable asserts" + --disable-asserts Disable assertion checking" ac_help="$ac_help --disable-symbols Disable debugging symbols (remove -g from CFLAGS)" ac_help="$ac_help @@ -1942,7 +1942,6 @@ else #line 1943 "configure" #include "confdefs.h" #include -#include main() { FILE *f=fopen("conftestval", "w"); @@ -1951,7 +1950,7 @@ main() exit(0); } EOF -if { (eval echo configure:1955: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:1954: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_short=`cat conftestval` else @@ -1971,7 +1970,7 @@ EOF echo $ac_n "checking size of int""... $ac_c" 1>&6 -echo "configure:1975: checking size of int" >&5 +echo "configure:1974: checking size of int" >&5 if eval "test \"`echo '$''{'ac_cv_sizeof_int'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -1979,10 +1978,9 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < -#include main() { FILE *f=fopen("conftestval", "w"); @@ -1991,7 +1989,7 @@ main() exit(0); } EOF -if { (eval echo configure:1995: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:1993: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_int=`cat conftestval` else @@ -2011,7 +2009,7 @@ EOF echo $ac_n "checking size of long""... $ac_c" 1>&6 -echo "configure:2015: checking size of long" >&5 +echo "configure:2013: checking size of long" >&5 if eval "test \"`echo '$''{'ac_cv_sizeof_long'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2019,10 +2017,9 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < -#include main() { FILE *f=fopen("conftestval", "w"); @@ -2031,7 +2028,7 @@ main() exit(0); } EOF -if { (eval echo configure:2035: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:2032: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_long=`cat conftestval` else @@ -2051,7 +2048,7 @@ EOF echo $ac_n "checking size of void *""... $ac_c" 1>&6 -echo "configure:2055: checking size of void *" >&5 +echo "configure:2052: checking size of void *" >&5 if eval "test \"`echo '$''{'ac_cv_sizeof_void_p'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2059,10 +2056,9 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < -#include main() { FILE *f=fopen("conftestval", "w"); @@ -2071,7 +2067,7 @@ main() exit(0); } EOF -if { (eval echo configure:2075: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:2071: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sizeof_void_p=`cat conftestval` else @@ -2092,12 +2088,12 @@ EOF if test "$ac_cv_sizeof_int" = 2 ; then echo $ac_n "checking for int16_t""... $ac_c" 1>&6 -echo "configure:2096: checking for int16_t" >&5 +echo "configure:2092: checking for int16_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_int16_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2125,12 +2121,12 @@ EOF fi echo $ac_n "checking for u_int16_t""... $ac_c" 1>&6 -echo "configure:2129: checking for u_int16_t" >&5 +echo "configure:2125: checking for u_int16_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_u_int16_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2159,12 +2155,12 @@ fi elif test "$ac_cv_sizeof_short" = 2 ; then echo $ac_n "checking for int16_t""... $ac_c" 1>&6 -echo "configure:2163: checking for int16_t" >&5 +echo "configure:2159: checking for int16_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_int16_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2192,12 +2188,12 @@ EOF fi echo $ac_n "checking for u_int16_t""... $ac_c" 1>&6 -echo "configure:2196: checking for u_int16_t" >&5 +echo "configure:2192: checking for u_int16_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_u_int16_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2229,12 +2225,12 @@ else fi if test "$ac_cv_sizeof_int" = 4 ; then echo $ac_n "checking for int32_t""... $ac_c" 1>&6 -echo "configure:2233: checking for int32_t" >&5 +echo "configure:2229: checking for int32_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_int32_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2262,12 +2258,12 @@ EOF fi echo $ac_n "checking for u_int32_t""... $ac_c" 1>&6 -echo "configure:2266: checking for u_int32_t" >&5 +echo "configure:2262: checking for u_int32_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_u_int32_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2296,12 +2292,12 @@ fi elif test "$ac_cv_sizeof_short" = 4 ; then echo $ac_n "checking for int32_t""... $ac_c" 1>&6 -echo "configure:2300: checking for int32_t" >&5 +echo "configure:2296: checking for int32_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_int32_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2329,12 +2325,12 @@ EOF fi echo $ac_n "checking for u_int32_t""... $ac_c" 1>&6 -echo "configure:2333: checking for u_int32_t" >&5 +echo "configure:2329: checking for u_int32_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_u_int32_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2363,12 +2359,12 @@ fi elif test "$ac_cv_sizeof_long" = 4 ; then echo $ac_n "checking for int32_t""... $ac_c" 1>&6 -echo "configure:2367: checking for int32_t" >&5 +echo "configure:2363: checking for int32_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_int32_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2396,12 +2392,12 @@ EOF fi echo $ac_n "checking for u_int32_t""... $ac_c" 1>&6 -echo "configure:2400: checking for u_int32_t" >&5 +echo "configure:2396: checking for u_int32_t" >&5 if eval "test \"`echo '$''{'ac_cv_type_u_int32_t'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < #if STDC_HEADERS @@ -2433,12 +2429,12 @@ else fi echo $ac_n "checking for kqueue""... $ac_c" 1>&6 -echo "configure:2437: checking for kqueue" >&5 +echo "configure:2433: checking for kqueue" >&5 if eval "test \"`echo '$''{'ac_cv_func_kqueue'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then +if { (eval echo configure:2461: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then rm -rf conftest* eval "ac_cv_func_kqueue=yes" else @@ -2482,7 +2478,7 @@ fi echo $ac_n "checking for restartable system calls""... $ac_c" 1>&6 -echo "configure:2486: checking for restartable system calls" >&5 +echo "configure:2482: checking for restartable system calls" >&5 if eval "test \"`echo '$''{'ac_cv_sys_restartable_syscalls'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2490,7 +2486,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext <&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:2508: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then ac_cv_sys_restartable_syscalls=yes else @@ -2532,15 +2528,15 @@ fi echo $ac_n "checking for donuts""... $ac_c" 1>&6 -echo "configure:2536: checking for donuts" >&5 +echo "configure:2532: checking for donuts" >&5 echo "$ac_t""yes" 1>&6 -for ac_prog in mawk gawk nawk awk +for ac_prog in gawk mawk nawk awk do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 -echo "configure:2544: checking for $ac_word" >&5 +echo "configure:2540: checking for $ac_word" >&5 if eval "test \"`echo '$''{'ac_cv_prog_AWK'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2570,7 +2566,7 @@ test -n "$AWK" && break done echo $ac_n "checking whether ${MAKE-make} sets \${MAKE}""... $ac_c" 1>&6 -echo "configure:2574: checking whether ${MAKE-make} sets \${MAKE}" >&5 +echo "configure:2570: checking whether ${MAKE-make} sets \${MAKE}" >&5 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y%./+-%__p_%'` if eval "test \"`echo '$''{'ac_cv_prog_make_${ac_make}_set'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 @@ -2608,7 +2604,7 @@ fi # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff" # ./install, which can be erroneously created by make from ./install.sh. echo $ac_n "checking for a BSD compatible install""... $ac_c" 1>&6 -echo "configure:2612: checking for a BSD compatible install" >&5 +echo "configure:2608: checking for a BSD compatible install" >&5 if test -z "$INSTALL"; then if eval "test \"`echo '$''{'ac_cv_path_install'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 @@ -2661,7 +2657,7 @@ test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL_PROGRAM}' test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644' echo $ac_n "checking whether ln -s works""... $ac_c" 1>&6 -echo "configure:2665: checking whether ln -s works" >&5 +echo "configure:2661: checking whether ln -s works" >&5 if eval "test \"`echo '$''{'ac_cv_prog_LN_S'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2686,7 +2682,7 @@ do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 -echo "configure:2690: checking for $ac_word" >&5 +echo "configure:2686: checking for $ac_word" >&5 if eval "test \"`echo '$''{'ac_cv_path_RMPROG'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2727,7 +2723,7 @@ do # Extract the first word of "$ac_prog", so it can be a program name with args. set dummy $ac_prog; ac_word=$2 echo $ac_n "checking for $ac_word""... $ac_c" 1>&6 -echo "configure:2731: checking for $ac_word" >&5 +echo "configure:2727: checking for $ac_word" >&5 if eval "test \"`echo '$''{'ac_cv_path_SHPROG'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2765,7 +2761,7 @@ test -n "$SHPROG" || SHPROG="/bin/sh" echo $ac_n "checking for posix non-blocking""... $ac_c" 1>&6 -echo "configure:2769: checking for posix non-blocking" >&5 +echo "configure:2765: checking for posix non-blocking" >&5 if eval "test \"`echo '$''{'unet_cv_sys_nonblocking_posix'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2773,7 +2769,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < #include @@ -2799,7 +2795,7 @@ int main(void) exit(1); } EOF -if { (eval echo configure:2803: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:2799: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then unet_cv_sys_nonblocking_posix=yes else @@ -2821,7 +2817,7 @@ EOF else echo $ac_n "checking for bsd non-blocking""... $ac_c" 1>&6 -echo "configure:2825: checking for bsd non-blocking" >&5 +echo "configure:2821: checking for bsd non-blocking" >&5 if eval "test \"`echo '$''{'unet_cv_sys_nonblocking_bsd'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2829,7 +2825,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < #include @@ -2855,7 +2851,7 @@ int main(void) exit(1); } EOF -if { (eval echo configure:2859: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:2855: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then unet_cv_sys_nonblocking_bsd=yes else @@ -2883,19 +2879,19 @@ EOF fi fi echo $ac_n "checking for posix signals""... $ac_c" 1>&6 -echo "configure:2887: checking for posix signals" >&5 +echo "configure:2883: checking for posix signals" >&5 if eval "test \"`echo '$''{'unet_cv_sys_signal_posix'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else cat > conftest.$ac_ext < int main() { sigaction(SIGTERM, (struct sigaction *)0L, (struct sigaction *)0L) ; return 0; } EOF -if { (eval echo configure:2899: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:2895: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* unet_cv_sys_signal_posix=yes else @@ -2915,7 +2911,7 @@ EOF else echo $ac_n "checking for bsd reliable signals""... $ac_c" 1>&6 -echo "configure:2919: checking for bsd reliable signals" >&5 +echo "configure:2915: checking for bsd reliable signals" >&5 if eval "test \"`echo '$''{'unet_cv_sys_signal_bsd'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else @@ -2923,7 +2919,7 @@ else { echo "configure: error: can not run test program while cross compiling" 1>&2; exit 1; } else cat > conftest.$ac_ext < int calls = 0; @@ -2941,7 +2937,7 @@ int main(void) exit (0); } EOF -if { (eval echo configure:2945: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null +if { (eval echo configure:2941: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null then unet_cv_sys_signal_bsd=yes else @@ -2970,20 +2966,20 @@ fi fi echo $ac_n "checking if the compiler understands -pipe""... $ac_c" 1>&6 -echo "configure:2974: checking if the compiler understands -pipe" >&5 +echo "configure:2970: checking if the compiler understands -pipe" >&5 unet_cv_pipe_flags="$ac_cv_prog_gcc" if test "$ac_cv_prog_gcc" = no; then OLDCFLAGS="$CFLAGS" CFLAGS="$CFLAGS -pipe" cat > conftest.$ac_ext <&5; (eval $ac_compile) 2>&5; }; then +if { (eval echo configure:2983: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then rm -rf conftest* unet_cv_pipe_flags=yes else @@ -3003,7 +2999,7 @@ fi echo $ac_n "checking for OS-dependent information""... $ac_c" 1>&6 -echo "configure:3007: checking for OS-dependent information" >&5 +echo "configure:3003: checking for OS-dependent information" >&5 case "$host" in *-linux*) echo "$ac_t""Linux ($host) found." 1>&6 @@ -3063,7 +3059,7 @@ esac echo $ac_n "checking whether to enable use of poll()""... $ac_c" 1>&6 -echo "configure:3067: checking whether to enable use of poll()" >&5 +echo "configure:3063: checking whether to enable use of poll()" >&5 # Check whether --enable-poll or --disable-poll was given. if test "${enable_poll+set}" = set; then enableval="$enable_poll" @@ -3097,7 +3093,7 @@ fi echo $ac_n "checking whether to enable debug mode""... $ac_c" 1>&6 -echo "configure:3101: checking whether to enable debug mode" >&5 +echo "configure:3097: checking whether to enable debug mode" >&5 # Check whether --enable-debug or --disable-debug was given. if test "${enable_debug+set}" = set; then enableval="$enable_debug" @@ -3121,7 +3117,7 @@ EOF fi echo $ac_n "checking whether to enable asserts""... $ac_c" 1>&6 -echo "configure:3125: checking whether to enable asserts" >&5 +echo "configure:3121: checking whether to enable asserts" >&5 # Check whether --enable-asserts or --disable-asserts was given. if test "${enable_asserts+set}" = set; then enableval="$enable_asserts" @@ -3130,7 +3126,7 @@ else if eval "test \"`echo '$''{'unet_cv_enable_asserts'+set}'`\" = set"; then echo $ac_n "(cached) $ac_c" 1>&6 else - unet_cv_enable_asserts=no + unet_cv_enable_asserts=yes fi fi @@ -3145,7 +3141,7 @@ EOF fi echo $ac_n "checking whether to enable debugging symbols""... $ac_c" 1>&6 -echo "configure:3149: checking whether to enable debugging symbols" >&5 +echo "configure:3145: checking whether to enable debugging symbols" >&5 # Check whether --enable-symbols or --disable-symbols was given. if test "${enable_symbols+set}" = set; then enableval="$enable_symbols" @@ -3166,7 +3162,7 @@ if test x"$unet_cv_enable_symbols" = xyes; then fi echo $ac_n "checking whether to enable profiling support (gprof)""... $ac_c" 1>&6 -echo "configure:3170: checking whether to enable profiling support (gprof)" >&5 +echo "configure:3166: checking whether to enable profiling support (gprof)" >&5 # Check whether --enable-profile or --disable-profile was given. if test "${enable_profile+set}" = set; then enableval="$enable_profile" @@ -3187,7 +3183,7 @@ if test x"$unet_cv_enable_profile" = xyes; then fi echo $ac_n "checking whether to enable pedantic compiler warnings""... $ac_c" 1>&6 -echo "configure:3191: checking whether to enable pedantic compiler warnings" >&5 +echo "configure:3187: checking whether to enable pedantic compiler warnings" >&5 # Check whether --enable-pedantic or --disable-pedantic was given. if test "${enable_pedantic+set}" = set; then enableval="$enable_pedantic" @@ -3208,7 +3204,7 @@ if test x"$unet_cv_enable_pedantic" = xyes; then fi echo $ac_n "checking whether to enable compiler warnings""... $ac_c" 1>&6 -echo "configure:3212: checking whether to enable compiler warnings" >&5 +echo "configure:3208: checking whether to enable compiler warnings" >&5 # Check whether --enable-warnings or --disable-warnings was given. if test "${enable_warnings+set}" = set; then enableval="$enable_warnings" @@ -3229,7 +3225,7 @@ if test x"$unet_cv_enable_warnings" = xyes; then fi echo $ac_n "checking whether to enable inlining for a few critical functions""... $ac_c" 1>&6 -echo "configure:3233: checking whether to enable inlining for a few critical functions" >&5 +echo "configure:3229: checking whether to enable inlining for a few critical functions" >&5 # Check whether --enable-inlines or --disable-inlines was given. if test "${enable_inlines+set}" = set; then enableval="$enable_inlines" @@ -3253,7 +3249,7 @@ EOF fi echo $ac_n "checking whether to enable the /dev/poll event engine""... $ac_c" 1>&6 -echo "configure:3257: checking whether to enable the /dev/poll event engine" >&5 +echo "configure:3253: checking whether to enable the /dev/poll event engine" >&5 # Check whether --enable-devpoll or --disable-devpoll was given. if test "${enable_devpoll+set}" = set; then enableval="$enable_devpoll" @@ -3283,7 +3279,7 @@ EOF fi echo $ac_n "checking whether to enable the kqueue event engine""... $ac_c" 1>&6 -echo "configure:3287: checking whether to enable the kqueue event engine" >&5 +echo "configure:3283: checking whether to enable the kqueue event engine" >&5 # Check whether --enable-kqueue or --disable-kqueue was given. if test "${enable_kqueue+set}" = set; then enableval="$enable_kqueue" @@ -3313,7 +3309,7 @@ EOF fi echo $ac_n "checking what name to give the symlink""... $ac_c" 1>&6 -echo "configure:3317: checking what name to give the symlink" >&5 +echo "configure:3313: checking what name to give the symlink" >&5 # Check whether --with-symlink or --without-symlink was given. if test "${with_symlink+set}" = set; then withval="$with_symlink" @@ -3345,7 +3341,7 @@ fi echo $ac_n "checking what permissions to set on the installed binary""... $ac_c" 1>&6 -echo "configure:3349: checking what permissions to set on the installed binary" >&5 +echo "configure:3345: checking what permissions to set on the installed binary" >&5 # Check whether --with-mode or --without-mode was given. if test "${with_mode+set}" = set; then withval="$with_mode" @@ -3371,7 +3367,7 @@ IRCDMODE=$unet_cv_with_mode unet_uid=`id | sed -e 's/.*uid=[0-9]*(//' -e 's/).*//' 2> /dev/null` echo $ac_n "checking which user should own the installed binary""... $ac_c" 1>&6 -echo "configure:3375: checking which user should own the installed binary" >&5 +echo "configure:3371: checking which user should own the installed binary" >&5 # Check whether --with-owner or --without-owner was given. if test "${with_owner+set}" = set; then withval="$with_owner" @@ -3397,7 +3393,7 @@ IRCDOWN=$unet_cv_with_owner unet_gid=`id | sed -e 's/.*gid=[0-9]*(//' -e 's/).*//' 2> /dev/null` echo $ac_n "checking which group should own the installed binary""... $ac_c" 1>&6 -echo "configure:3401: checking which group should own the installed binary" >&5 +echo "configure:3397: checking which group should own the installed binary" >&5 # Check whether --with-group or --without-group was given. if test "${with_group+set}" = set; then withval="$with_group" @@ -3429,7 +3425,7 @@ if test -f /etc/resolv.conf; then fi fi echo $ac_n "checking for site domain name""... $ac_c" 1>&6 -echo "configure:3433: checking for site domain name" >&5 +echo "configure:3429: checking for site domain name" >&5 # Check whether --with-domain or --without-domain was given. if test "${with_domain+set}" = set; then withval="$with_domain" @@ -3459,7 +3455,7 @@ EOF echo $ac_n "checking if chroot operation is desired""... $ac_c" 1>&6 -echo "configure:3463: checking if chroot operation is desired" >&5 +echo "configure:3459: checking if chroot operation is desired" >&5 # Check whether --with-chroot or --without-chroot was given. if test "${with_chroot+set}" = set; then withval="$with_chroot" @@ -3507,7 +3503,7 @@ prefix=$unet_save_prefix exec_prefix=$unet_save_exec_prefix echo $ac_n "checking where the binary will be for /restart""... $ac_c" 1>&6 -echo "configure:3511: checking where the binary will be for /restart" >&5 +echo "configure:3507: checking where the binary will be for /restart" >&5 if test x"$unet_cv_with_symlink" = xno; then unet_spath="$unet_bindir/ircd" else @@ -3529,7 +3525,7 @@ EOF echo $ac_n "checking what the data directory should be""... $ac_c" 1>&6 -echo "configure:3533: checking what the data directory should be" >&5 +echo "configure:3529: checking what the data directory should be" >&5 # Check whether --with-dpath or --without-dpath was given. if test "${with_dpath+set}" = set; then withval="$with_dpath" @@ -3572,7 +3568,7 @@ DPATH=$unet_cv_with_dpath echo $ac_n "checking where the default configuration file resides""... $ac_c" 1>&6 -echo "configure:3576: checking where the default configuration file resides" >&5 +echo "configure:3572: checking where the default configuration file resides" >&5 # Check whether --with-cpath or --without-cpath was given. if test "${with_cpath+set}" = set; then withval="$with_cpath" @@ -3614,7 +3610,7 @@ EOF echo $ac_n "checking where to put the debugging log if debugging enabled""... $ac_c" 1>&6 -echo "configure:3618: checking where to put the debugging log if debugging enabled" >&5 +echo "configure:3614: checking where to put the debugging log if debugging enabled" >&5 # Check whether --with-lpath or --without-lpath was given. if test "${with_lpath+set}" = set; then withval="$with_lpath" @@ -3660,7 +3656,7 @@ EOF unet_maxcon=`ulimit -Hn` unet_maxcon=`expr $unet_maxcon - 4` echo $ac_n "checking max connections""... $ac_c" 1>&6 -echo "configure:3664: checking max connections" >&5 +echo "configure:3660: checking max connections" >&5 # Check whether --with-maxcon or --without-maxcon was given. if test "${with_maxcon+set}" = set; then withval="$with_maxcon" diff --git a/configure.in b/configure.in index c466691..4a6f257 100644 --- a/configure.in +++ b/configure.in @@ -246,13 +246,13 @@ if test x"$unet_cv_enable_debug" = xyes; then AC_DEFINE([DEBUGMODE], , [Enable debugging code]) fi -dnl And now for --enable-asserts +dnl And now for --disable-asserts AC_MSG_CHECKING([whether to enable asserts]) AC_ARG_ENABLE([asserts], -[ --enable-asserts Enable asserts], +[ --disable-asserts Disable assertion checking], [unet_cv_enable_asserts=$enable_asserts], [AC_CACHE_VAL(unet_cv_enable_asserts, -[unet_cv_enable_asserts=no])]) +[unet_cv_enable_asserts=yes])]) AC_MSG_RESULT([$unet_cv_enable_asserts]) if test x"$unet_cv_enable_asserts" = xno; then diff --git a/doc/example.conf b/doc/example.conf index e83adc4..3d42f5f 100644 --- a/doc/example.conf +++ b/doc/example.conf @@ -444,6 +444,7 @@ P:192.168.*:::6666 # F:CLIENT_FLOOD:1024 # F:SERVER_PORT:4400 # F:NODEFAULTMOTD:TRUE +# F:MOTD_BANNER # F:KILL_IPMISMATCH:FALSE # F:IDLE_FROM_MSG:TRUE # F:HUB:FALSE @@ -452,6 +453,8 @@ P:192.168.*:::6666 # F:RANDOM_SEED: # F:DEFAULT_LIST_PARAM # F:NICKNAMEHISTORYLENGTH:800 +# F:HOST_HIDING:FALSE +# F:HIDDEN_HOST:users.undernet.org # F:KILLCHASETIMELIMIT:30 # F:MAXCHANNELSPERUSER:10 # F:AVBANLEN:40 @@ -472,6 +475,7 @@ P:192.168.*:::6666 # F:VIRTUAL_HOST:FALSE # F:TOS_SERVER:0x08 # F:TOS_CLIENT:0x08 +# F:POLLS_PER_LOOP:200 # F:CRYPT_OPER_PASSWORD:TRUE # F:OPER_NO_CHAN_LIMIT:TRUE # F:OPER_MODE_LCHAN:TRUE @@ -494,7 +498,7 @@ P:192.168.*:::6666 # F:OPER_LOPMODE:TRUE # F:OPER_BADCHAN:FALSE # F:OPER_LBADCHAN:FALSE -# F:OPER_SET:TRUE +# F:OPER_SET:FALSE # F:OPERS_SEE_IN_SECRET_CHANNELS:TRUE # F:OPER_WIDE_GLINE:TRUE # F:LOCOP_KILL:TRUE diff --git a/doc/p10.html b/doc/p10.html index c900715..fbbc4fe 100644 --- a/doc/p10.html +++ b/doc/p10.html @@ -12,7 +12,7 @@ (As of ircu 2.10.11)

Undernet Coder-com, coder-com@undernet.org

-$Id: p10.html,v 1.5 2000-07-09 04:52:58 isomer Exp $ +$Id: p10.html,v 1.6 2002-02-14 00:20:40 ghostwolf Exp $

This document aims to be a practical guide for implementing and maintaining the protocol, not just a reference @@ -552,6 +552,12 @@ by reducing the length of common message identifiers. CM + + +ACCOUNT + +AC + [Back]
@@ -703,7 +709,8 @@ the "Host" part of the user@host mask.
  • [Optional]: User modes. If present, this is always +<user modes -for this client>.
    • +for this client>. Note that the special +r usermode is followed by the +client's account name; see the documentation for ACCOUNT.
  • The real IP address of this client, a Base64 encoded 32bit int.
    • @@ -1094,7 +1101,7 @@ succeed never the less.

    4.1.4 - PART

    4.1.5 - KICK

    4.1.6 - TOPIC -

    4.1.4 - CLEARMODE +

    4.1.7 - CLEARMODE
     

      AZAAA CM #coder-com ovpsmikbl
    @@ -1103,6 +1110,12 @@ succeed never the less.
    AZAAA N Nick2 955423230
    4.2.2 - MODE
    AZAAA M Nick2 :+odi
    +4.2.3 - ACCOUNT +
    AX AC AZAAA oper
    +

    The ACCOUNT message provides a way for servers, such as the channel service +server, to set the account name information that is associated with a client. +Once set, it cannot be unset or changed, and will be propagated in NICK during +net bursts using the special user mode +r followed by the account name. 4.3 Channel/Client Messaging.

    4.3.1 - PRIVMSG @@ -1146,6 +1159,8 @@ from msg.h. -Gte. -Kev
    [2000-04-11]: Started work on chapter 4. -Gte
    [2000-06-01]: Changed some info about the max number of clients -Isomer +
    [2002-01-11]: Wrote a specification for ACCOUNT and noted that a usermode +in a NICK message may have an argument. -Kev

    8.1 TODO

    • diff --git a/doc/readme.features b/doc/readme.features index 74520d8..116e446 100644 --- a/doc/readme.features +++ b/doc/readme.features @@ -119,6 +119,13 @@ MOTD to the client by default; instead, it will only tell the client when the MOTD was last changed, and give instructions on how to obtain it by typing /MOTD. +MOTD_BANNER + * Type: string + * Default: NULL + +If you enable NODEFAULTMOTD, this specifies a one-line banner to be sent +to the client in addition to the instructions mentioned above. + KILL_IPMISMATCH * Type: boolean * Default: FALSE @@ -214,6 +221,20 @@ many client disappear that the whole "whowas" list is refreshed a few times (unless you make it rather large). A reasonable value is "total number of clients" / 25. +HOST_HIDING + * Type: boolean + * Default: FALSE + +This selects whether local users can set umode +x, thus allowing them +to hide their hostname if they have also registered with a channel +service (i.e. they have the ACCOUNT flag set). + +HIDDEN_HOST + * Type: string + * Default: users.undernet.org + +This selects the suffix for the hidden hostmask (see HOST_HIDING). + KILLCHASETIMELIMIT * Type: integer * Default: 30 @@ -402,6 +423,15 @@ This option is used to specify the type of service that will be requested for connections to users. The value may be given as a hexadecimal integer. +POLLS_PER_LOOP + * Type: integer + * Default: 200 + +Some of the engines used by the event interface get a number of events +from the kernel at once. Since the number retrieved can impact +performance, it can be tuned by modifying this value. The engines +enforce a lower limit of 20. + CRYPT_OPER_PASSWORD * Type: boolean * Default: TRUE @@ -587,7 +617,7 @@ REGULATED BY THE UNDERNET ADMINISTRATION. OPER_SET * Type: boolean - * Default: TRUE + * Default: FALSE This selects whether global IRC operators on this server are permitted to use the /SET command to set various feature values. diff --git a/include/channel.h b/include/channel.h index 75037c5..66ba3d5 100644 --- a/include/channel.h +++ b/include/channel.h @@ -84,8 +84,7 @@ struct Client; #define MODE_KEY 0x0100 #define MODE_BAN 0x0200 #define MODE_LIMIT 0x0400 -#define MODE_SENDTS 0x0800 /* TS was 0 during a local user /join; send - * temporary TS; can be removed when all 2.10 */ +#define MODE_REGONLY 0x0800 /* Only +r users may join */ #define MODE_LISTED 0x10000 #define MODE_SAVE 0x20000 /* save this mode-with-arg 'til later */ #define MODE_FREE 0x40000 /* string needs to be passed to MyFree() */ @@ -286,7 +285,7 @@ extern int LocalChanOperMode; */ extern void clean_channelname(char* name); extern void channel_modes(struct Client *cptr, char *mbuf, char *pbuf, - struct Channel *chptr); + int buflen, struct Channel *chptr); extern int set_mode(struct Client* cptr, struct Client* sptr, struct Channel* chptr, int parc, char* parv[], char* mbuf, char* pbuf, char* npbuf, int* badop); diff --git a/include/client.h b/include/client.h index 91ceba1..2e56345 100644 --- a/include/client.h +++ b/include/client.h @@ -355,11 +355,13 @@ struct Client { #define FLAGS_WALLOP 0x0040 /* send wallops to them */ #define FLAGS_SERVNOTICE 0x0080 /* server notices such as kill */ #define FLAGS_BLOCKED 0x0100 /* socket is in a blocked condition */ +#define FLAGS_ACCOUNT 0x0200 /* account name has been set */ #define FLAGS_CLOSING 0x0400 /* set when closing to suppress errors */ #define FLAGS_UPING 0x0800 /* has active UDP ping request */ #define FLAGS_CHKACCESS 0x1000 /* ok to check clients access if set */ #define FLAGS_HUB 0x2000 /* server is a hub */ #define FLAGS_SERVICE 0x4000 /* server is a service */ +#define FLAGS_HIDDENHOST 0x8000 /* user's host is hidden */ #define FLAGS_LOCAL 0x00010000 /* set for local clients */ #define FLAGS_GOTID 0x00020000 /* successful ident lookup achieved */ #define FLAGS_DOID 0x00040000 /* I-lines say must use ident return */ @@ -376,7 +378,7 @@ struct Client { #define FLAGS_IPCHECK 0x40000000 /* Added or updated IPregistry data */ #define SEND_UMODES \ - (FLAGS_INVISIBLE|FLAGS_OPER|FLAGS_WALLOP|FLAGS_DEAF|FLAGS_CHSERV|FLAGS_DEBUG) + (FLAGS_INVISIBLE|FLAGS_OPER|FLAGS_WALLOP|FLAGS_DEAF|FLAGS_CHSERV|FLAGS_DEBUG|FLAGS_ACCOUNT|FLAGS_HIDDENHOST) #define ALL_UMODES (SEND_UMODES|FLAGS_SERVNOTICE|FLAGS_LOCOP) #define FLAGS_ID (FLAGS_DOID|FLAGS_GOTID) @@ -406,6 +408,9 @@ struct Client { #define SendWallops(x) (cli_flags(x) & FLAGS_WALLOP) #define IsHub(x) (cli_flags(x) & FLAGS_HUB) #define IsService(x) (cli_flags(x) & FLAGS_SERVICE) +#define IsAccount(x) (cli_flags(x) & FLAGS_ACCOUNT) +#define IsHiddenHost(x) (cli_flags(x) & FLAGS_HIDDENHOST) +#define HasHiddenHost(x) (IsAccount(x) && IsHiddenHost(x)) #define IsPrivileged(x) (IsAnOper(x) || IsServer(x)) @@ -426,6 +431,8 @@ struct Client { #define SetServNotice(x) (cli_flags(x) |= FLAGS_SERVNOTICE) #define SetHub(x) (cli_flags(x) |= FLAGS_HUB) #define SetService(x) (cli_flags(x) |= FLAGS_SERVICE) +#define SetAccount(x) (cli_flags(x) |= FLAGS_ACCOUNT) +#define SetHiddenHost(x) (cli_flags(x) |= FLAGS_HIDDENHOST) #define ClearAccess(x) (cli_flags(x) &= ~FLAGS_CHKACCESS) #define ClearBurst(x) (cli_flags(x) &= ~FLAGS_BURST) @@ -440,6 +447,7 @@ struct Client { #define ClearUPing(x) (cli_flags(x) &= ~FLAGS_UPING) #define ClearWallops(x) (cli_flags(x) &= ~FLAGS_WALLOP) #define ClearServNotice(x) (cli_flags(x) &= ~FLAGS_SERVNOTICE) +#define ClearHiddenHost(x) (cli_flags(x) &= ~FLAGS_HIDDENHOST) /* free flags */ #define FREEFLAG_SOCKET 0x0001 /* socket needs to be freed */ diff --git a/include/fda.h b/include/fda.h index a8f465c..63a5edd 100644 --- a/include/fda.h +++ b/include/fda.h @@ -21,7 +21,7 @@ #ifndef INCLUDED_fda_h #define INCLUDED_fda_h -#if !defined(NDEBUG) +#if defined(MDEBUG) #ifndef INCLUDED_sys_types_h #include /* size_t */ #define INCLUDED_sys_types_h @@ -58,5 +58,5 @@ extern void fda_set_lowmem_handler(void (*fn)(void)); extern void fda_set_nomem_handler(void (*fn)(void)); -#endif /* !defined(NDEBUG) */ +#endif /* defined(MDEBUG) */ #endif /* INCLUDED_fda_h */ diff --git a/include/handlers.h b/include/handlers.h index 20a8751..9b2f566 100644 --- a/include/handlers.h +++ b/include/handlers.h @@ -135,6 +135,7 @@ extern int m_wallchops(struct Client*, struct Client*, int, char*[]); extern int m_who(struct Client*, struct Client*, int, char*[]); extern int m_whois(struct Client*, struct Client*, int, char*[]); extern int m_whowas(struct Client*, struct Client*, int, char*[]); +extern int mo_admin(struct Client*, struct Client*, int, char*[]); extern int mo_clearmode(struct Client*, struct Client*, int, char*[]); extern int mo_close(struct Client*, struct Client*, int, char*[]); extern int mo_connect(struct Client*, struct Client*, int, char*[]); @@ -160,12 +161,14 @@ extern int mo_squit(struct Client*, struct Client*, int, char*[]); extern int mo_stats(struct Client*, struct Client*, int, char*[]); extern int mo_trace(struct Client*, struct Client*, int, char*[]); extern int mo_uping(struct Client*, struct Client*, int, char*[]); +extern int mo_version(struct Client*, struct Client*, int, char*[]); extern int mo_wallops(struct Client*, struct Client*, int, char*[]); extern int mo_wallusers(struct Client*, struct Client*, int, char*[]); extern int mr_error(struct Client*, struct Client*, int, char*[]); extern int mr_error(struct Client*, struct Client*, int, char*[]); extern int mr_pong(struct Client*, struct Client*, int, char*[]); extern int mr_server(struct Client*, struct Client*, int, char*[]); +extern int ms_account(struct Client*, struct Client*, int, char*[]); extern int ms_admin(struct Client*, struct Client*, int, char*[]); extern int ms_away(struct Client*, struct Client*, int, char*[]); extern int ms_burst(struct Client*, struct Client*, int, char*[]); @@ -212,7 +215,7 @@ extern int ms_version(struct Client*, struct Client*, int, char*[]); extern int ms_wallchops(struct Client*, struct Client*, int, char*[]); extern int ms_wallops(struct Client*, struct Client*, int, char*[]); extern int ms_wallusers(struct Client*, struct Client*, int, char*[]); - +extern int ms_whois(struct Client*, struct Client*, int, char*[]); #endif /* INCLUDED_handlers_h */ diff --git a/include/ircd_alloc.h b/include/ircd_alloc.h index 9960293..63d916f 100644 --- a/include/ircd_alloc.h +++ b/include/ircd_alloc.h @@ -30,7 +30,7 @@ typedef void (*OutOfMemoryHandler)(void); extern void set_nomem_handler(OutOfMemoryHandler handler); -#if defined(NDEBUG) +#if !defined(MDEBUG) /* * RELEASE: allocation functions */ @@ -45,7 +45,7 @@ extern void* MyMalloc(size_t size); extern void* MyCalloc(size_t nelem, size_t size); extern void* MyRealloc(void* p, size_t size); -#else /* !defined(NDEBUG) */ +#else /* defined(MDEBUG) */ /* * DEBUG: allocation functions */ @@ -58,7 +58,7 @@ extern void* MyRealloc(void* p, size_t size); #define MyFree(p) fda_free((p)) #define MyRealloc(p, s) fda_realloc((p), (s), __FILE__, __LINE__) -#endif /* !defined(NDEBUG) */ +#endif /* defined(MDEBUG) */ #endif /* INCLUDED_ircd_alloc_h */ diff --git a/include/ircd_defs.h b/include/ircd_defs.h index e6ad720..492c49e 100644 --- a/include/ircd_defs.h +++ b/include/ircd_defs.h @@ -76,6 +76,12 @@ * are shorter. It is possible to have a valid FQDN longer than 63 characters. */ #define HOSTLEN 63 +/* + * ACCOUNTLEN is the maximum length for the account name, which can be set + * with the ACCOUNT (AC) command. This is used for keeping track of who's + * logged into which account, for the benefit of irc services. + */ +#define ACCOUNTLEN 12 /* * REALLEN is the maximum length for user supplied information about a client * connection (gcos). This information is set at client/server registration @@ -92,10 +98,13 @@ */ #define SOCKIPLEN 15 /* - * TOPICLEN is the maximum length for channel topics, kill comments, - * and quit comments + * TOPICLEN is the maximum length for channel topics and kill comments */ #define TOPICLEN 160 +/* + * AWAYLEN is the maximum length for away messages + */ +#define AWAYLEN 160 /* * BUFSIZE is exactly long enough to hold one protocol message (RFC 1459) * including the line termination (\r\n). diff --git a/include/ircd_events.h b/include/ircd_events.h index 54d034f..2dfe924 100644 --- a/include/ircd_events.h +++ b/include/ircd_events.h @@ -82,6 +82,8 @@ struct GenHeader { #define GEN_DESTROY 0x0001 /* generator is to be destroyed */ #define GEN_MARKED 0x0002 /* generator is marked for destruction */ #define GEN_ACTIVE 0x0004 /* generator is active */ +#define GEN_READD 0x0008 /* generator (timer) must be re-added */ +#define GEN_ERROR 0x0010 /* an error occurred on the generator */ struct Socket { struct GenHeader s_header; /* generator information */ @@ -141,6 +143,7 @@ struct Timer { #define t_ed_int(tim) ((tim)->t_header.gh_engdata.ed_int) #define t_ed_ptr(tim) ((tim)->t_header.gh_engdata.ed_ptr) #define t_active(tim) ((tim)->t_header.gh_flags & GEN_ACTIVE) +#define t_onqueue(tim) ((tim)->t_header.gh_prev_p) struct Event { struct Event* ev_next; /* linked list of events on queue */ @@ -208,6 +211,8 @@ do { \ event_generate(ET_DESTROY, _gen, 0); \ } \ } while (0) +#define gen_clear_error(gen) \ + (((struct GenHeader*) (gen))->gh_flags &= ~GEN_ERROR) void gen_dequeue(void* arg); @@ -215,6 +220,7 @@ void event_init(int max_sockets); void event_loop(void); void event_generate(enum EventType type, void* arg, int data); +struct Timer* timer_init(struct Timer* timer); void timer_add(struct Timer* timer, EventCallBack call, void* data, enum TimerType type, time_t value); void timer_del(struct Timer* timer); diff --git a/include/ircd_features.h b/include/ircd_features.h index 6d4dea3..ddb31db 100644 --- a/include/ircd_features.h +++ b/include/ircd_features.h @@ -33,6 +33,7 @@ enum Feature { FEAT_CLIENT_FLOOD, FEAT_SERVER_PORT, FEAT_NODEFAULTMOTD, + FEAT_MOTD_BANNER, FEAT_KILL_IPMISMATCH, FEAT_IDLE_FROM_MSG, FEAT_HUB, @@ -41,6 +42,8 @@ enum Feature { FEAT_RANDOM_SEED, FEAT_DEFAULT_LIST_PARAM, FEAT_NICKNAMEHISTORYLENGTH, + FEAT_HOST_HIDING, + FEAT_HIDDEN_HOST, /* features that probably should not be touched */ FEAT_KILLCHASETIMELIMIT, @@ -67,6 +70,7 @@ enum Feature { FEAT_VIRTUAL_HOST, FEAT_TOS_SERVER, FEAT_TOS_CLIENT, + FEAT_POLLS_PER_LOOP, /* features that affect all operators */ FEAT_CRYPT_OPER_PASSWORD, diff --git a/include/msg.h b/include/msg.h index a41acc1..878ebb9 100644 --- a/include/msg.h +++ b/include/msg.h @@ -326,6 +326,10 @@ struct Client; #define TOK_CLEARMODE "CM" #define CMD_CLEARMODE MSG_CLEARMODE, TOK_CLEARMODE +#define MSG_ACCOUNT "ACCOUNT" /* ACCO */ +#define TOK_ACCOUNT "AC" +#define CMD_ACCOUNT MSG_ACCOUNT, TOK_ACCOUNT + #define MSG_POST "POST" /* POST */ #define TOK_POST "POST" diff --git a/include/numeric.h b/include/numeric.h index 28ce4d0..b16d284 100644 --- a/include/numeric.h +++ b/include/numeric.h @@ -203,7 +203,6 @@ extern const struct Numeric* get_error_numeric(int err); #define RPL_TEXT 304 /* unused */ #define RPL_UNAWAY 305 #define RPL_NOWAWAY 306 -#define RPL_USERIP 307 /* Undernet extension */ /* NotAway, aircd */ /* RPL_WHOISREGNICK 307 Numeric List: Dalnet */ /* RPL_SUSERHOST 307 austnet */ @@ -240,6 +239,7 @@ extern const struct Numeric* get_error_numeric(int err); /* RPL_CHANNEL_URL 328 dalnet, anothernet */ #define RPL_CREATIONTIME 329 /* RPL_WHOWAS_TIME 330 ? */ +#define RPL_WHOISACCOUNT 330 #define RPL_NOTOPIC 331 #define RPL_TOPIC 332 #define RPL_TOPICWHOTIME 333 /* Undernet extension */ @@ -247,11 +247,9 @@ extern const struct Numeric* get_error_numeric(int err); /* RPL_COMMANDSYNTAX 334 Dalnet */ /* RPL_LISTSYNTAX 334 unreal */ /* RPL_CHANPASSOK 338 IRCnet extension (?)*/ -/* RPL_WHOISACTUALLY 338 dalnet */ -/* RPL_BADCHANPASS 339 IRCnet extension (?)*/ -/* 339 mIRC/DALnet extension */ -/* 440 mIRC/DALnet extension */ - +#define RPL_WHOISACTUALLY 338 /* Undernet extension, dalnet */ +/* RPL_BADCHANPASS 339 mIRC/DALnet extension */ +#define RPL_USERIP 340 /* Undernet extension */ #define RPL_INVITING 341 /* RPL_SUMMONING 342 removed from RFC1459 */ @@ -385,7 +383,7 @@ extern const struct Numeric* get_error_numeric(int err); #define ERR_BANNEDFROMCHAN 474 #define ERR_BADCHANNELKEY 475 #define ERR_BADCHANMASK 476 /* Undernet extension */ -/* ERR_NEEDREGGEDNICK 477 DalNet Extention */ +#define ERR_NEEDREGGEDNICK 477 /* DalNet&Undernet Extention */ #define ERR_BANLISTFULL 478 /* Undernet extension */ /* ERR_LINKFAIL 479 unreal */ diff --git a/include/s_user.h b/include/s_user.h index 542cc55..f9d9e4c 100644 --- a/include/s_user.h +++ b/include/s_user.h @@ -72,6 +72,7 @@ extern void send_user_info(struct Client* to, char* names, int rpl, InfoFormatter fmt); extern int add_silence(struct Client* sptr, const char* mask); +extern int hide_hostmask(struct Client *cptr, unsigned int flags); extern int set_user_mode(struct Client *cptr, struct Client *sptr, int parc, char *parv[]); extern int is_silenced(struct Client *sptr, struct Client *acptr); diff --git a/include/send.h b/include/send.h index 1fd6421..5554050 100644 --- a/include/send.h +++ b/include/send.h @@ -48,15 +48,19 @@ extern void sendcmdto_serv_butone(struct Client *from, const char *cmd, const char *pattern, ...); /* Send command to all channels user is on */ -extern void sendcmdto_common_channels(struct Client *from, const char *cmd, - const char *tok, const char *pattern, - ...); - +extern void sendcmdto_common_channels_butone(struct Client *from, + const char *cmd, + const char *tok, + struct Client *one, + const char *pattern, ...); /* Send command to all channel users on this server */ -extern void sendcmdto_channel_butserv(struct Client *from, const char *cmd, - const char *tok, struct Channel *to, - const char *pattern, ...); +extern void sendcmdto_channel_butserv_butone(struct Client *from, + const char *cmd, + const char *tok, + struct Channel *to, + struct Client *one, + const char *pattern, ...); /* Send command to all interested channel users */ extern void sendcmdto_channel_butone(struct Client *from, const char *cmd, diff --git a/include/struct.h b/include/struct.h index 34fbe40..2975fec 100644 --- a/include/struct.h +++ b/include/struct.h @@ -70,6 +70,8 @@ struct User { unsigned int invites; /* Number of channels we've been invited to */ char username[USERLEN + 1]; char host[HOSTLEN + 1]; + char realhost[HOSTLEN + 1]; + char account[ACCOUNTLEN + 1]; }; #endif /* INCLUDED_struct_h */ diff --git a/include/supported.h b/include/supported.h index 72f7602..677c091 100644 --- a/include/supported.h +++ b/include/supported.h @@ -43,19 +43,21 @@ " MAXBANS=%i" \ " NICKLEN=%i" \ " TOPICLEN=%i" \ - " KICKLEN=%i" \ - " CHANTYPES=%s" + " AWAYLEN=%i" \ + " KICKLEN=%i" -#define FEATURES2 "PREFIX=%s" \ +#define FEATURES2 "CHANTYPES=%s" \ + " PREFIX=%s" \ " CHANMODES=%s" \ - " CHARSET=%s" + " CHARSET=%s" \ + " NETWORK=%s" #define FEATURESVALUES1 feature_int(FEAT_MAXSILES), MAXMODEPARAMS, \ feature_int(FEAT_MAXCHANNELSPERUSER), \ feature_int(FEAT_MAXBANS), NICKLEN, TOPICLEN, \ - TOPICLEN, "+#&" + AWAYLEN, TOPICLEN -#define FEATURESVALUES2 "(ov)@+", "b,k,l,imnpst", "rfc1459" +#define FEATURESVALUES2 "+#&", "(ov)@+", "b,k,l,imnpstr", "rfc1459", NETWORK #endif /* INCLUDED_supported_h */ diff --git a/include/whowas.h b/include/whowas.h index 6c1254b..5da1e25 100644 --- a/include/whowas.h +++ b/include/whowas.h @@ -48,6 +48,7 @@ struct Whowas { char *name; char *username; char *hostname; + char *realhost; char *servername; char *realname; char *away; diff --git a/ircd/IPcheck.c b/ircd/IPcheck.c index 050ea0d..47c102f 100644 --- a/ircd/IPcheck.c +++ b/ircd/IPcheck.c @@ -197,7 +197,7 @@ static void ip_registry_expire(struct Event* ev) */ void IPcheck_init(void) { - timer_add(&expireTimer, ip_registry_expire, 0, TT_PERIODIC, 60); + timer_add(timer_init(&expireTimer), ip_registry_expire, 0, TT_PERIODIC, 60); } /* diff --git a/ircd/Makefile.in b/ircd/Makefile.in index 0375b8c..482de12 100644 --- a/ircd/Makefile.in +++ b/ircd/Makefile.in @@ -61,6 +61,7 @@ LIBS = @LIBS@ #### End of system configuration section. #### PURIFY = +RINGLOG_O = OSDEP_SRC = \ os_bsd.c \ @@ -100,6 +101,7 @@ IRCD_SRC = \ jupe.c \ list.c \ listener.c \ + m_account.c \ m_admin.c \ m_away.c \ m_burst.c \ @@ -195,11 +197,13 @@ IRCD_SRC = \ whocmds.c \ whowas.c +CHKCONF_SRC = chkconf.c + SRC = ${IRCD_SRC} ${OSDEP_C} ${ENGINE_C} OBJS = ${SRC:%.c=%.o} -DEP_SRC = ${IRCD_SRC} ${OSDEP_SRC} ${ENGINE_SRC} +DEP_SRC = ${IRCD_SRC} ${OSDEP_SRC} ${ENGINE_SRC} ${CHKCONF_SRC} all: ( cd ..; make -f Makefile ) @@ -212,7 +216,8 @@ all: build: ircd chkconf ircd: ${OBJS} ../include/patchlevel.h version.o - ${PURIFY} ${CC} ${OBJS} version.o ${LDFLAGS} ${LIBS} -o ircd + ${PURIFY} ${CC} ${OBJS} version.o ${RINGLOG_O} ${LDFLAGS} ${LIBS} \ + -o ircd ${CHMOD} ${IRCDMODE} ircd # @@ -225,7 +230,8 @@ ircd: ${OBJS} ../include/patchlevel.h version.o # must be a better solution...perhaps sum all of the .c files and include # only that one sum? # -version.c: version.c.SH s_serv.c s_user.c channel.c s_bsd.c s_misc.c ircd.c +version.c: version.c.SH s_serv.c s_user.c channel.c s_bsd.c s_misc.c ircd.c \ + ../include/version.h ../include/patchlevel.h ${SHELL} ${srcdir}/version.c.SH ircd_string.o: ircd_string.c chattr.tab.c @@ -337,45 +343,897 @@ depend: # DO NOT DELETE THIS LINE -- make depend depends on it. -IPcheck.o: IPcheck.c ../config.h ../include/IPcheck.h \ - ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ - ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ - ../include/ircd.h ../include/struct.h ../include/msg.h \ - ../include/numnicks.h ../include/ircd_alloc.h ../include/s_debug.h \ - ../include/s_user.h ../include/send.h +IPcheck.o: IPcheck.c ../config.h ../include/IPcheck.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/msg.h ../include/numnicks.h \ + ../include/ircd_alloc.h ../include/s_debug.h ../include/s_user.h \ + ../include/send.h channel.o: channel.c ../config.h ../include/channel.h \ - ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ - ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ - ../include/hash.h ../include/ircd.h ../include/struct.h \ - ../include/ircd_alloc.h ../include/ircd_chattr.h \ - ../include/ircd_features.h ../include/ircd_log.h \ - ../include/ircd_policy.h ../include/ircd_reply.h \ - ../include/ircd_snprintf.h ../include/ircd_string.h ../include/list.h \ - ../include/match.h ../include/msg.h ../include/numeric.h \ - ../include/numnicks.h ../include/querycmds.h ../include/s_bsd.h \ - ../include/s_conf.h ../include/s_debug.h ../include/s_misc.h \ - ../include/s_user.h ../include/send.h ../include/support.h \ - ../include/sys.h ../include/whowas.h + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_features.h ../include/ircd_log.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h ../include/list.h \ + ../include/match.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/querycmds.h ../include/s_bsd.h \ + ../include/s_conf.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_user.h ../include/send.h ../include/support.h \ + ../include/sys.h ../include/whowas.h class.o: class.c ../config.h ../include/class.h ../include/client.h \ - ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ - ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ - ../include/struct.h ../include/ircd_alloc.h \ - ../include/ircd_features.h ../include/ircd_reply.h ../include/list.h \ - ../include/numeric.h ../include/s_conf.h ../include/s_debug.h \ - ../include/send.h -client.o: client.c ../config.h ../include/client.h \ - ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ - ../include/ircd_events.h ../include/ircd_handler.h ../include/class.h \ - ../include/ircd.h ../include/struct.h ../include/ircd_features.h \ - ../include/ircd_reply.h ../include/list.h ../include/numeric.h \ - ../include/s_conf.h ../include/s_debug.h ../include/send.h + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_reply.h ../include/list.h ../include/numeric.h \ + ../include/s_conf.h ../include/s_debug.h ../include/send.h +client.o: client.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/class.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_features.h ../include/ircd_reply.h \ + ../include/list.h ../include/numeric.h ../include/s_conf.h \ + ../include/s_debug.h ../include/send.h crule.o: crule.c ../config.h ../include/crule.h ../include/client.h \ - ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ - ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ - ../include/struct.h ../include/ircd_alloc.h ../include/ircd_chattr.h \ - ../include/ircd_string.h ../include/match.h ../include/s_bsd.h \ - ../include/s_debug.h + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_string.h ../include/match.h ../include/s_bsd.h \ + ../include/s_debug.h dbuf.o: dbuf.c ../config.h ../include/dbuf.h ../include/ircd_alloc.h \ - ../include/ircd_chattr.h ../include/ircd_features.h ../include/send.h \ - ../include/sys.h + ../include/ircd_chattr.h ../include/ircd_features.h ../include/send.h \ + ../include/sys.h fda.o: fda.c ../config.h +fileio.o: fileio.c ../config.h ../include/fileio.h \ + ../include/ircd_alloc.h +gline.o: gline.c ../config.h ../include/gline.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/match.h ../include/numeric.h \ + ../include/s_bsd.h ../include/s_debug.h ../include/s_misc.h \ + ../include/send.h ../include/support.h ../include/msg.h \ + ../include/numnicks.h ../include/sys.h ../include/whocmds.h +hash.o: hash.c ../config.h ../include/hash.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/channel.h \ + ../include/ircd_chattr.h ../include/ircd_string.h ../include/ircd.h \ + ../include/struct.h ../include/msg.h ../include/send.h \ + ../include/support.h ../include/sys.h +ircd.o: ircd.c ../config.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_defs.h ../include/IPcheck.h ../include/class.h \ + ../include/client.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/crule.h \ + ../include/hash.h ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/ircd_reply.h ../include/ircd_signal.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/jupe.h \ + ../include/list.h ../include/match.h ../include/motd.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/parse.h \ + ../include/res.h ../include/s_auth.h ../include/s_bsd.h \ + ../include/s_conf.h ../include/s_debug.h ../include/s_misc.h \ + ../include/send.h ../include/sys.h ../include/uping.h \ + ../include/userload.h ../include/version.h ../include/whowas.h +ircd_alloc.o: ircd_alloc.c ../config.h ../include/ircd_alloc.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/s_debug.h \ + ../include/ircd_defs.h +ircd_events.o: ircd_events.c ../config.h ../include/ircd_events.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_defs.h \ + ../include/ircd_alloc.h ../include/ircd_log.h \ + ../include/ircd_snprintf.h ../include/s_debug.h +ircd_features.o: ircd_features.c ../config.h ../include/ircd_features.h \ + ../include/channel.h ../include/ircd_defs.h ../include/class.h \ + ../include/client.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_log.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/match.h ../include/motd.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/random.h ../include/s_bsd.h ../include/s_debug.h \ + ../include/s_misc.h ../include/send.h ../include/support.h \ + ../include/sys.h ../include/whowas.h +ircd_log.o: ircd_log.c ../config.h ../include/ircd_log.h \ + ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_alloc.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/ircd.h ../include/struct.h \ + ../include/numeric.h ../include/s_debug.h ../include/send.h +ircd_relay.o: ircd_relay.c ../config.h ../include/ircd_relay.h \ + ../include/channel.h ../include/ircd_defs.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_chattr.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_debug.h \ + ../include/s_misc.h ../include/s_user.h ../include/send.h +ircd_reply.o: ircd_reply.c ../config.h ../include/ircd_reply.h \ + ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_snprintf.h \ + ../include/msg.h ../include/numeric.h ../include/s_conf.h \ + ../include/s_debug.h ../include/send.h +ircd_signal.o: ircd_signal.c ../config.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_defs.h ../include/ircd_events.h \ + ../include/ircd_signal.h ../include/s_conf.h +ircd_snprintf.o: ircd_snprintf.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/channel.h \ + ../include/ircd_snprintf.h ../include/struct.h +ircd_string.o: ircd_string.c ../config.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/ircd_defs.h ../include/ircd_log.h \ + chattr.tab.c +ircd_xopen.o: ircd_xopen.c ../config.h ../include/ircd_xopen.h +jupe.o: jupe.c ../config.h ../include/jupe.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_log.h ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_bsd.h ../include/s_misc.h ../include/send.h \ + ../include/support.h ../include/sys.h +list.o: list.c ../config.h ../include/list.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/listener.h \ + ../include/match.h ../include/numeric.h ../include/res.h \ + ../include/s_auth.h ../include/s_bsd.h ../include/s_conf.h \ + ../include/s_debug.h ../include/s_misc.h ../include/s_user.h \ + ../include/send.h ../include/support.h ../include/whowas.h +listener.o: listener.c ../config.h ../include/listener.h \ + ../include/ircd_defs.h ../include/ircd_events.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_handler.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_features.h ../include/ircd_osdep.h \ + ../include/ircd_reply.h ../include/ircd_snprintf.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/numeric.h \ + ../include/s_bsd.h ../include/s_conf.h ../include/s_misc.h \ + ../include/send.h ../include/sys.h +m_account.o: m_account.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numnicks.h \ + ../include/s_user.h ../include/send.h +m_admin.o: m_admin.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_conf.h ../include/s_user.h +m_away.o: m_away.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_user.h \ + ../include/send.h +m_burst.o: m_burst.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/list.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_conf.h ../include/s_misc.h ../include/send.h \ + ../include/support.h +m_clearmode.o: m_clearmode.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/channel.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/list.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/send.h \ + ../include/support.h +m_close.o: m_close.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_reply.h ../include/numeric.h \ + ../include/s_bsd.h ../include/send.h +m_connect.o: m_connect.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/crule.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_features.h ../include/ircd_log.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/jupe.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_bsd.h ../include/s_conf.h ../include/s_user.h \ + ../include/send.h +m_cprivmsg.o: m_cprivmsg.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/s_user.h +m_create.o: m_create.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_user.h ../include/send.h +m_defaults.o: m_defaults.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_reply.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h ../include/supported.h \ + ../include/channel.h ../include/version.h +m_destruct.o: m_destruct.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/send.h +m_desynch.o: m_desynch.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_bsd.h \ + ../include/send.h +m_die.o: m_die.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_bsd.h ../include/send.h +m_endburst.o: m_endburst.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_error.o: m_error.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_debug.h ../include/s_misc.h ../include/send.h +m_get.o: m_get.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_features.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_gline.o: m_gline.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/gline.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_features.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_conf.h ../include/s_misc.h ../include/send.h \ + ../include/support.h +m_help.o: m_help.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_info.o: m_info.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_misc.h ../include/s_user.h \ + ../include/s_conf.h ../include/send.h ../include/version.h +m_invite.o: m_invite.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/list.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_user.h \ + ../include/send.h +m_ison.o: m_ison.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/numeric.h ../include/send.h +m_join.o: m_join.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/gline.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_chattr.h ../include/ircd_features.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_debug.h \ + ../include/s_user.h ../include/send.h +m_jupe.o: m_jupe.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/jupe.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_features.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_conf.h \ + ../include/s_misc.h ../include/send.h ../include/support.h +m_kick.o: m_kick.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_kill.o: m_kill.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_log.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/ircd_snprintf.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_misc.h \ + ../include/send.h ../include/whowas.h +m_links.o: m_links.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_user.h ../include/send.h +m_list.o: m_list.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_features.h ../include/ircd_log.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_bsd.h \ + ../include/send.h +m_lusers.o: m_lusers.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/querycmds.h \ + ../include/ircd_features.h ../include/s_user.h ../include/s_serv.h \ + ../include/send.h +m_map.o: m_map.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/list.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/s_user.h \ + ../include/s_serv.h ../include/send.h ../include/querycmds.h \ + ../include/ircd_features.h +m_mode.o: m_mode.c ../config.h ../include/handlers.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_conf.h ../include/s_debug.h \ + ../include/s_user.h ../include/send.h +m_motd.o: m_motd.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/motd.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_conf.h ../include/class.h \ + ../include/s_user.h ../include/send.h +m_names.o: m_names.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_user.h ../include/send.h +m_nick.o: m_nick.c ../config.h ../include/IPcheck.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_chattr.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_policy.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_user.h ../include/send.h +m_notice.o: m_notice.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_chattr.h ../include/ircd_relay.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/send.h \ + ../include/handlers.h +m_oper.o: m_oper.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_features.h ../include/ircd_log.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/ircd_xopen.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/querycmds.h \ + ../include/s_conf.h ../include/s_debug.h ../include/s_user.h \ + ../include/s_misc.h ../include/send.h ../include/support.h +m_opmode.o: m_opmode.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/channel.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_features.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/send.h +m_part.o: m_part.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/numeric.h ../include/numnicks.h \ + ../include/send.h +m_pass.o: m_pass.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/send.h +m_ping.o: m_ping.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/ircd.h \ + ../include/struct.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_debug.h ../include/send.h +m_pong.o: m_pong.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_user.h ../include/send.h +m_privmsg.o: m_privmsg.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_chattr.h ../include/ircd_features.h \ + ../include/ircd_relay.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/send.h +m_privs.o: m_privs.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_proto.o: m_proto.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_debug.h \ + ../include/s_misc.h ../include/send.h ../include/supported.h \ + ../include/channel.h ../include/version.h +m_quit.o: m_quit.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/struct.h \ + ../include/s_misc.h ../include/ircd_reply.h +m_rehash.o: m_rehash.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_log.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/motd.h \ + ../include/numeric.h ../include/s_conf.h ../include/send.h +m_reset.o: m_reset.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_features.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/numeric.h ../include/numnicks.h \ + ../include/send.h +m_restart.o: m_restart.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_log.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_rping.o: m_rping.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/opercmds.h \ + ../include/s_user.h ../include/send.h +m_rpong.o: m_rpong.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/opercmds.h \ + ../include/send.h +m_server.o: m_server.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_log.h \ + ../include/ircd_features.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/jupe.h \ + ../include/list.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/querycmds.h \ + ../include/s_bsd.h ../include/s_conf.h ../include/s_debug.h \ + ../include/s_misc.h ../include/s_serv.h ../include/send.h \ + ../include/userload.h +m_set.o: m_set.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_features.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_settime.o: m_settime.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_features.h \ + ../include/ircd_reply.h ../include/ircd_snprintf.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/list.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_user.h ../include/send.h +m_silence.o: m_silence.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/list.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_user.h \ + ../include/send.h +m_squit.o: m_squit.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_chattr.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/numeric.h \ + ../include/numnicks.h ../include/match.h ../include/s_debug.h \ + ../include/s_misc.h ../include/s_user.h ../include/send.h +m_stats.o: m_stats.c ../config.h ../include/handlers.h \ + ../include/s_stats.h ../include/channel.h ../include/ircd_defs.h \ + ../include/class.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/gline.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_features.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/list.h \ + ../include/listener.h ../include/match.h ../include/motd.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/opercmds.h ../include/s_bsd.h ../include/s_conf.h \ + ../include/s_debug.h ../include/s_misc.h ../include/s_serv.h \ + ../include/s_user.h ../include/send.h ../include/userload.h +m_time.o: m_time.c ../config.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_misc.h \ + ../include/s_user.h ../include/send.h +m_topic.o: m_topic.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h +m_trace.o: m_trace.c ../config.h ../include/class.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_bsd.h ../include/s_conf.h ../include/s_user.h \ + ../include/send.h ../include/version.h +m_uping.o: m_uping.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_conf.h ../include/s_user.h ../include/send.h \ + ../include/uping.h +m_user.o: m_user.c ../config.h ../include/handlers.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_chattr.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_debug.h ../include/s_misc.h ../include/s_user.h \ + ../include/send.h +m_userhost.o: m_userhost.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/numeric.h ../include/s_user.h \ + ../include/struct.h +m_userip.o: m_userip.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/numeric.h ../include/s_user.h \ + ../include/struct.h +m_version.o: m_version.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_features.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_debug.h ../include/s_user.h \ + ../include/send.h ../include/supported.h ../include/channel.h \ + ../include/version.h +m_wallchops.o: m_wallchops.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_user.h ../include/send.h +m_wallops.o: m_wallops.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/send.h +m_wallusers.o: m_wallusers.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/send.h +m_who.o: m_who.c ../config.h ../include/channel.h ../include/ircd_defs.h \ + ../include/client.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_chattr.h \ + ../include/ircd_log.h ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/match.h ../include/numeric.h \ + ../include/numnicks.h ../include/send.h ../include/support.h \ + ../include/whocmds.h +m_whois.o: m_whois.c ../config.h ../include/channel.h \ + ../include/ircd_defs.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/hash.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_user.h ../include/send.h ../include/whocmds.h +m_whowas.o: m_whowas.c ../config.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/s_user.h ../include/s_misc.h \ + ../include/send.h ../include/whowas.h +match.o: match.c ../config.h ../include/match.h ../include/ircd_chattr.h +motd.o: motd.c ../config.h ../include/motd.h ../include/class.h \ + ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/fileio.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_conf.h \ + ../include/s_debug.h ../include/s_user.h ../include/send.h +msgq.o: msgq.c ../config.h ../include/msgq.h ../include/ircd_defs.h \ + ../include/ircd_alloc.h ../include/ircd_snprintf.h ../include/s_debug.h +numnicks.o: numnicks.c ../config.h ../include/numnicks.h \ + ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/match.h \ + ../include/s_bsd.h ../include/s_debug.h ../include/s_misc.h +opercmds.o: opercmds.c ../config.h ../include/opercmds.h \ + ../include/class.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_chattr.h ../include/ircd_reply.h \ + ../include/ircd_string.h ../include/listener.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/s_conf.h ../include/send.h +packet.o: packet.c ../config.h ../include/packet.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_chattr.h ../include/parse.h \ + ../include/s_bsd.h ../include/s_misc.h ../include/send.h +parse.o: parse.c ../config.h ../include/parse.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/channel.h \ + ../include/handlers.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_features.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/ircd_string.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/opercmds.h \ + ../include/querycmds.h ../include/res.h ../include/s_bsd.h \ + ../include/s_conf.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_numeric.h ../include/s_user.h ../include/send.h \ + ../include/sys.h ../include/whocmds.h ../include/whowas.h +querycmds.o: querycmds.c ../config.h ../include/querycmds.h \ + ../include/ircd_features.h +random.o: random.c ../config.h ../include/random.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd_log.h ../include/ircd_reply.h ../include/send.h +res.o: res.c ../config.h ../include/res.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_log.h \ + ../include/ircd_osdep.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/msg.h ../include/numeric.h \ + ../include/s_bsd.h ../include/s_debug.h ../include/s_misc.h \ + ../include/send.h ../include/support.h ../include/sys.h +s_auth.o: s_auth.c ../config.h ../include/s_auth.h \ + ../include/ircd_events.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_handler.h \ + ../include/IPcheck.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_features.h ../include/ircd_log.h \ + ../include/ircd_osdep.h ../include/ircd_snprintf.h \ + ../include/ircd_string.h ../include/list.h ../include/numeric.h \ + ../include/querycmds.h ../include/res.h ../include/s_bsd.h \ + ../include/s_debug.h ../include/s_misc.h ../include/send.h \ + ../include/sys.h +s_bsd.o: s_bsd.c ../config.h ../include/s_bsd.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/IPcheck.h \ + ../include/channel.h ../include/class.h ../include/hash.h \ + ../include/ircd_log.h ../include/ircd_features.h \ + ../include/ircd_osdep.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/ircd.h ../include/struct.h \ + ../include/list.h ../include/listener.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/packet.h \ + ../include/parse.h ../include/querycmds.h ../include/res.h \ + ../include/s_auth.h ../include/s_conf.h ../include/s_debug.h \ + ../include/s_misc.h ../include/s_user.h ../include/send.h \ + ../include/support.h ../include/sys.h ../include/uping.h \ + ../include/version.h +s_conf.o: s_conf.c ../config.h ../include/s_conf.h ../include/IPcheck.h \ + ../include/class.h ../include/client.h ../include/ircd_defs.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/crule.h ../include/ircd_features.h \ + ../include/fileio.h ../include/gline.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_chattr.h ../include/ircd_log.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h ../include/list.h \ + ../include/listener.h ../include/match.h ../include/motd.h \ + ../include/numeric.h ../include/numnicks.h ../include/opercmds.h \ + ../include/parse.h ../include/res.h ../include/s_bsd.h \ + ../include/s_debug.h ../include/s_misc.h ../include/send.h \ + ../include/support.h ../include/sys.h +s_debug.o: s_debug.c ../config.h ../include/s_debug.h \ + ../include/ircd_defs.h ../include/channel.h ../include/class.h \ + ../include/client.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/ircd_osdep.h ../include/ircd_reply.h \ + ../include/ircd.h ../include/struct.h ../include/list.h \ + ../include/numeric.h ../include/numnicks.h ../include/res.h \ + ../include/s_bsd.h ../include/s_conf.h ../include/send.h \ + ../include/sys.h ../include/whowas.h +s_err.o: s_err.c ../config.h ../include/numeric.h ../include/s_debug.h \ + ../include/ircd_defs.h +s_misc.o: s_misc.c ../config.h ../include/s_misc.h ../include/IPcheck.h \ + ../include/channel.h ../include/ircd_defs.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_log.h \ + ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/list.h ../include/match.h \ + ../include/msg.h ../include/numeric.h ../include/numnicks.h \ + ../include/parse.h ../include/querycmds.h ../include/ircd_features.h \ + ../include/res.h ../include/s_bsd.h ../include/s_conf.h \ + ../include/s_debug.h ../include/s_user.h ../include/send.h \ + ../include/support.h ../include/sys.h ../include/uping.h \ + ../include/userload.h +s_numeric.o: s_numeric.c ../config.h ../include/s_numeric.h \ + ../include/channel.h ../include/ircd_defs.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_policy.h ../include/ircd_snprintf.h \ + ../include/numnicks.h ../include/send.h +s_serv.o: s_serv.c ../config.h ../include/s_serv.h ../include/IPcheck.h \ + ../include/channel.h ../include/ircd_defs.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/gline.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/ircd_snprintf.h \ + ../include/ircd_xopen.h ../include/jupe.h ../include/list.h \ + ../include/match.h ../include/msg.h ../include/numeric.h \ + ../include/numnicks.h ../include/parse.h ../include/querycmds.h \ + ../include/ircd_features.h ../include/s_bsd.h ../include/s_conf.h \ + ../include/s_debug.h ../include/s_misc.h ../include/s_user.h \ + ../include/send.h ../include/sys.h ../include/userload.h +s_stats.o: s_stats.c ../config.h ../include/s_stats.h ../include/class.h \ + ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_chattr.h \ + ../include/ircd_log.h ../include/ircd_reply.h ../include/ircd_string.h \ + ../include/listener.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_conf.h \ + ../include/s_user.h ../include/send.h +s_user.o: s_user.c ../config.h ../include/s_user.h ../include/IPcheck.h \ + ../include/channel.h ../include/ircd_defs.h ../include/class.h \ + ../include/client.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/hash.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_alloc.h \ + ../include/ircd_chattr.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/ircd_policy.h ../include/ircd_reply.h \ + ../include/ircd_snprintf.h ../include/ircd_string.h ../include/list.h \ + ../include/match.h ../include/motd.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/parse.h \ + ../include/querycmds.h ../include/random.h ../include/s_bsd.h \ + ../include/s_conf.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_serv.h ../include/send.h ../include/support.h \ + ../include/supported.h ../include/sys.h ../include/userload.h \ + ../include/version.h ../include/whowas.h ../include/handlers.h +send.o: send.c ../config.h ../include/send.h ../include/channel.h \ + ../include/ircd_defs.h ../include/class.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_policy.h ../include/ircd_snprintf.h \ + ../include/ircd_string.h ../include/ircd_chattr.h ../include/list.h \ + ../include/match.h ../include/msg.h ../include/numnicks.h \ + ../include/parse.h ../include/s_bsd.h ../include/s_debug.h \ + ../include/s_misc.h ../include/s_user.h ../include/sys.h +support.o: support.c ../config.h ../include/support.h ../include/fileio.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_defs.h \ + ../include/ircd_chattr.h ../include/ircd_snprintf.h ../include/s_bsd.h \ + ../include/s_debug.h ../include/send.h ../include/sys.h +uping.o: uping.c ../config.h ../include/uping.h ../include/ircd_defs.h \ + ../include/ircd_events.h ../include/client.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_log.h \ + ../include/ircd_osdep.h ../include/ircd_string.h \ + ../include/ircd_chattr.h ../include/match.h ../include/msg.h \ + ../include/numeric.h ../include/numnicks.h ../include/s_bsd.h \ + ../include/s_conf.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_user.h ../include/send.h ../include/sys.h +userload.o: userload.c ../config.h ../include/userload.h \ + ../include/client.h ../include/ircd_defs.h ../include/dbuf.h \ + ../include/msgq.h ../include/ircd_events.h ../include/ircd_handler.h \ + ../include/ircd.h ../include/struct.h ../include/msg.h \ + ../include/numnicks.h ../include/querycmds.h ../include/ircd_features.h \ + ../include/s_misc.h ../include/send.h ../include/sys.h +whocmds.o: whocmds.c ../config.h ../include/whocmds.h \ + ../include/channel.h ../include/ircd_defs.h ../include/client.h \ + ../include/dbuf.h ../include/msgq.h ../include/ircd_events.h \ + ../include/ircd_handler.h ../include/hash.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_chattr.h ../include/ircd_policy.h \ + ../include/ircd_reply.h ../include/ircd_snprintf.h \ + ../include/ircd_string.h ../include/list.h ../include/match.h \ + ../include/numeric.h ../include/numnicks.h ../include/querycmds.h \ + ../include/ircd_features.h ../include/random.h ../include/s_bsd.h \ + ../include/s_conf.h ../include/s_misc.h ../include/s_user.h \ + ../include/send.h ../include/support.h ../include/sys.h \ + ../include/userload.h ../include/version.h ../include/whowas.h \ + ../include/msg.h +whowas.o: whowas.c ../config.h ../include/whowas.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/ircd.h \ + ../include/struct.h ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_features.h ../include/ircd_string.h ../include/list.h \ + ../include/numeric.h ../include/s_debug.h ../include/s_misc.h \ + ../include/s_user.h ../include/send.h ../include/support.h \ + ../include/sys.h ../include/msg.h +os_bsd.o: os_bsd.c ../config.h ../include/ircd_osdep.h ../include/msgq.h \ + ../include/ircd_defs.h +os_linux.o: os_linux.c ../config.h ../include/ircd_osdep.h \ + ../include/msgq.h ../include/ircd_defs.h +os_openbsd.o: os_openbsd.c ../config.h ../include/ircd_osdep.h \ + ../include/msgq.h ../include/ircd_defs.h +os_generic.o: os_generic.c ../config.h ../include/ircd_osdep.h \ + ../include/msgq.h ../include/ircd_defs.h +os_solaris.o: os_solaris.c ../config.h ../include/ircd_osdep.h \ + ../include/msgq.h ../include/ircd_defs.h +engine_devpoll.o: engine_devpoll.c ../config.h ../include/ircd_events.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_defs.h \ + ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/s_debug.h +engine_poll.o: engine_poll.c ../config.h ../include/ircd_events.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_defs.h \ + ../include/ircd_alloc.h ../include/ircd_log.h ../include/s_debug.h +engine_kqueue.o: engine_kqueue.c ../config.h ../include/ircd_events.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_defs.h \ + ../include/ircd_alloc.h ../include/ircd_features.h \ + ../include/ircd_log.h ../include/s_debug.h +engine_select.o: engine_select.c ../config.h ../include/ircd_events.h \ + ../include/ircd.h ../include/struct.h ../include/ircd_defs.h \ + ../include/ircd_log.h ../include/s_debug.h +chkconf.o: chkconf.c ../config.h ../include/s_conf.h ../include/client.h \ + ../include/ircd_defs.h ../include/dbuf.h ../include/msgq.h \ + ../include/ircd_events.h ../include/ircd_handler.h ../include/class.h \ + ../include/fileio.h ../include/ircd.h ../include/struct.h \ + ../include/ircd_alloc.h ../include/ircd_chattr.h \ + ../include/ircd_string.h ../include/sys.h diff --git a/ircd/channel.c b/ircd/channel.c index c9cf899..1db9475 100644 --- a/ircd/channel.c +++ b/ircd/channel.c @@ -162,11 +162,11 @@ struct Client* find_chasing(struct Client* sptr, const char* user, int* chasing) * Create a string of form "foo!bar@fubar" given foo, bar and fubar * as the parameters. If NULL, they become "*". */ -static char *make_nick_user_host(const char *nick, const char *name, - const char *host) +#define NUH_BUFSIZE (NICKLEN + USERLEN + HOSTLEN + 3) +static char *make_nick_user_host(char *namebuf, const char *nick, + const char *name, const char *host) { - static char namebuf[NICKLEN + USERLEN + HOSTLEN + 3]; - ircd_snprintf(0, namebuf, sizeof(namebuf), "%s!%s@%s", nick, name, host); + ircd_snprintf(0, namebuf, NUH_BUFSIZE, "%s!%s@%s", nick, name, host); return namebuf; } @@ -174,10 +174,11 @@ static char *make_nick_user_host(const char *nick, const char *name, * Create a string of form "foo!bar@123.456.789.123" given foo, bar and the * IP-number as the parameters. If NULL, they become "*". */ -static char *make_nick_user_ip(char *nick, char *name, struct in_addr ip) +#define NUI_BUFSIZE (NICKLEN + USERLEN + 16 + 3) +static char *make_nick_user_ip(char *ipbuf, char *nick, char *name, + struct in_addr ip) { - static char ipbuf[NICKLEN + USERLEN + 16 + 3]; - ircd_snprintf(0, ipbuf, sizeof(ipbuf), "%s!%s@%s", nick, name, + ircd_snprintf(0, ipbuf, NUI_BUFSIZE, "%s!%s@%s", nick, name, ircd_ntoa((const char*) &ip)); return ipbuf; } @@ -410,7 +411,11 @@ static int is_banned(struct Client *cptr, struct Channel *chptr, struct Membership* member) { struct SLink* tmp; + char nu_host[NUH_BUFSIZE]; + char nu_realhost[NUH_BUFSIZE]; + char nu_ip[NUI_BUFSIZE]; char* s; + char* sr = NULL; char* ip_s = NULL; if (!IsUser(cptr)) @@ -419,19 +424,25 @@ static int is_banned(struct Client *cptr, struct Channel *chptr, if (member && IsBanValid(member)) return IsBanned(member); - s = make_nick_user_host(cli_name(cptr), (cli_user(cptr))->username, + s = make_nick_user_host(nu_host, cli_name(cptr), (cli_user(cptr))->username, (cli_user(cptr))->host); + if (HasHiddenHost(cptr)) + sr = make_nick_user_host(nu_realhost, cli_name(cptr), + (cli_user(cptr))->username, + cli_user(cptr)->realhost); for (tmp = chptr->banlist; tmp; tmp = tmp->next) { if ((tmp->flags & CHFL_BAN_IPMASK)) { if (!ip_s) - ip_s = make_nick_user_ip(cli_name(cptr), (cli_user(cptr))->username, - cli_ip(cptr)); + ip_s = make_nick_user_ip(nu_ip, cli_name(cptr), + (cli_user(cptr))->username, cli_ip(cptr)); if (match(tmp->value.ban.banstr, ip_s) == 0) break; } else if (match(tmp->value.ban.banstr, s) == 0) break; + else if (sr && match(tmp->value.ban.banstr, sr) == 0) + break; } if (member) { @@ -637,11 +648,12 @@ int client_can_send_to_channel(struct Client *cptr, struct Channel *chptr) * +n (no external messages) or +m (moderated). */ if (!member) { - if ((chptr->mode.mode & (MODE_NOPRIVMSGS|MODE_MODERATED)) - || IsModelessChannel(chptr->chname)) + if ((chptr->mode.mode & (MODE_NOPRIVMSGS|MODE_MODERATED)) || + IsModelessChannel(chptr->chname) || + ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(cptr))) return 0; else - return 1; + return !is_banned(cptr, chptr, NULL); } return member_can_send_to_channel(member); } @@ -669,7 +681,7 @@ const char* find_no_nickchange_channel(struct Client* cptr) * write the "simple" list of channel modes for channel chptr onto buffer mbuf * with the parameters in pbuf. */ -void channel_modes(struct Client *cptr, char *mbuf, char *pbuf, +void channel_modes(struct Client *cptr, char *mbuf, char *pbuf, int buflen, struct Channel *chptr) { assert(0 != mbuf); @@ -689,9 +701,11 @@ void channel_modes(struct Client *cptr, char *mbuf, char *pbuf, *mbuf++ = 'i'; if (chptr->mode.mode & MODE_NOPRIVMSGS) *mbuf++ = 'n'; + if (chptr->mode.mode & MODE_REGONLY) + *mbuf++ = 'r'; if (chptr->mode.limit) { *mbuf++ = 'l'; - ircd_snprintf(0, pbuf, sizeof(pbuf), "%u", chptr->mode.limit); + ircd_snprintf(0, pbuf, buflen, "%u", chptr->mode.limit); } if (*chptr->mode.key) { @@ -734,7 +748,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr) lp2 = chptr->banlist; *modebuf = *parabuf = '\0'; - channel_modes(cptr, modebuf, parabuf, chptr); + channel_modes(cptr, modebuf, parabuf, sizeof(parabuf), chptr); for (first = 1; full; first = 0) /* Loop for multiple messages */ { @@ -854,6 +868,7 @@ void send_channel_modes(struct Client *cptr, struct Channel *chptr) char *pretty_mask(char *mask) { static char star[2] = { '*', 0 }; + static char retmask[NUH_BUFSIZE]; char *last_dot = NULL; char *ptr; @@ -926,7 +941,7 @@ char *pretty_mask(char *mask) host = ptr - HOSTLEN; *host = '*'; } - return make_nick_user_host(nick, user, host); + return make_nick_user_host(retmask, nick, user, host); } static void send_ban_list(struct Client* cptr, struct Channel* chptr) @@ -1005,6 +1020,9 @@ int can_join(struct Client *sptr, struct Channel *chptr, char *key) if (chptr->mode.limit && chptr->users >= chptr->mode.limit) return overrideJoin + ERR_CHANNELISFULL; + + if ((chptr->mode.mode & MODE_REGONLY) && !IsAccount(sptr)) + return overrideJoin + ERR_NEEDREGGEDNICK; if (is_banned(sptr, chptr, NULL)) return overrideJoin + ERR_BANNEDFROMCHAN; @@ -1320,6 +1338,7 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all) MODE_TOPICLIMIT, 't', MODE_INVITEONLY, 'i', MODE_NOPRIVMSGS, 'n', + MODE_REGONLY, 'r', /* MODE_KEY, 'k', */ /* MODE_BAN, 'b', */ /* MODE_LIMIT, 'l', */ @@ -1465,7 +1484,7 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all) } /* send the messages off to their destination */ - if (mbuf->mb_dest & MODEBUF_DEST_HACK2) { + if (mbuf->mb_dest & MODEBUF_DEST_HACK2) sendto_opmask_butone(0, SNO_HACK2, "HACK(2): %s MODE %s %s%s%s%s%s%s " "[%Tu]", #ifdef HEAD_IN_SAND_SNOTICES @@ -1477,18 +1496,6 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all) rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "", addbuf, remstr, addstr, mbuf->mb_channel->creationtime); - sendcmdto_serv_butone(&me, CMD_DESYNCH, mbuf->mb_connect, - ":HACK: %s MODE %s %s%s%s%s%s%s [%Tu]", -#ifdef HEAD_IN_SAND_SNOTICES - cli_name(mbuf->mb_source), -#else - cli_name(app_source), -#endif - mbuf->mb_channel->chname, - rembuf_i ? "-" : "", rembuf, - addbuf_i ? "+" : "", addbuf, remstr, addstr, - mbuf->mb_channel->creationtime); - } if (mbuf->mb_dest & MODEBUF_DEST_HACK3) sendto_opmask_butone(0, SNO_HACK3, "BOUNCE or HACK(3): %s MODE %s " @@ -1522,7 +1529,7 @@ modebuf_flush_int(struct ModeBuf *mbuf, int all) addbuf_i ? "+" : "", addbuf, remstr, addstr); if (mbuf->mb_dest & MODEBUF_DEST_CHANNEL) - sendcmdto_channel_butserv(app_source, CMD_MODE, mbuf->mb_channel, + sendcmdto_channel_butserv_butone(app_source, CMD_MODE, mbuf->mb_channel, NULL, "%H %s%s%s%s%s%s", mbuf->mb_channel, rembuf_i ? "-" : "", rembuf, addbuf_i ? "+" : "", addbuf, remstr, addstr); @@ -1686,7 +1693,7 @@ modebuf_mode(struct ModeBuf *mbuf, unsigned int mode) assert(0 != (mode & (MODE_ADD | MODE_DEL))); mode &= (MODE_ADD | MODE_DEL | MODE_PRIVATE | MODE_SECRET | MODE_MODERATED | - MODE_TOPICLIMIT | MODE_INVITEONLY | MODE_NOPRIVMSGS); + MODE_TOPICLIMIT | MODE_INVITEONLY | MODE_NOPRIVMSGS | MODE_REGONLY); if (!(mode & ~(MODE_ADD | MODE_DEL))) /* don't add empty modes... */ return; @@ -1789,6 +1796,7 @@ modebuf_extract(struct ModeBuf *mbuf, char *buf) MODE_KEY, 'k', /* MODE_BAN, 'b', */ MODE_LIMIT, 'l', + MODE_REGONLY, 'r', 0x0, 0x0 }; unsigned int add; @@ -2434,6 +2442,7 @@ mode_parse(struct ModeBuf *mbuf, struct Client *cptr, struct Client *sptr, MODE_KEY, 'k', MODE_BAN, 'b', MODE_LIMIT, 'l', + MODE_REGONLY, 'r', MODE_ADD, '+', MODE_DEL, '-', 0x0, 0x0 @@ -2646,7 +2655,7 @@ joinbuf_join(struct JoinBuf *jbuf, struct Channel *chan, unsigned int flags) jbuf->jb_type == JOINBUF_TYPE_PARTALL) { /* Send notification to channel */ if (!(flags & CHFL_ZOMBIE)) - sendcmdto_channel_butserv(jbuf->jb_source, CMD_PART, chan, + sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_PART, chan, NULL, (flags & CHFL_BANNED || !jbuf->jb_comment) ? ":%H" : "%H :%s", chan, jbuf->jb_comment); else if (MyUser(jbuf->jb_source)) @@ -2673,12 +2682,12 @@ joinbuf_join(struct JoinBuf *jbuf, struct Channel *chan, unsigned int flags) "%H %Tu", chan, chan->creationtime); /* Send the notification to the channel */ - sendcmdto_channel_butserv(jbuf->jb_source, CMD_JOIN, chan, ":%H", chan); + sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_JOIN, chan, NULL, ":%H", chan); /* send an op, too, if needed */ if (!MyUser(jbuf->jb_source) && jbuf->jb_type == JOINBUF_TYPE_CREATE && !IsModelessChannel(chan->chname)) - sendcmdto_channel_butserv(jbuf->jb_source, CMD_MODE, chan, "%H +o %C", + sendcmdto_channel_butserv_butone(jbuf->jb_source, CMD_MODE, chan, NULL, "%H +o %C", chan, jbuf->jb_source); } diff --git a/ircd/client.c b/ircd/client.c index 4f416fb..3cbe27d 100644 --- a/ircd/client.c +++ b/ircd/client.c @@ -49,6 +49,8 @@ int client_get_ping(const struct Client* acptr) struct ConfItem* aconf; struct SLink* link; + assert(cli_verify(acptr)); + for (link = cli_confs(acptr); link; link = link->next) { aconf = link->value.aconf; if (aconf->status & (CONF_CLIENT | CONF_SERVER)) { @@ -61,6 +63,7 @@ int client_get_ping(const struct Client* acptr) ping = feature_int(FEAT_PINGFREQUENCY); Debug((DEBUG_DEBUG, "Client %s Ping %d", cli_name(acptr), ping)); + return ping; } diff --git a/ircd/engine_devpoll.c b/ircd/engine_devpoll.c index ece113a..5cf7eff 100644 --- a/ircd/engine_devpoll.c +++ b/ircd/engine_devpoll.c @@ -24,6 +24,7 @@ #include "ircd.h" #include "ircd_alloc.h" +#include "ircd_features.h" #include "ircd_log.h" #include "s_debug.h" @@ -40,8 +41,6 @@ #define DEVPOLL_ERROR_THRESHOLD 20 /* after 20 devpoll errors, restart */ #define ERROR_EXPIRE_TIME 3600 /* expire errors after an hour */ -#define POLLS_PER_DEVPOLL 20 /* get 20 pollfd's per turn */ - /* Figure out what bits to set for read */ #if defined(POLLMSG) && defined(POLLIN) && defined(POLLRDNORM) # define POLLREADFLAGS (POLLMSG|POLLIN|POLLRDNORM) @@ -241,16 +240,26 @@ static void engine_loop(struct Generators* gen) { struct dvpoll dopoll; - struct pollfd polls[POLLS_PER_DEVPOLL]; + struct pollfd *polls; + int polls_count; struct Socket* sock; int nfds; int i; int errcode; size_t codesize; + if ((polls_count = feature_int(FEAT_POLLS_PER_LOOP)) < 20) + polls_count = 20; + polls = (struct pollfd *)MyMalloc(sizeof(struct pollfd) * polls_count); + while (running) { + if ((i = feature_int(FEAT_POLLS_PER_LOOP)) >= 20 && i != polls_count) { + polls = (struct pollfd *)MyRealloc(polls, sizeof(struct pollfd) * i); + polls_count = i; + } + dopoll.dp_fds = polls; /* set up the struct dvpoll */ - dopoll.dp_nfds = POLLS_PER_DEVPOLL; + dopoll.dp_nfds = polls_count; /* calculate the proper timeout */ dopoll.dp_timeout = timer_next(gen) ? @@ -269,7 +278,7 @@ engine_loop(struct Generators* gen) /* Log the poll error */ log_write(LS_SOCKET, L_ERROR, 0, "ioctl(DP_POLL) error: %m"); if (!errors++) - timer_add(&clear_error, error_clear, 0, TT_PERIODIC, + timer_add(timer_init(&clear_error), error_clear, 0, TT_PERIODIC, ERROR_EXPIRE_TIME); else if (errors > DEVPOLL_ERROR_THRESHOLD) /* too many errors... */ server_restart("too many /dev/poll errors"); @@ -282,13 +291,13 @@ engine_loop(struct Generators* gen) for (i = 0; i < nfds; i++) { assert(-1 < polls[i].fd); - assert(0 != sockList[polls[i].fd]); - assert(s_fd(sockList[polls[i].fd]) == polls[i].fd); sock = sockList[polls[i].fd]; if (!sock) /* slots may become empty while processing events */ continue; + assert(s_fd(sock) == polls[i].fd); + gen_ref_inc(sock); /* can't have it going away on us */ Debug((DEBUG_ENGINE, "devpoll: Checking socket %p (fd %d) state %s, " diff --git a/ircd/engine_kqueue.c b/ircd/engine_kqueue.c index aafbb59..892c595 100644 --- a/ircd/engine_kqueue.c +++ b/ircd/engine_kqueue.c @@ -24,6 +24,7 @@ #include "ircd.h" #include "ircd_alloc.h" +#include "ircd_features.h" #include "ircd_log.h" #include "s_debug.h" @@ -40,8 +41,6 @@ #define KQUEUE_ERROR_THRESHOLD 20 /* after 20 kqueue errors, restart */ #define ERROR_EXPIRE_TIME 3600 /* expire errors after an hour */ -#define POLLS_PER_KQUEUE 20 /* get 20 kevents per turn */ - static struct Socket** sockList; static int kqueue_max; static int kqueue_id; @@ -177,7 +176,7 @@ set_or_clear(struct Socket* sock, unsigned int clear, unsigned int set) i++; /* advance count... */ } - if (kevent(kqueue_id, chglist, i, 0, 0, 0) < 0) + if (kevent(kqueue_id, chglist, i, 0, 0, 0) < 0 && errno != EBADF) event_generate(ET_ERROR, sock, errno); /* report error */ } @@ -278,7 +277,8 @@ engine_delete(struct Socket* sock) static void engine_loop(struct Generators* gen) { - struct kevent events[POLLS_PER_KQUEUE]; + struct kevent *events; + int events_count; struct Socket* sock; struct timespec wait; int nevs; @@ -286,7 +286,16 @@ engine_loop(struct Generators* gen) int errcode; size_t codesize; + if ((events_count = feature_int(FEAT_POLLS_PER_LOOP)) < 20) + events_count = 20; + events = (struct kevent *)MyMalloc(sizeof(struct kevent) * events_count); + while (running) { + if ((i = feature_int(FEAT_POLLS_PER_LOOP)) >= 20 && i != events_count) { + events = (struct kevent *)MyRealloc(events, sizeof(struct kevent) * i); + events_count = i; + } + /* set up the sleep time */ wait.tv_sec = timer_next(gen) ? (timer_next(gen) - CurrentTime) : -1; wait.tv_nsec = 0; @@ -295,7 +304,7 @@ engine_loop(struct Generators* gen) CurrentTime, wait.tv_sec)); /* check for active events */ - nevs = kevent(kqueue_id, 0, 0, events, POLLS_PER_KQUEUE, + nevs = kevent(kqueue_id, 0, 0, events, events_count, wait.tv_sec < 0 ? 0 : &wait); CurrentTime = time(0); /* set current time... */ @@ -305,7 +314,7 @@ engine_loop(struct Generators* gen) /* Log the kqueue error */ log_write(LS_SOCKET, L_ERROR, 0, "kevent() error: %m"); if (!errors++) - timer_add(&clear_error, error_clear, 0, TT_PERIODIC, + timer_add(timer_init(&clear_error), error_clear, 0, TT_PERIODIC, ERROR_EXPIRE_TIME); else if (errors > KQUEUE_ERROR_THRESHOLD) /* too many errors... */ server_restart("too many kevent errors"); diff --git a/ircd/engine_poll.c b/ircd/engine_poll.c index b5ca2c7..a166d4f 100644 --- a/ircd/engine_poll.c +++ b/ircd/engine_poll.c @@ -263,7 +263,7 @@ engine_loop(struct Generators* gen) /* Log the poll error */ log_write(LS_SOCKET, L_ERROR, 0, "poll() error: %m"); if (!errors++) - timer_add(&clear_error, error_clear, 0, TT_PERIODIC, + timer_add(timer_init(&clear_error), error_clear, 0, TT_PERIODIC, ERROR_EXPIRE_TIME); else if (errors > POLL_ERROR_THRESHOLD) /* too many errors... */ server_restart("too many poll errors"); diff --git a/ircd/engine_select.c b/ircd/engine_select.c index f09c771..2149b89 100644 --- a/ircd/engine_select.c +++ b/ircd/engine_select.c @@ -241,7 +241,7 @@ engine_loop(struct Generators* gen) /* Log the select error */ log_write(LS_SOCKET, L_ERROR, 0, "select() error: %m"); if (!errors++) - timer_add(&clear_error, error_clear, 0, TT_PERIODIC, + timer_add(timer_init(&clear_error), error_clear, 0, TT_PERIODIC, ERROR_EXPIRE_TIME); else if (errors > SELECT_ERROR_THRESHOLD) /* too many errors... */ server_restart("too many select errors"); diff --git a/ircd/fda.c b/ircd/fda.c index 6355a97..e932ab3 100644 --- a/ircd/fda.c +++ b/ircd/fda.c @@ -26,7 +26,7 @@ #include #include -#if !defined(NDEBUG) +#if defined(MDEBUG) #ifndef HTABLE_SIZE #define HTABLE_SIZE 65539 @@ -650,5 +650,5 @@ char* fda_strdup(const char* src, const char* file, int line) return p; } -#endif /* !defined(NDEBUG) */ +#endif /* defined(MDEBUG) */ diff --git a/ircd/gline.c b/ircd/gline.c index 403a1d4..3e99706 100644 --- a/ircd/gline.c +++ b/ircd/gline.c @@ -609,7 +609,7 @@ gline_lookup(struct Client *cptr, unsigned int flags) continue; } else { - if (match(gline->gl_host, (cli_user(cptr))->host) != 0) + if (match(gline->gl_host, (cli_user(cptr))->realhost) != 0) continue; } return gline; diff --git a/ircd/ircd.c b/ircd/ircd.c index 151f459..ea3a538 100644 --- a/ircd/ircd.c +++ b/ircd/ircd.c @@ -615,8 +615,8 @@ int main(int argc, char **argv) { uping_init(); IPcheck_init(); - timer_add(&connect_timer, try_connections, 0, TT_RELATIVE, 1); - timer_add(&ping_timer, check_pings, 0, TT_RELATIVE, 1); + timer_add(timer_init(&connect_timer), try_connections, 0, TT_RELATIVE, 1); + timer_add(timer_init(&ping_timer), check_pings, 0, TT_RELATIVE, 1); CurrentTime = time(NULL); diff --git a/ircd/ircd_alloc.c b/ircd/ircd_alloc.c index 17c6571..d363012 100644 --- a/ircd/ircd_alloc.c +++ b/ircd/ircd_alloc.c @@ -29,7 +29,7 @@ #include -#if defined(NDEBUG) +#if !defined(MDEBUG) /* * RELEASE: allocation functions */ @@ -71,7 +71,7 @@ void* MyCalloc(size_t nelem, size_t size) return p; } -#else /* !defined(NDEBUG) */ +#else /* defined(MDEBUG) */ /* * DEBUG: allocation functions */ @@ -81,5 +81,5 @@ void set_nomem_handler(OutOfMemoryHandler handler) fda_set_nomem_handler(handler); } -#endif /* !defined(NDEBUG) */ +#endif /* defined(MDEBUG) */ diff --git a/ircd/ircd_events.c b/ircd/ircd_events.c index e59cd05..00616e6 100644 --- a/ircd/ircd_events.c +++ b/ircd/ircd_events.c @@ -129,6 +129,8 @@ event_execute(struct Event* event) if (event->ev_type == ET_DESTROY) /* turn off active flag *before* destroy */ event->ev_gen.gen_header->gh_flags &= ~GEN_ACTIVE; + if (event->ev_type == ET_ERROR) /* turn on error flag before callback */ + event->ev_gen.gen_header->gh_flags |= GEN_ERROR; (*event->ev_gen.gen_header->gh_call)(event); /* execute the event */ @@ -217,6 +219,7 @@ timer_enqueue(struct Timer* timer) assert(0 != timer); assert(0 == timer->t_header.gh_prev_p); /* not already on queue */ + assert(timer->t_header.gh_flags & GEN_ACTIVE); /* timer is active */ /* Calculate expire time */ switch (timer->t_type) { @@ -368,6 +371,43 @@ event_generate(enum EventType type, void* arg, int data) event_add(ptr); /* add event to queue */ } +#if 0 +/* Try to verify the timer list */ +void +timer_verify(void) +{ + struct Timer* ptr; + struct Timer** ptr_p = &evInfo.gens.g_timer; + time_t lasttime = 0; + + for (ptr = evInfo.gens.g_timer; ptr; + ptr = (struct Timer*) ptr->t_header.gh_next) { + /* verify timer is supposed to be in the list */ + assert(ptr->t_header.gh_prev_p); + /* verify timer is correctly ordered */ + assert((struct Timer**) ptr->t_header.gh_prev_p == ptr_p); + /* verify timer is active */ + assert(ptr->t_header.gh_flags & GEN_ACTIVE); + /* verify timer ordering is correct */ + assert(lasttime <= ptr->t_expire); + + lasttime = ptr->t_expire; /* store time for ordering check */ + ptr_p = (struct Timer**) &ptr->t_header.gh_next; /* store prev pointer */ + } +} +#endif + +/* Initialize a timer structure */ +struct Timer* +timer_init(struct Timer* timer) +{ + gen_init((struct GenHeader*) timer, 0, 0, 0, 0); + + timer->t_header.gh_flags = 0; /* turn off active flag */ + + return timer; /* convenience return */ +} + /* Add a timer to be processed */ void timer_add(struct Timer* timer, EventCallBack call, void* data, @@ -380,13 +420,20 @@ timer_add(struct Timer* timer, EventCallBack call, void* data, timer_to_name(type))); /* initialize a timer... */ - gen_init((struct GenHeader*) timer, call, data, 0, 0); + timer->t_header.gh_flags |= GEN_ACTIVE; + if (timer->t_header.gh_flags & GEN_MARKED) + timer->t_header.gh_flags |= GEN_READD; + + timer->t_header.gh_ref = 0; + timer->t_header.gh_call = call; + timer->t_header.gh_data = data; timer->t_type = type; timer->t_value = value; timer->t_expire = 0; - timer_enqueue(timer); /* and enqueue it */ + if (!(timer->t_header.gh_flags & GEN_MARKED)) + timer_enqueue(timer); /* and enqueue it */ } /* Remove a timer from the processing queue */ @@ -395,18 +442,16 @@ timer_del(struct Timer* timer) { assert(0 != timer); - if (timer->t_header.gh_flags & GEN_MARKED) - return; /* timer already marked for destruction */ + timer->t_header.gh_flags &= ~GEN_READD; - timer->t_header.gh_flags |= GEN_DESTROY; + if (timer->t_header.gh_flags & GEN_MARKED) + return; /* timer is being used */ Debug((DEBUG_LIST, "Deleting timer %p (type %s)", timer, timer_to_name(timer->t_type))); - if (!timer->t_header.gh_ref) { /* not in use; destroy right now */ - gen_dequeue(timer); - event_generate(ET_DESTROY, timer, 0); - } + gen_dequeue(timer); + event_generate(ET_DESTROY, timer, 0); } /* Change the time a timer expires */ @@ -436,27 +481,27 @@ void timer_run(void) { struct Timer* ptr; - struct Timer* next = 0; /* go through queue... */ - for (ptr = evInfo.gens.g_timer; ptr; ptr = next) { - next = (struct Timer*) ptr->t_header.gh_next; + while ((ptr = evInfo.gens.g_timer)) { if (CurrentTime < ptr->t_expire) break; /* processed all pending timers */ gen_dequeue(ptr); /* must dequeue timer here */ - if (ptr->t_type == TT_ABSOLUTE || ptr->t_type == TT_RELATIVE) { - Debug((DEBUG_LIST, "Marking timer %p for later destruction", ptr)); - ptr->t_header.gh_flags |= GEN_MARKED; /* mark for destruction */ - } + ptr->t_header.gh_flags |= (GEN_MARKED | + (ptr->t_type == TT_PERIODIC ? GEN_READD : 0)); + event_generate(ET_EXPIRE, ptr, 0); /* generate expire event */ - if (ptr->t_header.gh_flags & (GEN_MARKED | GEN_DESTROY)) { + ptr->t_header.gh_flags &= ~GEN_MARKED; + + if (!(ptr->t_header.gh_flags & GEN_READD)) { Debug((DEBUG_LIST, "Destroying timer %p", ptr)); event_generate(ET_DESTROY, ptr, 0); - } else if (ptr->t_type == TT_PERIODIC) { - Debug((DEBUG_LIST, "Re-enqueuing periodic timer %p", ptr)); - timer_enqueue(ptr); /* re-queue periodic timer */ + } else { + Debug((DEBUG_LIST, "Re-enqueuing timer %p", ptr)); + timer_enqueue(ptr); /* re-queue timer */ + ptr->t_header.gh_flags &= ~GEN_READD; } } } @@ -550,7 +595,8 @@ socket_state(struct Socket* sock, enum SocketState state) /* connected datagram socket now unconnected */ assert(sock->s_state != SS_CONNECTDG || state == SS_DATAGRAM); - if (sock->s_header.gh_flags & GEN_DESTROY) /* socket's been destroyed */ + /* Don't continue if an error occurred or the socket got destroyed */ + if (sock->s_header.gh_flags & (GEN_DESTROY | GEN_ERROR)) return; /* tell engine we're changing socket state */ @@ -569,7 +615,8 @@ socket_events(struct Socket* sock, unsigned int events) assert(0 != evInfo.engine); assert(0 != evInfo.engine->eng_events); - if (sock->s_header.gh_flags & GEN_DESTROY) /* socket's been destroyed */ + /* Don't continue if an error occurred or the socket got destroyed */ + if (sock->s_header.gh_flags & (GEN_DESTROY | GEN_ERROR)) return; switch (events & SOCK_ACTION_MASK) { @@ -689,6 +736,9 @@ gen_flags(unsigned int flags) NS(unsigned int) map[] = { NM(GEN_DESTROY), NM(GEN_MARKED), + NM(GEN_ACTIVE), + NM(GEN_READD), + NM(GEN_ERROR), NE }; diff --git a/ircd/ircd_features.c b/ircd/ircd_features.c index 0baf30b..269af26 100644 --- a/ircd/ircd_features.c +++ b/ircd/ircd_features.c @@ -240,6 +240,7 @@ static struct FeatureDesc { F_I(CLIENT_FLOOD, 0, 1024, 0), F_I(SERVER_PORT, FEAT_OPER, 4400, 0), F_B(NODEFAULTMOTD, 0, 1, 0), + F_S(MOTD_BANNER, FEAT_NULL, 0, 0), F_B(KILL_IPMISMATCH, FEAT_OPER, 0, 0), F_B(IDLE_FROM_MSG, 0, 1, 0), F_B(HUB, 0, 0, 0), @@ -248,6 +249,8 @@ static struct FeatureDesc { F_N(RANDOM_SEED, FEAT_NODISP, random_seed_set, 0, 0, 0, 0, 0, 0), F_S(DEFAULT_LIST_PARAM, FEAT_NULL, 0, list_set_default), F_I(NICKNAMEHISTORYLENGTH, 0, 800, whowas_realloc), + F_B(HOST_HIDING, 0, 0, 0), + F_S(HIDDEN_HOST, FEAT_CASE, "users.undernet.org", 0), /* features that probably should not be touched */ F_I(KILLCHASETIMELIMIT, 0, 30, 0), @@ -274,6 +277,7 @@ static struct FeatureDesc { F_B(VIRTUAL_HOST, 0, 0, 0), F_I(TOS_SERVER, 0, 0x08, 0), F_I(TOS_CLIENT, 0, 0x08, 0), + F_I(POLLS_PER_LOOP, 0, 200, 0), /* features that affect all operators */ F_B(CRYPT_OPER_PASSWORD, FEAT_MYOPER | FEAT_READ, 1, 0), @@ -300,7 +304,7 @@ static struct FeatureDesc { F_B(OPER_LOPMODE, 0, 1, 0), F_B(OPER_BADCHAN, 0, 0, 0), F_B(OPER_LBADCHAN, 0, 0, 0), - F_B(OPER_SET, 0, 1, 0), + F_B(OPER_SET, 0, 0, 0), F_B(OPERS_SEE_IN_SECRET_CHANNELS, 0, 1, 0), F_B(OPER_WIDE_GLINE, 0, 1, 0), diff --git a/ircd/jupe.c b/ircd/jupe.c index b406f54..80691c7 100644 --- a/ircd/jupe.c +++ b/ircd/jupe.c @@ -153,7 +153,6 @@ jupe_activate(struct Client *cptr, struct Client *sptr, struct Jupe *jupe, unsigned int saveflags = 0; assert(0 != jupe); - assert(!JupeIsLocal(jupe)); saveflags = jupe->ju_flags; diff --git a/ircd/list.c b/ircd/list.c index b85597d..ebb637e 100644 --- a/ircd/list.c +++ b/ircd/list.c @@ -25,6 +25,7 @@ #include "client.h" #include "ircd.h" #include "ircd_alloc.h" +#include "ircd_events.h" #include "ircd_reply.h" #include "ircd_string.h" #include "listener.h" @@ -140,6 +141,7 @@ static struct Connection* alloc_connection(void) #endif memset(con, 0, sizeof(struct Connection)); + timer_init(&(con_proc(con))); return con; } @@ -147,6 +149,8 @@ static struct Connection* alloc_connection(void) static void dealloc_connection(struct Connection* con) { assert(con_verify(con)); + assert(!t_active(&(con_proc(con)))); + assert(!t_onqueue(&(con_proc(con)))); Debug((DEBUG_LIST, "Deallocating connection %p", con)); @@ -244,6 +248,9 @@ void free_client(struct Client* cptr) */ assert(cli_verify(cptr)); assert(cli_hnext(cptr) == cptr); + /* or from linked list? */ + assert(cli_next(cptr) == 0); + assert(cli_prev(cptr) == 0); Debug((DEBUG_LIST, "Freeing client %s [%p], connection %p", cli_name(cptr), cptr, cli_connect(cptr))); @@ -251,6 +258,10 @@ void free_client(struct Client* cptr) if (cli_auth(cptr)) destroy_auth_request(cli_auth(cptr), 0); + /* Make sure we didn't magically get re-added to the list */ + assert(cli_next(cptr) == 0); + assert(cli_prev(cptr) == 0); + if (cli_from(cptr) == cptr) { /* in other words, we're local */ cli_from(cptr) = 0; /* timer must be marked as not active */ @@ -299,6 +310,8 @@ void remove_client_from_list(struct Client *cptr) { assert(cli_verify(cptr)); assert(con_verify(cli_connect(cptr))); + assert(!cli_prev(cptr) || cli_verify(cli_prev(cptr))); + assert(!cli_next(cptr) || cli_verify(cli_next(cptr))); if (cli_prev(cptr)) cli_next(cli_prev(cptr)) = cli_next(cptr); @@ -346,6 +359,9 @@ void remove_client_from_list(struct Client *cptr) void add_client_to_list(struct Client *cptr) { assert(cli_verify(cptr)); + assert(cli_next(cptr) == 0); + assert(cli_prev(cptr) == 0); + /* * Since we always insert new clients to the top of the list, * this should mean the "me" is the bottom most item in the list. @@ -358,6 +374,36 @@ void add_client_to_list(struct Client *cptr) cli_prev(cli_next(cptr)) = cptr; } +#if 0 +/* WARNING: Major CPU sink! + * + * This is a debugging routine meant to verify the integrity of the client + * linked list. It is meant to be comprehensive, to detect *any* corruption + * of that list. This means that it will be majorly CPU-intensive, and + * should *only* be enabled on servers that have DEBUGMODE enabled. Ignore + * this warning at your peril! + */ +void verify_client_list(void) +{ + struct Client *client, *prev = 0, *sentinel = 0; + extern unsigned int ircrandom(void); + + for (client = GlobalClientList; client; client = cli_next(client)) { + /* Verify that this is a valid client, not a free'd one */ + assert(cli_verify(client)); + /* Verify that the list hasn't suddenly jumped around */ + assert(cli_prev(client) == prev); + /* Verify that the list hasn't become circular */ + assert(cli_next(client) != GlobalClientList); + assert(!sentinel || client != sentinel); + + prev = client; /* Remember what should preceed us */ + if (!(ircrandom() % 50)) /* probabilistic loop detector */ + sentinel = client; + } +} +#endif /* DEBUGMODE */ + /* * Look for ptr in the linked listed pointed to by link. */ diff --git a/ircd/listener.c b/ircd/listener.c index e0f9213..6959ff7 100644 --- a/ircd/listener.c +++ b/ircd/listener.c @@ -428,7 +428,7 @@ static void accept_connection(struct Event* ev) if (ev_type(ev) == ET_DESTROY) /* being destroyed */ free_listener(listener); else { - assert(ev_type(ev) == ET_ACCEPT); + assert(ev_type(ev) == ET_ACCEPT || ev_type(ev) == ET_ERROR); listener->last_accept = CurrentTime; /* diff --git a/ircd/m_account.c b/ircd/m_account.c new file mode 100644 index 0000000..f5615e5 --- /dev/null +++ b/ircd/m_account.c @@ -0,0 +1,130 @@ +/* + * IRC - Internet Relay Chat, ircd/m_account.c + * Copyright (C) 2002 Kevin L. Mitchell + * + * See file AUTHORS in IRC package for additional names of + * the programmers. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 1, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * + * $Id$ + */ + +/* + * m_functions execute protocol messages on this server: + * + * cptr is always NON-NULL, pointing to a *LOCAL* client + * structure (with an open socket connected!). This + * identifies the physical socket where the message + * originated (or which caused the m_function to be + * executed--some m_functions may call others...). + * + * sptr is the source of the message, defined by the + * prefix part of the message if present. If not + * or prefix not found, then sptr==cptr. + * + * (!IsServer(cptr)) => (cptr == sptr), because + * prefixes are taken *only* from servers... + * + * (IsServer(cptr)) + * (sptr == cptr) => the message didn't + * have the prefix. + * + * (sptr != cptr && IsServer(sptr) means + * the prefix specified servername. (?) + * + * (sptr != cptr && !IsServer(sptr) means + * that message originated from a remote + * user (not local). + * + * combining + * + * (!IsServer(sptr)) means that, sptr can safely + * taken as defining the target structure of the + * message in this server. + * + * *Always* true (if 'parse' and others are working correct): + * + * 1) sptr->from == cptr (note: cptr->from == cptr) + * + * 2) MyConnect(sptr) <=> sptr == cptr (e.g. sptr + * *cannot* be a local connection, unless it's + * actually cptr!). [MyConnect(x) should probably + * be defined as (x == x->from) --msa ] + * + * parc number of variable parameter strings (if zero, + * parv is allowed to be NULL) + * + * parv a NULL terminated list of parameter pointers, + * + * parv[0], sender (prefix string), if not present + * this points to an empty string. + * parv[1]...parv[parc-1] + * pointers to additional parameters + * parv[parc] == NULL, *always* + * + * note: it is guaranteed that parv[0]..parv[parc-1] are all + * non-NULL pointers. + */ +#include "config.h" + +#include "client.h" +#include "ircd.h" +#include "ircd_reply.h" +#include "ircd_string.h" +#include "msg.h" +#include "numnicks.h" +#include "s_user.h" +#include "send.h" + +#include + +/* + * ms_account - server message handler + * + * parv[0] = sender prefix + * parv[1] = numeric of client to act on + * parv[2] = account name (12 characters or less) + */ +int ms_account(struct Client* cptr, struct Client* sptr, int parc, + char* parv[]) +{ + struct Client *acptr; + + if (parc < 3) + return need_more_params(sptr, "ACCOUNT"); + + if (!IsServer(sptr)) + return protocol_violation(cptr, "ACCOUNT from non-server %s", + cli_name(sptr)); + + if (!(acptr = findNUser(parv[1]))) + return 0; /* Ignore ACCOUNT for a user that QUIT; probably crossed */ + + if (IsAccount(acptr)) + return protocol_violation(cptr, "ACCOUNT for already registered user %s " + "(%s -> %s)", cli_name(acptr), + cli_user(acptr)->account, parv[2]); + + assert(0 == cli_user(acptr)->account[0]); + + ircd_strncpy(cli_user(acptr)->account, parv[2], ACCOUNTLEN); + hide_hostmask(acptr, FLAGS_ACCOUNT); + + sendcmdto_serv_butone(sptr, CMD_ACCOUNT, cptr, "%C %s", acptr, + cli_user(acptr)->account); + + return 0; +} diff --git a/ircd/m_admin.c b/ircd/m_admin.c index 3fed22c..b918f3b 100644 --- a/ircd/m_admin.c +++ b/ircd/m_admin.c @@ -118,6 +118,23 @@ int m_admin(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) assert(0 != cptr); assert(cptr == sptr); + if (parc > 1) + return send_reply(sptr, ERR_NOPRIVILEGES); + + return send_admin_info(sptr); +} + +/* + * mo_admin - oper message handler + * + * parv[0] = sender prefix + * parv[1] = servername + */ +int mo_admin(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) +{ + assert(0 != cptr); + assert(cptr == sptr); + if (parc > 1) { struct Client *acptr; acptr = FindUser(parv[1]); diff --git a/ircd/m_away.c b/ircd/m_away.c index 642ea94..a321f9b 100644 --- a/ircd/m_away.c +++ b/ircd/m_away.c @@ -124,9 +124,9 @@ static int user_set_away(struct User* user, char* message) */ unsigned int len = strlen(message); - if (len > TOPICLEN) { - message[TOPICLEN] = '\0'; - len = TOPICLEN; + if (len > AWAYLEN) { + message[AWAYLEN] = '\0'; + len = AWAYLEN; } if (away) away = (char*) MyRealloc(away, len + 1); diff --git a/ircd/m_burst.c b/ircd/m_burst.c index ecde2f4..8b84667 100644 --- a/ircd/m_burst.c +++ b/ircd/m_burst.c @@ -309,7 +309,7 @@ int ms_burst(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) } add_user_to_channel(chptr, acptr, default_mode); - sendcmdto_channel_butserv(acptr, CMD_JOIN, chptr, "%H", chptr); + sendcmdto_channel_butserv_butone(acptr, CMD_JOIN, chptr, NULL, "%H", chptr); } } param++; diff --git a/ircd/m_clearmode.c b/ircd/m_clearmode.c index cbd961f..9005bed 100644 --- a/ircd/m_clearmode.c +++ b/ircd/m_clearmode.c @@ -122,6 +122,7 @@ do_clearmode(struct Client *cptr, struct Client *sptr, struct Channel *chptr, MODE_KEY, 'k', MODE_BAN, 'b', MODE_LIMIT, 'l', + MODE_REGONLY, 'r', 0x0, 0x0 }; int *flag_p; diff --git a/ircd/m_kick.c b/ircd/m_kick.c index 1951dd7..51c848e 100644 --- a/ircd/m_kick.c +++ b/ircd/m_kick.c @@ -145,7 +145,7 @@ int m_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) sendcmdto_serv_butone(sptr, CMD_KICK, cptr, "%H %C :%s", chptr, who, comment); - sendcmdto_channel_butserv(sptr, CMD_KICK, chptr, "%H %C :%s", chptr, who, + sendcmdto_channel_butserv_butone(sptr, CMD_KICK, chptr, NULL, "%H %C :%s", chptr, who, comment); make_zombie(member, who, cptr, sptr, chptr); @@ -224,7 +224,7 @@ int ms_kick(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) comment); if (member) { /* and tell the channel about it */ - sendcmdto_channel_butserv(sptr, CMD_KICK, chptr, "%H %C :%s", chptr, who, + sendcmdto_channel_butserv_butone(sptr, CMD_KICK, chptr, NULL, "%H %C :%s", chptr, who, comment); make_zombie(member, who, cptr, sptr, chptr); diff --git a/ircd/m_mode.c b/ircd/m_mode.c index f2b2f00..f32ea25 100644 --- a/ircd/m_mode.c +++ b/ircd/m_mode.c @@ -124,7 +124,7 @@ m_mode(struct Client *cptr, struct Client *sptr, int parc, char *parv[]) *modebuf = *parabuf = '\0'; modebuf[1] = '\0'; - channel_modes(sptr, modebuf, parabuf, chptr); + channel_modes(sptr, modebuf, parabuf, sizeof(parabuf), chptr); send_reply(sptr, RPL_CHANNELMODEIS, chptr->chname, modebuf, parabuf); send_reply(sptr, RPL_CREATIONTIME, chptr->chname, chptr->creationtime); return 0; diff --git a/ircd/m_quit.c b/ircd/m_quit.c index 38d47e2..9ca6786 100644 --- a/ircd/m_quit.c +++ b/ircd/m_quit.c @@ -83,6 +83,7 @@ #include "channel.h" #include "client.h" +#include "ircd.h" #include "ircd_string.h" #include "struct.h" #include "s_misc.h" @@ -99,7 +100,6 @@ */ int m_quit(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) { - char comment[TOPICLEN]; assert(0 != cptr); assert(0 != sptr); assert(cptr == sptr); @@ -111,16 +111,10 @@ int m_quit(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) return exit_client(cptr, sptr, sptr, "Signed off"); } } - - if (parc > 1) { - strcpy(comment,"Quit: "); - strncat(comment,parv[parc-1],sizeof(comment)-strlen("Quit: ")); - comment[sizeof(comment)] = '\0'; - } - else { - strncpy(comment,cli_name(cptr),sizeof(comment)); - } - return exit_client(cptr, sptr, sptr, comment); + if (parc > 1 && !BadPtr(parv[parc - 1])) + return exit_client_msg(cptr, sptr, sptr, "Quit: %s", parv[parc - 1]); + else + return exit_client(cptr, sptr, sptr, "Quit"); } diff --git a/ircd/m_squit.c b/ircd/m_squit.c index 67d541b..b71d28e 100644 --- a/ircd/m_squit.c +++ b/ircd/m_squit.c @@ -71,10 +71,10 @@ int ms_squit(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) if (BadPtr(parv[parc - 1])) comment = cli_name(sptr); - acptr = FindNServer(server); + acptr = FindServer(server); if (!acptr) - acptr = FindServer(server); + acptr = FindNServer(server); if (!acptr) { protocol_violation(sptr, "Issued SQUIT for unknown server %s (ignored)", @@ -85,8 +85,7 @@ int ms_squit(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) /* If they are squitting me, we reverse it */ if (IsMe(acptr)) { - cptr = acptr; - acptr = &me; + acptr = cptr; /* Bugfix by Prefect */ } timestamp = atoi(parv[2]); diff --git a/ircd/m_stats.c b/ircd/m_stats.c index e4c9e93..a6cda15 100644 --- a/ircd/m_stats.c +++ b/ircd/m_stats.c @@ -362,7 +362,7 @@ int m_stats(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) #ifdef HEAD_IN_SAND_STATS_M return m_not_oper(sptr,cptr,parc,parv); #else -#if !defined(NDEBUG) +#if defined(MDEBUG) send_reply(sptr, RPL_STATMEMTOT, fda_get_byte_count(), fda_get_block_count()); #endif @@ -667,7 +667,7 @@ int ms_stats(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) break; } case 'M': -#if !defined(NDEBUG) +#if defined(MDEBUG) send_reply(sptr, RPL_STATMEMTOT, fda_get_byte_count(), fda_get_block_count()); #endif @@ -887,7 +887,7 @@ int mo_stats(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) } break; case 'M': -#if !defined(NDEBUG) +#if defined(MDEBUG) send_reply(sptr, RPL_STATMEMTOT, fda_get_byte_count(), fda_get_block_count()); #endif diff --git a/ircd/m_topic.c b/ircd/m_topic.c index 950e0f4..b8cfc82 100644 --- a/ircd/m_topic.c +++ b/ircd/m_topic.c @@ -118,8 +118,8 @@ static void do_settopic(struct Client *sptr, struct Client *cptr, sendcmdto_serv_butone(sptr, CMD_TOPIC, cptr, "%H :%s", chptr, chptr->topic); if (newtopic) - sendcmdto_channel_butserv(sptr, CMD_TOPIC, chptr, "%H :%s", chptr, - chptr->topic); + sendcmdto_channel_butserv_butone(sptr, CMD_TOPIC, chptr, NULL, + "%H :%s", chptr, chptr->topic); /* if this is the same topic as before we send it to the person that * set it (so they knew it went through ok), but don't bother sending * it to everyone else on the channel to save bandwidth diff --git a/ircd/m_userip.c b/ircd/m_userip.c index 0f66e7b..a42cbcc 100644 --- a/ircd/m_userip.c +++ b/ircd/m_userip.c @@ -97,6 +97,7 @@ static void userip_formatter(struct Client* cptr, struct MsgBuf* mb) msgq_append(0, mb, "%s%s=%c%s@%s", cli_name(cptr), HasPriv(cptr, PRIV_DISPLAY) ? "*" : "", cli_user(cptr)->away ? '-' : '+', cli_user(cptr)->username, + HasHiddenHost(cptr) ? "127.0.0.1" : ircd_ntoa((const char*) &(cli_ip(cptr)))); } diff --git a/ircd/m_version.c b/ircd/m_version.c index 105b0f7..31dd236 100644 --- a/ircd/m_version.c +++ b/ircd/m_version.c @@ -107,6 +107,24 @@ * parv[1] = remote server */ int m_version(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) +{ + + if (parc > 1) + send_reply(sptr, ERR_NOPRIVILEGES); + else + send_reply(sptr, RPL_VERSION, version, debugmode, cli_name(&me), + debug_serveropts()); + + return 0; +} + +/* + * mo_version - generic message handler + * + * parv[0] = sender prefix + * parv[1] = remote server + */ +int mo_version(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) { struct Client *acptr; diff --git a/ircd/m_who.c b/ircd/m_who.c index 052e562..0622667 100644 --- a/ircd/m_who.c +++ b/ircd/m_who.c @@ -97,7 +97,6 @@ #include "support.h" #include "whocmds.h" - #include #include @@ -395,6 +394,10 @@ int m_who(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) || (!(cli_flags(cli_user(acptr)->server) & FLAGS_MAP))) && ((!(matchsel & WHO_FIELD_HOS)) || matchexec(cli_user(acptr)->host, mymask, minlen)) + && ((!(matchsel & WHO_FIELD_HOS)) + || !HasHiddenHost(acptr) + || !IsAnOper(sptr) + || matchexec(cli_user(acptr)->realhost, mymask, minlen)) && ((!(matchsel & WHO_FIELD_REN)) || matchexec(cli_info(acptr), mymask, minlen)) && ((!(matchsel & WHO_FIELD_NIP)) @@ -430,6 +433,10 @@ int m_who(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) || (!(cli_flags(cli_user(acptr)->server) & FLAGS_MAP))) && ((!(matchsel & WHO_FIELD_HOS)) || matchexec(cli_user(acptr)->host, mymask, minlen)) + && ((!(matchsel & WHO_FIELD_HOS)) + || !HasHiddenHost(acptr) + || !IsAnOper(sptr) + || matchexec(cli_user(acptr)->realhost, mymask, minlen)) && ((!(matchsel & WHO_FIELD_REN)) || matchexec(cli_info(acptr), mymask, minlen)) && ((!(matchsel & WHO_FIELD_NIP)) diff --git a/ircd/m_whois.c b/ircd/m_whois.c index 20835b5..79a7205 100644 --- a/ircd/m_whois.c +++ b/ircd/m_whois.c @@ -200,6 +200,13 @@ static void do_whois(struct Client* sptr, struct Client *acptr, int parc) if (IsAnOper(acptr) && (HasPriv(acptr, PRIV_DISPLAY) || HasPriv(sptr, PRIV_SEE_OPERS))) send_reply(sptr, RPL_WHOISOPERATOR, name); + + if (IsAccount(acptr)) + send_reply(sptr, RPL_WHOISACCOUNT, name, user->account); + + if (HasHiddenHost(acptr) && IsAnOper(sptr)) + send_reply(sptr, RPL_WHOISACTUALLY, name, user->username, + user->realhost, ircd_ntoa((const char*) &(cli_ip(acptr)))); /* Hint: if your looking to add more flags to a user, eg +h, here's * probably a good place to add them :) diff --git a/ircd/m_whowas.c b/ircd/m_whowas.c index 2d8e9d1..adcaaea 100644 --- a/ircd/m_whowas.c +++ b/ircd/m_whowas.c @@ -136,11 +136,12 @@ int m_whowas(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) if (0 == ircd_strcmp(nick, temp->name)) { send_reply(sptr, RPL_WHOWASUSER, temp->name, temp->username, + (IsAnOper(sptr) && temp->realhost) ? temp->realhost : temp->hostname, temp->realname); #ifdef HEAD_IN_SAND_WHOIS_SERVERNAME if (!IsOper(sptr)) - send_reply(sptr, RPL_WHOISSERVER, temp->name, "*.undernet.org", - myctime(temp->logoff)); + send_reply(sptr, RPL_WHOISSERVER, temp->name, + HEAD_IN_SAND_SERVERNAME, myctime(temp->logoff)); else #endif send_reply(sptr, RPL_WHOISSERVER, temp->name, temp->servername, diff --git a/ircd/motd.c b/ircd/motd.c index 262e2ea..468a151 100644 --- a/ircd/motd.c +++ b/ircd/motd.c @@ -288,6 +288,7 @@ void motd_signon(struct Client* cptr) { struct MotdCache *cache; + const char *banner = NULL; cache = motd_cache(motd_lookup(cptr)); @@ -295,6 +296,8 @@ motd_signon(struct Client* cptr) motd_forward(cptr, cache); else { send_reply(cptr, RPL_MOTDSTART, cli_name(&me)); + if ((banner = feature_str(FEAT_MOTD_BANNER))) + send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":%s", banner); send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":\002Type /MOTD to read the " "AUP before continuing using this service.\002"); send_reply(cptr, SND_EXPLICIT | RPL_MOTD, ":The message of the day was " diff --git a/ircd/parse.c b/ircd/parse.c index 59951d1..9e19f8f 100644 --- a/ircd/parse.c +++ b/ircd/parse.c @@ -266,7 +266,7 @@ struct Message msgtab[] = { TOK_WHOIS, 0, MAXPARA, MFLG_SLOW, 0, /* UNREG, CLIENT, SERVER, OPER, SERVICE */ - { m_unregistered, m_whois, m_whois, m_whois, m_ignore } + { m_unregistered, m_whois, ms_whois, m_whois, m_ignore } }, { MSG_WHO, @@ -393,7 +393,7 @@ struct Message msgtab[] = { TOK_VERSION, 0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0, /* UNREG, CLIENT, SERVER, OPER, SERVICE */ - { m_version, m_version, ms_version, m_version, m_ignore } + { m_version, m_version, ms_version, mo_version, m_ignore } }, { MSG_STATS, @@ -418,7 +418,7 @@ struct Message msgtab[] = { TOK_ADMIN, 0, MAXPARA, MFLG_SLOW | MFLG_UNREG, 0, /* UNREG, CLIENT, SERVER, OPER, SERVICE */ - { m_admin, m_admin, ms_admin, m_admin, m_ignore } + { m_admin, m_admin, ms_admin, mo_admin, m_ignore } }, { MSG_HELP, @@ -574,6 +574,13 @@ struct Message msgtab[] = { /* UNREG, CLIENT, SERVER, OPER, SERVICE */ { m_unregistered, m_not_oper, m_ignore, mo_privs, m_ignore } }, + { + MSG_ACCOUNT, + TOK_ACCOUNT, + 0, MAXPARA, MFLG_SLOW, 0, + /* UNREG, CLIENT, SERVER, OPER, SERVICE */ + { m_ignore, m_ignore, ms_account, m_ignore, m_ignore } + }, /* This command is an alias for QUIT during the unregistered part of * of the server. This is because someone jumping via a broken web * proxy will send a 'POST' as their first command - which we will @@ -586,9 +593,9 @@ struct Message msgtab[] = { 0, MAXPARA, MFLG_SLOW, 0, /* UNREG, CLIENT, SERVER, OPER, SERVICE */ { m_quit, m_ignore, m_ignore, m_ignore, m_ignore } - }, + }, { 0 } -}; +}; static char *para[MAXPARA + 2]; /* leave room for prefix and null */ @@ -716,7 +723,7 @@ static struct Message *do_msg_tree_cmd(struct MessageTree *mtree, char *prefix, } return mptr; } - /* + /* * This should never happen */ assert(0); @@ -745,7 +752,7 @@ void initmsgtree(void) int ii; struct Message **msgtab_tok; struct Message **msgtok; - + for (i = 0; msg->cmd; ++i, ++msg) continue; qsort(msgtab, i, sizeof(struct Message), @@ -1034,7 +1041,7 @@ int parse_server(struct Client *cptr, char *buffer, char *bufend) } else if (' ' == ch[1] || ' ' == ch[2]) from = FindNServer(numeric_prefix); - else + else from = findNUser(numeric_prefix); do diff --git a/ircd/res.c b/ircd/res.c index 3af11a5..d4d85fd 100644 --- a/ircd/res.c +++ b/ircd/res.c @@ -308,7 +308,7 @@ res_ourserver(const struct __res_state* statp, const struct sockaddr_in* inp) /* Socket callback for resolver */ static void res_callback(struct Event* ev) { - assert(ev_type(ev) == ET_READ); + assert(ev_type(ev) == ET_READ || ev_type(ev) == ET_ERROR); resolver_read(); } @@ -399,8 +399,10 @@ int init_resolver(void) requestListHead = requestListTail = 0; /* initiate the resolver timers */ - timer_add(&resExpireDNS, expire_DNS_callback, 0, TT_RELATIVE, 1); - timer_add(&resExpireCache, expire_cache_callback, 0, TT_RELATIVE, 1); + timer_add(timer_init(&resExpireDNS), expire_DNS_callback, 0, + TT_RELATIVE, 1); + timer_add(timer_init(&resExpireCache), expire_cache_callback, 0, + TT_RELATIVE, 1); errno = h_errno = 0; @@ -804,8 +806,10 @@ static int proc_answer(struct ResRequest* request, HEADER* header, u_char* current; /* current position in buf */ char** alias; /* alias list */ char** addr; /* address list */ + char** base_addr; /* original pointer to address list */ char* name; /* pointer to name string */ char* address; /* pointer to address */ + char* base_address; /* original pointer to address */ char* endp; /* end of our buffer */ int query_class; /* answer class */ int type; /* answer type */ @@ -814,6 +818,7 @@ static int proc_answer(struct ResRequest* request, HEADER* header, int n; /* temp count */ int addr_count = 0; /* number of addresses in hostent */ int alias_count = 0; /* number of aliases in hostent */ + int t_ptr_seen = 0; /* Seen a T_PTR in proc_answer? */ struct hostent* hp; /* hostent getting filled */ assert(0 != request); @@ -854,11 +859,14 @@ static int proc_answer(struct ResRequest* request, HEADER* header, ++addr; ++addr_count; } + base_addr = addr; /* * make address point to first available address slot */ address = request->he.buf + ADDRS_OFFSET + (sizeof(struct in_addr) * addr_count); + base_address = address; + /* * find the end of the alias list */ @@ -928,7 +936,10 @@ static int proc_answer(struct ResRequest* request, HEADER* header, case T_A: /* * check for invalid rd_length or too many addresses + * ignore T_A relies if looking for a T_PTR */ + if (t_ptr_seen) + return answer_count; if (rd_length != sizeof(struct in_addr)) return answer_count; if (++addr_count < RES_MAXADDRS) { @@ -952,6 +963,11 @@ static int proc_answer(struct ResRequest* request, HEADER* header, ++answer_count; break; case T_PTR: + t_ptr_seen = 1; + addr_count = 0; + addr = base_addr; + *addr = 0; + address = base_address; n = dn_expand(buf, eob, current, hostbuf, sizeof(hostbuf)); if (n < 0) { /* @@ -1597,7 +1613,7 @@ static struct CacheEntry* make_cache(struct ResRequest* request) * shouldn't happen but it just might... */ assert(0 != hp->h_name); - assert(0 != hp->h_addr_list[0]); +/* assert(0 != hp->h_addr_list[0]); */ if (!hp->h_name || !hp->h_addr_list[0]) return NULL; /* diff --git a/ircd/s_auth.c b/ircd/s_auth.c index 6ad278a..17dce05 100644 --- a/ircd/s_auth.c +++ b/ircd/s_auth.c @@ -206,11 +206,12 @@ void destroy_auth_request(struct AuthRequest* auth, int send_reports) sendheader(auth->client, REPORT_FAIL_DNS); } - if (send_reports) + if (send_reports) { log_write(LS_RESOLVER, L_INFO, 0, "DNS/AUTH timeout %s", get_client_name(auth->client, HIDE_IP)); + release_auth_client(auth->client); + } - release_auth_client(auth->client); unlink_auth_request(auth, authList); free_auth_request(auth); } @@ -228,8 +229,8 @@ static struct AuthRequest* make_auth_request(struct Client* client) auth->fd = -1; auth->client = client; cli_auth(client) = auth; - timer_add(&auth->timeout, auth_timeout_callback, (void*) auth, TT_RELATIVE, - AUTH_TIMEOUT); + timer_add(timer_init(&auth->timeout), auth_timeout_callback, (void*) auth, + TT_RELATIVE, AUTH_TIMEOUT); return auth; } @@ -304,6 +305,7 @@ static void auth_kill_client(struct AuthRequest* auth) delete_resolver_queries(auth); IPcheck_disconnect(auth->client); Count_unknowndisconnects(UserStats); + cli_auth(auth->client) = 0; free_client(auth->client); free_auth_request(auth); } @@ -675,7 +677,7 @@ void read_auth_reply(struct AuthRequest* auth) assert(0 != auth); assert(0 != auth->client); - assert(auth = cli_auth(auth->client)); + assert(auth == cli_auth(auth->client)); if (IO_SUCCESS == os_recv_nonb(auth->fd, buf, BUFSIZE, &len)) { buf[len] = '\0'; diff --git a/ircd/s_bsd.c b/ircd/s_bsd.c index 5e78031..e379e61 100644 --- a/ircd/s_bsd.c +++ b/ircd/s_bsd.c @@ -773,7 +773,7 @@ static int read_packet(struct Client *cptr, int socket_ready) /* If there's still data to process, wait 2 seconds first */ if (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) && - !(cli_freeflag(cptr) & FREEFLAG_TIMER)) { + !t_onqueue(&(cli_proc(cptr)))) { Debug((DEBUG_LIST, "Adding client process timer for %C", cptr)); cli_freeflag(cptr) |= FREEFLAG_TIMER; timer_add(&(cli_proc(cptr)), client_timer_callback, cli_connect(cptr), @@ -1066,9 +1066,9 @@ static void client_timer_callback(struct Event* ev) assert(0 == cptr || con == cli_connect(cptr)); - con_freeflag(con) &= ~FREEFLAG_TIMER; /* timer has expired... */ - if (ev_type(ev)== ET_DESTROY) { + con_freeflag(con) &= ~FREEFLAG_TIMER; /* timer has expired... */ + if (!con_freeflag(con) && !cptr) free_connection(con); /* client is being destroyed */ } else { diff --git a/ircd/s_conf.c b/ircd/s_conf.c index 276d426..4a1cbb0 100644 --- a/ircd/s_conf.c +++ b/ircd/s_conf.c @@ -1312,6 +1312,7 @@ int rehash(struct Client *cptr, int sig) else tmp = &tmp2->next; } + for (i = 0; i <= HighestFd; i++) { if ((acptr = LocalClientArray[i])) { assert(!IsMe(acptr)); @@ -1337,6 +1338,7 @@ int rehash(struct Client *cptr, int sig) } } } + return ret; } diff --git a/ircd/s_debug.c b/ircd/s_debug.c index dca9205..c45a532 100644 --- a/ircd/s_debug.c +++ b/ircd/s_debug.c @@ -82,8 +82,8 @@ const char* debug_serveropts(void) AddC((char)('0' + (bp / 1000000) % 10)); } -#ifdef CHROOTDIR - AddC('c'); +#ifndef NDEBUG + AddC('A'); #endif #ifdef DEBUGMODE AddC('D'); @@ -381,7 +381,7 @@ void count_memory(struct Client *cptr, char *nick) dbufs_allocated + msg_allocated + msgbuf_allocated + rm; tot += sizeof(void *) * HASHSIZE * 3; -#if !defined(NDEBUG) +#if defined(MDEBUG) send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Allocations: %zu(%zu)", fda_get_block_count(), fda_get_byte_count()); #endif diff --git a/ircd/s_err.c b/ircd/s_err.c index a08fbd3..0fdcc6c 100644 --- a/ircd/s_err.c +++ b/ircd/s_err.c @@ -36,7 +36,7 @@ static Numeric replyTable[] = { /* 003 */ { RPL_CREATED, ":This server was created %s", "003" }, /* 004 */ - { RPL_MYINFO, "%s %s dioswkg biklmnopstv bklov", "004" }, + { RPL_MYINFO, "%s %s dioswkgx biklmnopstvr bklov", "004" }, /* 005 */ { RPL_ISUPPORT, "%s :are supported by this server", "005" }, /* 006 */ @@ -646,7 +646,7 @@ static Numeric replyTable[] = { /* 306 */ { RPL_NOWAWAY, ":You have been marked as being away", "306" }, /* 307 */ - { RPL_USERIP, ":", "307" }, + { 0 }, /* 308 */ { 0 }, /* 309 */ @@ -692,7 +692,7 @@ static Numeric replyTable[] = { /* 329 */ { RPL_CREATIONTIME, "%s %Tu", "329" }, /* 330 */ - { 0 }, + { RPL_WHOISACCOUNT, "%s %s :is logged in as", "330" }, /* 331 */ { RPL_NOTOPIC, "%s :No topic is set.", "331" }, /* 332 */ @@ -708,11 +708,11 @@ static Numeric replyTable[] = { /* 337 */ { 0 }, /* 338 */ - { 0 }, + { RPL_WHOISACTUALLY, ":%s is actually %s@%s [%s]", "338" }, /* 339 */ { 0 }, /* 340 */ - { 0 }, + { RPL_USERIP, ":", "340" }, /* 341 */ { RPL_INVITING, "%s %s", "341" }, /* 342 */ @@ -986,7 +986,7 @@ static Numeric replyTable[] = { /* 476 */ { ERR_BADCHANMASK, "%s :Bad Channel Mask", "476" }, /* 477 */ - { 0 }, + { ERR_NEEDREGGEDNICK, "%s :Cannot join channel (+r)", "477" }, /* 478 */ { ERR_BANLISTFULL, "%s %s :Channel ban/ignore list is full", "478" }, /* 479 */ diff --git a/ircd/s_misc.c b/ircd/s_misc.c index 1b1dcad..1ea6d8c 100644 --- a/ircd/s_misc.c +++ b/ircd/s_misc.c @@ -233,7 +233,7 @@ static void exit_one_client(struct Client* bcptr, const char* comment) * that the client can show the "**signoff" message). * (Note: The notice is to the local clients *only*) */ - sendcmdto_common_channels(bcptr, CMD_QUIT, ":%s", comment); + sendcmdto_common_channels_butone(bcptr, CMD_QUIT, NULL, ":%s", comment); remove_user_from_all_channels(bcptr); @@ -245,6 +245,10 @@ static void exit_one_client(struct Client* bcptr, const char* comment) while ((lp = cli_user(bcptr)->silence)) del_silence(bcptr, lp->value.cp); + /* Clean up snotice lists */ + if (MyUser(bcptr)) + set_snomask(bcptr, ~0, SNO_DEL); + if (IsInvisible(bcptr)) --UserStats.inv_clients; if (IsOper(bcptr)) diff --git a/ircd/s_serv.c b/ircd/s_serv.c index f66cf0d..5ed58e4 100644 --- a/ircd/s_serv.c +++ b/ircd/s_serv.c @@ -231,7 +231,7 @@ int server_estab(struct Client *cptr, struct ConfItem *aconf) sendcmdto_one(cli_user(acptr)->server, CMD_NICK, cptr, "%s %d %Tu %s %s %s%s%s%s %s%s :%s", cli_name(acptr), cli_hopcount(acptr) + 1, cli_lastnick(acptr), - cli_user(acptr)->username, cli_user(acptr)->host, + cli_user(acptr)->username, cli_user(acptr)->realhost, *s ? "+" : "", s, *s ? " " : "", inttobase64(xxx_buf, ntohl(cli_ip(acptr).s_addr), 6), NumNick(acptr), cli_info(acptr)); diff --git a/ircd/s_user.c b/ircd/s_user.c index 690e150..82709b3 100644 --- a/ircd/s_user.c +++ b/ircd/s_user.c @@ -442,6 +442,7 @@ int register_user(struct Client *cptr, struct Client *sptr, return exit_client(cptr, sptr, &me, "Unknown error -- Try again"); } ircd_strncpy(user->host, cli_sockhost(sptr), HOSTLEN); + ircd_strncpy(user->realhost, cli_sockhost(sptr), HOSTLEN); aconf = cli_confs(sptr)->value.aconf; clean_user_id(user->username, @@ -621,7 +622,7 @@ int register_user(struct Client *cptr, struct Client *sptr, sendcmdto_serv_butone(user->server, CMD_NICK, cptr, "%s %d %Tu %s %s %s%s%s%s %s%s :%s", nick, cli_hopcount(sptr) + 1, cli_lastnick(sptr), - user->username, user->host, + user->username, user->realhost, *tmpstr ? "+" : "", tmpstr, *tmpstr ? " " : "", inttobase64(ip_base64, ntohl(cli_ip(sptr).s_addr), 6), NumNick(sptr), cli_info(sptr)); @@ -649,7 +650,9 @@ static const struct UserMode { { FLAGS_SERVNOTICE, 's' }, { FLAGS_DEAF, 'd' }, { FLAGS_CHSERV, 'k' }, - { FLAGS_DEBUG, 'g' } + { FLAGS_DEBUG, 'g' }, + { FLAGS_ACCOUNT, 'r' }, + { FLAGS_HIDDENHOST, 'x' } }; #define USERMODELIST_SIZE sizeof(userModeList) / sizeof(struct UserMode) @@ -664,6 +667,7 @@ int set_nick_name(struct Client* cptr, struct Client* sptr, { if (IsServer(sptr)) { int i; + const char* account = 0; const char* p; /* @@ -679,6 +683,8 @@ int set_nick_name(struct Client* cptr, struct Client* sptr, for (i = 0; i < USERMODELIST_SIZE; ++i) { if (userModeList[i].c == *p) { cli_flags(new_client) |= userModeList[i].flag; + if (userModeList[i].flag & FLAGS_ACCOUNT) + account = parv[7]; break; } } @@ -703,7 +709,13 @@ int set_nick_name(struct Client* cptr, struct Client* sptr, cli_serv(sptr)->ghost = 0; /* :server NICK means end of net.burst */ ircd_strncpy(cli_username(new_client), parv[4], USERLEN); ircd_strncpy(cli_user(new_client)->host, parv[5], HOSTLEN); + ircd_strncpy(cli_user(new_client)->realhost, parv[5], HOSTLEN); ircd_strncpy(cli_info(new_client), parv[parc - 1], REALLEN); + if (account) + ircd_strncpy(cli_user(new_client)->account, account, ACCOUNTLEN); + if (HasHiddenHost(new_client)) + ircd_snprintf(0, cli_user(new_client)->host, HOSTLEN, "%s.%s", + account, feature_str(FEAT_HIDDEN_HOST)); return register_user(cptr, new_client, cli_name(new_client), parv[4]); } @@ -757,7 +769,7 @@ int set_nick_name(struct Client* cptr, struct Client* sptr, * on that channel. Propagate notice to other servers. */ if (IsUser(sptr)) { - sendcmdto_common_channels(sptr, CMD_NICK, ":%s", nick); + sendcmdto_common_channels_butone(sptr, CMD_NICK, NULL, ":%s", nick); add_history(sptr, 1); sendcmdto_serv_butone(sptr, CMD_NICK, cptr, "%s %Tu", nick, cli_lastnick(sptr)); @@ -1028,6 +1040,51 @@ void send_user_info(struct Client* sptr, char* names, int rpl, InfoFormatter fmt msgq_clean(mb); } +/* + * hide_hostmask() + * + * If, after setting the flags, the user has both HiddenHost and Account + * set, its hostmask is changed. + */ +#define FLAGS_HOST_HIDDEN (FLAGS_ACCOUNT|FLAGS_HIDDENHOST) +int hide_hostmask(struct Client *cptr, unsigned int flags) +{ + struct Membership *chan; + int newflags; + + if (MyConnect(cptr) && !feature_bool(FEAT_HOST_HIDING)) + flags &= ~FLAGS_HIDDENHOST; + + newflags = cli_flags(cptr) | flags; + if ((newflags & FLAGS_HOST_HIDDEN) != FLAGS_HOST_HIDDEN) { + /* The user doesn't have both flags, don't change the hostmask */ + cli_flags(cptr) |= flags; + return 0; + } + + sendcmdto_common_channels_butone(cptr, CMD_QUIT, cptr, ":Registered"); + ircd_snprintf(0, cli_user(cptr)->host, HOSTLEN, "%s.%s", + cli_user(cptr)->account, feature_str(FEAT_HIDDEN_HOST)); + cli_flags(cptr) |= flags; + + /* + * Go through all channels the client was on, rejoin him + * and set the modes, if any + */ + for (chan = cli_user(cptr)->channel; chan; chan = chan->next_channel) { + sendcmdto_channel_butserv_butone(cptr, CMD_JOIN, chan->channel, cptr, + "%H", chan->channel); + if (IsChanOp(chan) && HasVoice(chan)) { + sendcmdto_channel_butserv_butone(&me, CMD_MODE, chan->channel, cptr, + "%H +ov %C %C", chan->channel, cptr, cptr); + } else if (IsChanOp(chan) || HasVoice(chan)) { + sendcmdto_channel_butserv_butone(&me, CMD_MODE, chan->channel, cptr, + "%H +%c %C", chan->channel, IsChanOp(chan) ? 'o' : 'v', cptr); + } + } + return 0; +} + /* * set_user_mode() added 15/10/91 By Darren Reed. @@ -1048,6 +1105,7 @@ int set_user_mode(struct Client *cptr, struct Client *sptr, int parc, char *parv int snomask_given = 0; char buf[BUFSIZE]; int prop = 0; + int do_host_hiding = 0; what = MODE_ADD; @@ -1077,7 +1135,8 @@ int set_user_mode(struct Client *cptr, struct Client *sptr, int parc, char *parv m = buf; *m++ = '+'; for (i = 0; i < USERMODELIST_SIZE; ++i) { - if ( (userModeList[i].flag & cli_flags(sptr))) + if ((userModeList[i].flag & cli_flags(sptr)) && + !(userModeList[i].flag & FLAGS_ACCOUNT)) *m++ = userModeList[i].c; } *m = '\0'; @@ -1176,6 +1235,10 @@ int set_user_mode(struct Client *cptr, struct Client *sptr, int parc, char *parv else ClearDebug(sptr); break; + case 'x': + if (what == MODE_ADD) + do_host_hiding = 1; + break; default: break; } @@ -1243,6 +1306,8 @@ int set_user_mode(struct Client *cptr, struct Client *sptr, int parc, char *parv --UserStats.inv_clients; if (!(setflags & FLAGS_INVISIBLE) && IsInvisible(sptr)) ++UserStats.inv_clients; + if (!(setflags & FLAGS_HIDDENHOST) && do_host_hiding) + hide_hostmask(sptr, FLAGS_HIDDENHOST); send_umode_out(cptr, sptr, setflags, prop); return 0; @@ -1268,6 +1333,15 @@ char *umode_str(struct Client *cptr) if ( (c_flags & userModeList[i].flag)) *m++ = userModeList[i].c; } + + if (IsAccount(cptr)) { + char* t = cli_user(cptr)->account; + + *m++ = ' '; + while ((*m++ = *t++)) + ; /* Empty loop */ + } + *m = '\0'; return umodeBuf; /* Note: static buffer, gets @@ -1450,6 +1524,7 @@ int is_silenced(struct Client *sptr, struct Client *acptr) struct User *user; static char sender[HOSTLEN + NICKLEN + USERLEN + 5]; static char senderip[16 + NICKLEN + USERLEN + 5]; + static char senderh[HOSTLEN + ACCOUNTLEN + USERLEN + 6]; if (!cli_user(acptr) || !(lp = cli_user(acptr)->silence) || !(user = cli_user(sptr))) return 0; @@ -1457,9 +1532,13 @@ int is_silenced(struct Client *sptr, struct Client *acptr) user->username, user->host); ircd_snprintf(0, senderip, sizeof(senderip), "%s!%s@%s", cli_name(sptr), user->username, ircd_ntoa((const char*) &(cli_ip(sptr)))); + if (HasHiddenHost(sptr)) + ircd_snprintf(0, senderh, sizeof(senderh), "%s!%s@%s", cli_name(sptr), + user->username, user->realhost); for (; lp; lp = lp->next) { - if ((!(lp->flags & CHFL_SILENCE_IPMASK) && !match(lp->value.cp, sender)) || + if ((!(lp->flags & CHFL_SILENCE_IPMASK) && (!match(lp->value.cp, sender) || + (HasHiddenHost(sptr) && !match(lp->value.cp, senderh)))) || ((lp->flags & CHFL_SILENCE_IPMASK) && !match(lp->value.cp, senderip))) { if (!MyConnect(sptr)) diff --git a/ircd/send.c b/ircd/send.c index 8f17ee6..2ba06e4 100644 --- a/ircd/send.c +++ b/ircd/send.c @@ -26,6 +26,7 @@ #include "class.h" #include "client.h" #include "ircd.h" +#include "ircd_policy.h" #include "ircd_snprintf.h" #include "ircd_string.h" #include "list.h" @@ -215,12 +216,13 @@ void send_buffer(struct Client* to, struct MsgBuf* buf, int prio) * addition -- Armin, 8jun90 (gruner@informatik.tu-muenchen.de) */ -static int match_it(struct Client *one, const char *mask, int what) +static int match_it(struct Client *from, struct Client *one, const char *mask, int what) { switch (what) { case MATCH_HOST: - return (match(mask, cli_user(one)->host) == 0); + return (match(mask, cli_user(one)->host) == 0 || + (HasHiddenHost(one) && match(mask, cli_user(one)->realhost) == 0)); case MATCH_SERVER: default: return (match(mask, cli_name(cli_user(one)->server)) == 0); @@ -330,6 +332,8 @@ void sendcmdto_serv_butone(struct Client *from, const char *cmd, * Send a (prefix) command originating from to all channels * is locally on. must be a user. is ignored in * this function. + * + * Update: don't send to 'one', if any. --Vampire */ /* XXX sentalong_marker used XXX * @@ -343,8 +347,9 @@ void sendcmdto_serv_butone(struct Client *from, const char *cmd, * message to, and then a final loop through the connected servers * to delete the flag. -Kev */ -void sendcmdto_common_channels(struct Client *from, const char *cmd, - const char *tok, const char *pattern, ...) +void sendcmdto_common_channels_butone(struct Client *from, const char *cmd, + const char *tok, struct Client *one, + const char *pattern, ...) { struct VarData vd; struct MsgBuf *mb; @@ -370,16 +375,20 @@ void sendcmdto_common_channels(struct Client *from, const char *cmd, /* * loop through from's channels, and the members on their channels */ - for (chan = cli_user(from)->channel; chan; chan = chan->next_channel) + for (chan = cli_user(from)->channel; chan; chan = chan->next_channel) { + if (IsZombie(chan)) + continue; for (member = chan->channel->members; member; member = member->next_member) if (MyConnect(member->user) && -1 < cli_fd(cli_from(member->user)) && + member->user != one && sentalong[cli_fd(cli_from(member->user))] != sentalong_marker) { sentalong[cli_fd(cli_from(member->user))] = sentalong_marker; send_buffer(member->user, mb, 0); } + } - if (MyConnect(from)) + if (MyConnect(from) && from != one) send_buffer(from, mb, 0); msgq_clean(mb); @@ -388,10 +397,13 @@ void sendcmdto_common_channels(struct Client *from, const char *cmd, /* * Send a (prefixed) command to all local users on the channel specified * by ; is ignored by this function + * + * Update: don't send to 'one', if any. --Vampire */ -void sendcmdto_channel_butserv(struct Client *from, const char *cmd, - const char *tok, struct Channel *to, - const char *pattern, ...) +void sendcmdto_channel_butserv_butone(struct Client *from, const char *cmd, + const char *tok, struct Channel *to, + struct Client *one, const char *pattern, + ...) { struct VarData vd; struct MsgBuf *mb; @@ -406,7 +418,7 @@ void sendcmdto_channel_butserv(struct Client *from, const char *cmd, /* send the buffer to each local channel member */ for (member = to->members; member; member = member->next_member) { - if (MyConnect(member->user) && !IsZombie(member)) + if (MyConnect(member->user) && member->user != one && !IsZombie(member)) send_buffer(member->user, mb, 0); } @@ -519,7 +531,12 @@ void sendwallto_group_butone(struct Client *from, int type, struct Client *one, if (!(cptr = LocalClientArray[i]) || (cli_fd(cli_from(cptr)) < 0) || (type == WALL_DESYNCH && !(cli_flags(cptr) & FLAGS_DEBUG)) || +#ifdef HEAD_IN_SAND_WALLOPS + (type == WALL_WALLOPS && (!(cli_flags(cptr) & FLAGS_WALLOP) || + !IsAnOper(cptr))) || +#else (type == WALL_WALLOPS && !(cli_flags(cptr) & FLAGS_WALLOP)) || +#endif (type == WALL_WALLUSERS && !(cli_flags(cptr) & FLAGS_WALLOP))) continue; /* skip it */ send_buffer(cptr, mb, 1); @@ -586,7 +603,7 @@ void sendcmdto_match_butone(struct Client *from, const char *cmd, sentalong_marker++; for (cptr = GlobalClientList; cptr; cptr = cli_next(cptr)) { if (!IsRegistered(cptr) || cli_from(cptr) == one || IsServer(cptr) || - IsMe(cptr) || !match_it(cptr, to, who) || cli_fd(cli_from(cptr)) < 0 || + IsMe(cptr) || !match_it(from, cptr, to, who) || cli_fd(cli_from(cptr)) < 0 || sentalong[cli_fd(cli_from(cptr))] == sentalong_marker) continue; /* skip it */ sentalong[cli_fd(cli_from(cptr))] = sentalong_marker; diff --git a/ircd/uping.c b/ircd/uping.c index a83c57e..8f89653 100644 --- a/ircd/uping.c +++ b/ircd/uping.c @@ -94,7 +94,7 @@ static void uping_erase(struct UPing* p) /* Called when the event engine detects activity on the UPing socket */ static void uping_echo_callback(struct Event* ev) { - assert(ev_type(ev) == ET_READ); + assert(ev_type(ev) == ET_READ || ev_type(ev) == ET_ERROR); uping_echo(); } @@ -204,7 +204,7 @@ static void uping_read_callback(struct Event* ev) if (!pptr->freeable) MyFree(pptr); /* done with it, finally */ } else { - assert(ev_type(ev) == ET_READ); + assert(ev_type(ev) == ET_READ || ev_type(ev) == ET_ERROR); uping_read(pptr); /* read uping response */ } @@ -271,9 +271,9 @@ static void uping_start(struct UPing* pptr) { assert(0 != pptr); - timer_add(&pptr->sender, uping_sender_callback, (void*) pptr, + timer_add(timer_init(&pptr->sender), uping_sender_callback, (void*) pptr, TT_PERIODIC, 1); - timer_add(&pptr->killer, uping_killer_callback, (void*) pptr, + timer_add(timer_init(&pptr->killer), uping_killer_callback, (void*) pptr, TT_RELATIVE, UPINGTIMEOUT); pptr->freeable |= UPING_PENDING_SENDER | UPING_PENDING_KILLER; diff --git a/ircd/whocmds.c b/ircd/whocmds.c index 25f3545..8bdb1ce 100644 --- a/ircd/whocmds.c +++ b/ircd/whocmds.c @@ -136,7 +136,15 @@ void do_who(struct Client* sptr, struct Client* acptr, struct Channel* repchan, if (!fields || (fields & WHO_FIELD_SER)) { - char *p2 = cli_name(cli_user(acptr)->server); + char *p2; +#ifdef HEAD_IN_SAND_WHO_SERVERNAME + if (IsOper(sptr)) +#endif + p2 = cli_name(cli_user(acptr)->server); +#ifdef HEAD_IN_SAND_WHO_SERVERNAME + else + p2 = HEAD_IN_SAND_SERVERNAME; +#endif *(p1++) = ' '; while ((*p2) && (*(p1++) = *(p2++))); } @@ -189,6 +197,8 @@ void do_who(struct Client* sptr, struct Client* acptr, struct Channel* repchan, if (SendDebug(acptr)) *(p1++) = 'g'; } + if (HasHiddenHost(acptr)) + *(p1++) = 'x'; } if (!fields || (fields & WHO_FIELD_DIS)) @@ -197,8 +207,7 @@ void do_who(struct Client* sptr, struct Client* acptr, struct Channel* repchan, if (!fields) *p1++ = ':'; /* Place colon here for default reply */ #ifdef HEAD_IN_SAND_WHO_HOPCOUNT - strcat(p1, sptr == acptr ? "0" : "3"); - p1++; + *p1++ = (sptr == acptr) ? '0' : '3'; #else /* three digit hopcount maximum */ p1 += ircd_snprintf(0, p1, 3, "%d", cli_hopcount(acptr)); diff --git a/ircd/whowas.c b/ircd/whowas.c index 48ab103..2aa9399 100644 --- a/ircd/whowas.c +++ b/ircd/whowas.c @@ -176,6 +176,8 @@ whowas_clean(struct Whowas *ww) MyFree(ww->username); if (ww->hostname) MyFree(ww->hostname); + if (ww->realhost) + MyFree(ww->realhost); if (ww->servername) MyFree(ww->servername); if (ww->realname) @@ -218,6 +220,7 @@ whowas_init(struct Whowas *ww) ww->name = 0; ww->username = 0; ww->hostname = 0; + ww->realhost = 0; ww->servername = 0; ww->realname = 0; ww->away = 0; @@ -290,6 +293,8 @@ void add_history(struct Client *cptr, int still_on) DupString(ww->name, cli_name(cptr)); DupString(ww->username, cli_user(cptr)->username); DupString(ww->hostname, cli_user(cptr)->host); + if (HasHiddenHost(cptr)) + DupString(ww->realhost, cli_user(cptr)->realhost); DupString(ww->servername, cli_name(cli_user(cptr)->server)); DupString(ww->realname, cli_info(cptr)); if (cli_user(cptr)->away) diff --git a/tools/ringlog.c b/tools/ringlog.c new file mode 100644 index 0000000..920ab5f --- /dev/null +++ b/tools/ringlog.c @@ -0,0 +1,341 @@ +/* +** Copyright (C) 2002 by Kevin L. Mitchell +** +** This program is free software; you can redistribute it and/or modify +** it under the terms of the GNU General Public License as published by +** the Free Software Foundation; either version 2 of the License, or +** (at your option) any later version. +** +** This program is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +** GNU General Public License for more details. +** +** You should have received a copy of the GNU General Public License +** along with this program; if not, write to the Free Software +** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +** +** @(#)$Id$ +*/ +/* + * This file contains two separate pieces, along with some common + * gunk. If RINGLOG_INSTRUMENT is defined, the two special functions + * __cyg_profile_func_enter() and __cyg_profile_func_exit() are + * defined; otherwise a main function is defined. The common gunk is + * init_log(), which opens and, if necessary, initializes a special + * binary log file that is treated as a ring buffer (to prevent the + * file from growing unboundedly). + * + * The object produced when compiled with RINGLOG_INSTRUMENT is + * designed to work with the special gcc option + * -finstrument-functions; this option causes the + * __cyg_profile_func_*() functions mentioned above to be called when + * a function is entered or exited. (Of course, ringlog.o should + * *not* be compiled with this option.) These functions will in turn + * call store_entry(), which will call init_log() as needed to open + * the log file, ensure that a start record is output, and then will + * store records for the function calls. The log file used is + * "call.ringlog" in the directory from which the program was + * started. + * + * When RINGLOG_INSTRUMENT is *not* defined while building, a main + * function is defined, and the result is an executable for + * interpretation of a ringlog. Usage is very simple: All arguments + * not beginning with '-' are treated as files to open, and all + * arguments beginning with '-' are treated as a specification for the + * number of entries new files should be created with. If this + * specification is 0 (which it is by default), files will not be + * created if they do not already exist. + * + * For every filename argument, at least one line will be printed + * out. If the file is not empty, the entries in the file will be + * printed out, one to a line. Each entry is numbered with a logical + * number. The entry numbers are followed by a two word description + * of the entry type ("Log start," "Function entry," "Function exit," + * and "Invalid entry"), followed by a colon (":"), followed by the + * word "addr" and the address of the function, followed by the word + * "call" and the address from which the function was called. The + * ringlog program is not able to convert these addresses to symbols + * or file and line numbers--that can be done with a program like + * addr2line (part of the binutils package). The output has been + * carefully contrived to be parsable by a script. + * + * The file format is documented below. Note that data is stored in + * host byte order. + * + * 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Magic number | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | First entry | Last entry | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Records | + * \ \ + * \ \ + * | Records | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * Record format: + * 1 2 3 + * 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Type code | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Function address | + * / / + * / / + * | Function address | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * | Calling location | + * / / + * / / + * | Calling location | + * +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + * + * Some systems may have pointers larger than 32 bits, which is why these + * fields are allowed to be variable width. + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* /etc/magic rules: + * + * 0 belong 0x52e45fd4 RingLog call trace file, big endian + * >4 beshort x (First entry %u, + * >>6 beshort x last entry %u) + * 0 lelong 0x52e45fd4 RingLog call trace file, little endian + * >4 leshort x (First entry %u, + * >>6 leshort x last entry %u) + */ +#define RINGLOG_MAGIC 0x52e45fd4 /* verify file format */ + +#define RINGLOG_INIT 0x00000000 /* mark when a session was initiated */ +#define RINGLOG_ENTER 0x01010101 /* record function entry */ +#define RINGLOG_EXIT 0x02020202 /* record function exit */ + +#define RINGLOG_FNAME "call.ringlog" /* default file name */ +#define RINGLOG_ILEN 2000 /* default number of entries */ + +/* length of the header and of individual entries */ +#define HEAD_LEN (sizeof(u_int32_t) + 2 * sizeof(u_int16_t)) +#define ENTRY_LEN (sizeof(u_int32_t) + 2 * sizeof(void *)) + +/* return an lvalue to the specified type stored at the specified location */ +#define rl_ref(log, loc, type) (*((type *)((log) + (loc)))) + +/* access particular header fields */ +#define rl_magic(log) rl_ref((log), 0, u_int32_t) +#define rl_first(log) rl_ref((log), 4, u_int16_t) +#define rl_last(log) rl_ref((log), 6, u_int16_t) + +/* translate physical entry number to a file location */ +#define rl_addr(loc) ((loc) * ENTRY_LEN + HEAD_LEN) + +/* extract the type, function, and call fields of an entry */ +#define rl_type(log, loc) rl_ref((log), rl_addr(loc), u_int32_t) +#define rl_func(log, loc) rl_ref((log), rl_addr(loc) + sizeof(u_int32_t), \ + void *) +#define rl_call(log, loc) rl_ref((log), rl_addr(loc) + sizeof(u_int32_t) + \ + sizeof(void *), void *) + +static char *log = 0; /* the log has to be global data */ +static size_t log_size = 0; /* remember the size of the log */ +static int log_length = 0; /* remember how many entries it'll hold */ + +/* Open and initialize the log file */ +static int +init_log(char *fname, size_t init_len) +{ + char c = 0; + int fd, err = 0, size = -1; + struct stat buf; + + /* open file */ + if ((fd = open(fname, O_RDWR | (init_len > 0 ? O_CREAT : 0), + S_IRUSR | S_IWUSR)) < 0) + return errno; /* return error */ + + if (fstat(fd, &buf)) { /* get size */ + err = errno; /* save errno... */ + close(fd); /* close file descriptor */ + return err; /* return error */ + } + + if (buf.st_size <= 8) /* too small */ + size = HEAD_LEN + ENTRY_LEN * init_len; + else if ((buf.st_size - 8) % ENTRY_LEN) /* not a multiple of entry length */ + size = ((buf.st_size - 8) / ENTRY_LEN + 1) * ENTRY_LEN + 8; /* round up */ + + if (size >= 0) { /* need to set the size */ + if (lseek(fd, size - 1, SEEK_SET) < 0) { /* seek to the end of our file */ + err = errno; /* save errno... */ + close(fd); /* close file descriptor */ + return err; /* return error */ + } + + if (write(fd, &c, 1) < 0) { /* write a zero to set the new size */ + err = errno; /* save errno... */ + close(fd); /* close file descriptor */ + return err; /* return error */ + } + + log_size = size; /* record log size */ + } else + log_size = buf.st_size; /* record log size */ + + /* map the file to memory */ + if ((log = (char *)mmap(0, log_size, PROT_READ | PROT_WRITE, + MAP_SHARED, fd, 0)) == MAP_FAILED) + err = errno; /* save errno... */ + + close(fd); /* don't need the file descriptor anymore */ + + if (err) /* an error occurred while mapping the file; return it */ + return err; + + log_length = (log_size - HEAD_LEN) / ENTRY_LEN; /* store number of entries */ + + if (rl_magic(log) == 0) { /* initialize if necessary */ + rl_magic(log) = RINGLOG_MAGIC; + rl_first(log) = -1; + rl_last(log) = -1; + } + + if (rl_magic(log) != RINGLOG_MAGIC) { /* verify file format */ + munmap(log, log_size); /* unmap file */ + return -1; /* -1 indicates file format error */ + } + + return 0; /* return success */ +} + +#ifdef RINGLOG_INSTRUMENT + +/* store an entry in the log file */ +static void +store_entry(u_int32_t type, void *this_fn, void *call_site) +{ + if (!log) { /* open the log file if necessary; die if unable */ + assert(init_log(RINGLOG_FNAME, RINGLOG_ILEN) == 0); + store_entry(RINGLOG_INIT, 0, 0); /* mark start of logging */ + } + + if (++(rl_last(log)) >= log_length) /* select next entry to fill */ + rl_last(log) = 0; /* wrap if needed */ + + if (rl_first(log) == rl_last(log)) { /* advance start pointer if collision */ + if (++(rl_first(log)) >= log_length) /* wrap if necessary */ + rl_first(log) = 0; + } else if (rl_first(log) == (u_int16_t)-1) /* no entries yet; enter one */ + rl_first(log) = 0; + + rl_type(log, rl_last(log)) = type; /* record the entry */ + rl_func(log, rl_last(log)) = this_fn; + rl_call(log, rl_last(log)) = call_site; +} + +/* called upon function entry */ +void +__cyg_profile_func_enter(void *this_fn, void *call_site) +{ + store_entry(RINGLOG_ENTER, this_fn, call_site); +} + +/* called upon function exit */ +void +__cyg_profile_func_exit(void *this_fn, void *call_site) +{ + store_entry(RINGLOG_EXIT, this_fn, call_site); +} + +#else /* !defined(RINGLOG_INSTRUMENT) */ + +/* converts a type to a printable string */ +static char * +get_type(u_int32_t type) +{ + switch (type) { + case RINGLOG_INIT: + return " Logging start"; + break; + case RINGLOG_ENTER: + return "Function entry"; + break; + case RINGLOG_EXIT: + return " Function exit"; + break; + } + + return " Invalid entry"; +} + +/* Print out entries from a starting point to an end point */ +static void +extract(int *count, u_int16_t start, u_int16_t end) +{ + for (; start <= end; start++) + printf("% 4d %s: addr %p call %p\n", (*count)++, + get_type(rl_type(log, start)), rl_func(log, start), + rl_call(log, start)); +} + +int +main(int argc, char **argv) +{ + char *arg; + int i, err, size = 0; + + while ((arg = *++argv)) { + if (arg[0] == '-') { /* - turns into log file size */ + size = atoi(arg + 1); + continue; + } + + log = 0; /* initialize our data */ + log_size = 0; + log_length = 0; + + switch ((err = init_log(arg, size))) { /* initialize the log */ + case -1: /* file is in an invalid format */ + printf("File %s not a valid ringlog file\n", arg); + continue; + break; + + case 0: /* file has opened and is ready to be read */ + break; + + default: /* some error occurred */ + printf("Error %d opening file %s: %s\n", err, arg, strerror(err)); + continue; + break; + } + + if (rl_first(log) == (u_int16_t)-1) /* it's an empty file */ + printf("File %s is empty\n", arg); + else { /* print out file contents */ + printf("File %s contents:\n", arg); + + i = 0; /* initialize counter */ + if (rl_last(log) <= rl_first(log)) { /* print out log file */ + extract(&i, rl_first(log), log_length - 1); /* end of buffer... */ + extract(&i, 0, rl_last(log)); /* then beginning of buffer */ + } else + extract(&i, rl_first(log), rl_last(log)); + } + + munmap(log, log_size); /* unmap the file */ + } + + return 0; +} + +#endif /* !RINGLOG_INSTRUMENT */ diff --git a/tools/ringlog.pl b/tools/ringlog.pl new file mode 100755 index 0000000..346b05f --- /dev/null +++ b/tools/ringlog.pl @@ -0,0 +1,187 @@ +#! /usr/bin/perl -w +# +# Copyright (C) 2002 by Kevin L. Mitchell +# +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# @(#)$Id$ +# +# This program is intended to be used in conjunction with ringlog and +# the binutils program addr2line. The -r option specifies the path to +# the ringlog program; the -a option specifies the path to addr2line. +# (Both of these default to assuming that the programs are in your +# PATH.) All other options are passed to addr2line, and any other +# arguments are treated as filenames to pass to ringlog. If no +# filenames are given, the program operates in filter mode, expecting +# to get output from ringlog on its standard input. In this case, +# ringlog will not be directly executed, but addr2line still will. + +use strict; + +use Socket; +use IO::Handle; + +sub start_addr2line { + my ($location, @args) = @_; + + unshift(@args, '-f'); # always get functions + + # Get a socket pair + socketpair(CHILD, PARENT, AF_UNIX, SOCK_STREAM, PF_UNSPEC) + or die "socketpair: $!"; + + CHILD->autoflush(1); # Make sure autoflush is turned on + PARENT->autoflush(1); + + my $pid; + + # Fork... + die "cannot fork: $!" + unless (defined($pid = fork)); + + if (!$pid) { # in child + close(CHILD); + open(STDIN, "<&PARENT"); + open(STDOUT, ">&PARENT"); + exec($location, @args); # exec! + } + + # in parent + close(PARENT); + + return \*CHILD; # Return a filehandle for it +} + +sub xlate_addr { + my ($fh, $addr) = @_; + + # Feed address into addr2line + print $fh "$addr\n"; + + # Get function name, file name, and line number + my $function = <$fh> || die "Couldn't get function name"; + my $fileline = <$fh> || die "Couldn't get file name or line number"; + + # Remove newlines... + chomp($function, $fileline); + + # If addr2line couldn't translate the address, just return it + return "[$addr]" + if ($function eq "??"); + + # return function(file:line)[address] + return "$function($fileline)[$addr]"; +} + +sub start_ringlog { + my ($location, @args) = @_; + + # Build a pipe and fork, through the magic of open() + my $pid = open(RINGLOG, "-|"); + + # Make sure we forked! + die "couldn't fork: $!" + unless (defined($pid)); + + # Execute ringlog... + exec($location, @args) + unless ($pid); + + return \*RINGLOG; +} + +sub parse_ringlog { + my ($ringlog, $addr) = @_; + my $state = "reading"; + + while (<$ringlog>) { + chomp; + + # Beginning of parsable data + if (/^File.*contents:$/) { + $state = "parsing"; + + # Here's actual parsable data, so parse it + } elsif ($state eq "parsing" && /^\s*\d+/) { + s/(0x[a-fA-F0-9]+)/&xlate_addr($addr, $1)/eg; + + # Switch out of parsing mode + } else { + $state = "reading"; + } + + # Print the final result + print "$_\n"; + } +} + +# get an argument for an option that requires one +sub getarg (\$) { + my ($iref) = @_; + + $ARGV[$$iref] =~ /^(-.)(.*)/; + + die "Argument for $1 missing" + unless ((defined($2) && $2 ne "") || @ARGV > $$iref + 1); + + return defined($2) && $2 ne "" ? $2 : $ARGV[++$$iref]; +} + +my ($ringlog_exe, $addr2line_exe) = ("ringlog", "addr2line"); +my (@addr2line_args, @files); + +# Deal with arguments; note that we have to deal with -b and -e for +# addr2line. +for (my $i = 0; $i < @ARGV; $i++) { + if ($ARGV[$i] =~ /^-r/) { + $ringlog_exe = getarg($i); + } elsif ($ARGV[$i] =~ /^-a/) { + $addr2line_exe = getarg($i); + } elsif ($ARGV[$i] =~ /^-([be])/) { + push(@addr2line_args, "-$1", getarg($i)); + } elsif ($ARGV[$i] =~ /^-/) { + push(@addr2line_args, $ARGV[$i]); + } else { + push(@files, [ $ARGV[$i], @addr2line_args ]); + @addr2line_args = (); + } +} + +# Verify that that left us with executable names, at least +die "No ringlog executable" + unless (defined($ringlog_exe) && $ringlog_exe ne ""); +die "No addr2line executable" + unless (defined($addr2line_exe) && $addr2line_exe ne ""); + +# Ok, process each file we've been asked to process +foreach my $file (@files) { + my ($addr2line, $ringlog) = + (start_addr2line($addr2line_exe, @{$file}[1..$#{$file}]), + start_ringlog($ringlog_exe, $file->[0])); + + parse_ringlog($ringlog, $addr2line); + + close($addr2line); + close($ringlog); +} + +# Now if there are still more unprocessed arguments, expect ringlog +# input on stdin... +if (@addr2line_args) { + my $addr2line = start_addr2line($addr2line_exe, @addr2line_args); + + parse_ringlog(\*STDIN, $addr2line); + close($addr2line); +} -- 2.20.1