void add_hit(void *pc, size_t size, void *target, int read, void *drcontext,
ctx_t *ctx)
{
malloc_t *block = search_on_tree(active_blocks, target);
access_t *access;
// if the access is not on a malloc block we do nothing
// we have to check if the target is not the and of the block
// (because last offset is out of the user
// data and use only for malloc's internal purposes)
if (!block || target == block->end)
return;
dr_mutex_lock(lock);
if (read)
access = get_access(target - block->start, &(block->read), block);
else
access = get_access(target - block->start, &(block->write), block);
access->total_hits++;
incr_orig(access, size, pc, drcontext, block, ctx);
dr_mutex_unlock(lock);
}
void run() {
if (busy != 0) {
fprintf(stderr, "FAIL: %d %d\n", get_access(0).get_handle()->version, get_access(0).required_version);
assert(busy == 0);
}
busy = 1;
// delay to make sure several tasks have the chance to run concurrently
Time::TimeUnit stop = Time::getTime() + 100000;
while (Time::getTime() < stop);
busy = 0;
}
/*
* touch_seg: <seg-name> [<offset> <length>] [read|write]
*/
static int touch_seg(char *args)
{
glctx_t *gcp = &glctx;
char *segname, *nextarg;
range_t range = { 0L, 0L };
int axcs;
args += strspn(args, whitespace);
if (!required_arg(args, "<seg-name>"))
return CMD_ERROR;
segname = strtok_r(args, whitespace, &nextarg);
args = nextarg + strspn(nextarg, whitespace);
/*
* offset, length are optional
*/
if (get_range(args, &range, &nextarg) == CMD_ERROR)
return CMD_ERROR;
args = nextarg;
axcs = get_access(args);
if (axcs == 0)
return CMD_ERROR;
if (!segment_touch(segname, &range, axcs - 1))
return CMD_ERROR;
return CMD_SUCCESS;
}
/**
@brief take a snapshot of the current status of a memory interface
Get a memory status and store the status data to @b @@mst
@param mld the pointer to a mem_link_device instance
@param dir the direction of a communication (TX or RX)
@param[out] mst the pointer to a mem_status instance
*/
static void __take_mem_status(struct mem_link_device *mld, enum direction dir,
struct mem_snapshot *mst)
{
int i;
getnstimeofday(&mst->ts);
mst->dir = dir;
mst->magic = get_magic(mld);
mst->access = get_access(mld);
for (i = 0; i < MAX_SIPC5_DEVICES; i++) {
struct mem_ipc_device *dev = mld->dev[i];
mst->head[i][TX] = get_txq_head(dev);
mst->tail[i][TX] = get_txq_tail(dev);
mst->head[i][RX] = get_rxq_head(dev);
mst->tail[i][RX] = get_rxq_tail(dev);
}
if (mld->recv_cp2ap_irq)
mst->int2ap = mld->recv_cp2ap_irq(mld);
else
mst->int2ap = 0;
if (mld->read_ap2cp_irq)
mst->int2cp = mld->read_ap2cp_irq(mld);
else
mst->int2cp = 0;
}
/**
@brief check whether or not IPC link is active
@param mld the pointer to a mem_link_device instance
@retval "TRUE" if IPC via the mem_link_device instance is possible.
@retval "FALSE" otherwise.
*/
static inline bool ipc_active(struct mem_link_device *mld)
{
struct link_device *ld = &mld->link_dev;
struct modem_ctl *mc = ld->mc;
if (unlikely(!cp_online(mc))) {
mif_err("%s<->%s: %s.state %s != ONLINE <%pf>\n",
ld->name, mc->name, mc->name, mc_state(mc), CALLER);
return false;
}
if (atomic_read(&mc->forced_cp_crash)) {
mif_err("%s<->%s: ERR! forced_cp_crash:%d <%pf>\n",
ld->name, mc->name, atomic_read(&mc->forced_cp_crash),
CALLER);
return false;
}
if (mld->dpram_magic) {
unsigned int magic = get_magic(mld);
unsigned int access = get_access(mld);
if (magic != MEM_IPC_MAGIC || access != 1) {
mif_err("%s<->%s: ERR! magic:0x%X access:%d <%pf>\n",
ld->name, mc->name, magic, access, CALLER);
return false;
}
}
return true;
}
static int dpram_init_ipc(struct dpram_link_device *dpld)
{
struct link_device *ld = &dpld->ld;
int i;
if (ld->mode == LINK_MODE_IPC &&
get_magic(dpld) == DPRAM_MAGIC_CODE &&
get_access(dpld) == 1)
mif_info("%s: IPC already initialized\n", ld->name);
/* Clear pointers in every circular queue */
for (i = 0; i < dpld->max_ipc_dev; i++) {
set_tx_head(dpld, i, 0);
set_tx_tail(dpld, i, 0);
set_rx_head(dpld, i, 0);
set_rx_tail(dpld, i, 0);
}
/* Initialize variables for efficient TX/RX processing */
for (i = 0; i < dpld->max_ipc_dev; i++)
dpld->iod[i] = link_get_iod_with_format(ld, i);
dpld->iod[IPC_RAW] = link_get_iod_with_format(ld, IPC_MULTI_RAW);
if (dpld->iod[IPC_RAW]->recv_skb)
dpld->use_skb = true;
for (i = 0; i < dpld->max_ipc_dev; i++) {
spin_lock_init(&dpld->tx_lock[i]);
atomic_set(&dpld->res_required[i], 0);
skb_queue_purge(&dpld->skb_rxq[i]);
}
/* Enable IPC */
atomic_set(&dpld->accessing, 0);
set_magic(dpld, DPRAM_MAGIC_CODE);
set_access(dpld, 1);
if (get_magic(dpld) != DPRAM_MAGIC_CODE || get_access(dpld) != 1)
return -EACCES;
ld->mode = LINK_MODE_IPC;
if (wake_lock_active(&dpld->wlock))
wake_unlock(&dpld->wlock);
return 0;
}
/*
** Functions for debugging
*/
static inline void log_dpram_status(struct dpram_link_device *dpld)
{
pr_info("mif: %s: {M:0x%X A:%d} {FMT TI:%u TO:%u RI:%u RO:%u} "
"{RAW TI:%u TO:%u RI:%u RO:%u} {INT:0x%X}\n",
dpld->ld.mc->name,
get_magic(dpld), get_access(dpld),
get_tx_head(dpld, IPC_FMT), get_tx_tail(dpld, IPC_FMT),
get_rx_head(dpld, IPC_FMT), get_rx_tail(dpld, IPC_FMT),
get_tx_head(dpld, IPC_RAW), get_tx_tail(dpld, IPC_RAW),
get_rx_head(dpld, IPC_RAW), get_rx_tail(dpld, IPC_RAW),
recv_intr(dpld));
}
static int dpram_init_ipc(struct dpram_link_device *dpld)
{
struct link_device *ld = &dpld->ld;
int i;
if (ld->mode == LINK_MODE_IPC &&
get_magic(dpld) == DPRAM_MAGIC_CODE &&
get_access(dpld) == 1)
mif_info("%s: IPC already initialized\n", ld->name);
/* Clear pointers in every circular queue */
for (i = 0; i < dpld->max_ipc_dev; i++) {
set_tx_head(dpld, i, 0);
set_tx_tail(dpld, i, 0);
set_rx_head(dpld, i, 0);
set_rx_tail(dpld, i, 0);
}
for (i = 0; i < dpld->max_ipc_dev; i++) {
spin_lock_init(&dpld->tx_lock[i]);
atomic_set(&dpld->res_required[i], 0);
}
atomic_set(&dpld->accessing, 0);
/* Enable IPC */
set_magic(dpld, DPRAM_MAGIC_CODE);
set_access(dpld, 1);
if (get_magic(dpld) != DPRAM_MAGIC_CODE || get_access(dpld) != 1)
return -EACCES;
ld->mode = LINK_MODE_IPC;
if (wake_lock_active(&dpld->wlock))
wake_unlock(&dpld->wlock);
return 0;
}
static int dpram_check_access(struct dpram_link_device *dpld)
{
struct link_device *ld = &dpld->ld;
int i;
u16 magic = get_magic(dpld);
u16 access = get_access(dpld);
if (likely(magic == DPRAM_MAGIC_CODE && access == 1))
return 0;
for (i = 1; i <= 10; i++) {
mif_info("%s: ERR! magic:%X access:%X -> retry:%d\n",
ld->name, magic, access, i);
mdelay(1);
magic = get_magic(dpld);
access = get_access(dpld);
if (likely(magic == DPRAM_MAGIC_CODE && access == 1))
return 0;
}
mif_info("%s: !CRISIS! magic:%X access:%X\n", ld->name, magic, access);
return -EACCES;
}
static void set_dpram_map(struct dpram_link_device *dpld,
struct mif_irq_map *map)
{
map->magic = get_magic(dpld);
map->access = get_access(dpld);
map->fmt_tx_in = get_tx_head(dpld, IPC_FMT);
map->fmt_tx_out = get_tx_tail(dpld, IPC_FMT);
map->fmt_rx_in = get_rx_head(dpld, IPC_FMT);
map->fmt_rx_out = get_rx_tail(dpld, IPC_FMT);
map->raw_tx_in = get_tx_head(dpld, IPC_RAW);
map->raw_tx_out = get_tx_tail(dpld, IPC_RAW);
map->raw_rx_in = get_rx_head(dpld, IPC_RAW);
map->raw_rx_out = get_rx_tail(dpld, IPC_RAW);
map->cp2ap = recv_intr(dpld);
}
/**
@brief take a snapshot of the current status of a memory interface
Get a memory status and store the status data to @b @@mst
@param mld the pointer to a mem_link_device instance
@param dir the direction of a communication (TX or RX)
@param[out] mst the pointer to a mem_status instance
*/
static void __take_sbd_status(struct mem_link_device *mld, enum direction dir,
struct mem_snapshot *mst)
{
mst->dir = dir;
mst->magic = get_magic(mld);
mst->access = get_access(mld);
if (mld->recv_cp2ap_irq)
mst->int2ap = mld->recv_cp2ap_irq(mld);
else
mst->int2ap = 0;
if (mld->read_ap2cp_irq)
mst->int2cp = mld->read_ap2cp_irq(mld);
else
mst->int2cp = 0;
}
void parse_data2(char *buffer, int *step, t_map *map)
{
char **tab2;
tab2 = my_strd_to_wordtab(buffer, "-");
if (tab2 == NULL)
my_error("Empty line : check how to build a map\n");
if (my_strlen_tabs(tab2) == 1)
get_nb_ants(tab2, step, map);
else if (my_strlen_tabs(tab2) == 2)
{
get_access(tab2, step, map);
printf("%s\n", buffer);
}
else
{
fprintf(stderr, "Invalid line : %s\n", buffer);
exit(EXIT_FAILURE);
}
free_tab(tab2);
}
void run_cmd(const char *service, User *u, Command *list, const char *cmd, ChannelInfo *ci)
{
Command *c = lookup_cmd(list, cmd);
int ulevel = 0;
ulevel = check_cservice(u);
if ( (ulevel == 0) && ci )
ulevel = get_access(u, ci);
if ( ulevel == 0 )
if ( (stricmp(u->nick, ServicesRoot) == 0) && nick_recognized(u) )
ulevel = ACCLEV_GOD;
if (c && c->routine)
{
if ( ((c->has_priv == NULL) || c->has_priv(u)) && (ulevel >= c->level) )
c->routine(u);
else
notice_lang(service, u, ACCESS_DENIED);
} else {
notice_lang(service, u, UNKNOWN_COMMAND_HELP, cmd, service);
}
}
/**
@brief check whether or not IPC link is active
@param mld the pointer to a mem_link_device instance
@retval "TRUE" if IPC via the mem_link_device instance is possible.
@retval "FALSE" otherwise.
*/
static inline bool ipc_active(struct mem_link_device *mld)
{
bool active;
unsigned int magic = get_magic(mld);
unsigned int access = get_access(mld);
bool crash = mld->forced_cp_crash;
if (magic != MEM_IPC_MAGIC || access != 1 || crash)
active = false;
else
active = true;
#ifdef DEBUG_MODEM_IF
if (!active) {
struct link_device *ld = &mld->link_dev;
struct modem_ctl *mc = ld->mc;
mif_err("%s<->%s: ERR! magic:0x%X access:%d crash:%d <%pf>\n",
ld->name, mc->name, magic, access, crash, CALLER);
}
#endif
return active;
}
int mem_reset_ipc_link(struct mem_link_device *mld)
{
struct link_device *ld = &mld->link_dev;
unsigned int magic;
unsigned int access;
int i;
set_access(mld, 0);
set_magic(mld, 0);
reset_ipc_map(mld);
for (i = 0; i < MAX_SIPC5_DEVICES; i++) {
struct mem_ipc_device *dev = mld->dev[i];
skb_queue_purge(dev->skb_txq);
atomic_set(&dev->txq.busy, 0);
dev->req_ack_cnt[TX] = 0;
skb_queue_purge(dev->skb_rxq);
atomic_set(&dev->rxq.busy, 0);
dev->req_ack_cnt[RX] = 0;
}
atomic_set(&ld->netif_stopped, 0);
set_magic(mld, MEM_IPC_MAGIC);
set_access(mld, 1);
magic = get_magic(mld);
access = get_access(mld);
if (magic != MEM_IPC_MAGIC || access != 1)
return -EACCES;
return 0;
}
int mem_reset_ipc_link(struct mem_link_device *mld)
{
struct link_device *ld = &mld->link_dev;
unsigned int magic;
unsigned int access;
set_access(mld, 0);
set_magic(mld, 0);
reset_ipc_map(mld);
reset_ipc_devices(mld);
atomic_set(&ld->netif_stopped, 0);
set_magic(mld, MEM_IPC_MAGIC);
set_access(mld, 1);
magic = get_magic(mld);
access = get_access(mld);
if (magic != MEM_IPC_MAGIC || access != 1)
return -EACCES;
return 0;
}
svn_error_t *cyrus_auth_request(svn_ra_svn_conn_t *conn,
apr_pool_t *pool,
server_baton_t *b,
enum access_type required,
svn_boolean_t needs_username)
{
sasl_conn_t *sasl_ctx;
apr_pool_t *subpool;
apr_status_t apr_err;
const char *localaddrport = NULL, *remoteaddrport = NULL;
const char *mechlist, *val;
char hostname[APRMAXHOSTLEN + 1];
sasl_security_properties_t secprops;
svn_boolean_t success, no_anonymous;
int mech_count, result = SASL_OK;
SVN_ERR(svn_ra_svn__get_addresses(&localaddrport, &remoteaddrport,
conn, pool));
apr_err = apr_gethostname(hostname, sizeof(hostname), pool);
if (apr_err)
{
svn_error_t *err = svn_error_wrap_apr(apr_err, _("Can't get hostname"));
SVN_ERR(write_failure(conn, pool, &err));
return svn_ra_svn_flush(conn, pool);
}
/* Create a SASL context. SASL_SUCCESS_DATA tells SASL that the protocol
supports sending data along with the final "success" message. */
result = sasl_server_new(SVN_RA_SVN_SASL_NAME,
hostname, b->realm,
localaddrport, remoteaddrport,
NULL, SASL_SUCCESS_DATA,
&sasl_ctx);
if (result != SASL_OK)
{
svn_error_t *err = svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
sasl_errstring(result, NULL, NULL));
SVN_ERR(write_failure(conn, pool, &err));
return svn_ra_svn_flush(conn, pool);
}
/* Make sure the context is always destroyed. */
apr_pool_cleanup_register(b->pool, sasl_ctx, sasl_dispose_cb,
apr_pool_cleanup_null);
/* Initialize security properties. */
svn_ra_svn__default_secprops(&secprops);
/* Don't allow ANONYMOUS if a username is required. */
no_anonymous = needs_username || get_access(b, UNAUTHENTICATED) < required;
if (no_anonymous)
secprops.security_flags |= SASL_SEC_NOANONYMOUS;
svn_config_get(b->cfg, &val,
SVN_CONFIG_SECTION_SASL,
SVN_CONFIG_OPTION_MIN_SSF,
"0");
SVN_ERR(svn_cstring_atoui(&secprops.min_ssf, val));
svn_config_get(b->cfg, &val,
SVN_CONFIG_SECTION_SASL,
SVN_CONFIG_OPTION_MAX_SSF,
"256");
SVN_ERR(svn_cstring_atoui(&secprops.max_ssf, val));
/* Set security properties. */
result = sasl_setprop(sasl_ctx, SASL_SEC_PROPS, &secprops);
if (result != SASL_OK)
return fail_cmd(conn, pool, sasl_ctx);
/* SASL needs to know if we are externally authenticated. */
if (b->tunnel_user)
result = sasl_setprop(sasl_ctx, SASL_AUTH_EXTERNAL, b->tunnel_user);
if (result != SASL_OK)
return fail_cmd(conn, pool, sasl_ctx);
/* Get the list of mechanisms. */
result = sasl_listmech(sasl_ctx, NULL, NULL, " ", NULL,
&mechlist, NULL, &mech_count);
if (result != SASL_OK)
return fail_cmd(conn, pool, sasl_ctx);
if (mech_count == 0)
{
svn_error_t *err = svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
_("Could not obtain the list"
" of SASL mechanisms"));
SVN_ERR(write_failure(conn, pool, &err));
return svn_ra_svn_flush(conn, pool);
}
/* Send the list of mechanisms and the realm to the client. */
SVN_ERR(svn_ra_svn_write_cmd_response(conn, pool, "(w)c",
mechlist, b->realm));
/* The main authentication loop. */
subpool = svn_pool_create(pool);
do
{
svn_pool_clear(subpool);
SVN_ERR(try_auth(conn, sasl_ctx, subpool, b, &success));
}
while (!success);
svn_pool_destroy(subpool);
SVN_ERR(svn_ra_svn__enable_sasl_encryption(conn, sasl_ctx, pool));
if (no_anonymous)
{
char *p;
const void *user;
/* Get the authenticated username. */
result = sasl_getprop(sasl_ctx, SASL_USERNAME, &user);
if (result != SASL_OK)
return fail_cmd(conn, pool, sasl_ctx);
if ((p = strchr(user, '@')) != NULL)
{
/* Drop the realm part. */
b->user = apr_pstrndup(b->pool, user, p - (const char *)user);
}
else
{
svn_error_t *err;
err = svn_error_create(SVN_ERR_RA_NOT_AUTHORIZED, NULL,
_("Couldn't obtain the authenticated"
" username"));
SVN_ERR(write_failure(conn, pool, &err));
return svn_ra_svn_flush(conn, pool);
}
}
return SVN_NO_ERROR;
}
static int do_util(User * u, CSModeUtil * util)
{
char *av[2];
char *chan = strtok(NULL, " ");
char *nick = strtok(NULL, " ");
Channel *c;
ChannelInfo *ci;
User *u2;
int is_same;
if (!chan) {
struct u_chanlist *uc;
av[0] = util->mode;
av[1] = u->nick;
/* Sets the mode to the user on every channels he is on. */
for (uc = u->chans; uc; uc = uc->next) {
if ((ci = uc->chan->ci) && !(ci->flags & CI_VERBOTEN)
&& check_access(u, ci, util->levelself)) {
anope_cmd_mode(whosends(ci), uc->chan->name, "%s %s",
util->mode, GET_USER(u));
chan_set_modes(s_ChanServ, uc->chan, 2, av, 2);
if (util->notice && ci->flags & util->notice)
notice(whosends(ci), uc->chan->name,
"%s command used for %s by %s", util->name,
u->nick, u->nick);
}
}
return MOD_CONT;
} else if (!nick) {
nick = u->nick;
}
is_same = (nick == u->nick) ? 1 : (stricmp(nick, u->nick) == 0);
if (!(c = findchan(chan))) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_IN_USE, chan);
} else if (!(ci = c->ci)) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, c->name);
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, ci->name);
} else if (is_same ? !(u2 = u) : !(u2 = finduser(nick))) {
notice_lang(s_ChanServ, u, NICK_X_NOT_IN_USE, nick);
} else if (is_same ? !check_access(u, ci, util->levelself) :
!check_access(u, ci, util->level)) {
notice_lang(s_ChanServ, u, ACCESS_DENIED);
} else if (*util->mode == '-' && !is_same && (ci->flags & CI_PEACE)
&& (get_access(u2, ci) >= get_access(u, ci))) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
} else if (*util->mode == '-' && is_protected(u2) && !is_same) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
} else if (!is_on_chan(c, u2)) {
notice_lang(s_ChanServ, u, NICK_X_NOT_ON_CHAN, u2->nick, c->name);
} else {
anope_cmd_mode(whosends(ci), c->name, "%s %s", util->mode,
GET_USER(u2));
av[0] = util->mode;
av[1] = GET_USER(u2);
chan_set_modes(s_ChanServ, c, 2, av, 3);
if (util->notice && ci->flags & util->notice)
notice(whosends(ci), c->name, "%s command used for %s by %s",
util->name, u2->nick, u->nick);
}
return MOD_CONT;
}
/**
* The /cs ban command.
* @param u The user who issued the command
* @param MOD_CONT to continue processing other modules, MOD_STOP to stop processing.
**/
int do_ban(User * u)
{
char *chan = strtok(NULL, " ");
char *params = strtok(NULL, " ");
char *reason = strtok(NULL, "");
Channel *c;
ChannelInfo *ci;
User *u2;
int is_same;
if (!reason) {
reason = "Requested";
} else {
if (strlen(reason) > 200)
reason[200] = '\0';
}
if (!chan) {
struct u_chanlist *uc, *next;
/* Bans the user on every channels he is on. */
for (uc = u->chans; uc; uc = next) {
next = uc->next;
if ((ci = uc->chan->ci) && !(ci->flags & CI_VERBOTEN)
&& check_access(u, ci, CA_BANME)) {
char *av[3];
char mask[BUFSIZE];
/*
* Dont ban/kick the user on channels where he is excepted
* to prevent services <-> server wars.
*/
if (ircd->except) {
if (is_excepted(ci, u))
notice_lang(s_ChanServ, u, CHAN_EXCEPTED,
u->nick, ci->name);
continue;
}
if (is_protected(u)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
continue;
}
av[0] = sstrdup("+b");
get_idealban(ci, u, mask, sizeof(mask));
av[1] = mask;
xanadu_cmd_mode(whosends(ci), uc->chan->name, "+b %s",
av[1]);
chan_set_modes(s_ChanServ, uc->chan, 2, av, 1);
free(av[0]);
if ((ci->flags & CI_SIGNKICK)
|| ((ci->flags & CI_SIGNKICK_LEVEL)
&& !check_access(u, ci, CA_SIGNKICK)))
xanadu_cmd_kick(whosends(ci), ci->name, u->nick,
"%s (%s)", reason, u->nick);
else
xanadu_cmd_kick(whosends(ci), ci->name, u->nick, "%s",
reason);
av[0] = ci->name;
av[1] = u->nick;
av[2] = reason;
do_kick(s_ChanServ, 3, av);
}
}
return MOD_CONT;
} else if (!params) {
params = u->nick;
}
is_same = (params == u->nick) ? 1 : (stricmp(params, u->nick) == 0);
if (!(c = findchan(chan))) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_IN_USE, chan);
} else if (!(ci = c->ci)) {
notice_lang(s_ChanServ, u, CHAN_X_NOT_REGISTERED, chan);
} else if (ci->flags & CI_VERBOTEN) {
notice_lang(s_ChanServ, u, CHAN_X_FORBIDDEN, chan);
} else if (is_same ? !(u2 = u) : !(u2 = finduser(params))) {
notice_lang(s_ChanServ, u, NICK_X_NOT_IN_USE, params);
} else if (!is_same ? !check_access(u, ci, CA_BAN) :
!check_access(u, ci, CA_BANME)) {
notice_lang(s_ChanServ, u, ACCESS_DENIED);
} else if (!is_same && (ci->flags & CI_PEACE)
&& (get_access(u2, ci) >= get_access(u, ci))) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
/*
* Dont ban/kick the user on channels where he is excepted
* to prevent services <-> server wars.
*/
} else if (ircd->except && is_excepted(ci, u2)) {
notice_lang(s_ChanServ, u, CHAN_EXCEPTED, u2->nick, ci->name);
} else if (ircd->protectedumode && is_protected(u2)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
} else {
char *av[3];
char mask[BUFSIZE];
av[0] = sstrdup("+b");
get_idealban(ci, u2, mask, sizeof(mask));
av[1] = mask;
xanadu_cmd_mode(whosends(ci), c->name, "+b %s", av[1]);
chan_set_modes(s_ChanServ, c, 2, av, 1);
free(av[0]);
/* We still allow host banning while not allowing to kick */
if (!is_on_chan(c, u2))
return MOD_CONT;
if ((ci->flags & CI_SIGNKICK)
|| ((ci->flags & CI_SIGNKICK_LEVEL)
&& !check_access(u, ci, CA_SIGNKICK)))
xanadu_cmd_kick(whosends(ci), ci->name, params, "%s (%s)",
reason, u->nick);
else
xanadu_cmd_kick(whosends(ci), ci->name, params, "%s", reason);
av[0] = ci->name;
av[1] = params;
av[2] = reason;
do_kick(s_ChanServ, 3, av);
}
return MOD_CONT;
}
int do_akick(User * u, Channel *c, char *cmd, char *mask, char *reason) {
ChannelInfo *ci = c->ci;
AutoKick *akick;
int i;
struct c_userlist *cu = NULL, *next = NULL;
User *u2;
char *argv[3];
int count = 0;
if (!cmd || (!mask && (!stricmp(cmd, "ADD") || !stricmp(cmd, "STICK")
|| !stricmp(cmd, "UNSTICK") || !stricmp(cmd, "DEL")))) {
noticeLang(ci->bi->nick, u, LANG_AKICK_SYNTAX);
} else if (!check_access(u, ci, CA_AKICK) && !is_services_admin(u)) {
notice_lang(ci->bi->nick, u, ACCESS_DENIED);
} else if (stricmp(cmd, "ADD") == 0) {
NickAlias *na = findnick(mask), *na2;
User *target = finduser(mask);
NickCore *nc = NULL;
char *nick, *user, *host;
int freemask = 0;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (!na) {
if (target) {
char tmp[BUFSIZE];
mask = NULL;
freemask = 1;
get_idealban(ci, target, tmp, BUFSIZE);
mask = sstrdup(tmp);
} else {
split_usermask(mask, &nick, &user, &host);
mask = scalloc(strlen(nick) + strlen(user) + strlen(host) + 3, 1);
freemask = 1;
sprintf(mask, "%s!%s@%s", nick, user, host);
free(nick);
free(user);
free(host);
}
} else {
if (na->status & NS_VERBOTEN) {
notice_lang(ci->bi->nick, u, NICK_X_FORBIDDEN, mask);
return MOD_CONT;
}
nc = na->nc;
}
/* Check excepts BEFORE we get this far */
if (ircd->except) {
if (is_excepted_mask(ci, mask) == 1) {
notice_lang(ci->bi->nick, u, CHAN_EXCEPTED, mask, c->name);
if (freemask) free(mask);
return MOD_CONT;
}
}
/* Check whether target nick has equal/higher access
* or whether the mask matches a user with higher/equal access ~ Viper */
if ((ci->flags & CI_PEACE) && nc) {
if ((nc == ci->founder) || (get_access_nc(nc, ci) >= get_access(u, ci))) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
if (freemask)
free(mask);
return MOD_CONT;
}
} else if ((ci->flags & CI_PEACE)) {
char buf[BUFSIZE];
/* Match against all currently online users with equal or
* higher access. - Viper */
for (i = 0; i < 1024; i++) {
for (u2 = userlist[i]; u2; u2 = u2->next) {
if (is_founder(u2, ci) || (get_access(u2, ci) >= get_access(u, ci))) {
if (match_usermask(mask, u2)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
free(mask);
return MOD_CONT;
}
}
}
}
/* Match against the lastusermask of all nickalias's with equal
* or higher access. ~ Viper */
for (i = 0; i < 1024; i++) {
for (na2 = nalists[i]; na2; na2 = na2->next) {
if (na2->status & NS_VERBOTEN)
continue;
if (na2->nc && ((na2->nc == ci->founder) || (get_access_nc(na2->nc, ci)
>= get_access(u, ci)))) {
snprintf(buf, BUFSIZE, "%s!%s", na2->nick, na2->last_usermask);
if (match_wild_nocase(mask, buf)) {
notice_lang(s_ChanServ, u, PERMISSION_DENIED);
free(mask);
return MOD_CONT;
}
}
}
}
}
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if ((akick->flags & AK_ISNICK) ? akick->u.nc == nc : stricmp(akick->u.mask, mask) == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_ALREADY_EXISTS, (akick->flags & AK_ISNICK) ? akick->u.nc->
display : akick->u.mask, c->name);
if (freemask) free(mask);
return MOD_CONT;
}
}
/* All entries should be in use so we don't have to go over
* the entire list. We simply add new entries at the end. */
if (ci->akickcount >= CSAutokickMax) {
notice_lang(s_ChanServ, u, CHAN_AKICK_REACHED_LIMIT, CSAutokickMax);
if (freemask) free(mask);
return MOD_CONT;
}
ci->akickcount++;
ci->akick = srealloc(ci->akick, sizeof(AutoKick) * ci->akickcount);
akick = &ci->akick[i];
akick->flags = AK_USED;
if (nc) {
akick->flags |= AK_ISNICK;
akick->u.nc = nc;
} else {
akick->u.mask = sstrdup(mask);
}
akick->creator = sstrdup(u->nick);
akick->addtime = time(NULL);
if (reason) {
if (strlen(reason) > 200)
reason[200] = '\0';
akick->reason = sstrdup(reason);
} else {
akick->reason = NULL;
}
/* Auto ENFORCE #63 */
cu = c->users;
while (cu) {
next = cu->next;
if (check_kick(cu->user, c->name, c->creation_time)) {
argv[0] = sstrdup(c->name);
argv[1] = sstrdup(cu->user->nick);
if (akick->reason)
argv[2] = sstrdup(akick->reason);
else
argv[2] = sstrdup("none");
do_kick(ci->bi->nick, 3, argv);
free(argv[2]);
free(argv[1]);
free(argv[0]);
count++;
}
cu = next;
}
alog("%s: %s!%s@%s added akick for %s to %s",
ci->bi->nick, u->nick, u->username, u->host, mask, c->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_ADDED, mask, c->name);
if (count)
notice_lang(ci->bi->nick, u, CHAN_AKICK_ENFORCE_DONE, c->name, count);
if (freemask) free(mask);
} else if (stricmp(cmd, "STICK") == 0) {
NickAlias *na;
NickCore *nc;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, ci->name);
return MOD_CONT;
}
na = findnick(mask);
nc = (na ? na->nc : NULL);
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED) || (akick->flags & AK_ISNICK))
continue;
if (!stricmp(akick->u.mask, mask))
break;
}
if (i == ci->akickcount) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NOT_FOUND, mask, ci->name);
return MOD_CONT;
}
akick->flags |= AK_STUCK;
alog("%s: %s!%s@%s set STICK on akick %s on %s",
ci->bi->nick, u->nick, u->username, u->host, akick->u.mask, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_STUCK, akick->u.mask, ci->name);
if (ci->c)
stick_mask(ci, akick);
} else if (stricmp(cmd, "UNSTICK") == 0) {
NickAlias *na;
NickCore *nc;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, ci->name);
return MOD_CONT;
}
na = findnick(mask);
nc = (na ? na->nc : NULL);
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED) || (akick->flags & AK_ISNICK))
continue;
if (!stricmp(akick->u.mask, mask))
break;
}
if (i == ci->akickcount) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NOT_FOUND, mask, ci->name);
return MOD_CONT;
}
akick->flags &= ~AK_STUCK;
alog("%s: %s!%s@%s unset STICK on akick %s on %s",
ci->bi->nick, u->nick, u->username, u->host, akick->u.mask, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_UNSTUCK, akick->u.mask, ci->name);
} else if (stricmp(cmd, "DEL") == 0) {
int deleted, a, b;
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, c->name);
return MOD_CONT;
}
/* Special case: is it a number/list? Only do search if it isn't. */
if (isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) {
int count, last = -1;
deleted = process_numlist(mask, &count, akick_del_callback, u, ci, &last);
if (!deleted) {
if (count == 1) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_SUCH_ENTRY, last, ci->name);
} else {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_MATCH, ci->name);
}
} else if (deleted == 1) {
alog("%s: %s!%s@%s deleted 1 akick on %s",
ci->bi->nick, u->nick, u->username, u->host, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_DELETED_ONE, ci->name);
} else {
alog("%s: %s!%s@%s deleted %d akicks on %s",
ci->bi->nick, u->nick, u->username, u->host, deleted, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_DELETED_SEVERAL, deleted, ci->name);
}
} else {
NickAlias *na = findnick(mask);
NickCore *nc = (na ? na->nc : NULL);
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if (((akick->flags & AK_ISNICK) && akick->u.nc == nc) || (!(akick->flags & AK_ISNICK)
&& stricmp(akick->u.mask, mask) == 0))
break;
}
if (i == ci->akickcount) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_NOT_FOUND, mask, c->name);
return MOD_CONT;
}
alog("%s: %s!%s@%s deleted akick %s on %s",
ci->bi->nick, u->nick, u->username, u->host, mask, c->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_DELETED, mask, c->name);
akick_del(u, akick);
deleted = 1;
}
if (deleted) {
/* Reordering - DrStein */
for (b = 0; b < ci->akickcount; b++) {
if (ci->akick[b].flags & AK_USED) {
for (a = 0; a < ci->akickcount; a++) {
if (a > b)
break;
if (!(ci->akick[a].flags & AK_USED)) {
ci->akick[a].flags = ci->akick[b].flags;
if (ci->akick[b].flags & AK_ISNICK) {
ci->akick[a].u.nc = ci->akick[b].u.nc;
} else {
ci->akick[a].u.mask = sstrdup(ci->akick[b].u.mask);
}
/* maybe we should first check whether there
is a reason before we sstdrup it -Certus */
if (ci->akick[b].reason)
ci->akick[a].reason = sstrdup(ci->akick[b].reason);
else
ci->akick[a].reason = NULL;
ci->akick[a].creator = sstrdup(ci->akick[b].creator);
ci->akick[a].addtime = ci->akick[b].addtime;
akick_del(u, &ci->akick[b]);
break;
}
}
}
}
/* After reordering only the entries at the end could still be empty.
* We ll free the places no longer in use... - Viper */
for (i = ci->akickcount - 1; i >= 0; i--) {
if (ci->akick[i].flags & AK_USED)
break;
ci->akickcount--;
}
ci->akick = srealloc(ci->akick,sizeof(AutoKick) * ci->akickcount);
}
} else if (stricmp(cmd, "LIST") == 0) {
int sent_header = 0;
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, c->name);
return MOD_CONT;
}
if (mask && isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) {
process_numlist(mask, NULL, akick_list_callback, u, ci, &sent_header);
} else {
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if (mask) {
if (!(akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.mask))
continue;
if ((akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.nc->display))
continue;
}
akick_list(u, i, ci, &sent_header);
}
}
if (!sent_header)
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_MATCH, c->name);
} else if (stricmp(cmd, "VIEW") == 0) {
int sent_header = 0;
if (ci->akickcount == 0) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_LIST_EMPTY, c->name);
return MOD_CONT;
}
if (mask && isdigit(*mask) && strspn(mask, "1234567890,-") == strlen(mask)) {
process_numlist(mask, NULL, akick_view_callback, u, ci, &sent_header);
} else {
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
if (mask) {
if (!(akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.mask))
continue;
if ((akick->flags & AK_ISNICK) && !my_match_wild_nocase(mask, akick->u.nc->display))
continue;
}
akick_view(u, i, ci, &sent_header);
}
}
if (!sent_header)
notice_lang(ci->bi->nick, u, CHAN_AKICK_NO_MATCH, c->name);
} else if (stricmp(cmd, "ENFORCE") == 0) {
struct c_userlist *cu = NULL, *next = NULL;
char *argv[3];
int count = 0;
if (!c) {
notice_lang(ci->bi->nick, u, CHAN_X_NOT_IN_USE, ci->name);
return MOD_CONT;
}
cu = c->users;
while (cu) {
next = cu->next;
if (check_kick(cu->user, c->name, c->creation_time)) {
argv[0] = sstrdup(c->name);
argv[1] = sstrdup(cu->user->nick);
argv[2] = sstrdup(CSAutokickReason);
do_kick(ci->bi->nick, 3, argv);
free(argv[2]);
free(argv[1]);
free(argv[0]);
count++;
}
cu = next;
}
notice_lang(ci->bi->nick, u, CHAN_AKICK_ENFORCE_DONE, ci->name, count);
} else if (stricmp(cmd, "CLEAR") == 0) {
if (readonly) {
notice_lang(ci->bi->nick, u, CHAN_AKICK_DISABLED);
return MOD_CONT;
}
for (akick = ci->akick, i = 0; i < ci->akickcount; akick++, i++) {
if (!(akick->flags & AK_USED))
continue;
akick_del(u, akick);
}
free(ci->akick);
ci->akick = NULL;
ci->akickcount = 0;
alog("%s: %s!%s@%s cleared akicks on %s",
ci->bi->nick, u->nick, u->username, u->host, ci->name);
notice_lang(ci->bi->nick, u, CHAN_AKICK_CLEAR, ci->name);
} else {
noticeLang(ci->bi->nick, u, LANG_AKICK_SYNTAX);
}
return MOD_CONT;
}
int do_core_kickban(User * u, Channel *c, char *target, char *reason) {
ChannelInfo *ci = c->ci;
User *u2;
int is_same, exists;
char *av[2];
if (!target)
target = u->nick;
is_same = (target == u->nick) ? 1 : (stricmp(target, u->nick) == 0);
if (is_same) {
u2 = u;
exists = 1;
} else
exists = ((u2 = finduser(target)) ? 1 : 0);
if (!is_same ? !check_access(u, ci, CA_BAN) : !check_access(u, ci, CA_BANME)) {
notice_lang(ci->bi->nick, u, ACCESS_DENIED);
} else if (!is_same && exists && (ci->flags & CI_PEACE) && (get_access(u2, ci) >= get_access(u, ci))) {
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
} else if (exists && ((ircd->protectedumode && is_protected(u2)) && !is_founder(u, ci))) {
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
/**
* Dont ban the user on channels where he is excepted
* to prevent services <-> server wars.
**/
} else if (exists && (ircd->except && is_excepted(ci, u2))) {
notice_lang(ci->bi->nick, u, CHAN_EXCEPTED, u2->nick, ci->name);
} else if (!exists && (ircd->except && is_excepted_mask(ci, target))) {
notice_lang(ci->bi->nick, u, CHAN_EXCEPTED, target, ci->name);
} else if (exists && RestrictKB && ((!is_founder(u, ci) && is_services_oper(u2)) ||
(is_founder(u, ci) && is_services_admin(u2)))) {
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
} else if (stricmp(target, ci->bi->nick) == 0) {
bot_raw_ban(u, ci, u->nick, "Oops!");
} else {
if (exists) {
if (is_on_chan(ci->c, u2)) {
if (!reason)
bot_raw_ban(u, ci, target, "Requested");
else
bot_raw_ban(u, ci, target, reason);
}
} else if (my_match_wild_nocase("*@*", target)) {
char mask[BUFSIZE];
/* If we get a *@* target we need to add the *!... */
if (!my_match_wild_nocase("*!*@*", target))
snprintf(mask, BUFSIZE, "*!%s", target);
else
snprintf(mask, BUFSIZE, "%s", target);
/* Only continue if the mask doesn't match an exception or is otherwise prohibited.. */
if (check_banmask(u, c, mask)) {
struct c_userlist *cu = NULL, *next = NULL;
av[0] = "+b";
av[1] = mask;
anope_cmd_mode(ci->bi->nick, c->name, "+b %s", av[1]);
chan_set_modes(ci->bi->nick, c, 2, av, 1);
cu = c->users;
while (cu) {
next = cu->next;
/* This only checks against the cloacked host & vhost for normal users.
* IPs are only checked when triggered by an oper.. */
if (is_oper(u) ? match_usermask_full(mask, cu->user, true) : match_usermask(mask, cu->user)) {
if (!reason)
bot_raw_kick(u, ci, cu->user->nick, "Requested");
else
bot_raw_kick(u, ci, cu->user->nick, reason);
}
cu = next;
}
}
} else
noticeLang(ci->bi->nick, u, LANG_REQ_NICK_OR_MASK);
}
return MOD_CONT;
}
void CoreCloseBipartitePairContainer::do_before_evaluate() {
IMP_OBJECT_LOG;
if (covers_[0]==base::get_invalid_index<ParticleIndexTag>()
|| algebra::get_distance(get_model()->get_sphere(covers_[0]),
get_model()->get_sphere(covers_[1]))
< distance_ || reset_) {
if (!reset_ && were_close_ && !internal::get_if_moved(get_model(), slack_,
xyzrs_[0], rbs_[0],
constituents_,
rbs_backup_[0],
xyzrs_backup_[0])
&& !internal::get_if_moved(get_model(), slack_,
xyzrs_[1], rbs_[1], constituents_,
rbs_backup_[1], xyzrs_backup_[1])){
// all ok
} else {
// rebuild
IMP_LOG(TERSE, "Recomputing bipartite close pairs list." << std::endl);
internal::reset_moved(get_model(),
xyzrs_[0], rbs_[0], constituents_,
rbs_backup_[0], xyzrs_backup_[0]);
internal::reset_moved(get_model(),
xyzrs_[1], rbs_[1], constituents_,
rbs_backup_[1], xyzrs_backup_[1]);
ParticleIndexPairs pips;
internal::fill_list(get_model(), access_pair_filters(),
key_, 2*slack_+distance_, xyzrs_, rbs_,
constituents_, pips);
reset_=false;
update_list(pips);
}
were_close_=true;
} else {
ParticleIndexPairs none;
update_list(none);
}
IMP_IF_CHECK(base::USAGE_AND_INTERNAL) {
for (unsigned int i=0; i< sc_[0]->get_number_of_particles(); ++i) {
XYZR d0(sc_[0]->get_particle(i));
for (unsigned int j=0; j< sc_[1]->get_number_of_particles(); ++j) {
XYZR d1(sc_[1]->get_particle(j));
double dist = get_distance(d0, d1);
if (dist < .9*distance_) {
ParticleIndexPair pip(d0.get_particle_index(),
d1.get_particle_index());
bool filtered=false;
for (unsigned int i=0; i< get_number_of_pair_filters(); ++i) {
if (get_pair_filter(i)->get_value_index(get_model(), pip)) {
filtered=true;
break;
}
}
IMP_INTERNAL_CHECK(filtered|| std::find(get_access().begin(),
get_access().end(), pip)
!= get_access().end(),
"Pair " << pip
<< " not found in list with coordinates "
<< d0 << " and " << d1
<< " list is " << get_access());
}
}
}
}
}
int do_core_kick(User * u, Channel *c, char *target, char *reason) {
ChannelInfo *ci = c->ci;
User *u2;
int is_same, exists;
if (!target)
target = u->nick;
is_same = (target == u->nick) ? 1 : (stricmp(target, u->nick) == 0);
if (is_same) {
u2 = u;
exists = 1;
} else
exists = ((u2 = finduser(target)) ? 1 : 0);
if (!is_same ? !check_access(u, ci, CA_KICK) : !check_access(u, ci, CA_KICKME)) {
notice_lang(ci->bi->nick, u, ACCESS_DENIED);
} else if (!is_same && exists && (ci->flags & CI_PEACE) && (get_access(u2, ci) >= get_access(u, ci))) {
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
} else if (exists && ((ircd->protectedumode && is_protected(u2)) && !is_founder(u, ci))) {
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
} else if (exists && RestrictKB && ((!is_founder(u, ci) && is_services_oper(u2)) ||
(is_founder(u, ci) && is_services_admin(u2)))) {
notice_lang(ci->bi->nick, u, PERMISSION_DENIED);
} else if (stricmp(target, ci->bi->nick) == 0) {
bot_raw_kick(u, ci, u->nick, "Oops!");
} else {
if (exists) {
if (is_on_chan(ci->c, u2)) {
if (!reason)
bot_raw_kick(u, ci, target, "Requested");
else
bot_raw_kick(u, ci, target, reason);
}
} else {
char mask[BUFSIZE];
struct c_userlist *cu = NULL, *next = NULL;
if (my_match_wild_nocase("*!*@*", target))
snprintf(mask, BUFSIZE, "%s", target);
/* If we get a *@* target we need to add the *!... */
else if (my_match_wild_nocase("*@*", target))
snprintf(mask, BUFSIZE, "*!%s", target);
else if (my_match_wild_nocase("*!*", target))
snprintf(mask, BUFSIZE, "%s@*", target);
/* If we get a * target we need to add the !*@* (assume nick)... */
else
snprintf(mask, BUFSIZE, "%s!*@*", target);
cu = c->users;
while (cu) {
next = cu->next;
/* This only checks against the cloacked host & vhost for normal users.
* IPs are only checked when triggered by an oper.. */
if (is_oper(u) ? match_usermask_full(mask, cu->user, true) : match_usermask(mask, cu->user)) {
/* Check whether we are allowed to kick this matching user.. */
if (!((ircd->protectedumode && is_protected(cu->user) && !is_founder(u, ci))
|| ((ci->flags & CI_PEACE) && (get_access(cu->user, ci) >= get_access(u, ci)))
|| (RestrictKB && ((!is_founder(u, ci) && is_services_oper(cu->user)) ||
(is_founder(u, ci) && is_services_admin(cu->user)))))) {
if (!reason)
bot_raw_kick(u, ci, cu->user->nick, "Requested");
else
bot_raw_kick(u, ci, cu->user->nick, reason);
}
}
cu = next;
}
}
}
return MOD_CONT;
}
void OpenGL3Driver::set_image(const Texture& texture, size_t unit, int access)
{
const OpenGL3Texture* opengl_texture = static_cast<const OpenGL3Texture*>(texture.impl());
OpenGLExtensions::instance().glBindImageTexture(unit, opengl_texture->id(), 0, GL_FALSE, 0, get_access(access), opengl_texture->image_format());
CHECK_GL_ERRORS();
}
/*
** m_whois
** parv[0] = sender prefix
** parv[1] = nickname masklist
*/
DLLFUNC int m_whois(aClient *cptr, aClient *sptr, int parc, char *parv[])
{
Membership *lp;
anUser *user;
aClient *acptr, *a2cptr;
aChannel *chptr;
char *nick, *tmp, *name;
char *p = NULL;
int found, len, mlen, cnt = 0;
char querybuf[BUFSIZE];
if (IsServer(sptr))
return 0;
if (parc < 2)
{
sendto_one(sptr, err_str(ERR_NONICKNAMEGIVEN),
me.name, parv[0]);
return 0;
}
if (parc > 2)
{
if (hunt_server(cptr, sptr, ":%s WHOIS %s :%s", 1, parc, parv) != HUNTED_ISME)
return 0;
parv[1] = parv[2];
}
strcpy(querybuf, parv[1]);
for (tmp = canonize(parv[1]); (nick = strtok_r(tmp, ",", &p)); tmp = NULL)
{
unsigned char invis, showchannel, member, wilds, hideoper; /* <- these are all boolean-alike */
if (++cnt > MAXTARGETS)
break;
found = 0;
/* We do not support "WHOIS *" */
wilds = (index(nick, '?') || index(nick, '*'));
if (wilds)
continue;
if ((acptr = find_client(nick, NULL)))
{
if (IsServer(acptr))
continue;
/*
* I'm always last :-) and acptr->next == NULL!!
*/
if (IsMe(acptr))
break;
/*
* 'Rules' established for sending a WHOIS reply:
* - only send replies about common or public channels
* the target user(s) are on;
*/
if (!IsPerson(acptr))
continue;
user = acptr->user;
name = (!*acptr->name) ? "?" : acptr->name;
invis = acptr != sptr && IsInvisible(acptr);
member = (user->channel) ? 1 : 0;
a2cptr = find_server_quick(user->server);
hideoper = 0;
if (IsHideOper(acptr) && (acptr != sptr) && !IsAnOper(sptr))
hideoper = 1;
if (IsWhois(acptr) && (sptr != acptr))
{
sendnotice(acptr,
"*** %s (%s@%s) did a /whois on you.",
sptr->name,
sptr->user->username, sptr->user->realhost);
}
sendto_one(sptr, rpl_str(RPL_WHOISUSER), me.name,
parv[0], name,
user->username,
IsHidden(acptr) ? user->virthost : user->realhost,
acptr->info);
if (IsOper(sptr) || acptr == sptr)
{
char sno[512];
strcpy(sno, get_sno_str(acptr));
/* send the target user's modes */
sendto_one(sptr, rpl_str(RPL_WHOISMODES),
me.name, parv[0], name,
get_mode_str(acptr), sno[1] == 0 ? "" : sno);
}
if ((acptr == sptr) || IsAnOper(sptr))
{
sendto_one(sptr, rpl_str(RPL_WHOISHOST),
me.name, parv[0], acptr->name,
(MyConnect(acptr) && strcmp(acptr->username, "unknown")) ? acptr->username : "******",
user->realhost, user->ip_str ? user->ip_str : "");
}
if (IsARegNick(acptr))
sendto_one(sptr, rpl_str(RPL_WHOISREGNICK), me.name, parv[0], name);
found = 1;
mlen = strlen(me.name) + strlen(parv[0]) + 10 + strlen(name);
for (len = 0, *buf = '\0', lp = user->channel; lp; lp = lp->next)
{
chptr = lp->chptr;
showchannel = 0;
if (ShowChannel(sptr, chptr))
showchannel = 1;
if (OPCanSeeSecret(sptr))
showchannel = 1;
if ((acptr->umodes & UMODE_HIDEWHOIS) && !IsMember(sptr, chptr) && !IsAnOper(sptr))
showchannel = 0;
if (IsServices(acptr) && !IsNetAdmin(sptr) && !IsSAdmin(sptr))
showchannel = 0;
if (acptr == sptr)
showchannel = 1;
/* Hey, if you are editting here... don't forget to change the webtv w_whois ;p. */
if (showchannel)
{
long access;
if (len + strlen(chptr->chname) > (size_t)BUFSIZE - 4 - mlen)
{
sendto_one(sptr,
":%s %d %s %s :%s",
me.name,
RPL_WHOISCHANNELS,
parv[0], name, buf);
*buf = '\0';
len = 0;
}
#ifdef SHOW_SECRET
if (IsAnOper(sptr)
#else
if (IsNetAdmin(sptr)
#endif
&& SecretChannel(chptr) && !IsMember(sptr, chptr))
*(buf + len++) = '?';
if (acptr->umodes & UMODE_HIDEWHOIS && !IsMember(sptr, chptr)
&& IsAnOper(sptr))
*(buf + len++) = '!';
access = get_access(acptr, chptr);
if (!SupportNAMESX(sptr))
{
#ifdef PREFIX_AQ
if (access & CHFL_CHANOWNER)
*(buf + len++) = '~';
else if (access & CHFL_CHANPROT)
*(buf + len++) = '&';
else
#endif
if (access & CHFL_CHANOP)
*(buf + len++) = '@';
else if (access & CHFL_HALFOP)
*(buf + len++) = '%';
else if (access & CHFL_VOICE)
*(buf + len++) = '+';
}
else
{
#ifdef PREFIX_AQ
if (access & CHFL_CHANOWNER)
*(buf + len++) = '~';
if (access & CHFL_CHANPROT)
*(buf + len++) = '&';
#endif
if (access & CHFL_CHANOP)
*(buf + len++) = '@';
if (access & CHFL_HALFOP)
*(buf + len++) = '%';
if (access & CHFL_VOICE)
*(buf + len++) = '+';
}
if (len)
*(buf + len) = '\0';
(void)strcpy(buf + len, chptr->chname);
len += strlen(chptr->chname);
(void)strcat(buf + len, " ");
len++;
}
}
if (buf[0] != '\0')
sendto_one(sptr, rpl_str(RPL_WHOISCHANNELS), me.name, parv[0], name, buf);
if (!(IsULine(acptr) && !IsOper(sptr) && HIDE_ULINES))
sendto_one(sptr, rpl_str(RPL_WHOISSERVER),
me.name, parv[0], name, user->server,
a2cptr ? a2cptr->info : "*Not On This Net*");
if (user->away)
sendto_one(sptr, rpl_str(RPL_AWAY), me.name,
parv[0], name, user->away);
/* makesure they aren't +H (we'll also check
before we display a helpop or IRCD Coder msg)
-- codemastr */
if ((IsAnOper(acptr) || IsServices(acptr)) && !hideoper)
{
buf[0] = '\0';
if (IsNetAdmin(acptr))
strlcat(buf, "a Network Administrator", sizeof buf);
else if (IsSAdmin(acptr))
strlcat(buf, "a Services Administrator", sizeof buf);
else if (IsAdmin(acptr) && !IsCoAdmin(acptr))
strlcat(buf, "a Server Administrator", sizeof buf);
else if (IsCoAdmin(acptr))
strlcat(buf, "a Co Administrator", sizeof buf);
else if (IsServices(acptr))
strlcat(buf, "a Network Service", sizeof buf);
else if (IsOper(acptr))
strlcat(buf, "an IRC Operator", sizeof buf);
else
strlcat(buf, "a Local IRC Operator", sizeof buf);
if (buf[0])
{
if (IsOper(sptr) && MyClient(acptr))
sendto_one(sptr,
":%s 313 %s %s :is %s (%s)", me.name,
parv[0], name, buf, acptr->user->operlogin);
else
sendto_one(sptr,
rpl_str(RPL_WHOISOPERATOR), me.name,
parv[0], name, buf);
}
}
if (IsHelpOp(acptr) && !hideoper && !user->away)
sendto_one(sptr, rpl_str(RPL_WHOISHELPOP), me.name, parv[0], name);
if (acptr->umodes & UMODE_BOT)
sendto_one(sptr, rpl_str(RPL_WHOISBOT), me.name, parv[0], name, ircnetwork);
if (acptr->umodes & UMODE_SECURE)
sendto_one(sptr, rpl_str(RPL_WHOISSECURE), me.name, parv[0], name,
"is using a Secure Connection");
if (!BadPtr(user->swhois) && !hideoper)
sendto_one(sptr, ":%s %d %s %s :%s",
me.name, RPL_WHOISSPECIAL, parv[0],
name, acptr->user->swhois);
/*
* display services account name if it's actually a services account name and
* not a legacy timestamp. --nenolod
*/
if (!isdigit(*user->svid))
sendto_one(sptr, rpl_str(RPL_WHOISLOGGEDIN), me.name, parv[0], name, user->svid);
/*
* Umode +I hides an oper's idle time from regular users.
* -Nath.
*/
if (MyConnect(acptr) && (IsAnOper(sptr) || !(acptr->umodes & UMODE_HIDLE)))
{
sendto_one(sptr, rpl_str(RPL_WHOISIDLE),
me.name, parv[0], name,
TStime() - acptr->last, acptr->firsttime);
}
}
if (!found)
sendto_one(sptr, err_str(ERR_NOSUCHNICK),
me.name, parv[0], nick);
}
sendto_one(sptr, rpl_str(RPL_ENDOFWHOIS), me.name, parv[0], querybuf);
return 0;
}
