static void
global_conf_read(void)
{
dict_t conf_node;
const char *str;
if (!(conf_node = conf_get_data(GLOBAL_CONF_NAME, RECDB_OBJECT))) {
log_module(G_LOG, LOG_ERROR, "config node `%s' is missing or has wrong type.", GLOBAL_CONF_NAME);
return;
}
str = database_get_data(conf_node, KEY_DB_BACKUP_FREQ, RECDB_QSTRING);
global_conf.db_backup_frequency = str ? ParseInterval(str) : 7200;
str = database_get_data(conf_node, KEY_ANNOUNCEMENTS_DEFAULT, RECDB_QSTRING);
global_conf.announcements_default = str ? enabled_string(str) : 1;
str = database_get_data(conf_node, KEY_NICK, RECDB_QSTRING);
if(global && str)
NickChange(global, str, 0);
}
/*
* mo_zline - oper message handler
*
* parv[0] = Sender prefix
* parv[1] = [[+|-]<Z-line mask>]
*
* For other parameters, see doc/readme.zline.
*/
int
mo_zline(struct Client *cptr, struct Client *sptr, int parc, char *parv[])
{
struct Client *acptr = 0;
struct Zline *azline = 0;
unsigned int flags = 0;
enum ZlineAction action = ZLINE_MODIFY;
time_t expire = 0;
char *mask = parv[1], *target = 0, *reason = 0, *end;
if (parc < 2)
return zline_list(sptr, 0);
if (*mask == '!') {
mask++;
if (HasPriv(sptr, PRIV_WIDE_ZLINE))
flags |= ZLINE_OPERFORCE;
}
switch (*mask) { /* handle +, -, <, and > */
case '+': /* activate the Z-line */
action = ZLINE_ACTIVATE;
mask++;
break;
case '-': /* deactivate the Z-line */
action = ZLINE_DEACTIVATE;
mask++;
break;
case '>': /* locally activate the Z-line */
action = ZLINE_LOCAL_ACTIVATE;
mask++;
break;
case '<': /* locally deactivate the Z-line */
action = ZLINE_LOCAL_DEACTIVATE;
mask++;
break;
}
/* OK, let's figure out the parameters... */
switch (action) {
case ZLINE_MODIFY: /* no specific action on the Z-line... */
if (parc == 2) /* user wants a listing of a specific Z-line */
return zline_list(sptr, mask);
else if (parc < 4) /* must have target and expire, minimum */
return need_more_params(sptr, "ZLINE");
target = parv[2]; /* get the target... */
if (is_timestamp(parv[3])) {
expire = strtol(parv[3], &end, 10) + TStime(); /* and the expiration */
if (*end != '\0')
return send_reply(sptr, SND_EXPLICIT | ERR_BADEXPIRE, "%s :Bad expire time", parv[3]);
} else
expire = ParseInterval(parv[3]) + TStime();
flags |= ZLINE_EXPIRE; /* remember that we got an expire time */
if (parc > 4) { /* also got a reason... */
reason = parv[parc - 1];
flags |= ZLINE_REASON;
}
/* target is not global, interpolate action and require reason */
if (target[0] != '*' || target[1] != '\0') {
if (!reason) /* have to have a reason for this */
return need_more_params(sptr, "ZLINE");
action = ZLINE_ACTIVATE;
}
break;
case ZLINE_LOCAL_ACTIVATE: /* locally activate a Z-line */
case ZLINE_LOCAL_DEACTIVATE: /* locally deactivate a Z-line */
if (parc > 2) { /* if target is available, pick it */
target = parv[2];
if (target[0] == '*' && target[1] == '\0')
return send_reply(sptr, ERR_NOSUCHSERVER, target);
}
break;
case ZLINE_ACTIVATE: /* activating/adding a Z-line */
case ZLINE_DEACTIVATE: /* deactivating/removing a Z-line */
if (parc < 3)
return need_more_params(sptr, "ZLINE");
if (parc > 3) {
/* get expiration and target */
reason = parv[parc - 1];
if (is_timestamp(parv[parc - 2])) {
expire = strtol(parv[parc - 2], &end, 10) + TStime();
if (*end != '\0')
return send_reply(sptr, SND_EXPLICIT | ERR_BADEXPIRE, "%s :Bad expire time", parv[parc - 2]);
} else
expire = ParseInterval(parv[parc - 2]) + TStime();
flags |= ZLINE_EXPIRE | ZLINE_REASON; /* remember that we got 'em */
if (parc > 4) /* also have a target! */
target = parv[2];
} else {
target = parv[2]; /* target has to be present, and has to be '*' */
if (target[0] != '*' || target[1] != '\0')
return need_more_params(sptr, "ZLINE");
}
break;
}
/* Is there no mask left? */
if (mask[0] == '\0')
return need_more_params(sptr, "ZLINE");
/* Now let's figure out which is the target server */
if (!target) /* no target, has to be me... */
acptr = &me;
/* if it's not '*', look up the server */
else if ((target[0] != '*' || target[1] != '\0') &&
!(acptr = find_match_server(target)))
return send_reply(sptr, ERR_NOSUCHSERVER, target);
/* Z-line deprecation notice */
sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :Use of Z-line is deprecated. "
" Please use G-line instead.", sptr);
/* Now, is the Z-line local or global? */
if (action == ZLINE_LOCAL_ACTIVATE || action == ZLINE_LOCAL_DEACTIVATE ||
!acptr)
flags |= ZLINE_GLOBAL;
else /* it's some form of local Z-line */
flags |= ZLINE_LOCAL;
/* If it's a local activate/deactivate and server isn't me, propagate it */
if ((action == ZLINE_LOCAL_ACTIVATE || action == ZLINE_LOCAL_DEACTIVATE) &&
!IsMe(acptr)) {
/* check for permissions... */
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "ZLINE");
else if (!HasPriv(sptr, PRIV_ZLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
Debug((DEBUG_DEBUG, "I am forwarding a local change to a global zline "
"to a remote server; target %s, mask %s, operforce %s, action %c",
cli_name(acptr), mask, flags & ZLINE_OPERFORCE ? "YES" : "NO",
action == ZLINE_LOCAL_ACTIVATE ? '>' : '<'));
sendcmdto_one(sptr, CMD_ZLINE, acptr, "%C %s%c%s", acptr,
flags & ZLINE_OPERFORCE ? "!" : "",
action == ZLINE_LOCAL_ACTIVATE ? '>' : '<', mask);
return 0; /* all done */
}
/* Next, try to find the Z-line... */
if ((flags & ZLINE_GLOBAL) || IsMe(acptr)) /* don't bother if it's not me! */
azline = zline_find(mask, flags | ZLINE_ANY | ZLINE_EXACT);
/* We now have all the pieces to tell us what we've got; let's put
* it all together and convert the rest of the arguments.
*/
/* Handle the local Z-lines first... */
if (flags & ZLINE_LOCAL) {
assert(acptr);
/* normalize the action, first */
if (action == ZLINE_LOCAL_ACTIVATE || action == ZLINE_MODIFY)
action = ZLINE_ACTIVATE;
else if (action == ZLINE_LOCAL_DEACTIVATE)
action = ZLINE_DEACTIVATE;
/* If it's not for us, forward */
/* UPDATE NOTE: Once all servers are updated to u2.10.12.11, the
* format string in this sendcmdto_one() may be updated to omit
* <lastmod> for ZLINE_ACTIVATE and to omit <expire>, <lastmod>,
* and <reason> for ZLINE_DEACTIVATE.
*/
if (!IsMe(acptr)) {
/* check for permissions... */
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "ZLINE");
else if (!HasPriv(sptr, PRIV_ZLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
Debug((DEBUG_DEBUG, "I am forwarding a local Z-line to a remote "
"server; target %s, mask %s, operforce %s, action %c, "
"expire %Tu, reason %s", target, mask,
flags & ZLINE_OPERFORCE ? "YES" : "NO",
action == ZLINE_ACTIVATE ? '+' : '-', expire, reason));
sendcmdto_one(sptr, CMD_ZLINE, acptr, "%C %s%c%s %Tu %Tu :%s",
acptr, flags & ZLINE_OPERFORCE ? "!" : "",
action == ZLINE_ACTIVATE ? '+' : '-', mask,
expire - TStime(), TStime(), reason);
return 0; /* all done */
}
/* check local Z-line permissions... */
if (!HasPriv(sptr, PRIV_LOCAL_ZLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
/* let's handle activation... */
if (action == ZLINE_ACTIVATE) {
if (azline) /* Z-line already exists, so let's ignore it... */
return 0;
/* OK, create the local Z-line */
Debug((DEBUG_DEBUG, "I am creating a local Z-line here; target %s, "
"mask %s, operforce %s, action %s, expire %Tu, reason: %s",
target, mask, flags & ZLINE_OPERFORCE ? "YES" : "NO",
action == ZLINE_ACTIVATE ? "+" : "-", expire, reason));
return zline_add(cptr, sptr, mask, reason, expire, 0, 0,
flags | ZLINE_ACTIVE);
} else { /* OK, it's a deactivation/destruction */
if (!azline) /* Z-line doesn't exist, so let's complain... */
return send_reply(sptr, ERR_NOSUCHZLINE, mask);
/* Let's now destroy the Z-line */
Debug((DEBUG_DEBUG, "I am destroying a local Z-line here; target %s, "
"mask %s, operforce %s, action %s", target, mask,
flags & ZLINE_OPERFORCE ? "YES" : "NO",
action == ZLINE_ACTIVATE ? "+" : "-"));
return zline_destroy(cptr, sptr, azline);
}
}
/* can't modify a Z-line that doesn't exist...
* (and if we are creating a new one, we need a reason and expiration)
*/
if (!azline &&
(action == ZLINE_MODIFY || action == ZLINE_LOCAL_ACTIVATE ||
action == ZLINE_LOCAL_DEACTIVATE || !reason || !expire))
return send_reply(sptr, ERR_NOSUCHZLINE, mask);
/* check for Z-line permissions... */
if (action == ZLINE_LOCAL_ACTIVATE || action == ZLINE_LOCAL_DEACTIVATE) {
/* only need local privileges for locally-limited status changes */
if (!HasPriv(sptr, PRIV_LOCAL_ZLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
} else { /* global privileges required */
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "ZLINE");
else if (!HasPriv(sptr, PRIV_ZLINE))
return send_reply(sptr, ERR_NOPRIVILEGES);
}
Debug((DEBUG_DEBUG, "I have a global Z-line I am acting upon now; "
"target %s, mask %s, operforce %s, action %s, expire %Tu, "
"reason: %s; zline %s! (fields present: %s %s)", target,
mask, flags & ZLINE_OPERFORCE ? "YES" : "NO",
action == ZLINE_ACTIVATE ? "+" :
(action == ZLINE_DEACTIVATE ? "-" :
(action == ZLINE_LOCAL_ACTIVATE ? ">" :
(action == ZLINE_LOCAL_DEACTIVATE ? "<" : "(MODIFY)"))),
expire, reason, azline ? "EXISTS" : "does not exist",
flags & ZLINE_EXPIRE ? "expire" : "",
flags & ZLINE_REASON ? "reason" : ""));
if (azline) /* modifying an existing Z-line */
return zline_modify(cptr, sptr, azline, action, reason, expire,
TStime(), 0, flags);
assert(action != ZLINE_LOCAL_ACTIVATE);
assert(action != ZLINE_LOCAL_DEACTIVATE);
assert(action != ZLINE_MODIFY);
/* create a new Z-line */
return zline_add(cptr, sptr, mask, reason, expire, TStime(), 0,
flags | ((action == ZLINE_ACTIVATE) ? ZLINE_ACTIVE : 0));
}
void
SynchronizeFile(const char *dpath, const char *fileName, const char *userName)
{
CronFile **pfile;
CronFile *file;
int maxEntries;
int maxLines;
char buf[RW_BUFFER]; /* max length for crontab lines */
char *path;
FILE *fi;
/*
* Limit entries
*/
if (strcmp(userName, "root") == 0)
maxEntries = 65535;
else
maxEntries = MAXLINES;
maxLines = maxEntries * 10;
/*
* Delete any existing copy of this CronFile
*/
pfile = &FileBase;
while ((file = *pfile) != NULL) {
if (file->cf_Deleted == 0 && strcmp(file->cf_DPath, dpath) == 0 &&
strcmp(file->cf_FileName, fileName) == 0
) {
DeleteFile(pfile);
} else {
pfile = &file->cf_Next;
}
}
if (!(path = concat(dpath, "/", fileName, NULL))) {
errno = ENOMEM;
perror("SynchronizeFile");
exit(1);
}
if ((fi = fopen(path, "r")) != NULL) {
struct stat sbuf;
if (fstat(fileno(fi), &sbuf) == 0 && sbuf.st_uid == DaemonUid) {
CronFile *file = calloc(1, sizeof(CronFile));
CronLine **pline;
time_t tnow = time(NULL);
tnow -= tnow % 60;
file->cf_UserName = strdup(userName);
file->cf_FileName = strdup(fileName);
file->cf_DPath = strdup(dpath);
pline = &file->cf_LineBase;
/* fgets reads at most size-1 chars until \n or EOF, then adds a\0; \n if present is stored in buf */
while (fgets(buf, sizeof(buf), fi) != NULL && --maxLines) {
CronLine line;
char *ptr = buf;
int len;
while (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')
++ptr;
len = strlen(ptr);
if (len && ptr[len-1] == '\n')
ptr[--len] = 0;
if (*ptr == 0 || *ptr == '#')
continue;
if (--maxEntries == 0)
break;
memset(&line, 0, sizeof(line));
if (DebugOpt)
printlogf(LOG_DEBUG, "User %s Entry %s\n", userName, buf);
if (*ptr == '@') {
/*
* parse @hourly, etc
*/
int j;
line.cl_Delay = -1;
ptr += 1;
for (j = 0; FreqAry[j]; ++j) {
if (strncmp(ptr, FreqAry[j], strlen(FreqAry[j])) == 0) {
break;
}
}
if (FreqAry[j]) {
ptr += strlen(FreqAry[j]);
switch(j) {
case 0:
/* noauto */
line.cl_Freq = -2;
line.cl_Delay = 0;
break;
case 1:
/* reboot */
line.cl_Freq = -1;
line.cl_Delay = 0;
break;
case 2:
line.cl_Freq = HOURLY_FREQ;
break;
case 3:
line.cl_Freq = DAILY_FREQ;
break;
case 4:
line.cl_Freq = WEEKLY_FREQ;
break;
case 5:
line.cl_Freq = MONTHLY_FREQ;
break;
case 6:
line.cl_Freq = YEARLY_FREQ;
break;
/* else line.cl_Freq will remain 0 */
}
}
if (!line.cl_Freq || (*ptr != ' ' && *ptr != '\t')) {
printlogf(LOG_WARNING, "failed parsing crontab for user %s: %s\n", userName, buf);
continue;
}
if (line.cl_Delay < 0) {
/*
* delays on @daily, @hourly, etc are 1/20 of the frequency
* so they don't all start at once
* this also affects how they behave when the job returns EAGAIN
*/
line.cl_Delay = line.cl_Freq / 20;
line.cl_Delay -= line.cl_Delay % 60;
if (line.cl_Delay == 0)
line.cl_Delay = 60;
/* all minutes are permitted */
for (j=0; j<60; ++j)
line.cl_Mins[j] = 1;
for (j=0; j<24; ++j)
line.cl_Hrs[j] = 1;
for (j=1; j<32; ++j)
/* days are numbered 1..31 */
line.cl_Days[j] = 1;
for (j=0; j<12; ++j)
line.cl_Mons[j] = 1;
}
while (*ptr == ' ' || *ptr == '\t')
++ptr;
} else {
/*
* parse date ranges
*/
ptr = ParseField(file->cf_UserName, line.cl_Mins, 60, 0, 1,
NULL, ptr);
ptr = ParseField(file->cf_UserName, line.cl_Hrs, 24, 0, 1,
NULL, ptr);
ptr = ParseField(file->cf_UserName, line.cl_Days, 32, 0, 1,
NULL, ptr);
ptr = ParseField(file->cf_UserName, line.cl_Mons, 12, -1, 1,
MonAry, ptr);
ptr = ParseField(file->cf_UserName, line.cl_Dow, 7, 0, 31,
DowAry, ptr);
/*
* check failure
*/
if (ptr == NULL)
continue;
/*
* fix days and dow - if one is not * and the other
* is *, the other is set to 0, and vise-versa
*/
FixDayDow(&line);
}
/* check for ID=... and AFTER=... and FREQ=... */
do {
if (strncmp(ptr, ID_TAG, strlen(ID_TAG)) == 0) {
if (line.cl_JobName) {
/* only assign ID_TAG once */
printlogf(LOG_WARNING, "failed parsing crontab for user %s: repeated %s\n", userName, ptr);
ptr = NULL;
} else {
ptr += strlen(ID_TAG);
/*
* name = strsep(&ptr, seps):
* return name = ptr, and if ptr contains sep chars, overwrite first with 0 and point ptr to next char
* else set ptr=NULL
*/
if (!(line.cl_Description = concat("job ", strsep(&ptr, " \t"), NULL))) {
errno = ENOMEM;
perror("SynchronizeFile");
exit(1);
}
line.cl_JobName = line.cl_Description + 4;
if (!ptr)
printlogf(LOG_WARNING, "failed parsing crontab for user %s: no command after %s%s\n", userName, ID_TAG, line.cl_JobName);
}
} else if (strncmp(ptr, FREQ_TAG, strlen(FREQ_TAG)) == 0) {
if (line.cl_Freq) {
/* only assign FREQ_TAG once */
printlogf(LOG_WARNING, "failed parsing crontab for user %s: repeated %s\n", userName, ptr);
ptr = NULL;
} else {
char *base = ptr;
ptr += strlen(FREQ_TAG);
ptr = ParseInterval(&line.cl_Freq, ptr);
if (ptr && *ptr == '/')
ptr = ParseInterval(&line.cl_Delay, ++ptr);
else
line.cl_Delay = line.cl_Freq;
if (!ptr) {
printlogf(LOG_WARNING, "failed parsing crontab for user %s: %s\n", userName, base);
} else if (*ptr != ' ' && *ptr != '\t') {
printlogf(LOG_WARNING, "failed parsing crontab for user %s: no command after %s\n", userName, base);
ptr = NULL;
}
}
} else if (strncmp(ptr, WAIT_TAG, strlen(WAIT_TAG)) == 0) {
if (line.cl_Waiters) {
/* only assign WAIT_TAG once */
printlogf(LOG_WARNING, "failed parsing crontab for user %s: repeated %s\n", userName, ptr);
ptr = NULL;
} else {
short more = 1;
char *name;
ptr += strlen(WAIT_TAG);
do {
CronLine *job, **pjob;
if (strcspn(ptr,",") < strcspn(ptr," \t"))
name = strsep(&ptr, ",");
else {
more = 0;
name = strsep(&ptr, " \t");
}
if (!ptr || *ptr == 0) {
/* unexpectedly this was the last token in buf; so abort */
printlogf(LOG_WARNING, "failed parsing crontab for user %s: no command after %s%s\n", userName, WAIT_TAG, name);
ptr = NULL;
} else {
int waitfor = 0;
char *w, *wsave;
if ((w = strchr(name, '/')) != NULL) {
wsave = w++;
w = ParseInterval(&waitfor, w);
if (!w || *w != 0) {
printlogf(LOG_WARNING, "failed parsing crontab for user %s: %s%s\n", userName, WAIT_TAG, name);
ptr = NULL;
} else
/* truncate name */
*wsave = 0;
}
if (ptr) {
/* look for a matching CronLine */
pjob = &file->cf_LineBase;
while ((job = *pjob) != NULL) {
if (job->cl_JobName && strcmp(job->cl_JobName, name) == 0) {
CronWaiter *waiter = malloc(sizeof(CronWaiter));
CronNotifier *notif = malloc(sizeof(CronNotifier));
waiter->cw_Flag = -1;
waiter->cw_MaxWait = waitfor;
waiter->cw_NotifLine = job;
waiter->cw_Notifier = notif;
waiter->cw_Next = line.cl_Waiters; /* add to head of line.cl_Waiters */
line.cl_Waiters = waiter;
notif->cn_Waiter = waiter;
notif->cn_Next = job->cl_Notifs; /* add to head of job->cl_Notifs */
job->cl_Notifs = notif;
break;
} else
pjob = &job->cl_Next;
}
if (!job) {
printlogf(LOG_WARNING, "failed parsing crontab for user %s: unknown job %s\n", userName, name);
/* we can continue parsing this line, we just don't install any CronWaiter for the requested job */
}
}
}
} while (ptr && more);
}
} else
break;
if (!ptr)
break;
while (*ptr == ' ' || *ptr == '\t')
++ptr;
} while (!line.cl_JobName || !line.cl_Waiters || !line.cl_Freq);
if (line.cl_JobName && (!ptr || *line.cl_JobName == 0)) {
/* we're aborting, or ID= was empty */
free(line.cl_Description);
line.cl_Description = NULL;
line.cl_JobName = NULL;
}
if (ptr && line.cl_Delay > 0 && !line.cl_JobName) {
printlogf(LOG_WARNING, "failed parsing crontab for user %s: writing timestamp requires job %s to be named\n", userName, ptr);
ptr = NULL;
}
if (!ptr) {
/* couldn't parse so we abort; free any cl_Waiters */
if (line.cl_Waiters) {
CronWaiter **pwaiters, *waiters;
pwaiters = &line.cl_Waiters;
while ((waiters = *pwaiters) != NULL) {
*pwaiters = waiters->cw_Next;
/* leave the Notifier allocated but disabled */
waiters->cw_Notifier->cn_Waiter = NULL;
free(waiters);
}
}
continue;
}
/* now we've added any ID=... or AFTER=... */
/*
* copy command string
*/
line.cl_Shell = strdup(ptr);
if (line.cl_Delay > 0) {
if (!(line.cl_Timestamp = concat(TSDir, "/", userName, ".", line.cl_JobName, NULL))) {
errno = ENOMEM;
perror("SynchronizeFile");
exit(1);
}
line.cl_NotUntil = tnow + line.cl_Delay;
}
if (line.cl_JobName) {
if (DebugOpt)
printlogf(LOG_DEBUG, " Command %s Job %s\n", line.cl_Shell, line.cl_JobName);
} else {
/* when cl_JobName is NULL, we point cl_Description to cl_Shell */
line.cl_Description = line.cl_Shell;
if (DebugOpt)
printlogf(LOG_DEBUG, " Command %s\n", line.cl_Shell);
}
*pline = calloc(1, sizeof(CronLine));
/* copy working CronLine to newly allocated one */
**pline = line;
pline = &((*pline)->cl_Next);
}
*pline = NULL;
file->cf_Next = FileBase;
FileBase = file;
if (maxLines == 0 || maxEntries == 0)
printlogf(LOG_WARNING, "maximum number of lines reached for user %s\n", userName);
}
fclose(fi);
}
free(path);
}
/*
* mo_jupe - oper message handler
*
* parv[0] = Send prefix
* parv[1] = [[+|-]<server name>]
*
* Local (to me) style:
*
* parv[2] = [Expiration offset]
* parv[3] = [Comment]
*
* Global (or remote local) style:
*
* parv[2] = [target]
* parv[3] = [Expiration offset]
* parv[4] = [Comment]
*
*/
int mo_jupe(struct Client* cptr, struct Client* sptr, int parc, char* parv[])
{
struct Client *acptr = 0;
struct Jupe *ajupe;
unsigned int flags = 0;
time_t expire_off;
char *server = parv[1], *target = 0, *reason;
if (parc < 2)
return jupe_list(sptr, 0);
if (*server == '+') {
flags |= JUPE_ACTIVE;
server++;
} else if (*server == '-')
server++;
else
return jupe_list(sptr, server);
if (!feature_bool(FEAT_CONFIG_OPERCMDS))
return send_reply(sptr, ERR_DISABLED, "JUPE");
if (parc == 4) {
if (is_timestamp(parv[2])) {
expire_off = atoi(parv[2]);
} else {
expire_off = ParseInterval(parv[2]);
}
reason = parv[3];
flags |= JUPE_LOCAL;
} else if (parc > 4) {
target = parv[2];
if (is_timestamp(parv[3])) {
expire_off = atoi(parv[3]);
} else {
expire_off = ParseInterval(parv[3]);
}
reason = parv[4];
} else
return need_more_params(sptr, "JUPE");
if (target) {
if (!(target[0] == '*' && target[1] == '\0')) {
if (!(acptr = find_match_server(target)))
return send_reply(sptr, ERR_NOSUCHSERVER, target);
if (!IsMe(acptr)) { /* manually propagate, since we don't set it */
if (!HasPriv(sptr, PRIV_JUPE))
return send_reply(sptr, ERR_NOPRIVILEGES);
sendcmdto_one(sptr, CMD_JUPE, acptr, "%C %c%s %s %Tu :%s", acptr,
flags & JUPE_ACTIVE ? '+' : '-', server, parv[3],
TStime(), reason);
return 0;
} else if (!HasPriv(sptr, PRIV_LOCAL_JUPE))
return send_reply(sptr, ERR_NOPRIVILEGES);
flags |= JUPE_LOCAL;
} else if (!HasPriv(sptr, PRIV_JUPE))
return send_reply(sptr, ERR_NOPRIVILEGES);
}
ajupe = jupe_find(server);
if (ajupe) {
if (JupeIsLocal(ajupe) && !(flags & JUPE_LOCAL)) /* global over local */
jupe_free(ajupe);
else {
if (flags & JUPE_ACTIVE)
return jupe_activate(cptr, sptr, ajupe, TStime(), flags);
else
return jupe_deactivate(cptr, sptr, ajupe, TStime(), flags);
}
}
return jupe_add(cptr, sptr, server, reason, expire_off, TStime(), flags);
}
static struct globalMessage*
message_create(struct userNode *user, unsigned int argc, char *argv[])
{
unsigned long duration = 0;
char *text = NULL;
char *sender;
long flags = 0;
unsigned int i;
sender = user->handle_info->handle;
for(i = 0; i < argc; i++)
{
if((i + 1) > argc)
{
global_notice(user, "MSG_MISSING_PARAMS", argv[argc]);
return NULL;
}
if(!irccasecmp(argv[i], "text"))
{
i++;
text = unsplit_string(argv + i, argc - i, NULL);
break;
} else if (!irccasecmp(argv[i], "sourceless")) {
i++;
flags |= MESSAGE_OPTION_SOURCELESS;
} else if (!irccasecmp(argv[i], "target")) {
i++;
if(!irccasecmp(argv[i], "all")) {
flags |= MESSAGE_RECIPIENT_ALL;
} else if(!irccasecmp(argv[i], "authed")) {
flags |= MESSAGE_RECIPIENT_AUTHED;
} else if(!irccasecmp(argv[i], "users")) {
flags |= MESSAGE_RECIPIENT_LUSERS;
} else if(!irccasecmp(argv[i], "helpers")) {
flags |= MESSAGE_RECIPIENT_HELPERS;
} else if(!irccasecmp(argv[i], "opers")) {
flags |= MESSAGE_RECIPIENT_OPERS;
} else if(!irccasecmp(argv[i], "staff") || !irccasecmp(argv[i], "privileged")) {
flags |= MESSAGE_RECIPIENT_STAFF;
} else if(!irccasecmp(argv[i], "channels")) {
flags |= MESSAGE_RECIPIENT_CHANNELS;
} else if(!irccasecmp(argv[i], "rchannels")) {
flags |= MESSAGE_RECIPIENT_RCHANNELS;
} else if(!irccasecmp(argv[i], "announcement") || !irccasecmp(argv[i], "announce")) {
flags |= MESSAGE_RECIPIENT_ANNOUNCE;
} else {
global_notice(user, "GMSG_INVALID_TARGET", argv[i]);
return NULL;
}
} else if (irccasecmp(argv[i], "duration") == 0) {
duration = ParseInterval(argv[++i]);
} else if (irccasecmp(argv[i], "from") == 0) {
sender = argv[++i];
} else {
global_notice(user, "MSG_INVALID_CRITERIA", argv[i]);
return NULL;
}
}
if(!flags)
{
flags = MESSAGE_RECIPIENT_LUSERS;
}
if(!text) {
global_notice(user, "GMSG_MESSAGE_REQUIRED");
return NULL;
}
return message_add(flags, now, duration, sender, text);
}
