modules/server/channels.h File Reference

Go to the source code of this file.

Data Structures

struct  uhost_cache_entry_t

Defines

#define CHANNEL_WHOLIST   0x1
#define CHANNEL_BANLIST   0x2
#define CHANNEL_NAMESLIST   0x4
#define CHANNEL_JOINED   0x8
#define CHANNEL_STATIC   0x1
#define CHANNEL_INACTIVE   0x2
#define BOT_ISOP(chanptr)   (((chanptr)->status & CHANNEL_JOINED) && flag_match_single_char(&((chanptr)->bot->mode), 'o'))
#define BOT_ISHALFOP(chanptr)   (((chanptr)->status & CHANNEL_JOINED) && flag_match_single_char(&((chanptr)->bot->mode), 'h'))
#define BOT_CAN_SET_MODES(chanptr)

Functions

void channel_init ()
void channel_reset ()
void channel_destroy ()
void channel_free (channel_t *chan)
channel_t * channel_probe (const char *chan_name, int create)
channel_t * channel_lookup (const char *chan_name)
channel_t * channel_add (const char *name)
int channel_remove (const char *name)
int channel_load (const char *fname)
int channel_save (const char *fname)
int channel_set (channel_t *chan, const char *value,...)
int channel_get (channel_t *chan, char **strptr,...)
int channel_get_int (channel_t *chan, int *intptr,...)
xml_node_t * channel_get_node (channel_t *chan,...)
int channel_mode (const char *chan_name, const char *nick, char *buf)
int channel_mode_arg (const char *chan_name, int type, const char **value)
channel_mode_arg_t * channel_get_arg (channel_t *chan, int type)
channel_mask_list_t * channel_get_mask_list (channel_t *chan, int type)
void channel_add_mask (channel_t *chan, char type, const char *mask, const char *set_by, int time)
void channel_del_mask (channel_t *chan, char type, const char *mask)
void channel_events_init ()
void channel_events_destroy ()
void channel_free_online (channel_t *chan)
void channel_on_quit (const char *nick, const char *uhost, user_t *u)
void channel_on_connect ()
void uhost_cache_init ()
void uhost_cache_reset ()
void uhost_cache_destroy ()
char * uhost_cache_lookup (const char *nick)
void uhost_cache_addref (const char *nick, const char *uhost)
void uhost_cache_decref (const char *nick)
void uhost_cache_swap (const char *old_nick, const char *new_nick)

Variables

channel_t * channel_head
int nchannels

Define Documentation

#define BOT_CAN_SET_MODES ( chanptr   ) 

Value:

(((chanptr)->status & CHANNEL_JOINED) && (flag_match_single_char(&((chanptr)->bot->mode), 'o') \
                  || flag_match_single_char(&((chanptr)->bot->mode), 'h')))

Definition at line 37 of file channels.h.

#define BOT_ISHALFOP ( chanptr   )     (((chanptr)->status & CHANNEL_JOINED) && flag_match_single_char(&((chanptr)->bot->mode), 'h'))

Definition at line 36 of file channels.h.

#define BOT_ISOP ( chanptr   )     (((chanptr)->status & CHANNEL_JOINED) && flag_match_single_char(&((chanptr)->bot->mode), 'o'))

Definition at line 35 of file channels.h.

#define CHANNEL_BANLIST   0x2

Definition at line 27 of file channels.h.

#define CHANNEL_INACTIVE   0x2

Definition at line 33 of file channels.h.

#define CHANNEL_JOINED   0x8

Definition at line 29 of file channels.h.

Referenced by channel_on_join().

#define CHANNEL_NAMESLIST   0x4

Definition at line 28 of file channels.h.

Referenced by got366().

#define CHANNEL_STATIC   0x1

Definition at line 32 of file channels.h.

Referenced by channel_add(), channel_on_leave(), channel_remove(), channel_save(), party_chaninfo(), and party_pls_chan().

#define CHANNEL_WHOLIST   0x1

Definition at line 26 of file channels.h.

Referenced by channel_on_join(), and got315().

Function Documentation

channel_t* channel_add ( const char *  name  ) 

Definition at line 103 of file channels.c.

References channel_probe, CHANNEL_STATIC, and channel::flags.

00104 {
00105   channel_t *chan;
00106 
00107   chan = channel_probe(name, 1);
00108   chan->flags |= CHANNEL_STATIC;
00109   return(chan);
00110 }

void channel_add_mask ( channel_t *  chan,
char  type,
const char *  mask,
const char *  set_by,
int  time 
)

Definition at line 164 of file channels.c.

References channel_get_mask_list, channel_mask_list::head, channel_mask::last_used, channel_mask_list::len, channel_mask::mask, channel_mask::next, channel_mask::set_by, and channel_mask::time.

00165 {
00166   channel_mask_list_t *l;
00167   channel_mask_t *m;
00168 
00169   l = channel_get_mask_list(chan, type);
00170 
00171   if (!l) return;
00172 
00173   m = calloc(1, sizeof(*m));
00174   m->mask = strdup(mask);
00175   m->next = l->head;
00176   if (set_by) m->set_by = strdup(set_by);
00177   m->time = time;
00178   m->last_used = 0;
00179 
00180   l->head = m;
00181   l->len++;
00182 }

void channel_del_mask ( channel_t *  chan,
char  type,
const char *  mask 
)

Definition at line 184 of file channels.c.

References channel_get_mask_list, channel_mask_list::head, channel_mask_list::len, channel_mask::mask, channel_mask::next, NULL, and channel_mask::set_by.

00185 {
00186   channel_mask_list_t *l;
00187   channel_mask_t *m, *prev;
00188 
00189   l = channel_get_mask_list(chan, type);
00190   if (!l) return;
00191 
00192   prev = NULL;
00193   for (m = l->head; m; m = m->next) {
00194     if (m->mask && !strcasecmp(m->mask, mask)) {
00195       free(m->mask);
00196       if (m->set_by) free(m->set_by);
00197       if (prev) prev->next = m->next;
00198       else l->head = m->next;
00199       l->len--;
00200       free(m);
00201       break;
00202     }
00203     prev = m;
00204   }
00205 }

void channel_destroy (  ) 

Definition at line 48 of file channels.c.

References channel_reset, channel_save, and server_config.

00049 {
00050   channel_reset();
00051   channel_save(server_config.chanfile);
00052 }

void channel_events_destroy (  ) 

Definition at line 114 of file channel_events.c.

References bind_rem_list().

00115 {
00116   bind_rem_list("raw", channel_raw_binds);
00117 }

void channel_events_init (  ) 

Definition at line 34 of file channel_events.c.

References bind_add_list(), bind_entry_add(), bind_table_lookup_or_fake(), BIND_WANTS_CD, got_list_end(), got_list_item(), and NULL.

00035 {
00036   bind_table_t *table;
00037 
00038   bind_add_list("raw", channel_raw_binds);
00039   table = bind_table_lookup_or_fake("raw");
00040   if (!table) return;
00041 
00042   /* FIXME Putting these here for now... but they should probably be
00043    * configurable or moved to an addon module/script. */
00044   bind_entry_add(table, NULL, "367", "banlistitem", BIND_WANTS_CD, got_list_item, (void *)'b', NULL);
00045   bind_entry_add(table, NULL, "346", "invitelistitem", BIND_WANTS_CD, got_list_item, (void *)'I', NULL);
00046   bind_entry_add(table, NULL, "348", "exceptlistitem", BIND_WANTS_CD, got_list_item, (void *)'e', NULL);
00047   bind_entry_add(table, NULL, "368", "banlistend", BIND_WANTS_CD, got_list_end, (void *)'b', NULL);
00048   bind_entry_add(table, NULL, "347", "invitelistend", BIND_WANTS_CD, got_list_end, (void *)'I', NULL);
00049   bind_entry_add(table, NULL, "349", "exceptlistend", BIND_WANTS_CD, got_list_end, (void *)'e', NULL);
00050 }

void channel_free ( channel_t *  chan  ) 

Definition at line 54 of file channels.c.

References channel_free_online, channel::name, nchannels, channel::next, channel::prev, channel::settings, and xml_node_delete().

00055 {
00056   /* Free online things. */
00057   channel_free_online(chan);
00058 
00059   /* Delete settings. */
00060   if (chan->name) free(chan->name);
00061   if (chan->settings) xml_node_delete(chan->settings);
00062 
00063   /* Unlink. */
00064   if (chan->prev) chan->prev->next = chan->next;
00065   else channel_head = chan->next;
00066   if (chan->next) chan->next->prev = chan->prev;
00067   nchannels--;
00068 }

void channel_free_online ( channel_t *  chan  ) 

Definition at line 85 of file channel_events.c.

References channel::args, clear_masklists(), free_member(), channel::key, channel::limit, channel::member_head, channel::nargs, channel_member::next, channel_member::nick, channel::nmembers, NULL, channel::status, channel::topic, channel::topic_nick, uhost_cache_decref, and channel_mode_arg::value.

00086 {
00087   channel_member_t *m, *next_mem;
00088   int i;
00089 
00090   for (m = chan->member_head; m; m = next_mem) {
00091     next_mem = m->next;
00092     uhost_cache_decref(m->nick);
00093     free_member(m);
00094   }
00095 
00096   if (chan->topic) free(chan->topic);
00097   if (chan->topic_nick) free(chan->topic_nick);
00098   if (chan->key) free(chan->key);
00099 
00100   clear_masklists(chan);
00101 
00102   for (i = 0; i < chan->nargs; i++) {
00103     if (chan->args[i].value) free(chan->args[i].value);
00104   }
00105   if (chan->args) free(chan->args);
00106 
00107   chan->topic = chan->topic_nick = chan->key = NULL;
00108   chan->args = NULL;
00109   chan->member_head = NULL;
00110   chan->status = chan->nargs = chan->nmembers = 0;
00111   chan->limit = -1;
00112 }

int channel_get ( channel_t *  chan,
char **  strptr,
  ... 
)

Definition at line 264 of file channels.c.

References NULL, channel::settings, xml_node_get_str(), and xml_node_vlookup().

00265 {
00266   va_list args;
00267   xml_node_t *node;
00268 
00269   va_start(args, strptr);
00270   node = xml_node_vlookup(chan->settings, args, 0);
00271   va_end(args);
00272   return xml_node_get_str(strptr, node, NULL);
00273 }

channel_mode_arg_t* channel_get_arg ( channel_t *  chan,
int  type 
)

Definition at line 123 of file channels.c.

References channel::args, current_server, channel::nargs, NULL, and channel_mode_arg::type.

00124 {
00125   int i;
00126   char *c;
00127   channel_mode_arg_t *arg;
00128 
00129   if (!chan->args && (current_server.type2modes || current_server.type3modes)) {
00130     chan->nargs = strlen(current_server.type2modes) + strlen(current_server.type3modes);
00131     chan->args = calloc(chan->nargs, sizeof(*chan->args));
00132     for (arg = chan->args, c = current_server.type2modes; *c; arg++, c++) {
00133       arg->type = *c;
00134     }
00135     for (c = current_server.type3modes; *c; arg++, c++) {
00136       arg->type = *c;
00137     }
00138   }
00139   for (i = 0; i < chan->nargs; i++) {
00140     if (chan->args[i].type == type) return chan->args+i;
00141   }
00142   return(NULL);
00143 }

int channel_get_int ( channel_t *  chan,
int *  intptr,
  ... 
)

Definition at line 275 of file channels.c.

References NULL, channel::settings, xml_node_get_int(), and xml_node_vlookup().

00276 {
00277   va_list args;
00278   xml_node_t *node;
00279 
00280   va_start(args, intptr);
00281   node = xml_node_vlookup(chan->settings, args, 0);
00282   va_end(args);
00283   return xml_node_get_int(intptr, node, NULL);
00284 }

channel_mask_list_t* channel_get_mask_list ( channel_t *  chan,
int  type 
)

Definition at line 145 of file channels.c.

References current_server, channel::lists, channel::nlists, NULL, and channel_mask_list::type.

00146 {
00147   int i;
00148 
00149   if (!chan->lists && current_server.type1modes) {
00150     chan->nlists = strlen(current_server.type1modes);
00151     chan->lists = calloc(chan->nlists, sizeof(*chan->lists));
00152     for (i = 0; i < chan->nlists; i++) {
00153       chan->lists[i] = calloc(1, sizeof(*chan->lists[i]));
00154       chan->lists[i]->type = current_server.type1modes[i];
00155     }
00156   }
00157 
00158   for (i = 0; i < chan->nlists; i++) {
00159     if (chan->lists[i]->type == type) return(chan->lists[i]);
00160   }
00161   return(NULL);
00162 }

xml_node_t* channel_get_node ( channel_t *  chan,
  ... 
)

Definition at line 286 of file channels.c.

References channel::settings, and xml_node_vlookup().

00287 {
00288   va_list args;
00289   xml_node_t *node;
00290 
00291   va_start(args, chan);
00292   node = xml_node_vlookup(chan->settings, args, 0);
00293   va_end(args);
00294   return(node);
00295 }

void channel_init (  ) 

Definition at line 29 of file channels.c.

References channel_load, nchannels, NULL, and server_config.

00030 {
00031   channel_head = NULL;
00032   nchannels = 0;
00033   channel_load(server_config.chanfile);
00034 }

int channel_load ( const char *  fname  ) 

Definition at line 297 of file channels.c.

References channel_probe, channel::flags, LOG_MISC, xml_node::next_sibling, putlog(), channel::settings, xml_last_error(), xml_node_delete(), xml_node_get_vars(), xml_node_lookup(), xml_node_unlink(), and xml_parse_file().

00298 {
00299   xml_node_t *root = xml_parse_file(fname);
00300   xml_node_t *chan_node, *settings;
00301   channel_t *chan;
00302   char *name;
00303   int flags;
00304 
00305   if (!root) {
00306     putlog(LOG_MISC, "*", "Could not load channel file '%s': %s", fname, xml_last_error());
00307     return(-1);
00308   }
00309 
00310   chan_node = xml_node_lookup(root, 0, "channel", 0, 0);
00311   for (; chan_node; chan_node = chan_node->next_sibling) {
00312     xml_node_get_vars(chan_node, "sin", "name", &name, "flags", &flags, "settings", &settings);
00313     if (!name) continue;
00314     chan = channel_probe(name, 1);
00315     if (settings) {
00316       xml_node_unlink(settings);
00317       xml_node_delete(chan->settings);
00318       chan->settings = settings;
00319     }
00320     chan->flags = flags;
00321   }
00322   return(0);
00323 }

channel_t* channel_lookup ( const char *  chan_name  ) 

Definition at line 97 of file channels.c.

References channel_probe.

00098 {
00099   return channel_probe(chan_name, 0);
00100 }

int channel_mode ( const char *  chan_name,
const char *  nick,
char *  buf 
)

Definition at line 207 of file channels.c.

References channel_probe, current_server, flag_to_str(), channel::member_head, channel_member::mode, channel::mode, channel_member::next, channel_member::nick, and NULL.

00208 {
00209   channel_t *chan;
00210   channel_member_t *m;
00211   flags_t *flags = NULL;
00212 
00213   buf[0] = 0;
00214   chan = channel_probe(chan_name, 0);
00215   if (!chan) return(-1);
00216   if (!nick) flags = &chan->mode;
00217   else {
00218     for (m = chan->member_head; m; m = m->next) {
00219       if (!(current_server.strcmp)(nick, m->nick)) {
00220         flags = &m->mode;
00221         break;
00222       }
00223     }
00224     if (!flags) return(-2);
00225   }
00226   flag_to_str(flags, buf);
00227   return(0);
00228 }

int channel_mode_arg ( const char *  chan_name,
int  type,
const char **  value 
)

Definition at line 230 of file channels.c.

References channel::args, channel_probe, channel::nargs, channel_mode_arg::type, and channel_mode_arg::value.

00231 {
00232   int i;
00233   channel_t *chan;
00234 
00235   chan = channel_probe(chan_name, 0);
00236   if (!chan) return(-1);
00237   for (i = 0; i < chan->nargs; i++) {
00238     if (chan->args[i].type == type) {
00239       *value = chan->args[i].value;
00240       return(0);
00241     }
00242   }
00243   return(-2);
00244 }

void channel_on_connect (  ) 

Definition at line 159 of file channel_events.c.

References channel_get, channel_get_int, channel_head, channel::name, channel::next, NULL, printserv, and SERVER_NORMAL.

00160 {
00161   channel_t *chan;
00162   char *key;
00163   int inactive;
00164 
00165   for (chan = channel_head; chan; chan = chan->next) {
00166     channel_get_int(chan, &inactive, "inactive", 0, NULL);
00167     if (inactive) continue;
00168     channel_get(chan, &key, "key", 0, NULL);
00169     if (key && strlen(key)) printserv(SERVER_NORMAL, "JOIN %s %s", chan->name, key);
00170     else printserv(SERVER_NORMAL, "JOIN %s", chan->name);
00171   }
00172 }

void channel_on_quit ( const char *  nick,
const char *  uhost,
user_t *  u 
)

Definition at line 229 of file channel_events.c.

References channel_head, channel_on_leave, channel::name, and channel::next.

00230 {
00231   channel_t *chan;
00232 
00233   for (chan = channel_head; chan; chan = chan->next) {
00234     channel_on_leave(chan->name, nick, uhost, u);
00235   }
00236 }

channel_t* channel_probe ( const char *  chan_name,
int  create 
)

Definition at line 71 of file channels.c.

References xml_node::name, channel::name, nchannels, channel::next, NULL, channel::prev, channel::settings, and xml_node_new().

00072 {
00073   channel_t *chan, *prev;
00074 
00075   prev = NULL;
00076   for (chan = channel_head; chan; chan = chan->next) {
00077     if (!strcasecmp(chan->name, chan_name)) return(chan);
00078     prev = chan;
00079   }
00080   if (!create) return(NULL);
00081 
00082   /* Create a new channel. */
00083   nchannels++;
00084   chan = calloc(1, sizeof(*chan));
00085   chan->name = strdup(chan_name);
00086   chan->settings = xml_node_new();
00087   chan->settings->name = strdup("settings");
00088 
00089   /* Link to list. */
00090   if (prev) prev->next = chan;
00091   else channel_head = chan;
00092   chan->prev = prev;
00093   return(chan);
00094 }

int channel_remove ( const char *  name  ) 

Definition at line 113 of file channels.c.

References channel_probe, CHANNEL_STATIC, and channel::flags.

00114 {
00115   channel_t *chan;
00116 
00117   chan = channel_probe(name, 0);
00118   if (!chan) return(-1);
00119   chan->flags &= ~CHANNEL_STATIC;
00120   return(0);
00121 }

void channel_reset (  ) 

Definition at line 37 of file channels.c.

References channel_free_online, channel::next, and uhost_cache_reset.

00038 {
00039   channel_t *chan;
00040 
00041   /* Clear out channel list. */
00042   for (chan = channel_head; chan; chan = chan->next) {
00043     channel_free_online(chan);
00044   }
00045   uhost_cache_reset();
00046 }

int channel_save ( const char *  fname  ) 

Definition at line 325 of file channels.c.

References CHANNEL_STATIC, channel::flags, channel::name, xml_node::name, channel::next, channel::settings, XML_INDENT, xml_node_append(), xml_node_delete(), xml_node_new(), xml_node_set_int(), xml_node_set_str(), xml_node_unlink(), and xml_save_file().

00326 {
00327   xml_node_t *root = xml_node_new();
00328   xml_node_t *chan_node;
00329   channel_t *chan;
00330 
00331   if (!fname) fname = "channels.xml";
00332   root->name = strdup("channels");
00333   for (chan = channel_head; chan; chan = chan->next) {
00334     if (!(chan->flags & CHANNEL_STATIC)) continue;
00335 
00336     chan_node = xml_node_new();
00337     chan_node->name = strdup("channel");
00338     xml_node_set_str(chan->name, chan_node, "name", 0, 0);
00339     xml_node_set_int(chan->flags, chan_node, "flags", 0, 0);
00340     xml_node_append(chan_node, chan->settings);
00341     xml_node_append(root, chan_node);
00342   }
00343   xml_save_file(fname, root, XML_INDENT);
00344   for (chan = channel_head; chan; chan = chan->next) {
00345     if (chan->settings) xml_node_unlink(chan->settings);
00346   }
00347   xml_node_delete(root);
00348   return(0);
00349 }

int channel_set ( channel_t *  chan,
const char *  value,
  ... 
)

Definition at line 246 of file channels.c.

References bind_check(), BIND_RET_BREAK, BT_chanset, channel::name, NULL, channel::settings, xml_node_fullname(), xml_node_get_str(), xml_node_set_str(), and xml_node_vlookup().

00247 {
00248   va_list args;
00249   xml_node_t *node;
00250   char *setting, *oldvalue;
00251   int r;
00252 
00253   va_start(args, value);
00254   node = xml_node_vlookup(chan->settings, args, 1);
00255   va_end(args);
00256   setting = xml_node_fullname(node);
00257   xml_node_get_str(&oldvalue, node, NULL);
00258   r = bind_check(BT_chanset, NULL, setting, chan->name, setting, oldvalue, value);
00259   free(setting);
00260   if (!(r & BIND_RET_BREAK)) xml_node_set_str(value, node, NULL);
00261   return(0);
00262 }

void uhost_cache_addref ( const char *  nick,
const char *  uhost 
)

Definition at line 59 of file uhost_cache.c.

References cache, egg_msprintf(), hash_table_find(), hash_table_insert(), uhost_cache_entry_t::nick, NULL, uhost_cache_entry_t::ref_count, str_tolower(), and uhost_cache_entry_t::uhost.

00060 {
00061   char buf[64], *lnick;
00062   uhost_cache_entry_t *cache = NULL;
00063 
00064   lnick = egg_msprintf(buf, sizeof(buf), NULL, "%s", nick);
00065   str_tolower(lnick);
00066   hash_table_find(uhost_cache_ht, lnick, &cache);
00067   if (!cache) {
00068     cache = calloc(1, sizeof(*cache));
00069     cache->nick = strdup(nick);
00070     str_tolower(cache->nick);
00071     if (uhost) cache->uhost = strdup(uhost);
00072     hash_table_insert(uhost_cache_ht, cache->nick, cache);
00073   }
00074   cache->ref_count++;
00075   if (lnick != buf) free(lnick);
00076 }

void uhost_cache_decref ( const char *  nick  ) 

Definition at line 78 of file uhost_cache.c.

References cache, cache_lookup(), hash_table_remove(), match_my_nick, uhost_cache_entry_t::nick, NULL, uhost_cache_entry_t::ref_count, and uhost_cache_delete().

00079 {
00080   uhost_cache_entry_t *cache;
00081 
00082   /* We don't decrement ourselves.. we always know our own host. */
00083   if (match_my_nick(nick)) return;
00084 
00085   cache = cache_lookup(nick);
00086   if (!cache) return;
00087 
00088   cache->ref_count--;
00089   if (cache->ref_count <= 0) {
00090     hash_table_remove(uhost_cache_ht, cache->nick, NULL);
00091     uhost_cache_delete(NULL, &cache, NULL);
00092   }
00093 }

void uhost_cache_destroy (  ) 

Definition at line 22 of file uhost_cache.c.

References hash_table_delete(), hash_table_walk(), NULL, and uhost_cache_delete().

00023 {
00024   hash_table_walk(uhost_cache_ht, uhost_cache_delete, NULL);
00025   hash_table_delete(uhost_cache_ht);
00026 }

void uhost_cache_init (  ) 

Definition at line 10 of file uhost_cache.c.

References hash_table_create(), HASH_TABLE_STRINGS, NULL, and UHOST_CACHE_SIZE.

00011 {
00012   uhost_cache_ht = hash_table_create(NULL, NULL, UHOST_CACHE_SIZE, HASH_TABLE_STRINGS);
00013 }

char* uhost_cache_lookup ( const char *  nick  ) 

Definition at line 50 of file uhost_cache.c.

References cache, cache_lookup(), NULL, and uhost_cache_entry_t::uhost.

00051 {
00052   uhost_cache_entry_t *cache;
00053 
00054   cache = cache_lookup(nick);
00055   if (cache) return(cache->uhost);
00056   return(NULL);
00057 }

void uhost_cache_reset (  ) 

Definition at line 16 of file uhost_cache.c.

References uhost_cache_destroy, and uhost_cache_init.

00017 {
00018   uhost_cache_destroy();
00019   uhost_cache_init();
00020 }

void uhost_cache_swap ( const char *  old_nick,
const char *  new_nick 
)

Definition at line 95 of file uhost_cache.c.

References cache, egg_msprintf(), hash_table_insert(), hash_table_remove(), uhost_cache_entry_t::nick, NULL, str_redup(), and str_tolower().

00096 {
00097   uhost_cache_entry_t *cache;
00098   char buf[64], *lnick;
00099 
00100   lnick = egg_msprintf(buf, sizeof(buf), NULL, "%s", old_nick);
00101   str_tolower(lnick);
00102   hash_table_remove(uhost_cache_ht, lnick, &cache);
00103   if (lnick != buf) free(lnick);
00104 
00105   if (cache) {
00106     str_redup(&cache->nick, new_nick);
00107     str_tolower(cache->nick);
00108     hash_table_insert(uhost_cache_ht, cache->nick, cache);
00109   }
00110 }

Variable Documentation

channel_t* channel_head

Definition at line 26 of file channels.c.

int nchannels

Definition at line 27 of file channels.c.

Generated on Sun Nov 30 18:43:35 2008 for eggdrop1.9 by  doxygen 1.5.6