static int channelmode_hook(int argc, char *argv[])
{
char *nick = grab_nick(argv[0]);
channel_t *ch = find_channel(argv[2], irc_pick_server());
if (!ch)
return -1;
cwio_out(ch->win, "%s sets %s %s in %s [%s]\n",
nick, argv[4], argv[3], ch->name, ch->server);
free(nick);
return 0;
}
void supla_device_channels::add_channel(int Id, int Number, int Type, int Func, int Param1, int Param2, int Param3) {
safe_array_lock(arr);
if ( find_channel(Id) == 0 ) {
safe_array_add(arr, new supla_device_channel(Id, Number, Type, Func, Param1, Param2, Param3));
}
safe_array_unlock(arr);
}
void
inbound_kick (server * serv, char *chan, char *user, char *kicker,
char *reason)
{
session *sess = find_channel (serv, chan);
if (sess)
{
EMIT_SIGNAL (XP_TE_KICK, sess, kicker, user, chan, reason, 0);
userlist_remove (sess, user);
}
}
/*
* part_one_client
*
* inputs - pointer to server
* - pointer to source client to remove
* - char pointer of name of channel to remove from
* output - none
* side effects - remove ONE client given the channel name
*/
static void
part_one_client(struct Client *client_p, struct Client *source_p, char *name, char *reason)
{
struct Channel *chptr;
struct membership *msptr;
char reason2[BUFSIZE];
if((chptr = find_channel(name)) == NULL)
{
sendto_one_numeric(source_p, ERR_NOSUCHCHANNEL, form_str(ERR_NOSUCHCHANNEL), name);
return;
}
msptr = find_channel_membership(chptr, source_p);
if(msptr == NULL)
{
sendto_one_numeric(source_p, ERR_NOTONCHANNEL, form_str(ERR_NOTONCHANNEL), name);
return;
}
if(MyConnect(source_p) && !IsOper(source_p) && !IsExemptSpambot(source_p))
check_spambot_warning(source_p, NULL);
/*
* Remove user from the old channel (if any)
* only allow /part reasons in -m chans
*/
if(reason[0] && (is_chanop(msptr) || !MyConnect(source_p) ||
((can_send(chptr, source_p, msptr) > 0 &&
(source_p->localClient->firsttime +
ConfigFileEntry.anti_spam_exit_message_time) < rb_current_time()))))
{
if(chptr->mode.mode & MODE_NOCOLOR)
{
rb_strlcpy(reason2, reason, BUFSIZE);
strip_colour(reason2);
reason = reason2;
}
sendto_server(client_p, chptr, CAP_TS6, NOCAPS,
":%s PART %s :%s", use_id(source_p), chptr->chname, reason);
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s :%s",
source_p->name, source_p->username,
source_p->host, chptr->chname, reason);
}
else
{
sendto_server(client_p, chptr, CAP_TS6, NOCAPS,
":%s PART %s", use_id(source_p), chptr->chname);
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s",
source_p->name, source_p->username,
source_p->host, chptr->chname);
}
remove_user_from_channel(msptr);
}
void poller_epoll::assert_channel( evt_channel* channel,bool need_exist)
{
//LOG_INFO.stream()<< "check channel :"<<channel->get_name();
evt_channel* ptr=find_channel(channel->fd());
if(need_exist && !ptr){
LOG_EROR.stream()<< channel->get_name()<<" not exists";
}
if(!need_exist && ptr){
LOG_EROR.stream()<< channel->get_name()<<" alreay exists";
}
}
OpenSLAudioChannel* OpenSLAudioEngine::GetChannel(int freq,int channels,int bits) {
SLDataFormat_PCM formatPCM = {0};
formatPCM.formatType = SL_DATAFORMAT_PCM;
formatPCM.numChannels = channels;
formatPCM.samplesPerSec = freq*1000;
formatPCM.bitsPerSample = bits ;//header.bitsPerSample;
formatPCM.containerSize = bits;// header.fmtSize;
formatPCM.channelMask = channels == 2 ? (SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT) : SL_SPEAKER_FRONT_CENTER;
formatPCM.endianness = SL_BYTEORDER_LITTLEENDIAN;
return find_channel(formatPCM);
}
void
inbound_join (server *serv, char *chan, char *user, char *ip)
{
session *sess = find_channel (serv, chan);
if (sess)
{
if (!sess->hide_join_part)
EMIT_SIGNAL (XP_TE_JOIN, sess, user, chan, ip, NULL, 0);
add_name (sess, user, ip);
}
}
void
inbound_join (server *serv, char *chan, char *user, char *ip, char *account,
char *realname, const message_tags_data *tags_data)
{
session *sess = find_channel (serv, chan);
if (sess)
{
EMIT_SIGNAL_TIMESTAMP (XP_TE_JOIN, sess, tags_data->timestamp, user, chan, ip, account);
userlist_add (sess, user, ip, account, realname, tags_data);
}
}
int Server::msg_channel(const char *msg, const uint16_t len, const uint32_t sender, const uint16_t channel) {
Channel *chan = find_channel(channel);
if (chan) {
int success = 0;
for (int x = 0; x < chan->n_members; ++x) {
success += chan->members[x].ptr->msg(msg, len, sender, channel);
}
return success;
}
return 0;
}
/*
get a pointer to first auxillary channel for a channel function
*/
SRV_Channel *SRV_Channels::get_channel_for(SRV_Channel::Aux_servo_function_t function, int8_t default_chan)
{
uint8_t chan;
if (default_chan >= 0) {
set_aux_channel_default(function, default_chan);
}
if (!find_channel(function, chan)) {
return nullptr;
}
return &channels[chan];
}
/* m_tb()
*
* parv[1] - channel
* parv[2] - topic ts
* parv[3] - optional topicwho/topic
* parv[4] - topic
*/
static int
ms_tb(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Channel *chptr;
const char *newtopic;
const char *newtopicwho;
time_t newtopicts;
struct Client *fakesource_p;
chptr = find_channel(parv[1]);
if(chptr == NULL)
return 0;
newtopicts = atol(parv[2]);
/* Hide connecting server on netburst -- jilles */
if (ConfigServerHide.flatten_links && !HasSentEob(source_p))
fakesource_p = &me;
else
fakesource_p = source_p;
if(parc == 5) {
newtopic = parv[4];
newtopicwho = parv[3];
} else {
newtopic = parv[3];
newtopicwho = fakesource_p->name;
}
if (EmptyString(newtopic))
return 0;
if(chptr->topic == NULL || chptr->topic_time > newtopicts) {
/* its possible the topicts is a few seconds out on some
* servers, due to lag when propagating it, so if theyre the
* same topic just drop the message --fl
*/
if(chptr->topic != NULL && strcmp(chptr->topic, newtopic) == 0)
return 0;
set_channel_topic(chptr, newtopic, newtopicwho, newtopicts);
sendto_channel_local(ALL_MEMBERS, chptr, ":%s TOPIC %s :%s",
fakesource_p->name, chptr->chname, newtopic);
sendto_server(client_p, chptr, CAP_TB|CAP_TS6, NOCAPS,
":%s TB %s %ld %s%s:%s",
use_id(source_p), chptr->chname, (long) chptr->topic_time,
ConfigChannel.burst_topicwho ? chptr->topic_info : "",
ConfigChannel.burst_topicwho ? " " : "", chptr->topic);
}
return 0;
}
void
inbound_topictime (server *serv, char *chan, char *nick, time_t stamp)
{
char *tim = ctime (&stamp);
session *sess = find_channel (serv, chan);
if (!sess)
sess = serv->server_session;
tim[24] = 0; /* get rid of the \n */
EMIT_SIGNAL (XP_TE_TOPICDATE, sess, chan, nick, tim, NULL, 0);
}
void
inbound_kick (server *serv, char *chan, char *user, char *kicker, char *reason,
const message_tags_data *tags_data)
{
session *sess = find_channel (serv, chan);
if (sess)
{
EMIT_SIGNAL_TIMESTAMP (XP_TE_KICK, sess, kicker, user, chan, reason, 0,
tags_data->timestamp);
userlist_remove (sess, user);
}
}
/* This function stops all transfers on the given channel with the given
* direction. This function is required to stop any video transfers, or any
* non-blocking transfers. */
void axidma_stop_transfer(axidma_dev_t dev, int channel)
{
struct axidma_chan chan;
dma_channel_t *dma_chan;
assert(find_channel(dev, channel) != NULL);
// Setup the argument structure for the IOCTL
dma_chan = find_channel(dev, channel);
chan.channel_id = channel;
chan.dir = dma_chan->dir;
chan.type = dma_chan->type;
// Stop all transfers on the given DMA channel
if (ioctl(dev->fd, AXIDMA_STOP_DMA_CHANNEL, &chan) < 0) {
perror("Failed to stop the DMA channel");
assert(false);
}
return;
}
bool supla_client_channels::channel_exists(int ChannelID) {
bool result = false;
safe_array_lock(arr);
if ( find_channel(ChannelID) != NULL )
result = true;
safe_array_unlock(arr);
return result;
}
static int
mo_forcepart(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Client *target_p;
struct Channel *chptr;
struct membership *msptr;
if(!IsOperAdmin(source_p))
{
sendto_one(source_p, form_str(ERR_NOPRIVS), me.name, source_p->name, "forcepart");
return 0;
}
if((hunt_server(client_p, source_p, ":%s FORCEPART %s %s", 1, parc, parv)) != HUNTED_ISME)
return 0;
/* if target_p == NULL then let the oper know */
if((target_p = find_client(parv[1])) == NULL)
{
sendto_one(source_p, form_str(ERR_NOSUCHNICK), me.name, source_p->name, parv[1]);
return 0;
}
if(!IsClient(target_p))
return 0;
if((chptr = find_channel(parv[2])) == NULL)
{
sendto_one_numeric(source_p, ERR_NOSUCHCHANNEL,
form_str(ERR_NOSUCHCHANNEL), parv[1]);
return 0;
}
if((msptr = find_channel_membership(chptr, target_p)) == NULL)
{
sendto_one(source_p, form_str(ERR_USERNOTINCHANNEL),
me.name, source_p->name, parv[1], parv[2]);
return 0;
}
sendto_server(target_p, chptr, NOCAPS, NOCAPS,
":%s PART %s :%s", target_p->name, chptr->chname, target_p->name);
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%s@%s PART %s :%s",
target_p->name, target_p->username,
target_p->host, chptr->chname, target_p->name);
remove_user_from_channel(msptr);
return 0;
}
/* Sets up a callback function to be called whenever the transaction completes
* on the given channel for asynchronous transfers. */
void axidma_set_callback(axidma_dev_t dev, int channel, axidma_cb_t callback,
void *data)
{
dma_channel_t *chan;
assert(find_channel(dev, channel) != NULL);
chan = &dev->channels[channel];
chan->callback = callback;
chan->user_data = data;
return;
}
void
inbound_topictime (server *serv, char *chan, char *nick, time_t stamp,
const message_tags_data *tags_data)
{
char *tim = ctime (&stamp);
session *sess = find_channel (serv, chan);
if (!sess)
sess = serv->server_session;
tim[24] = 0; /* get rid of the \n */
EMIT_SIGNAL_TIMESTAMP (XP_TE_TOPICDATE, sess, tags_data->timestamp, chan, nick, tim);
}
static int
me_roleplay(struct Client *client_p, struct Client *source_p, int parc, const char *parv[])
{
struct Channel *chptr;
/* Don't segfault if we get ROLEPLAY with an invalid channel.
* This shouldn't happen but it's best to be on the safe side. */
if((chptr = find_channel(parv[1])) == NULL)
return 0;
sendto_channel_local(ALL_MEMBERS, chptr, ":%s!%[email protected] PRIVMSG %s :%s (%s)", parv[2], source_p->name, parv[1], parv[3], source_p->name);
return 0;
}
static int kick_hook(int argc, char *argv[])
{
channel_t *ch = find_channel(argv[2], irc_pick_server());
if (!ch)
return -1;
user_t *u = find_user(argv[3], irc_pick_server());
char *nick = grab_nick(argv[0]);
cwio_out(ch->win, "%s %s was kicked from %s by %s [%s]\n", timestamp(),
argv[3], argv[2], nick, argv[4]);
u->rm_channel(u, ch->name);
free(nick);
return 0;
}
void
inbound_part (server *serv, char *chan, char *user, char *ip, char *reason)
{
session *sess = find_channel (serv, chan);
if (sess)
{
if (*reason)
EMIT_SIGNAL (XP_TE_PARTREASON, sess, user, ip, chan, reason, 0);
else
EMIT_SIGNAL (XP_TE_PART, sess, user, ip, chan, NULL, 0);
userlist_remove (sess, user);
}
}
void recv_text_handler( string & str )
{
mud_channel *channel = nullptr;
char_data *ch = nullptr;
string arg1, arg2, arg3, arg4, arg5, chname;
int ilevel = -1, clevel = -1;
bool isnpc, isinvis;
str = one_argument( str, arg1 );
str = one_argument( str, arg2 );
str = one_argument( str, arg3 );
str = one_argument( str, arg4 );
str = one_argument( str, arg5 );
str = one_argument( str, chname );
ilevel = atoi( arg2.c_str( ) );
clevel = atoi( arg3.c_str( ) );
isnpc = atoi( arg4.c_str( ) );
isinvis = atoi( arg5.c_str( ) );
if( !( channel = find_channel( arg1 ) ) )
{
bug( "%s: channel %s doesn't exist!", __func__, arg1.c_str( ) );
return;
}
/*
* Massive punt here
*/
ch = new char_data;
if( !isnpc )
{
ch->name = STRALLOC( capitalize( chname.c_str( ) ) );
ch->pcdata = new pc_data;
ch->pcdata->wizinvis = ilevel;
if( isinvis )
ch->set_pcflag( PCFLAG_WIZINVIS );
}
else
{
ch->set_actflag( ACT_IS_NPC );
ch->short_descr = STRALLOC( capitalize( chname.c_str( ) ) );
ch->mobinvis = ilevel;
}
ch->level = clevel;
ch->to_room( get_room_index( ROOM_VNUM_LIMBO ) );
send_tochannel( ch, channel, str );
ch->from_room( );
deleteptr( ch );
}
void
inbound_upart (server *serv, char *chan, char *ip, char *reason)
{
session *sess = find_channel (serv, chan);
if (sess)
{
if (*reason)
EMIT_SIGNAL (XP_TE_UPARTREASON, sess, serv->nick, ip, chan, reason,
0);
else
EMIT_SIGNAL (XP_TE_UPART, sess, serv->nick, ip, chan, NULL, 0);
clear_channel (sess);
}
}
int
_gpgme_io_read (int fd, void *buffer, size_t count)
{
int saved_errno = 0;
gsize nread;
GIOChannel *chan;
GIOStatus status;
TRACE_BEG2 (DEBUG_SYSIO, "_gpgme_io_read", fd,
"buffer=%p, count=%u", buffer, count);
chan = find_channel (fd);
if (!chan)
{
TRACE_LOG ("no channel registered");
errno = EINVAL;
return TRACE_SYSRES (-1);
}
TRACE_LOG1 ("channel %p", chan);
{
GError *err = NULL;
status = g_io_channel_read_chars (chan, (gchar *) buffer,
count, &nread, &err);
if (err)
{
TRACE_LOG2 ("status %i, err %s", status, err->message);
g_error_free (err);
}
}
if (status == G_IO_STATUS_EOF)
nread = 0;
else if (status == G_IO_STATUS_AGAIN)
{
nread = -1;
saved_errno = EAGAIN;
}
else if (status != G_IO_STATUS_NORMAL)
{
TRACE_LOG1 ("status %d", status);
nread = -1;
saved_errno = EIO;
}
if (nread != 0 && nread != -1)
TRACE_LOGBUF (buffer, nread);
errno = saved_errno;
return TRACE_SYSRES (nread);
}
void
inbound_part (server *serv, char *chan, char *user, char *ip, char *reason,
const message_tags_data *tags_data)
{
session *sess = find_channel (serv, chan);
if (sess)
{
if (*reason)
EMIT_SIGNAL_TIMESTAMP (XP_TE_PARTREASON, sess, tags_data->timestamp, user, ip, chan, reason);
else
EMIT_SIGNAL_TIMESTAMP (XP_TE_PART, sess, tags_data->timestamp, user, ip, chan);
userlist_remove (sess, user);
}
}
void
inbound_upart (server *serv, char *chan, char *ip, char *reason,
const message_tags_data *tags_data)
{
session *sess = find_channel (serv, chan);
if (sess)
{
if (*reason)
EMIT_SIGNAL_TIMESTAMP (XP_TE_UPARTREASON, sess, tags_data->timestamp, serv->nick, ip, chan, reason);
else
EMIT_SIGNAL_TIMESTAMP (XP_TE_UPART, sess, tags_data->timestamp, serv->nick, ip, chan);
clear_channel (sess);
}
}
void
inbound_ujoin (server *serv, char *chan, char *nick, char *ip,
const message_tags_data *tags_data)
{
session *sess;
/* already joined? probably a bnc */
sess = find_channel (serv, chan);
if (!sess)
{
/* see if a window is waiting to join this channel */
sess = find_session_from_waitchannel (chan, serv);
if (!sess)
{
/* find a "<none>" tab and use that */
sess = find_unused_session (serv);
if (!sess)
/* last resort, open a new tab/window */
sess = new_ircwindow (serv, chan, SESS_CHANNEL, 1);
}
}
safe_strcpy (sess->channel, chan, CHANLEN);
fe_set_channel (sess);
fe_set_title (sess);
fe_set_nonchannel (sess, TRUE);
userlist_clear (sess);
log_open_or_close (sess);
sess->waitchannel[0] = 0;
sess->ignore_date = TRUE;
sess->ignore_mode = TRUE;
sess->ignore_names = TRUE;
sess->end_of_names = FALSE;
/* sends a MODE */
serv->p_join_info (sess->server, chan);
EMIT_SIGNAL_TIMESTAMP (XP_TE_UJOIN, sess, nick, chan, ip, NULL, 0,
tags_data->timestamp);
if (prefs.hex_irc_who_join)
{
/* sends WHO #channel */
serv->p_user_list (sess->server, chan);
sess->doing_who = TRUE;
}
}
void
inbound_topic (server * serv, char *chan, char *topic_text)
{
session *sess = find_channel (serv, chan);
if (sess)
{
set_topic (sess, topic_text, topic_text);
}
else
sess = serv->server_session;
EMIT_SIGNAL (XP_TE_TOPIC, sess, chan, topic_text, NULL, NULL, 0);
}
static
void authenticate_tcp_channel(struct bufferevent *bev, void *_)
{
debug("tcp channel: authentication reading data");
struct evbuffer *input = bufferevent_get_input(bev);
size_t len = evbuffer_get_length(input);
size_t wanted = sizeof(struct MessageResponse);
if(len < wanted)
return;
debug("tcp channel: authentication checking message");
struct MessageResponse *res =
(struct MessageResponse *) evbuffer_pullup(input, wanted);
if(res->type != RESPONSE)
{
debug( "tcp channel: invalid authentication message %s",
message_get_type_string((struct Message *) res));
bufferevent_free(bev);
return;
}
union Channel *current = find_channel(&res->response);
if(!current)
{
debug("tcp channel: authentication failed");
bufferevent_free(bev);
return;
}
evbuffer_drain(input, wanted);
debug("tcp channel: authenticated");
assert(current->base.proto == IPPROTO_TCP);
current->tcp.channel_buffers = bev;
bufferevent_setcb( current->tcp.peer_buffers,
read_tcp_peer,
NULL,
error_on_tcp_peer,
current);
bufferevent_enable(current->tcp.peer_buffers, EV_READ | EV_WRITE);
bufferevent_setcb( bev,
read_tcp_channel,
NULL,
error_on_tcp_channel,
current);
read_tcp_channel(bev, current);
}
void
inbound_ujoin (server *serv, char *chan, char *nick, char *ip)
{
session *sess;
/* already joined? probably a bnc */
sess = find_channel (serv, chan);
if (!sess)
{
/* see if a window is waiting to join this channel */
sess = find_session_from_waitchannel (chan, serv);
if (!sess)
{
/* find a "<none>" tab and use that */
sess = find_unused_session (serv);
if (!sess)
/* last resort, open a new tab/window */
sess = new_ircwindow (serv, chan, SESS_CHANNEL);
}
}
safe_strcpy (sess->channel, chan, CHANLEN);
fe_set_channel (sess);
fe_set_title (sess);
fe_set_nonchannel (sess, TRUE);
clear_user_list (sess);
if (prefs.logging)
log_open (sess);
sess->waitchannel[0] = 0;
sess->ignore_date = TRUE;
sess->ignore_mode = TRUE;
sess->ignore_names = TRUE;
sess->end_of_names = FALSE;
/* sends a MODE */
serv->p_join_info (sess->server, chan);
EMIT_SIGNAL (XP_TE_UJOIN, sess, nick, chan, ip, NULL, 0);
if (prefs.userhost)
{
/* sends WHO #channel */
serv->p_user_list (sess->server, chan);
sess->doing_who = TRUE;
}
}
