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); } }