static void connection_error_callback(int fd)
{
connection_t *conn = connections + fd;
bool client = conn->client;
int remote_fd = valid_remote_fd(fd) ? conn->remote_fd : REMOTE_NULL;
connection_reset(conn);
ev_io_stop(EV_DEFAULT_ &conn->watcher);
close(fd);
if (client) {
if (remote_fd >= 0) {
server_t *server = find_server(remote_fd);
if (server && server->pid >= 0)
kill(server->pid, SIGHUP);
}
} else {
server_t *server = find_server(fd);
if (server) {
server->pid = -1;
server->fd = -1;
--server_size;
if (proxy_shutdown) {
if (!server_size)
ev_break(EV_DEFAULT_ EVBREAK_ALL);
} else {
spawn_server(server);
}
}
}
}
static void start_auth_request(PgSocket *client, const char *username)
{
int res;
char quoted_username[64], query[128];
client->auth_user = client->db->auth_user;
/* have to fetch user info from db */
client->pool = get_pool(client->db, client->db->auth_user);
if (!find_server(client)) {
client->wait_for_user_conn = true;
return;
}
slog_noise(client, "Doing auth_conn query");
client->wait_for_user_conn = false;
client->wait_for_user = true;
if (!sbuf_pause(&client->sbuf)) {
release_server(client->link);
disconnect_client(client, true, "pause failed");
return;
}
client->link->ready = 0;
pg_quote_literal(quoted_username, username, sizeof(quoted_username));
snprintf(query, sizeof(query), "SELECT usename, passwd FROM pg_shadow WHERE usename=%s", quoted_username);
SEND_generic(res, client->link, 'Q', "s", query);
if (!res)
disconnect_server(client->link, false, "unable to send login query");
}
static int
m_alis(struct Client *client_p, struct Client *source_p,
int parc, const char *parv[])
{
char buf[BUFSIZE];
int i = 1;
if(find_server(NULL, "services.azzurra.org") == NULL)
{
sendto_one(source_p,
":%s 440 %s alis :Services are currently unavailable",
me.name, source_p->name);
return 0;
}
buf[0] = '\0';
while(i < parc)
{
rb_strlcat(buf, parv[i], sizeof(buf));
rb_strlcat(buf, " ", sizeof(buf));
i++;
}
sendto_match_servs(client_p, "services.azzurra.org", CAP_ENCAP, NOCAPS,
"ENCAP services.azzurra.org RSMSG alis %s",
buf);
return 0;
}
DST_KEY *
tsig_key_from_addr(struct in_addr addr) {
server_info si = find_server(addr);
if (si == NULL || si->key_list == NULL || si->key_list->first == NULL)
return(NULL);
return(si->key_list->first->key);
}
void avrcp_unregister(const bdaddr_t *src)
{
struct avctp_server *server;
server = find_server(servers, src);
if (!server)
return;
servers = g_slist_remove(servers, server);
#ifndef ANDROID
remove_record_from_server(server->ct_record_id);
#endif
remove_record_from_server(server->tg_record_id);
g_io_channel_shutdown(server->io, TRUE, NULL);
g_io_channel_unref(server->io);
g_free(server);
if (servers)
return;
dbus_connection_unref(connection);
connection = NULL;
}
int server_unregister(struct btd_adapter *adapter, uint16_t id)
{
struct network_adapter *na;
struct network_server *ns;
na = find_adapter(adapters, adapter);
if (!na)
return -EINVAL;
ns = find_server(na->servers, id);
if (!ns)
return -EINVAL;
na->servers = g_slist_remove(na->servers, ns);
server_free(ns);
if (g_slist_length(na->servers) > 0)
return 0;
g_dbus_unregister_interface(btd_get_dbus_connection(),
adapter_get_path(adapter),
NETWORK_SERVER_INTERFACE);
return 0;
}
/*
** m_ping
** parv[1] = origin
** parv[2] = destination
*/
static int
m_ping(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Client *target_p;
const char *destination;
destination = parv[2]; /* Will get NULL or pointer (parc >= 2!!) */
if(!EmptyString(destination) && !match(destination, me.name))
{
if((target_p = find_server(source_p, destination)))
{
sendto_one(target_p, ":%s PING %s :%s",
get_id(source_p, target_p),
source_p->name, get_id(target_p, target_p));
}
else
{
sendto_one_numeric(source_p, ERR_NOSUCHSERVER,
form_str(ERR_NOSUCHSERVER),
destination);
return 0;
}
}
else
sendto_one(source_p, ":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, parv[1]);
return 0;
}
static struct avctp *avctp_get_internal(const bdaddr_t *src,
const bdaddr_t *dst)
{
struct avctp_server *server;
struct avctp *session;
assert(src != NULL);
assert(dst != NULL);
server = find_server(servers, src);
if (server == NULL)
return NULL;
session = find_session(server->sessions, dst);
if (session)
return session;
session = g_new0(struct avctp, 1);
session->server = server;
bacpy(&session->dst, dst);
session->state = AVCTP_STATE_DISCONNECTED;
server->sessions = g_slist_append(server->sessions, session);
return session;
}
static void ms_ping(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
struct Client *target_p;
char *origin, *destination;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(source_p, form_str(ERR_NOORIGIN), me.name, parv[0]);
return;
}
/* origin == source_p->name, lets not even both wasting effort on it --fl_ */
origin = source_p->name;
destination = parv[2]; /* Will get NULL or pointer (parc >= 2!!) */
if (!EmptyString(destination) && irccmp(destination, me.name))
{
if ((target_p = find_server(destination)))
sendto_one(target_p,":%s PING %s :%s", parv[0],
origin, destination);
else
{
sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return;
}
}
else
sendto_one(source_p,":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, origin);
}
static void
ms_pong(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
struct Client *target_p;
const char *origin, *destination;
if(parc < 2 || *parv[1] == '\0')
{
sendto_one(source_p, form_str(ERR_NOORIGIN), me.name, parv[0]);
return;
}
origin = parv[1];
destination = parv[2];
/* Now attempt to route the PONG, comstud pointed out routable PING
* is used for SPING. routable PING should also probably be left in
* -Dianora
* That being the case, we will route, but only for registered clients (a
* case can be made to allow them only from servers). -Shadowfax
*/
if(!EmptyString(destination) && !match(destination, me.name) && irccmp(destination, me.id))
{
if((target_p = find_client(destination)) || (target_p = find_server(destination)))
sendto_one(target_p, ":%s PONG %s %s", parv[0], origin, destination);
else
{
sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return;
}
}
else if(!HasSentEob(source_p))
server_eob(source_p);
}
void avctp_unregister(const bdaddr_t *src)
{
struct avctp_server *server;
server = find_server(servers, src);
if (!server)
return;
while (server->sessions)
avctp_disconnected(server->sessions->data);
servers = g_slist_remove(servers, server);
g_io_channel_shutdown(server->io, TRUE, NULL);
g_io_channel_unref(server->io);
g_free(server);
if (servers)
return;
if (passthrough_id) {
avctp_unregister_pdu_handler(passthrough_id);
passthrough_id = 0;
}
if (unit_id) {
avctp_unregister_pdu_handler(unit_id);
passthrough_id = 0;
}
if (subunit_id) {
avctp_unregister_pdu_handler(subunit_id);
subunit_id = 0;
}
}
int sasl_capability_visible(void)
{
if (!SASL_SERVER || !find_server(SASL_SERVER, NULL))
return 0;
return 1;
}
static void
ms_ping(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
struct Client *target_p;
const char *origin, *destination;
if(parc < 2 || *parv[1] == '\0')
{
sendto_one(source_p, form_str(ERR_NOORIGIN), me.name, parv[0]);
return;
}
origin = source_p->name;
destination = parv[2]; /* Will get NULL or pointer (parc >= 2!!) */
if(!EmptyString(destination) && irccmp(destination, me.name) != 0
&& irccmp(destination, me.id) != 0)
{
if((target_p = find_server(destination)))
sendto_one(target_p, ":%s PING %s :%s", parv[0], origin, destination);
else
{
sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
ID_or_name(&me, client_p), parv[0], destination);
return;
}
}
else
sendto_one(source_p, ":%s PONG %s :%s",
ID_or_name(&me, client_p), (destination) ? destination : me.name,
origin);
}
/*
* mo_restart
*
*/
static int
mo_restart(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
if (!IsOperDie(source_p)) {
sendto_one(source_p, form_str(ERR_NOPRIVS),
me.name, source_p->name, "die");
return 0;
}
if (parc < 2 || EmptyString(parv[1])) {
sendto_one_notice(source_p, ":Need server name /restart %s", me.name);
return 0;
}
if (parc > 2) {
/* Remote restart. Pass it along. */
struct Client *server_p = find_server(NULL, parv[2]);
if (!server_p) {
sendto_one_numeric(source_p, ERR_NOSUCHSERVER, form_str(ERR_NOSUCHSERVER), parv[2]);
return 0;
}
if (!IsMe(server_p)) {
sendto_one(server_p, ":%s ENCAP %s RESTART %s", source_p->name, parv[2], parv[1]);
return 0;
}
}
return do_restart(source_p, parv[1]);
}
int m_map(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct ConfItem* conf;
if (!HasUmode(sptr,UMODE_SEEROUTING))
{
if (SeesOperMessages(sptr))
sendto_one(sptr,":%s NOTICE %s :You have no V umode", me.name, parv[0]);
else
sendto_one(sptr, form_str(ERR_NOPRIVILEGES), me.name, parv[0]);
return 0;
}
if (parc > 1)
if (hunt_server(cptr, sptr, ":%s MAP %s", 1, parc, parv) != HUNTED_ISME)
return 0;
header_length = 0;
header[0] = '\0';
map_send_server(sptr, parv[0], &me);
for (conf = ConfigItemList; conf; conf = conf->next)
{
if (conf->status != CONF_NOCONNECT_SERVER)
continue;
if (strcmp(conf->name, me.name) == 0)
continue;
if (!find_server(conf->name))
sendto_one(sptr, form_str(RPL_MAP), me.name, parv[0], "** ", conf->name, -1);
}
sendto_one(sptr,form_str(RPL_ENDOFMAP),me.name,parv[0]);
return 0;
}
/*
** m_ping
** parv[0] = sender prefix
** parv[1] = origin
** parv[2] = destination
*/
static void
m_ping(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
struct Client *target_p;
char *origin, *destination;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(source_p, form_str(ERR_NOORIGIN), me.name, parv[0]);
return;
}
origin = parv[1];
destination = parv[2]; /* Will get NULL or pointer (parc >= 2!!) */
if (ConfigFileEntry.disable_remote && !IsOper(source_p))
{
sendto_one(source_p,":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, origin);
return;
}
if (!EmptyString(destination) && irccmp(destination, me.name) != 0)
{
/* We're sending it across servers.. origin == client_p->name --fl_ */
origin = client_p->name;
/* XXX - sendto_server() ? --fl_ */
if ((target_p = find_server(destination)) != NULL)
{
struct Client *ll_p;
/* use the direct link for LL checking */
ll_p = target_p->from;
if(ServerInfo.hub && IsCapable(ll_p, CAP_LL))
{
if((ll_p->lazyLinkClientExists & target_p->localClient->serverMask) == 0)
client_burst_if_needed(target_p, ll_p);
}
sendto_one(target_p,":%s PING %s :%s", parv[0],
origin, destination);
}
else
{
sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return;
}
}
else
sendto_one(source_p,":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, origin);
}
/*
** m_pong
** parv[0] = sender prefix
** parv[1] = origin
** parv[2] = destination
*/
int m_pong(struct Client *cptr,
struct Client *sptr,
int parc,
char *parv[])
{
struct Client *acptr = NULL;
char *origin, *destination;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, form_str(ERR_NOORIGIN), me.name, parv[0]);
return 0;
}
origin = parv[1];
destination = parv[2];
/* Now attempt to route the PONG, comstud pointed out routable PING
* is used for SPING. routable PING should also probably be left in
* -Dianora
* That being the case, we will route, but only for registered clients (a
* case can be made to allow them only from servers). -Shadowfax
*/
if (!EmptyString(destination) && irccmp(destination, me.name) != 0
&& IsRegistered(sptr))
{
if ((acptr = find_client(destination, NULL)) ||
(acptr = find_server(destination)))
sendto_one(acptr,":%s PONG %s %s",
parv[0], origin, destination);
else
{
sendto_one(sptr, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return 0;
}
}
else
{
if (MyConnect(sptr))
{
sptr->flags &= ~FLAGS_PINGSENT;
#ifdef NEED_SPLITCODE
#ifdef SPLIT_PONG
if (IsServer(sptr))
got_server_pong = 1;
#endif
#endif
}
#ifdef DEBUGMODE
Debug((DEBUG_NOTICE, "PONG: %s %s", origin,
destination ? destination : "*"));
#endif
}
return 0;
}
/*
** m_ping
** parv[0] = sender prefix
** parv[1] = origin
** parv[2] = destination
*/
int m_ping(struct Client *cptr,
struct Client *sptr,
int parc,
char *parv[])
{
struct Client *acptr;
char *origin, *destination;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(sptr, form_str(ERR_NOORIGIN), me.name, parv[0]);
return 0;
}
origin = parv[1];
destination = parv[2]; /* Will get NULL or pointer (parc >= 2!!) */
acptr = find_client(origin, NULL);
if (!acptr)
acptr = find_server(origin);
if (acptr && acptr != sptr)
origin = cptr->name;
if (!EmptyString(destination) && irccmp(destination, me.name) != 0)
{
if ((acptr = find_server(destination)))
sendto_one(acptr,":%s PING %s :%s", parv[0],
origin, destination);
else
{
sendto_one(sptr, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return 0;
}
}
else
{
sendto_one(sptr,":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, origin);
if(MyClient(sptr) && cptr->user)
check_idle_actions(cptr);
}
return 0;
}
static void confirm_event(GIOChannel *chan, gpointer user_data)
{
struct network_adapter *na = user_data;
struct network_server *ns;
int perr;
bdaddr_t src, dst;
char address[18];
GError *err = NULL;
bt_io_get(chan, BT_IO_L2CAP, &err,
BT_IO_OPT_SOURCE_BDADDR, &src,
BT_IO_OPT_DEST_BDADDR, &dst,
BT_IO_OPT_DEST, address,
BT_IO_OPT_INVALID);
if (err) {
error("%s", err->message);
g_error_free(err);
goto drop;
}
DBG("BNEP: incoming connect from %s", address);
if (na->setup) {
error("Refusing connect from %s: setup in progress", address);
goto drop;
}
ns = find_server(na->servers, BNEP_SVC_NAP);
if (!ns)
goto drop;
if (!ns->record_id)
goto drop;
if (!ns->bridge)
goto drop;
na->setup = g_new0(struct network_session, 1);
bacpy(&na->setup->dst, &dst);
na->setup->io = g_io_channel_ref(chan);
perr = btd_request_authorization(&src, &dst, BNEP_SVC_UUID,
auth_cb, na);
if (perr < 0) {
error("Refusing connect from %s: %s (%d)", address,
strerror(-perr), -perr);
setup_destroy(na);
goto drop;
}
return;
drop:
g_io_channel_shutdown(chan, TRUE, NULL);
}
void serverlist_frame() {
int i;
for (i = 0; i < server_count; i++) {
msg_t *msg = sock_recv(&serverlist[i].sock);
if (msg) {
serverlist[i].ping_end = millis();
skip_data(msg, strlen("info\n"));
read_server(serverlist + i, read_string(msg));
if (partial_match(filter, serverlist[i].name) || partial_match(filter, serverlist[i].map)
|| partial_match(filter, serverlist[i].mod) || partial_match(filter, serverlist[i].gametype))
ui_output(output_client, "^5%i ^7(%i) %s %s ^5[^7%s^5] [^7%s:%s^5]\n", i, serverlist[i].ping_end - serverlist[i].ping_start,
serverlist[i].players, serverlist[i].name, serverlist[i].map, serverlist[i].mod, serverlist[i].gametype);
serverlist[i].received = qtrue;
}
if (serverlist[i].ping_retries > 0
&& !serverlist[i].received && millis() >= serverlist[i].ping_start + PING_TIMEOUT)
ping_server(serverlist + i);
}
master_t *master;
for (master = masters; master->address; master++) {
msg_t *msg = sock_recv(&master->sock);
if (!msg)
continue;
char address_string[32];
qbyte address[4];
unsigned short port;
skip_data(msg, strlen("getserversResponse"));
while (msg->readcount + 7 <= msg->cursize) {
char prefix = read_char(msg);
port = 0;
if (prefix == '\\') {
read_data(msg, address, 4);
port = ShortSwap(read_short(msg));
sprintf(address_string, "%u.%u.%u.%u", address[0], address[1], address[2], address[3]);
}
if (port != 0) {
server_t *server = find_server(address_string, port);
if (server != NULL)
continue;
server = serverlist + server_count++;
sock_init(&server->sock);
strcpy(server->address, address_string);
server->port = port;
server->received = qfalse;
server->ping_retries = MAX_PING_RETRIES + 1;
ping_server(server);
}
}
}
}
void ec_server(char *from, char *to)
{
Server *sv;
char *s;
if ((sv = find_server(current->server)))
s = (*sv->realname) ? sv->realname : sv->name;
else
s = TEXT_NOTINSERVLIST;
nobo_strcpy(s);
}
static gboolean
slmock_check_login(GDBusConnection * session, slmock_table_t * slmockdata, gboolean clear_cache)
{
if (clear_cache) {
gchar *username_sha = g_compute_checksum_for_string (G_CHECKSUM_SHA256, slmockdata->username, -1);
gchar *file_path = g_build_path ("/", g_get_user_cache_dir(), "remote-logon-service", "cache", username_sha, NULL);
unlink (file_path);
g_free (username_sha);
g_free (file_path);
}
GVariant * retval = g_dbus_connection_call_sync(session,
"org.ArcticaProject.RemoteLogon",
"/org/ArcticaProject/RemoteLogon",
"org.ArcticaProject.RemoteLogon",
"GetServersForLogin",
g_variant_new("(sssb)",
"https://slmock.com/",
slmockdata->username,
slmockdata->password,
TRUE), /* params */
G_VARIANT_TYPE("(bsa(sssba(sbva{sv})a(si)))"), /* ret type */
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
NULL);
g_assert(retval != NULL);
g_assert(g_variant_n_children(retval) == 3);
GVariant * loggedin = g_variant_get_child_value(retval, 0);
g_assert(g_variant_get_boolean(loggedin));
g_variant_unref(loggedin); loggedin = NULL;
GVariant * data = g_variant_get_child_value(retval, 1);
g_assert(g_strcmp0(g_variant_get_string(data, NULL), "network") == 0);
g_variant_unref(data); data = NULL;
GVariant * array = g_variant_get_child_value(retval, 2);
int i;
// Check all servers should be in the result are in the result
for (i = 0; slmockdata->servers[i].name != NULL; i++) {
g_assert(find_server(array, &slmockdata->servers[i]));
}
// Check there is no more servers in the result than we expected
g_assert(i == g_variant_n_children(array));
g_variant_unref(array);
g_variant_unref(retval);
return TRUE;
}
static void ms_pong(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
struct Client *target_p;
char *origin, *destination;
cluster_prefix(client_p, parc, parv, 0, 0, 0);
if (parc > 0 && parv[1] && !strchr(parv[1], '.'))
cluster_prefix(client_p, parc, parv, 1, 0, 0);
if (parc > 1 && parv[2] && !strchr(parv[2], '.'))
cluster_prefix(client_p, parc, parv, 2, 0, 0);
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(source_p, form_str(source_p,ERR_NOORIGIN), me.name, parv[0]);
return;
}
origin = parv[1];
destination = parv[2];
source_p->flags &= ~FLAGS_PINGSENT;
/* Now attempt to route the PONG, comstud pointed out routable PING
* is used for SPING. routable PING should also probably be left in
* -Dianora
* That being the case, we will route, but only for registered clients (a
* case can be made to allow them only from servers). -Shadowfax
*/
if (!EmptyString(destination) && !match(destination, me.name))
{
if ((target_p = find_client(destination)) ||
(target_p = find_server(destination)))
sendto_one(target_p,":%s PONG %s %s",
parv[0], origin, destination);
else
{
sendto_one(source_p, form_str(source_p,ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return;
}
}
#ifdef DEBUGMODE
else
Debug((DEBUG_NOTICE, "PONG: %s %s", origin,
destination ? destination : "*"));
#endif
return;
}
/*
** m_ping
** parv[0] = sender prefix
** parv[1] = origin
** parv[2] = destination
*/
static void m_ping(struct Client *client_p,
struct Client *source_p,
int parc,
char *parv[])
{
struct Client *target_p;
char *origin, *destination;
if (parc < 2 || *parv[1] == '\0')
{
sendto_one(source_p, form_str(ERR_NOORIGIN), me.name, parv[0]);
return;
}
origin = parv[1];
destination = parv[2]; /* Will get NULL or pointer (parc >= 2!!) */
if (ConfigServerHide.disable_remote && !IsOper(source_p))
{
sendto_one(source_p,":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, origin);
return;
}
if (!EmptyString(destination) && irccmp(destination, me.name))
{
/* We're sending it across servers.. origin == client_p->name --fl_ */
origin = client_p->name;
/* XXX - sendto_server() ? --fl_ */
if ((target_p = find_server(destination)))
{
/* use the direct link for LL checking */
target_p = target_p->from;
sendto_one(target_p,":%s PING %s :%s", parv[0],
origin, destination);
}
else
{
sendto_one(source_p, form_str(ERR_NOSUCHSERVER),
me.name, parv[0], destination);
return;
}
}
else
sendto_one(source_p,":%s PONG %s :%s", me.name,
(destination) ? destination : me.name, origin);
}
int server_register(struct btd_adapter *adapter, uint16_t id)
{
struct network_adapter *na;
struct network_server *ns;
const char *path;
na = find_adapter(adapters, adapter);
if (!na) {
na = create_adapter(adapter);
if (!na)
return -EINVAL;
adapters = g_slist_append(adapters, na);
}
ns = find_server(na->servers, id);
if (ns)
return 0;
ns = g_new0(struct network_server, 1);
ns->name = g_strdup("Network service");
path = adapter_get_path(adapter);
if (g_slist_length(na->servers) > 0)
goto done;
if (!g_dbus_register_interface(btd_get_dbus_connection(), path,
NETWORK_SERVER_INTERFACE,
server_methods, NULL, NULL, na,
path_unregister)) {
error("D-Bus failed to register %s interface",
NETWORK_SERVER_INTERFACE);
server_free(ns);
return -1;
}
DBG("Registered interface %s on path %s", NETWORK_SERVER_INTERFACE,
path);
done:
bacpy(&ns->src, btd_adapter_get_address(adapter));
ns->id = id;
ns->na = na;
ns->record_id = 0;
na->servers = g_slist_append(na->servers, ns);
return 0;
}
/*
* m_spingtime - SPINGTIME
* parv[0] - sender
* parv[1] - server to set ping time for
* parv[2] - ping time
*/
static void ms_spingtime(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
struct Client *target_p;
if ((target_p = find_server(parv[1])) == NULL)
return;
target_p->ping_time.tv_sec = 0;
target_p->ping_time.tv_usec = atol(parv[2]);
sendto_server(client_p, NULL, NULL, NOCAPS, NOCAPS, NOFLAGS,
":%s SPINGTIME %s %s", parv[0], parv[1],
parv[2]);
}
/*
* m_svinfo - SVINFO message handler
* parv[0] = sender prefix
* parv[1] = TS_CURRENT for the server
* parv[2] = TS_MIN for the server
* parv[3] = clock ts
*/
int m_svinfo(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
aConfItem *aconf;
time_t remote_ts = 0;
struct Client *acptr;
if (MyConnect(sptr) && IsUnknown(sptr))
return exit_client(sptr, sptr, sptr, "Need SERVER before SVINFO");
if (!IsServer(sptr) || !MyConnect(sptr) || parc < 3)
return 0;
if (TS_CURRENT < atoi(parv[2]) || atoi(parv[1]) < TS_MIN)
{
/*
* a server with the wrong TS version connected; since we're
* TS_ONLY we can't fall back to the non-TS protocol so
* we drop the link -orabidoo
*/
#ifdef HIDE_SERVERS_IPS
sendto_realops("Link %s dropped, incompatible TS protocol version (%s,%s)",
get_client_name(sptr,MASK_IP), parv[1], parv[2]);
#else
sendto_realops("Link %s dropped, incompatible TS protocol version (%s,%s)",
get_client_name(sptr, TRUE), parv[1], parv[2]);
#endif
return exit_client(sptr, sptr, sptr, "Incompatible TS version");
}
if(parc>3)
{
remote_ts = atol(parv[3]);
if (UseIRCNTP && (remote_ts > 0))
{
if(IsService(cptr) ||
((aconf = find_conf_host(cptr->confs, sptr->name, CONF_HUB))
&& !(acptr = find_server(ServicesServer))))
{
ircntp_offset = remote_ts - time(NULL);
sendto_realops("Adjusting IRCNTP offset to %d",
ircntp_offset);
}
}
}
return 0;
}
static int
ms_pong(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Client *target_p;
const char *destination;
destination = parv[2];
source_p->flags &= ~FLAGS_PINGSENT;
/* Now attempt to route the PONG, comstud pointed out routable PING
* is used for SPING. routable PING should also probably be left in
* -Dianora
* That being the case, we will route, but only for registered clients (a
* case can be made to allow them only from servers). -Shadowfax
*/
if(!EmptyString(destination) && !match(destination, me.name) &&
irccmp(destination, me.id))
{
if((target_p = find_client(destination)) ||
(target_p = find_server(NULL, destination)))
sendto_one(target_p, ":%s PONG %s %s",
get_id(source_p, target_p), parv[1],
get_id(target_p, target_p));
else
{
if(!IsDigit(*destination))
sendto_one_numeric(source_p, ERR_NOSUCHSERVER,
form_str(ERR_NOSUCHSERVER), destination);
return 0;
}
}
/* destination is us, emulate EOB */
if(IsServer(source_p) && !HasSentEob(source_p))
{
if(MyConnect(source_p))
sendto_realops_snomask(SNO_GENERAL, L_ALL,
"End of burst (emulated) from %s (%d seconds)",
source_p->name,
(signed int) (CurrentTime - source_p->localClient->firsttime));
SetEob(source_p);
eob_count++;
call_hook(h_server_eob, source_p);
}
return 0;
}
int server_register(struct btd_adapter *adapter)
{
struct network_adapter *na;
struct network_server *ns;
const char *path;
na = find_adapter(adapters, adapter);
if (!na) {
na = create_adapter(adapter);
if (!na)
return -EINVAL;
adapters = g_slist_append(adapters, na);
}
ns = find_server(na->servers, BNEP_SVC_NAP);
if (ns)
return 0;
ns = g_new0(struct network_server, 1);
ns->iface = g_strdup(NETWORK_SERVER_INTERFACE);
ns->name = g_strdup("Network service");
path = adapter_get_path(adapter);
if (!g_dbus_register_interface(connection, path, ns->iface,
server_methods, NULL, NULL,
ns, path_unregister)) {
error("D-Bus failed to register %s interface",
ns->iface);
server_free(ns);
return -1;
}
adapter_get_address(adapter, &ns->src);
ns->id = BNEP_SVC_NAP;
ns->na = na;
ns->record_id = 0;
na->servers = g_slist_append(na->servers, ns);
DBG("Registered interface %s on path %s", ns->iface, path);
return 0;
}
int server_unregister(struct btd_adapter *adapter)
{
struct network_adapter *na;
struct network_server *ns;
uint16_t id = BNEP_SVC_NAP;
na = find_adapter(adapters, adapter);
if (!na)
return -EINVAL;
ns = find_server(na->servers, id);
if (!ns)
return -EINVAL;
g_dbus_unregister_interface(connection, adapter_get_path(adapter),
ns->iface);
return 0;
}
