int main(void) {
if ((chan = make_channel()) == NULL) {
perror("make_channel() error");
exit(EXIT_FAILURE);
}
size_t i;
for (i = 0; i < THREADS_N; i++) {
int thr_res = pthread_create(&threads[i], NULL, thr_fn, (void *) (uintptr_t) i);
if (thr_res != 0) {
fprintf(stderr, "pthread_create(3) error: %s\n", strerror(thr_res));
exit(EXIT_FAILURE);
}
}
for (i = 0; i < COUNT; i++) {
int j;
if (channel_read(chan, (char *) &j, sizeof(j)) == -1) {
perror("channel_read() error");
exit(EXIT_FAILURE);
}
printf("%d\n", j);
}
return 0;
}
static void start(struct mwServiceDirectory *srvc) {
struct mwChannel *chan;
chan = make_channel(srvc);
if(chan) {
srvc->channel = chan;
} else {
mwService_stopped(MW_SERVICE(srvc));
return;
}
}
static void start(struct mwService *srvc) {
struct mwServiceStorage *srvc_store;
struct mwChannel *chan;
g_return_if_fail(srvc != NULL);
srvc_store = (struct mwServiceStorage *) srvc;
chan = make_channel(srvc_store);
if(chan) {
srvc_store->channel = chan;
} else {
mwService_stopped(srvc);
}
}
/*
* m_lljoin
* parv[0] = sender prefix
* parv[1] = channel
* parv[2] = nick ("!nick" == cjoin)
* parv[3] = key (optional)
*
* If a lljoin is received, from our uplink, join
* the requested client to the given channel, or ignore it
* if there is an error.
*
* Ok, the way this works. Leaf client tries to join a channel,
* it doesn't exist so the join does a cburst request on behalf of the
* client, and aborts that join. The cburst sjoin's the channel if it
* exists on the hub, and sends back an LLJOIN to the leaf. Thats where
* this is now..
*
*/
static void
ms_lljoin(struct Client *client_p, struct Client *source_p,
int parc, char *parv[])
{
char *chname = NULL;
char *nick = NULL;
char *key = NULL;
int flags;
int i;
struct Client *target_p;
struct Channel *chptr;
if (uplink && !IsCapable(uplink,CAP_LL))
{
sendto_realops_flags(UMODE_ALL, L_ALL,
"*** LLJOIN requested from non LL server %s",
client_p->name);
return;
}
chname = parv[1];
if(chname == NULL)
return;
nick = parv[2];
if(nick == NULL)
return;
if (parc >3)
key = parv[3];
flags = 0;
target_p = find_person(client_p, nick);
if (!target_p)
return;
if (!MyClient(target_p))
return;
if (!check_channel_name(chname, 0))
{
sendto_gnotice_flags(UMODE_DEBUG, L_ALL, me.name, &me, NULL,
"*** Too long or invalid channel name from %s: %s",
target_p->name, chname);
return;
}
chptr = make_channel(chname);
flags = CHFL_CHANOP;
if(!chptr)
return;
if (dlink_list_length(&chptr->members) == 0)
flags = CHFL_CHANOP;
else
flags = 0;
/* XXX in m_join.c :( */
/* check_spambot_warning(target_p, chname); */
/* They _could_ join a channel twice due to lag */
if(chptr)
{
if (IsMember(target_p, chptr)) /* already a member, ignore this */
return;
}
else
{
sendto_one(target_p, form_str(ERR_UNAVAILRESOURCE),
me.name, nick, chptr->chname);
return;
}
if ((i = can_join(target_p, chptr, key)))
{
sendto_one(target_p, form_str(i),
me.name, nick, chptr->chname);
return;
}
if ((dlink_list_length(&target_p->channel) >= ConfigChannel.max_chans_per_user) &&
(!IsOper(target_p) || (dlink_list_length(&target_p->channel) >=
ConfigChannel.max_chans_per_user*3)))
{
sendto_one(target_p, form_str(ERR_TOOMANYCHANNELS),
me.name, nick, chptr->chname );
return;
}
if (flags == CHFL_CHANOP)
{
chptr->channelts = CurrentTime;
sendto_one(uplink,
":%s SJOIN %lu %s + :@%s",
me.name,
(unsigned long) chptr->channelts,
chptr->chname,
nick);
}
sendto_one(uplink,
":%s SJOIN %lu %s + :%s",
me.name,
(unsigned long) chptr->channelts,
chptr->chname,
nick);
add_user_to_channel(chptr, target_p, flags, YES);
sendto_channel_local(ALL_MEMBERS, NO, chptr,
":%s!%s@%s JOIN :%s",
target_p->name,
target_p->username,
target_p->host,
chptr->chname);
if (flags & CHFL_CHANOP)
{
chptr->mode.mode |= MODE_TOPICLIMIT;
chptr->mode.mode |= MODE_NOPRIVMSGS;
sendto_channel_local(ALL_MEMBERS, NO, chptr,
":%s MODE %s +nt",
me.name, chptr->chname);
sendto_one(uplink,
":%s MODE %s +nt",
me.name, chptr->chname);
}
channel_member_names(target_p, chptr, 1);
}
static void
ms_cburst(struct Client *client_p, struct Client *source_p, int parc, char *parv[])
{
char *name;
char *nick;
const char *key;
struct Channel *chptr;
if(parc < 2 || *parv[1] == '\0')
return;
name = parv[1];
if(parc > 2)
nick = parv[2];
else
nick = NULL;
if(parc > 3)
key = parv[3];
else
key = "";
#ifdef DEBUGLL
sendto_realops_flags(UMODE_ALL, L_ALL, "CBURST called by %s for %s %s %s",
client_p->name, name, nick ? nick : "", key ? key : "");
#endif
if((chptr = hash_find_channel(name)) == NULL)
{
if((!nick) || (nick && *nick != '!'))
{
if(!check_channel_name(name, 0))
{
sendto_realops_flags(UMODE_DEBUG, L_ALL,
"*** Too long or invalid channel name from %s: %s",
client_p->name, name);
return;
}
chptr = make_channel(name);
chptr->channelts = (time_t) (-1); /* highest possible TS so its always
* over-ruled
*/
}
else if(nick && *nick == '!')
{
sendto_one(source_p, form_str(ERR_NOSUCHCHANNEL), me.name, nick + 1, name);
return;
}
}
if(IsCapable(client_p, CAP_LL))
{
burst_channel(client_p, chptr);
if(nick)
sendto_one(client_p, ":%s LLJOIN %s %s %s", me.name, name, nick, key);
}
else
{
sendto_realops_flags(UMODE_ALL, L_ALL,
"*** CBURST request received from non LL capable server! [%s]",
client_p->name);
}
}
