static int console_pack(struct userrec *u, struct user_entry *e)
{
char work[1024];
struct console_info *ci;
int l;
Assert(e);
Assert(e->u.extra);
Assert(!e->name);
ci = (struct console_info *) e->u.extra;
l = simple_sprintf(work, "%s %s %s %d %d %d",
ci->channel, masktype(ci->conflags),
stripmasktype(ci->stripflags), ci->echoflags,
ci->page, ci->conchan);
e->u.list = user_malloc(sizeof(struct list_type));
e->u.list->next = NULL;
e->u.list->extra = user_malloc(l + 1);
strcpy(e->u.list->extra, work);
nfree(ci->channel);
nfree(ci);
return 1;
}
static int console_unpack(struct userrec *u, struct user_entry *e)
{
struct console_info *ci = user_malloc(sizeof(struct console_info));
char *par, *arg;
Context;
Assert(e);
Assert(e->name);
par = e->u.list->extra;
arg = newsplit(&par);
ci->channel = user_malloc(strlen(arg) + 1);
strcpy(ci->channel, arg);
arg = newsplit(&par);
ci->conflags = logmodes(arg);
arg = newsplit(&par);
ci->stripflags = stripmodes(arg);
arg = newsplit(&par);
ci->echoflags = (arg[0] == '1') ? 1 : 0;
arg = newsplit(&par);
ci->page = atoi(arg);
arg = newsplit(&par);
ci->conchan = atoi(arg);
list_type_kill(e->u.list);
e->u.extra = ci;
return 1;
}
static int botfl_pack(struct userrec *u, struct user_entry *e)
{
char x[100];
struct flag_record fr = {FR_BOT, 0, 0, 0, 0, 0};
fr.bot = e->u.ulong;
e->u.list = user_malloc(sizeof(struct list_type));
e->u.list->next = NULL;
e->u.list->extra = user_malloc (build_flags (x, &fr, NULL) + 1);
strcpy(e->u.list->extra, x);
return 1;
}
int del_note_ignore(struct userrec *u, char *mask)
{
struct user_entry *ue;
struct xtra_key *xk;
char **ignores, *buf = NULL;
int ignoresn, i, size = 0, foundit = 0;
ignoresn = get_note_ignores(u, &ignores);
if (!ignoresn)
return 0;
buf = user_malloc(1);
buf[0] = 0;
for (i = 0; i < ignoresn; i++) {
if (strcmp(ignores[i], mask)) {
size += strlen(ignores[i]);
if (buf[0])
size++;
buf = user_realloc(buf, size + 1);
if (buf[0])
strcat(buf, " ");
strcat(buf, ignores[i]);
} else
foundit = 1;
}
nfree(ignores[0]); /* Free the string buffer */
nfree(ignores); /* Free the ptr array */
/* Entry not found */
if (!foundit) {
nfree(buf);
return 0;
}
ue = find_user_entry(&USERENTRY_XTRA, u);
/* Delete the entry if the buffer is empty */
xk = user_malloc(sizeof(struct xtra_key));
xk->key = user_malloc(strlen(NOTES_IGNKEY) + 1);
xk->next = 0;
if (!buf[0]) {
nfree(buf); /* The allocated byte needs to be free'd too */
strcpy(xk->key, NOTES_IGNKEY);
xk->data = 0;
} else {
xk->data = buf;
strcpy(xk->key, NOTES_IGNKEY);
}
xtra_set(u, ue, xk);
return 1;
}
/* Parse the NOTES_IGNKEY xtra field. You must free the memory allocated
* in here: the buffer 'ignores[0]' and the array 'ignores'.
*/
int get_note_ignores(struct userrec *u, char ***ignores)
{
struct xtra_key *xk;
char *buf, *p;
int ignoresn;
/* Hullo? sanity? */
if (!u)
return 0;
xk = getnotesentry(u);
if (!xk)
return 0;
rmspace(xk->data);
buf = user_malloc(strlen(xk->data) + 1);
strcpy(buf, xk->data);
p = buf;
/* Split up the string into small parts */
*ignores = nmalloc(sizeof(char *) + 100);
**ignores = p;
ignoresn = 1;
while ((p = strchr(p, ' ')) != NULL) {
*ignores = nrealloc(*ignores, sizeof(char *) * (ignoresn + 1));
(*ignores)[ignoresn] = p + 1;
ignoresn++;
*p = 0;
p++;
}
return ignoresn;
}
static void set_handle_chaninfo(struct userrec *bu, char *handle,
char *chname, char *info)
{
struct userrec *u;
struct chanuserrec *ch;
struct chanset_t *cst;
u = get_user_by_handle(bu, handle);
if (!u)
return;
ch = get_chanrec(u, chname);
if (!ch) {
add_chanrec_by_handle(bu, handle, chname);
ch = get_chanrec(u, chname);
}
if (ch->info != NULL)
nfree(ch->info);
if (info && info[0]) {
ch->info = (char *) user_malloc(strlen(info) + 1);
strcpy(ch->info, info);
} else
ch->info = NULL;
cst = findchan_by_dname(chname);
if ((!noshare) && (bu == userlist) &&
!(u->flags & (USER_UNSHARED | USER_BOT)) && share_greet) {
shareout(cst, "chchinfo %s %s %s\n", handle, chname, info ? info : "");
}
}
void main()
{
int *ptr;
user_malloc(ptr);
*ptr = 8;
printf("%d\n", *ptr);
}
int def_pack(struct userrec *u, struct user_entry *e)
{
char *tmp;
tmp = e->u.string;
e->u.list = user_malloc(sizeof(struct list_type));
e->u.list->next = NULL;
e->u.list->extra = tmp;
return 1;
}
int add_note_ignore(struct userrec *u, char *mask)
{
struct xtra_key *xk;
char **ignores;
int ignoresn, i;
ignoresn = get_note_ignores(u, &ignores);
if (ignoresn > 0) {
/* Search for existing mask */
for (i = 0; i < ignoresn; i++)
if (!strcmp(ignores[i], mask)) {
nfree(ignores[0]); /* Free the string buffer */
nfree(ignores); /* Free the ptr array */
/* The mask already exists, exit. */
return 0;
}
nfree(ignores[0]); /* Free the string buffer */
nfree(ignores); /* Free the ptr array */
}
xk = getnotesentry(u);
/* First entry? */
if (!xk) {
struct xtra_key *mxk = user_malloc(sizeof(struct xtra_key));
struct user_entry *ue = find_user_entry(&USERENTRY_XTRA, u);
if (!ue)
return 0;
mxk->next = 0;
mxk->data = user_malloc(strlen(mask) + 1);
strcpy(mxk->data, mask);
mxk->key = user_malloc(strlen(NOTES_IGNKEY) + 1);
strcpy(mxk->key, NOTES_IGNKEY);
xtra_set(u, ue, mxk);
} else { /* ... else, we already have other entries. */
xk->data = user_realloc(xk->data, strlen(xk->data) + strlen(mask) + 2);
strcat(xk->data, " ");
strcat(xk->data, mask);
}
return 1;
}
static int console_tcl_set(Tcl_Interp *irp, struct userrec *u,
struct user_entry *e, int argc, char **argv)
{
struct console_info *i = e->u.extra;
int l;
BADARGS(4, 9, " handle CONSOLE channel flags strip echo page conchan");
if (!i) {
i = user_malloc(sizeof(struct console_info));
egg_bzero(i, sizeof(struct console_info));
}
if (i->channel)
nfree(i->channel);
l = strlen(argv[3]);
if (l > 80)
l = 80;
i->channel = user_malloc(l + 1);
strncpy(i->channel, argv[3], l);
i->channel[l] = 0;
if (argc > 4) {
i->conflags = logmodes(argv[4]);
if (argc > 5) {
i->stripflags = stripmodes(argv[5]);
if (argc > 6) {
i->echoflags = (argv[6][0] == '1') ? 1 : 0;
if (argc > 7) {
i->page = atoi(argv[7]);
if (argc > 8)
i->conchan = atoi(argv[8]);
}
}
}
}
set_user(&USERENTRY_CONSOLE, u, i);
return TCL_OK;
}
void set_user_flagrec(struct userrec *u, struct flag_record *fr,
char *chname)
{
struct chanuserrec *cr = NULL;
int oldflags = fr->match;
char buffer[100];
struct chanset_t *ch;
if (!u)
return;
if (oldflags & FR_GLOBAL) {
u->flags = fr->global;
u->flags_udef = fr->udef_global;
if (!noshare && !(u->flags & USER_UNSHARED)) {
fr->match = FR_GLOBAL;
build_flags(buffer, fr, NULL);
shareout(NULL, "a %s %s\n", u->handle, buffer);
}
}
if ((oldflags & FR_BOT) && (u->flags & USER_BOT))
set_user(&USERENTRY_BOTFL, u, (void *) fr->bot);
/* dont share bot attrs */
if ((oldflags & FR_CHAN) && chname) {
for (cr = u->chanrec; cr; cr = cr->next)
if (!rfc_casecmp(chname, cr->channel))
break;
ch = findchan(chname);
if (!cr && ch) {
cr = user_malloc(sizeof(struct chanuserrec));
bzero(cr, sizeof(struct chanuserrec));
cr->next = u->chanrec;
u->chanrec = cr;
strncpy(cr->channel, chname, 80);
cr->channel[80] = 0;
}
if (cr && ch) {
cr->flags = fr->chan;
cr->flags_udef = fr->udef_chan;
if (!noshare && !(u->flags & USER_UNSHARED) && channel_shared(ch)) {
fr->match = FR_CHAN;
build_flags(buffer, fr, NULL);
shareout(ch, "a %s %s %s\n", u->handle, buffer, chname);
}
}
}
fr->match = oldflags;
}
static struct chanuserrec *add_chanrec(struct userrec *u, char *chname)
{
struct chanuserrec *ch = NULL;
if (findchan_by_dname(chname)) {
ch = user_malloc(sizeof(struct chanuserrec));
ch->next = u->chanrec;
u->chanrec = ch;
ch->info = NULL;
ch->flags = 0;
ch->flags_udef = 0;
ch->laston = 0;
strncpy(ch->channel, chname, 81);
ch->channel[80] = 0;
if (!noshare && !(u->flags & USER_UNSHARED))
shareout(findchan_by_dname(chname), "+cr %s %s\n", u->handle, chname);
}
return ch;
}
dprintf(idx, " Saved Console Settings:\n");
dprintf(idx, " Channel: %s\n", i->channel);
dprintf(idx, " Console flags: %s, Strip flags: %s, Echo: %s\n",
masktype(i->conflags), stripmasktype(i->stripflags),
i->echoflags ? "yes" : "no");
dprintf(idx, " Page setting: %d, Console channel: %s%d\n",
i->page, (i->conchan < 100000) ? "" : "*", i->conchan % 100000);
}
}
static int console_dupuser(struct userrec *new, struct userrec *old,
struct user_entry *e)
{
struct console_info *i = e->u.extra, *j;
j = user_malloc(sizeof(struct console_info));
my_memcpy(j, i, sizeof(struct console_info));
j->channel = user_malloc(strlen(i->channel) + 1);
strcpy(j->channel, i->channel);
return set_user(e->type, new, j);
}
static struct user_entry_type USERENTRY_CONSOLE =
{
NULL, /* always 0 ;) */
NULL,
console_dupuser,
console_unpack,
console_pack,
console_write_userfile,
/* Note: If first char of note is '*' it's a sticky exempt.
*/
static int u_addexempt(struct chanset_t *chan, char *exempt, char *from,
char *note, time_t expire_time, int flags)
{
char host[1024], s[1024];
maskrec *p = NULL, *l, **u = chan ? &chan->exempts : &global_exempts;
strcpy(host, exempt);
/* Choke check: fix broken exempts (must have '!' and '@') */
if ((strchr(host, '!') == NULL) && (strchr(host, '@') == NULL))
strcat(host, "!*@*");
else if (strchr(host, '@') == NULL)
strcat(host, "@*");
else if (strchr(host, '!') == NULL) {
char *i = strchr(host, '@');
strcpy(s, i);
*i = 0;
strcat(host, "!*");
strcat(host, s);
}
for (l = *u; l; l = l->next)
if (!rfc_casecmp(l->mask, host)) {
p = l;
break;
}
/* It shouldn't expire and be sticky also */
if (note[0] == '*') {
flags |= MASKREC_STICKY;
note++;
}
if ((expire_time == 0L) || (flags & MASKREC_PERM)) {
flags |= MASKREC_PERM;
expire_time = 0L;
}
if (p == NULL) {
p = user_malloc(sizeof(maskrec));
p->next = *u;
*u = p;
} else {
nfree(p->mask);
nfree(p->user);
nfree(p->desc);
}
p->expire = expire_time;
p->added = now;
p->lastactive = 0;
p->flags = flags;
p->mask = user_malloc(strlen(host) + 1);
strcpy(p->mask, host);
p->user = user_malloc(strlen(from) + 1);
strcpy(p->user, from);
p->desc = user_malloc(strlen(note) + 1);
strcpy(p->desc, note);
if (!noshare) {
char *mask = str_escape(host, ':', '\\');
if (mask) {
if (!chan)
shareout(NULL, "+e %s %li %s%s %s %s\n", mask, expire_time - now,
(flags & MASKREC_STICKY) ? "s" : "",
(flags & MASKREC_PERM) ? "p" : "-", from, note);
else
shareout(chan, "+ec %s %li %s %s%s %s %s\n", mask, expire_time - now,
chan->dname, (flags & MASKREC_STICKY) ? "s" : "",
(flags & MASKREC_PERM) ? "p" : "-", from, note);
nfree(mask);
}
}
return 1;
}
/* Note: If first char of note is '*' it's a sticky ban.
*/
static int u_addban(struct chanset_t *chan, char *ban, char *from, char *note,
time_t expire_time, int flags)
{
char host[1024], s[1024];
maskrec *p = NULL, *l, **u = chan ? &chan->bans : &global_bans;
module_entry *me;
strcpy(host, ban);
/* Choke check: fix broken bans (must have '!' and '@') */
if ((strchr(host, '!') == NULL) && (strchr(host, '@') == NULL))
strcat(host, "!*@*");
else if (strchr(host, '@') == NULL)
strcat(host, "@*");
else if (strchr(host, '!') == NULL) {
char *i = strchr(host, '@');
strcpy(s, i);
*i = 0;
strcat(host, "!*");
strcat(host, s);
}
if ((me = module_find("server", 0, 0)) && me->funcs) {
simple_sprintf(s, "%s!%s", me->funcs[SERVER_BOTNAME],
me->funcs[SERVER_BOTUSERHOST]);
if (match_addr(host, s)) {
putlog(LOG_MISC, "*", IRC_IBANNEDME);
return 0;
}
}
if (expire_time == now)
return 1;
for (l = *u; l; l = l->next)
if (!rfc_casecmp(l->mask, host)) {
p = l;
break;
}
/* It shouldn't expire and be sticky also */
if (note[0] == '*') {
flags |= MASKREC_STICKY;
note++;
}
if ((expire_time == 0L) || (flags & MASKREC_PERM)) {
flags |= MASKREC_PERM;
expire_time = 0L;
}
if (p == NULL) {
p = user_malloc(sizeof(maskrec));
p->next = *u;
*u = p;
} else {
nfree(p->mask);
nfree(p->user);
nfree(p->desc);
}
p->expire = expire_time;
p->added = now;
p->lastactive = 0;
p->flags = flags;
p->mask = user_malloc(strlen(host) + 1);
strcpy(p->mask, host);
p->user = user_malloc(strlen(from) + 1);
strcpy(p->user, from);
p->desc = user_malloc(strlen(note) + 1);
strcpy(p->desc, note);
if (!noshare) {
char *mask = str_escape(host, ':', '\\');
if (mask) {
if (!chan)
shareout(NULL, "+b %s %li %s%s %s %s\n", mask, expire_time - now,
(flags & MASKREC_STICKY) ? "s" : "",
(flags & MASKREC_PERM) ? "p" : "-", from, note);
else
shareout(chan, "+bc %s %li %s %s%s %s %s\n", mask, expire_time - now,
chan->dname, (flags & MASKREC_STICKY) ? "s" : "",
(flags & MASKREC_PERM) ? "p" : "-", from, note);
nfree(mask);
}
}
return 1;
}
