*
* This file is part of x3.
*
- * srvx is free software; you can redistribute it and/or modify
+ * x3 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
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
#include "hash.h"
#include "log.h"
+#if defined(HAVE_LIBGEOIP)&&defined(HAVE_GEOIP_H)&&defined(HAVE_GEOIPCITY_H)
+#include <GeoIP.h>
+#include <GeoIPCity.h>
+
+GeoIP * gi = NULL;
+GeoIP * cgi = NULL;
+#endif
+
struct server *self;
dict_t channels;
dict_t clients;
free(old_nick);
}
+void
+SVSNickChange(struct userNode* user, const char *new_nick)
+{
+ char *old_nick;
+ unsigned int nn;
+
+ /* don't do anything if there's no change */
+ old_nick = user->nick;
+ if (!strncmp(new_nick, old_nick, NICKLEN))
+ return;
+
+ /* remove old entry from clients dictionary */
+ dict_remove(clients, old_nick);
+#if !defined(WITH_PROTOCOL_P10)
+ /* Remove from uplink's clients dict */
+ dict_remove(user->uplink->users, old_nick);
+#endif
+ /* and reinsert */
+ user->nick = strdup(new_nick);
+ dict_insert(clients, user->nick, user);
+#if !defined(WITH_PROTOCOL_P10)
+ dict_insert(user->uplink->users, user->nick, user);
+#endif
+
+ /* Make callbacks for nick changes. Do this with new nick in
+ * place because that is slightly more useful.
+ */
+ for (nn=0; nn<ncf2_used; nn++)
+ ncf2_list[nn](user, old_nick);
+ user->timestamp = now;
+
+ free(old_nick);
+}
+
struct userNode *
GetUserH(const char *nick)
{
irc_fakehost(user, host);
}
+void
+set_geoip_info(struct userNode *user)
+{
+ if(IsLocal(user))
+ return;
+/* Need the libs and the headers if this is going to compile properly */
+#if defined(HAVE_LIBGEOIP)&&defined(HAVE_GEOIP_H)&&defined(HAVE_GEOIPCITY_H)
+ GeoIPRecord * gir;
+ const char *geoip_data_file = NULL;
+ const char *geoip_city_file = NULL;
+
+ geoip_data_file = conf_get_data("services/opserv/geoip_data_file", RECDB_QSTRING);
+ geoip_city_file = conf_get_data("services/opserv/geoip_city_data_file", RECDB_QSTRING);
+
+ if ((!geoip_data_file && !geoip_city_file))
+ return; /* Admin doesnt want to use geoip functions */
+
+ if (geoip_data_file && !gi)
+ gi = GeoIP_open(geoip_data_file, GEOIP_MEMORY_CACHE | GEOIP_CHECK_CACHE);
+
+ if (geoip_city_file && !cgi)
+ cgi = GeoIP_open(geoip_city_file, GEOIP_MEMORY_CACHE | GEOIP_CHECK_CACHE);
+
+ if (cgi) {
+ gir = GeoIP_record_by_name(cgi, user->hostname);
+ if (gir) {
+ user->country_name = strdup(gir->country_name ? gir->country_name : "");
+ user->country_code = strdup(gir->country_code ? gir->country_code : "");
+ user->city = strdup(gir->city ? gir->city : "");
+ user->region = strdup(gir->region ? gir->region : "");
+ user->postal_code = strdup(gir->postal_code ? gir->postal_code : "");
+
+ user->latitude = gir->latitude ? gir->latitude : 0;
+ user->longitude = gir->longitude ? gir->longitude : 0;
+ user->dma_code = gir->dma_code ? gir->dma_code : 0;
+ user->area_code = gir->area_code ? gir->area_code : 0;
+
+ GeoIPRecord_delete(gir);
+ }
+
+ return;
+ } else if (gi) {
+ const char *country = GeoIP_country_name_by_name(gi, user->hostname);
+ user->country_name = strdup(country ? country : "");
+ return;
+ }
+
+ return;
+#endif
+}
+
static new_channel_func_t *ncf_list;
static unsigned int ncf_size = 0, ncf_used = 0;
unsigned int orig_limit;
chan_mode_t orig_modes;
char orig_key[KEYLEN+1];
+ char orig_apass[KEYLEN+1];
+ char orig_upass[KEYLEN+1];
unsigned int nn, argc;
/* nuke old topic */
orig_modes = cNode->modes;
orig_limit = cNode->limit;
strcpy(orig_key, cNode->key);
+ strcpy(orig_upass, cNode->upass);
+ strcpy(orig_apass, cNode->apass);
cNode->modes = 0;
mod_chanmode(NULL, cNode, modes, modec, 0);
cNode->timestamp = new_time;
change->modes_set = orig_modes;
change->new_limit = orig_limit;
strcpy(change->new_key, orig_key);
+ strcpy(change->new_upass, orig_upass);
+ strcpy(change->new_apass, orig_apass);
for (nn = argc = 0; nn < cNode->members.used; ++nn) {
struct modeNode *mn = cNode->members.list[nn];
if ((mn->modes & MODE_CHANOP) && IsService(mn->user) && IsLocal(mn->user)) {
banList_init(&cNode->banlist);
exemptList_init(&cNode->exemptlist);
modeList_init(&cNode->members);
- mod_chanmode(NULL, cNode, argv, nn, 0);
+ mod_chanmode(NULL, cNode, argv, nn, MCP_FROM_SERVER);
dict_insert(channels, cNode->name, cNode);
cNode->timestamp = time_;
rel_age = 1;
wipeout_channel(cNode, time_, argv, nn);
rel_age = 1;
} else if (cNode->timestamp == time_) {
- mod_chanmode(NULL, cNode, argv, nn, 0);
+ mod_chanmode(NULL, cNode, argv, nn, MCP_FROM_SERVER);
rel_age = 0;
} else {
rel_age = -1;
mNode->channel = channel;
mNode->user = user;
mNode->modes = 0;
+ mNode->oplevel = -1;
mNode->idle_since = now;
/* Add modeNode to channel and to user.
modeList_append(&user->channels, mNode);
if (channel->members.used == 1
- && !(channel->modes & MODE_REGISTERED))
+ && !(channel->modes & MODE_REGISTERED)
+ && !(channel->modes & MODE_APASS))
mNode->modes |= MODE_CHANOP;
for (n=0; n<jf_used; n++) {
/* free memory */
free(mNode);
- if (!deleting && !channel->members.used && !channel->locks && !(channel->modes & MODE_REGISTERED))
+ /* A single check for APASS only should be enough here */
+ if (!deleting && !channel->members.used && !channel->locks
+ && !(channel->modes & MODE_REGISTERED) && !(channel->modes & MODE_APASS))
DelChannel(channel);
}
+static kick_func_t *kf_list;
+static unsigned int kf_size = 0, kf_used = 0;
+
void
KickChannelUser(struct userNode* target, struct chanNode* channel, struct userNode *kicker, const char *why)
{
+ unsigned int n;
+
if (!target || !channel || IsService(target) || !GetUserMode(channel, target))
return;
+
+ /* This may break things, but lets see.. -Rubin */
+ for (n=0; n<kf_used; n++)
+ kf_list[n](kicker, target, channel);
+
/* don't remove them from the channel, since the server will send a PART */
irc_kick(kicker, target, channel, why);
}
}
-static kick_func_t *kf_list;
-static unsigned int kf_size = 0, kf_used = 0;
-
void
reg_kick_func(kick_func_t handler)
{
unsigned int n;
struct modeNode *mn;
- if (!victim || !channel || IsService(victim) || !GetUserMode(channel, victim))
+ if (!victim || !channel || !GetUserMode(channel, victim))
return;
/* Update the kicker's idle time (kicker may be null if it was a server) */
}
void
-SetChannelTopic(struct chanNode *channel, struct userNode *user, const char *topic, int announce)
+SetChannelTopic(struct chanNode *channel, struct userNode *service, struct userNode *user, const char *topic, int announce)
{
unsigned int n;
struct modeNode *mn;
if (announce) {
/* We don't really care if a local user messes with the topic,
* so don't call the tf_list functions. */
- irc_topic(user, channel, topic);
+ irc_topic(service, user, channel, topic);
} else {
for (n=0; n<tf_used; n++)
if (tf_list[n](user, channel, old_topic))
struct userNode *IsInChannel(struct chanNode *channel, struct userNode *user)
{
unsigned int n;
- struct modeNode *mn = NULL;
verify(channel);
verify(channel->members.list);
projects / irc / evilnet / x3.git / blobdiff