X-Git-Url: http://git.pk910.de/?p=ircu2.10.12-pk.git;a=blobdiff_plain;f=ircd%2Fm_create.c;fp=ircd%2Fm_create.c;h=df2085e1415e3a61fff32391a3bc8cdf9916c45b;hp=0000000000000000000000000000000000000000;hb=0400a5a6479398d82526785c18c0df8bc8b92dce;hpb=d17e10da972ce5776c60b4c317267c6abe0e1ead diff --git a/ircd/m_create.c b/ircd/m_create.c new file mode 100644 index 0000000..df2085e --- /dev/null +++ b/ircd/m_create.c @@ -0,0 +1,233 @@ +/* + * IRC - Internet Relay Chat, ircd/m_create.c + * Copyright (C) 1990 Jarkko Oikarinen and + * University of Oulu, Computing Center + * + * 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 "channel.h" +#include "client.h" +#include "hash.h" +#include "ircd.h" +#include "ircd_log.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 "s_user.h" +#include "send.h" + +/* #include -- Now using assert in ircd_log.h */ +#include +#include + +/* + * ms_create - server message handler + */ +int ms_create(struct Client* cptr, struct Client* sptr, int parc, char* parv[]) +{ + time_t chanTS; /* channel creation time */ + char *p; /* strtok state */ + char *name; /* channel name */ + struct Channel *chptr; /* channel */ + struct JoinBuf join; /* join and create buffers */ + struct JoinBuf create; + struct ModeBuf mbuf; /* a mode buffer */ + int badop; /* a flag */ + + if (IsServer(sptr)) + return protocol_violation(sptr,"%s tried to CREATE a channel", cli_name(sptr)); + + /* sanity checks: Only accept CREATE messages from servers */ + if (parc < 3 || *parv[2] == '\0') + return need_more_params(sptr,"CREATE"); + + chanTS = atoi(parv[2]); + + /* A create that didn't appear during a burst has that servers idea of + * the current time. Use it for lag calculations. + */ + if (!IsBurstOrBurstAck(sptr) && 0 != chanTS) + cli_serv(cli_user(sptr)->server)->lag = TStime() - chanTS; + + /* If this server is >1 minute fast, warn */ + if (TStime() - chanTS<-60) + { + static time_t rate; + sendto_opmask_butone_ratelimited(0, SNO_NETWORK, &rate, + "Timestamp drift from %C (%is); issuing " + "SETTIME to correct this", + cli_user(sptr)->server, + chanTS - TStime()); + /* Now issue a SETTIME to resync. If we're in the wrong, our + * (RELIABLE_CLOCK) hub will bounce a SETTIME back to us. + */ + sendcmdto_prio_one(&me, CMD_SETTIME, cli_user(sptr)->server, + "%Tu %C", TStime(), cli_user(sptr)->server); + } + + joinbuf_init(&join, sptr, cptr, JOINBUF_TYPE_JOIN, 0, 0); + joinbuf_init(&create, sptr, cptr, JOINBUF_TYPE_CREATE, 0, chanTS); + + /* For each channel in the comma separated list: */ + for (name = ircd_strtok(&p, parv[1], ","); name; + name = ircd_strtok(&p, 0, ",")) { + badop = 0; + + if (IsLocalChannel(name)) + continue; + + if ((chptr = FindChannel(name))) + { + /* Is the remote server confused? */ + if (find_member_link(chptr, sptr)) { + protocol_violation(sptr, "%s tried to CREATE a channel already joined (%s)", cli_name(sptr), chptr->chname); + continue; + } + + /* Check if we need to bounce a mode */ + if (TStime() - chanTS > TS_LAG_TIME || + (chptr->creationtime && chanTS > chptr->creationtime && + /* Accept CREATE for zannels. This is only really necessary on a network + with servers prior to 2.10.12.02: we just accept their TS and ignore + the fact that it was a zannel. The influence of this on a network + that is completely 2.10.12.03 or higher is neglectable: Normally + a server only sends a CREATE after first sending a DESTRUCT. Thus, + by receiving a CREATE for a zannel one of three things happened: + 1. The DESTRUCT was sent during a net.break; this could mean that + our zannel is at the verge of expiring too, it should have been + destructed. It is correct to copy the newer TS now, all modes + already have been reset, so it will be as if it was destructed + and immediately recreated. In order to avoid desyncs of modes, + we don't accept a CREATE for channels that have +A set. + 2. The DESTRUCT passed, then someone created the channel on our + side and left it again. In this situation we have a near + simultaneous creation on two servers; the person on our side + already left within the time span of a message propagation. + The channel will therefore be less than 48 hours old and no + 'protection' is necessary. + 3. The source server sent the CREATE while linking, + before it got the BURST for our zannel. If this + happens, we should reset the channel back to the old + timestamp. This can be distinguished from case #1 by + checking IsBurstOrBurstAck(cli_user(sptr)->server). + */ + !(chptr->users == 0 && !chptr->mode.apass[0]))) { + if (!IsBurstOrBurstAck(cli_user(sptr)->server)) { + modebuf_init(&mbuf, sptr, cptr, chptr, + (MODEBUF_DEST_SERVER | /* Send mode to server */ + MODEBUF_DEST_HACK2 | /* Send a HACK(2) message */ + MODEBUF_DEST_BOUNCE)); /* And bounce the mode */ + + modebuf_mode_client(&mbuf, MODE_ADD | MODE_CHANOP, sptr, MAXOPLEVEL + 1); + + modebuf_flush(&mbuf); + + badop = 1; + } else if (chanTS > chptr->creationtime + 4) { + /* If their handling of the BURST will lead to deopping the + * user, have the user join without getting ops (if the + * server's handling of the BURST keeps their ops, the channel + * will use our timestamp). + */ + badop = 1; + } + + if (badop) + joinbuf_join(&join, chptr, 0); + } + } + else /* Channel doesn't exist: create it */ + chptr = get_channel(sptr, name, CGT_CREATE); + + if (!badop) { + /* Set (or correct) our copy of the TS */ + chptr->creationtime = chanTS; + joinbuf_join(&create, chptr, CHFL_CHANOP); + } + } + + joinbuf_flush(&join); /* flush out the joins and creates */ + joinbuf_flush(&create); + + return 0; +}