lib/eggdrop/partychan.h File Reference

Go to the source code of this file.

Data Structures

struct partychan_member

struct partychan

struct partymember_common

Functions

partychan_t * partychan_new (int cid, const char *name)

void partychan_delete (partychan_t *chan)

partychan_t * partychan_lookup_cid (int cid)

partychan_t * partychan_lookup_name (const char *name)

partychan_t * partychan_get_default (partymember_t *p)

int partychan_ison_name (const char *chan, partymember_t *p)

int partychan_ison (partychan_t *chan, partymember_t *p)

int partychan_join_name (const char *chan, partymember_t *p, int linking)

int partychan_join_cid (int cid, partymember_t *p, int linking)

int partychan_join (partychan_t *chan, partymember_t *p, int linking)

int partychan_part_name (const char *chan, partymember_t *p, const char *text)

int partychan_part_cid (int cid, partymember_t *p, const char *text)

int partychan_part (partychan_t *chan, partymember_t *p, const char *text)

int partychan_msg_name (const char *name, botnet_entity_t *src, const char *text, int len)

int partychan_msg_cid (int cid, botnet_entity_t *src, const char *text, int len)

int partychan_msg (partychan_t *chan, botnet_entity_t *src, const char *text, int len)

int localchan_msg (partychan_t *chan, botnet_entity_t *src, const char *text, int len)

partymember_common_t * partychan_get_common (partymember_t *p)

int partychan_free_common (partymember_common_t *common)

Function Documentation

int localchan_msg	(	partychan_t *	chan,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 395 of file partychan.c.

References chan_msg().

Referenced by on_putlog().

00396 {
00397   return chan_msg(chan, src, text, len, 1);
00398 }

void partychan_delete ( partychan_t * chan )

Definition at line 165 of file partychan.c.

References partychan::cid, partychan::flags, garbage_add(), GARBAGE_ONCE, hash_table_remove(), NULL, PARTY_DELETED, and partychan_cleanup().

Referenced by partychan_shutdown().

00166 {
00167   chan->flags |= PARTY_DELETED;
00168   hash_table_remove(cid_ht, (void *)chan->cid, NULL);
00169   garbage_add((garbage_proc_t)partychan_cleanup, chan, GARBAGE_ONCE);
00170 }

int partychan_free_common ( partymember_common_t * common )

Definition at line 438 of file partychan.c.

References partymember_common::len, and partymember_common::next.

Referenced by partymember_delete(), and partymember_set_nick().

00439 {
00440   common->len = 0;
00441   common->next = common_list_head;
00442   common_list_head = common;
00443   return(0);
00444 }

partymember_common_t* partychan_get_common ( partymember_t * p )

Definition at line 401 of file partychan.c.

References partymember::bot, partymember::channels, partymember::flags, partychan_member::flags, partychan::flags, partymember_common::len, partymember_common::max, partymember_common::members, partychan::members, partymember::nchannels, partymember_common::next, partychan::nmembers, partychan_member::p, PARTY_DELETED, and PARTY_SELECTED.

Referenced by partymember_delete(), and partymember_set_nick().

00402 {
00403   partymember_common_t *common;
00404   partychan_t *chan;
00405   partymember_t *mem;
00406   int i, j;
00407 
00408   if (common_list_head) {
00409     common = common_list_head;
00410     common_list_head = common_list_head->next;
00411   }
00412   else {
00413     common = calloc(1, sizeof(*common));
00414   }
00415 
00416   common->len = 0;
00417   for (i = 0; i < p->nchannels; i++) {
00418     chan = p->channels[i];
00419     if (chan->flags & PARTY_DELETED) continue;
00420     for (j = 0; j < chan->nmembers; j++) {
00421       if (chan->members[j].flags & PARTY_DELETED) continue;
00422       mem = chan->members[j].p;
00423       if (mem->flags & (PARTY_DELETED | PARTY_SELECTED)) continue;
00424       if (mem->bot) continue;
00425       mem->flags |= PARTY_SELECTED;
00426       if (common->len >= common->max) {
00427         common->max = common->len + 10;
00428         common->members = realloc(common->members, sizeof(*common->members) * common->max);
00429       }
00430       common->members[common->len] = mem;
00431       common->len++;
00432     }
00433   }
00434   for (i = 0; i < common->len; i++) common->members[i]->flags &= ~PARTY_SELECTED;
00435   return(common);
00436 }

partychan_t* partychan_get_default ( partymember_t * p )

Definition at line 192 of file partychan.c.

References partymember::channels, partymember::nchannels, and NULL.

Referenced by got_join(), party_chanmembermode(), party_part(), and partyline_on_input().

00193 {
00194   if (p->nchannels > 0) return(p->channels[p->nchannels-1]);
00195   return(NULL);
00196 }

int partychan_ison	(	partychan_t *	chan,
		partymember_t *	p
	)

Definition at line 208 of file partychan.c.

References egg_assert_val, partychan_member::flags, partychan::members, partychan::nmembers, NULL, partychan_member::p, and PARTY_DELETED.

Referenced by partychan_ison_name().

00209 {
00210   int i;
00211 
00212   egg_assert_val (chan != NULL, 0);
00213   egg_assert_val (p != NULL, 0);
00214   
00215   for (i = 0; i < chan->nmembers; i++) {
00216     if (chan->members[i].flags & PARTY_DELETED) continue;
00217     if (chan->members[i].p == p) return(1);
00218   }
00219     
00220   return(0);
00221 }

int partychan_ison_name	(	const char *	chan,
		partymember_t *	p
	)

Definition at line 198 of file partychan.c.

References partychan_ison(), and partychan_lookup_name().

00199 {
00200   partychan_t *chanptr;
00201 
00202   if (!chan) return(0);
00203   chanptr = partychan_lookup_name(chan);
00204   if (!chanptr) return(0);
00205   return partychan_ison(chanptr, p);
00206 }

int partychan_join	(	partychan_t *	chan,
		partymember_t *	p,
		int	linking
	)

Definition at line 241 of file partychan.c.

References bind_check(), botnet_member_join(), partymember::channels, partychan::cid, partymember::client_data, partymember::flags, partychan_member::flags, partymember::handler, partychan::members, partychan::name, partymember::nchannels, partychan::nmembers, NULL, partyline_event::on_join, partychan_member::p, and PARTY_DELETED.

Referenced by partychan_join_cid(), and partychan_join_name().

00242 {
00243   partychan_member_t *mem;
00244   int i;
00245 
00246   if (!chan || !p) return(-1);
00247 
00248   /* Check to see if he's already on. We put this here just to save some
00249    * redundancy in partyline modules. */
00250   for (i = 0; i < chan->nmembers; i++) {
00251     if (chan->members[i].flags & PARTY_DELETED) continue;
00252     if (chan->members[i].p == p) return(-1);
00253   }
00254 
00255   /* Add the member. */
00256   chan->members = realloc(chan->members, sizeof(*chan->members) * (chan->nmembers+1));
00257   chan->members[chan->nmembers].p = p;
00258   chan->members[chan->nmembers].flags = 0;
00259   chan->nmembers++;
00260 
00261   /* Now add the channel to the member's list. */
00262   p->channels = realloc(p->channels, sizeof(chan) * (p->nchannels+1));
00263   p->channels[p->nchannels] = chan;
00264   p->nchannels++;
00265 
00266   /* Trigger the partyline channel join bind. */
00267   bind_check(BT_partyjoin, NULL, NULL, chan->name, chan->cid, p);
00268 
00269   /* Send out the join event to the members. */
00270   for (i = 0; i < chan->nmembers; i++) {
00271     mem = chan->members+i;
00272     if (mem->flags & PARTY_DELETED || mem->p->flags & PARTY_DELETED) continue;
00273     if (mem->p->handler && mem->p->handler->on_join)
00274       (mem->p->handler->on_join)(mem->p->client_data, chan, p, linking);
00275   }
00276 
00277   botnet_member_join(chan, p, linking);
00278 
00279   return(0);
00280 }

int partychan_join_cid	(	int	cid,
		partymember_t *	p,
		int	linking
	)

Definition at line 233 of file partychan.c.

References partychan_join(), and partychan_lookup_cid().

00234 {
00235   partychan_t *chanptr;
00236 
00237   chanptr = partychan_lookup_cid(cid);
00238   return partychan_join(chanptr, p, linking);
00239 }

int partychan_join_name	(	const char *	chan,
		partymember_t *	p,
		int	linking
	)

Definition at line 223 of file partychan.c.

References partychan_join(), partychan_lookup_name(), and partychan_new().

Referenced by dcc_on_read(), got_join(), irc_on_read(), party_join(), telnet_on_read(), and terminal_init().

00224 {
00225   partychan_t *chanptr;
00226 
00227   if (!chan) return(-1);
00228   chanptr = partychan_lookup_name(chan);
00229   if (!chanptr) chanptr = partychan_new(-1, chan);
00230   return partychan_join(chanptr, p, linking);
00231 }

partychan_t* partychan_lookup_cid ( int cid )

Definition at line 172 of file partychan.c.

References partychan::flags, hash_table_find(), NULL, and PARTY_DELETED.

Referenced by partychan_get_cid(), partychan_join_cid(), partychan_msg_cid(), and partychan_part_cid().

00173 {
00174   partychan_t *chan = NULL;
00175 
00176   hash_table_find(cid_ht, (void *)cid, &chan);
00177   if (chan && chan->flags & PARTY_DELETED) chan = NULL;
00178   return(chan);
00179 }

partychan_t* partychan_lookup_name ( const char * name )

Definition at line 181 of file partychan.c.

References partychan::flags, partychan::name, partychan::next, NULL, and PARTY_DELETED.

Referenced by assoc_get_name(), got_privmsg(), got_who(), on_putlog(), party_part(), partychan_ison_name(), partychan_join_name(), partychan_msg_name(), and partychan_part_name().

00182 {
00183   partychan_t *chan = NULL;
00184 
00185   for (chan = partychan_head; chan; chan = chan->next) {
00186     if (chan->flags & PARTY_DELETED) continue;
00187     if (!strcasecmp(name, chan->name)) break;
00188   }
00189   return(chan);
00190 }

int partychan_msg	(	partychan_t *	chan,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 390 of file partychan.c.

References chan_msg().

Referenced by partyline_on_input().

00391 {
00392   return chan_msg(chan, src, text, len, 0);
00393 }

int partychan_msg_cid	(	int	cid,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 382 of file partychan.c.

References chan_msg(), and partychan_lookup_cid().

00383 {
00384   partychan_t *chan;
00385 
00386   chan = partychan_lookup_cid(cid);
00387   return chan_msg(chan, src, text, len, 0);
00388 }

int partychan_msg_name	(	const char *	name,
		botnet_entity_t *	src,
		const char *	text,
		int	len
	)

Definition at line 374 of file partychan.c.

References chan_msg(), and partychan_lookup_name().

Referenced by got_actchan(), got_chanmsg(), and got_chat().

00375 {
00376   partychan_t *chan;
00377 
00378   chan = partychan_lookup_name(name);
00379   return chan_msg(chan, src, text, len, 0);
00380 }

partychan_t* partychan_new	(	int	cid,
		const char *	name
	)

Definition at line 102 of file partychan.c.

References partychan::cid, partychan::name, partychan::next, partychan_get_cid(), and partychan::prev.

Referenced by partychan_join_name().

00103 {
00104   partychan_t *chan;
00105 
00106   chan = calloc(1, sizeof(*chan));
00107   if (cid == -1) cid = partychan_get_cid();
00108   chan->cid = cid;
00109   chan->name = strdup(name);
00110   chan->next = partychan_head;
00111   if (partychan_head) partychan_head->prev = chan;
00112   partychan_head = chan;
00113   return(chan);
00114 }

int partychan_part	(	partychan_t *	chan,
		partymember_t *	p,
		const char *	text
	)

Definition at line 299 of file partychan.c.

References bind_check(), botnet_member_part(), BT_partypart, partymember::channels, partychan::cid, partymember::client_data, partychan_member::flags, partymember::flags, garbage_add(), GARBAGE_ONCE, partymember::handler, partychan::members, partychan::name, partymember::nchannels, partychan::nmembers, NULL, partyline_event::on_part, partychan_member::p, PARTY_DELETED, and partychan_cleanup().

Referenced by got_join(), party_part(), partychan_part_cid(), partychan_part_name(), and partymember_delete().

00300 {
00301   int i, len;
00302   partychan_member_t *mem;
00303 
00304   if (!chan || !p) return(-1);
00305 
00306   /* Remove the channel entry from the member. */
00307   if (!(p->flags & PARTY_DELETED)) for (i = 0; i < p->nchannels; i++) {
00308     if (p->channels[i] == chan) {
00309       memmove(p->channels+i, p->channels+i+1, sizeof(chan) * (p->nchannels-i-1));
00310       p->nchannels--;
00311       break;
00312     }
00313   }
00314 
00315   /* Mark the member to be deleted. */
00316   for (i = 0; i < chan->nmembers; i++) {
00317     if (chan->members[i].flags & PARTY_DELETED) continue;
00318     if (chan->members[i].p == p) {
00319       chan->members[i].flags |= PARTY_DELETED;
00320       garbage_add((garbage_proc_t)partychan_cleanup, chan, GARBAGE_ONCE);
00321       break;
00322     }
00323   }
00324 
00325   /* If the member is already deleted, then the quit event has been
00326    * fired already. */
00327   if (p->flags & PARTY_DELETED) return(0);
00328 
00329   if (!text) text = "";
00330   len = strlen(text);
00331 
00332   /* Trigger the partyline channel part bind. */
00333   bind_check(BT_partypart, NULL, NULL, chan->name, chan->cid, p, text, len);
00334 
00335   if (p->handler && p->handler->on_part) p->handler->on_part(p->client_data, chan, p, text, len);
00336 
00337   /* Send out the part event to the members. */
00338   for (i = 0; i < chan->nmembers; i++) {
00339     mem = chan->members+i;
00340     if (mem->flags & PARTY_DELETED || mem->p->flags & PARTY_DELETED) continue;
00341     if (mem->p->handler && mem->p->handler->on_part)
00342       (mem->p->handler->on_part)(mem->p->client_data, chan, p, text, len);
00343   }
00344 
00345   botnet_member_part(chan, p, text, len);
00346 
00347   return(0);
00348 }

int partychan_part_cid	(	int	cid,
		partymember_t *	p,
		const char *	text
	)

Definition at line 291 of file partychan.c.

References partychan_lookup_cid(), and partychan_part().

00292 {
00293   partychan_t *chanptr;
00294 
00295   chanptr = partychan_lookup_cid(cid);
00296   return partychan_part(chanptr, p, text);
00297 }

int partychan_part_name	(	const char *	chan,
		partymember_t *	p,
		const char *	text
	)

Definition at line 282 of file partychan.c.

References partychan_lookup_name(), and partychan_part().

Referenced by got_part().

00283 {
00284   partychan_t *chanptr;
00285 
00286   if (!chan) return(-1);
00287   chanptr = partychan_lookup_name(chan);
00288   return partychan_part(chanptr, p, text);
00289 }


Data Structures
struct	partychan_member
struct	partychan
struct	partymember_common
Functions
partychan_t *	partychan_new (int cid, const char *name)
void	partychan_delete (partychan_t *chan)
partychan_t *	partychan_lookup_cid (int cid)
partychan_t *	partychan_lookup_name (const char *name)
partychan_t *	partychan_get_default (partymember_t *p)
int	partychan_ison_name (const char chan, partymember_t p)
int	partychan_ison (partychan_t chan, partymember_t p)
int	partychan_join_name (const char chan, partymember_t p, int linking)
int	partychan_join_cid (int cid, partymember_t *p, int linking)
int	partychan_join (partychan_t chan, partymember_t p, int linking)
int	partychan_part_name (const char chan, partymember_t p, const char *text)
int	partychan_part_cid (int cid, partymember_t p, const char text)
int	partychan_part (partychan_t chan, partymember_t p, const char *text)
int	partychan_msg_name (const char name, botnet_entity_t src, const char *text, int len)
int	partychan_msg_cid (int cid, botnet_entity_t src, const char text, int len)
int	partychan_msg (partychan_t chan, botnet_entity_t src, const char *text, int len)
int	localchan_msg (partychan_t chan, botnet_entity_t src, const char *text, int len)
partymember_common_t *	partychan_get_common (partymember_t *p)
int	partychan_free_common (partymember_common_t *common)