static char *get_path(struct emailinfo *ep, struct emailinfo *ep2)
{
char *path = "";
if (ep2->subdir && ep2->subdir != ep->subdir)
trio_asprintf(&path, "%s%s", ep2->subdir->rel_path_to_top, ep2->subdir->subdir);
return path;
}
char *messageindex_name(void)
{
char *buf;
trio_asprintf(&buf, "%s%s", set_dir, "msgindex");
return (buf);
}
char *htmlfilename(const char *file, struct emailinfo *email, const char *suffix)
{
char *buf;
trio_asprintf(&buf, "%s%s%s%s", email && email->subdir ? email->subdir->full_path : set_dir, file, *suffix ? "." : "", suffix);
return buf;
}
char *haofname(struct emailinfo *email)
{
char *buf;
trio_asprintf(&buf, "%s%s", email && email->subdir ? email->subdir->full_path : set_dir, HAOF_NAME);
return buf;
}
char *articlehtmlfilename(struct emailinfo *email)
{
char *buf;
char *name;
name = message_name(email);
trio_asprintf(&buf, "%s%s.%s", email->subdir ? email->subdir->full_path : set_dir, name, set_htmlsuffix);
return buf;
}
int edg_wll_SetServerState(edg_wll_Context ctx,const char *name,const char *val)
{
char *stmt = NULL;
int sql_retval;
// Check if record exists
trio_asprintf(&stmt,"select value from server_state "
"where prefix = 'https://%|Ss:%d' and name = '%|Ss'",
ctx->srvName,ctx->srvPort,name);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
sql_retval = edg_wll_ExecSQL(ctx,stmt,NULL);
free(stmt);
if (!sql_retval) {
trio_asprintf(&stmt,"insert into server_state (prefix,name,value) "
"values ('https://%|Ss:%d','%|Ss','%|Ss')",
ctx->srvName,ctx->srvPort,name,val);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
edg_wll_ExecSQL(ctx,stmt,NULL);
free(stmt);
}
else {
if (sql_retval > 0) {
trio_asprintf(&stmt,"update server_state set value = '%|Ss' "
"where prefix = 'https://%|Ss:%d' "
"and name = '%|Ss'",
val,ctx->srvName,ctx->srvPort,name);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB,
LOG_PRIORITY_DEBUG, stmt);
edg_wll_ExecSQL(ctx,stmt,NULL);
free(stmt);
}
else abort();
}
return edg_wll_Error(ctx,NULL,NULL);
}
int unset_server_flag(edg_wll_Context ctx, glite_jobid_const_t job)
{
char *stmt = NULL;
char *dbjob;
edg_wll_ResetError(ctx);
dbjob = glite_jobid_getUnique(job);
trio_asprintf(&stmt,"update jobs set server='0' where jobid='%|Ss'", dbjob);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
free(dbjob);
return(edg_wll_ExecSQL(ctx,stmt,NULL));
}
int edg_wll_NotifExpired(edg_wll_Context ctx,const char *notif)
{
char *dn = NULL,*dj = NULL;
trio_asprintf(&dn,"delete from notif_registrations where notifid='%|Ss'",notif);
trio_asprintf(&dj,"delete from notif_jobs where notifid='%|Ss'",notif);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, dn);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, dj);
if (edg_wll_ExecSQL(ctx,dn,NULL) < 0 ||
edg_wll_ExecSQL(ctx,dj,NULL) < 0)
{
char *et,*ed;
edg_wll_Error(ctx,&et,&ed);
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_WARN,
"delete notification %s: %s (%s)", notif, et, ed);
free(et); free(ed);
}
free(dn);
free(dj);
return edg_wll_ResetError(ctx);
}
int job_exists(edg_wll_Context ctx, glite_jobid_const_t job) {
char *stmt, *dbjob;
int retval;
edg_wll_ResetError(ctx);
if (check_strict_jobid(ctx, job)) return 0;
dbjob = glite_jobid_getUnique(job);
trio_asprintf(&stmt, "SELECT jobid FROM jobs WHERE jobid='%|Ss'", dbjob);
retval = edg_wll_ExecSQL(ctx, stmt, NULL);
free(dbjob);
free(stmt);
return retval;
}
int edg_wll_GetServerState(edg_wll_Context ctx,const char *name,char **val)
{
char *stmt = NULL;
glite_lbu_Statement q = NULL;
trio_asprintf(&stmt,"select value from server_state "
"where prefix = 'https://%|Ss:%d' and name = '%|Ss'",
ctx->srvName,ctx->srvPort,name);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
switch (edg_wll_ExecSQL(ctx,stmt,&q)) {
case 0: edg_wll_SetError(ctx,ENOENT,name); break;
case -1: break;
default: edg_wll_FetchRow(ctx,q,sizeof(val)/sizeof(val[0]),NULL,val); break;
}
glite_lbu_FreeStmt(&q);
free(stmt);
return edg_wll_Error(ctx,NULL,NULL);
}
char * set_component_seqcode(char *a,edg_wll_Source index,int val)
{
unsigned int c[EDG_WLL_SOURCE__LAST];
int res;
char *ret;
char sc[EDG_WLL_SEQ_SIZE];
if (!strstr(a, "LBS")) snprintf(sc,EDG_WLL_SEQ_SIZE,"%s:LBS=000000",a);
else snprintf(sc,EDG_WLL_SEQ_SIZE,"%s",a);
res = sscanf(sc, EDG_WLL_SEQ_FORMAT_SCANF,
&c[EDG_WLL_SOURCE_USER_INTERFACE],
&c[EDG_WLL_SOURCE_NETWORK_SERVER],
&c[EDG_WLL_SOURCE_WORKLOAD_MANAGER],
&c[EDG_WLL_SOURCE_BIG_HELPER],
&c[EDG_WLL_SOURCE_JOB_SUBMISSION],
&c[EDG_WLL_SOURCE_LOG_MONITOR],
&c[EDG_WLL_SOURCE_LRMS],
&c[EDG_WLL_SOURCE_APPLICATION],
&c[EDG_WLL_SOURCE_LB_SERVER]);
if (res != EDG_WLL_SEQ_FORMAT_NUMBER) {
/* FIXME: syslog(LOG_ERR, "unparsable sequence code %s\n", sc); */
fprintf(stderr, "unparsable sequence code %s\n", sc);
return NULL;
}
c[index] = val;
trio_asprintf(&ret, EDG_WLL_SEQ_FORMAT_PRINTF,
c[EDG_WLL_SOURCE_USER_INTERFACE],
c[EDG_WLL_SOURCE_NETWORK_SERVER],
c[EDG_WLL_SOURCE_WORKLOAD_MANAGER],
c[EDG_WLL_SOURCE_BIG_HELPER],
c[EDG_WLL_SOURCE_JOB_SUBMISSION],
c[EDG_WLL_SOURCE_LOG_MONITOR],
c[EDG_WLL_SOURCE_LRMS],
c[EDG_WLL_SOURCE_APPLICATION],
c[EDG_WLL_SOURCE_LB_SERVER]);
return ret;
}
static int flush_bufferd_insert(glite_lbu_bufInsert bi)
{
char *stmt, *vals, *temp;
long i;
if (!bi->rec_num)
return STATUS(bi->ctx);
asprintf(&vals,"(%s)", bi->rows[0]);
for (i=1; i < bi->rec_num; i++) {
// XXX: use string add (preallocated memory)
asprintf(&temp,"%s,(%s)", vals, bi->rows[i]);
free(vals); vals = temp; temp = NULL;
free(bi->rows[i]);
bi->rows[i] = NULL;
}
trio_asprintf(&stmt, "insert into %|Ss(%|Ss) values %s;",
bi->table_name, bi->columns, vals);
glite_common_log_msg(bi->ctx->log_category, LOG_PRIORITY_DEBUG, stmt);
if (glite_lbu_ExecSQL(bi->ctx,stmt,NULL) < 0) {
if (STATUS(bi->ctx) == EEXIST)
CLR_ERR(bi->ctx);
}
/* reset bi counters */
bi->rec_size = 0;
bi->rec_num = 0;
free(vals);
free(stmt);
return STATUS(bi->ctx);
}
int main(int argc, char **argv)
{
int i, use_stdin, use_mbox;
char *configfile = NULL;
char **tlang, *locale_code;
int cmd_show_variables;
int print_usage;
int amount_old = 0; /* number of old mails */
int amount_new = 0; /* number of new mails */
#ifdef HAVE_LOCALE_H
setlocale(LC_ALL, "");
#endif
lockfile[0] = '\0';
use_stdin = 0;
print_usage = 0;
use_mbox = 0;
firstdatenum = lastdatenum = 0;
configfile = strsav(CONFIGFILE);
cmd_show_variables = 0;
opterr = 0;
#define GETOPT_OPTSTRING ("a:Ab:c:d:gil:L:m:n:o:ps:tTuvVxX0:1M?")
/* get pre config options here */
while ((i = getopt(argc, argv, GETOPT_OPTSTRING)) != -1) {
switch ((char)i) {
case 'c':
configfile = strreplace(configfile, optarg);
break;
case 'v':
cmd_show_variables = TRUE;
break;
case 'V':
version();
/*NOTREACHED*/ case 'a':
case 'A':
case 'b':
case 'd':
case 'g':
case 'i':
case 'l':
case 'L':
case 'm':
case 'n':
case 'o':
case 'p':
case 's':
case 't':
case 'T':
case 'u':
case 'x':
case 'X':
case '0':
case '1':
case 'M':
break;
case '?':
default:
/*
* Because we need to setup the language support,
* printing of the usage message must be deferred
* until the proper language is determined.
*/
print_usage = 1;
break;
}
}
/*
* ...then read the configuration file.
*/
readconfigs(configfile, cmd_show_variables);
/* reset the getopt() index variable */
optind = 1;
/* now get the post-config options! */
while ((i = getopt(argc, argv, GETOPT_OPTSTRING)) != -1) {
switch ((char)i) {
case 'A':
set_append = 1;
break;
case 'a':
set_archives = strreplace(set_archives, optarg);
break;
case 'b':
set_about = strreplace(set_about, optarg);
break;
case 'c':
/* config file from pre-config options */
break;
case 'd':
set_dir = strreplace(set_dir, optarg);
break;
case 'g':
set_usegdbm = 1;
break;
case 'i':
use_stdin = TRUE;
break;
case 'l':
set_label = strreplace(set_label, optarg);
break;
case 'L':
set_language = strreplace(set_language, optarg);
break;
case 'm':
set_mbox = strreplace(set_mbox, optarg);
break;
case 'n':
set_hmail = strreplace(set_hmail, optarg);
break;
case 'o':
ConfigAddItem(optarg);
break;
case 'p':
set_showprogress = TRUE;
break;
case 's':
set_htmlsuffix = strreplace(set_htmlsuffix, optarg);
break;
case 't':
set_usetable = TRUE;
break;
case 'T':
set_indextable = TRUE;
break;
case 'u':
set_increment = TRUE;
break;
case 'v':
cmd_show_variables = TRUE;
break;
case 'x':
set_overwrite = TRUE;
break;
case 'X':
set_writehaof = TRUE;
break;
case '0':
set_delete_msgnum = add_list(set_delete_msgnum, optarg);
break;
case '1':
set_readone = TRUE;
break;
case 'M':
set_usemeta = TRUE;
break;
case 'N':
set_nonsequential = TRUE;
break;
case '?':
default:
break;
}
}
#ifdef DEBUG
dump_config();
exit(0);
#endif
/*
* Now override the configuration file variables with any explicitly
* passed on the command line. This way you need not change the
* configuration file settings for a minor change in a single run.
*/
/*
* Check and make sure that the supplied language is a
* valid language. Otherwise strange things happen quickly.
*/
if (strlen(set_language) > 2) {
locale_code = strsav(set_language);
set_language[2] = 0; /* shorten to 2-letter code */
}
else
locale_code = NULL;
if ((tlang = valid_language(set_language, &locale_code)) == NULL) {
snprintf(errmsg, sizeof(errmsg), "\"%s\" %s.", set_language, lang[MSG_LANGUAGE_NOT_SUPPORTED]);
cmderr(errmsg);
}
#ifdef HAVE_LOCALE_H
if (!setlocale(LC_ALL, locale_code)) {
snprintf(errmsg, sizeof(errmsg), "WARNING: locale \"%s\", not supported.\n", locale_code);
fprintf(stderr, "%s", errmsg);/* AUDIT biege: avoid format-bug warning */
}
#endif
lang = tlang; /* A good language, make it so. */
if (print_usage) /* Print the usage message and terminate */
usage();
#ifndef GDBM
if (set_usegdbm) {
fprintf(stderr, "%s: %s\n", PROGNAME, lang[MSG_OPTION_G_NOT_BUILD_IN]);
usage();
}
#endif
#ifndef HAVE_LIBFNV
if (set_nonsequential)
progerr("Hypermail isn't built with the libfnv hash library.\n"
"You cannot use the nonsequential option.\n");
#endif /* HAVE_LIBFNV */
if (set_mbox && !strcasecmp(set_mbox, "NONE")) {
use_stdin = TRUE;
}
/* the list of headers that we always show and that we want to avoid
showing twice when printing the body */
set_skip_headers = add_list(set_skip_headers, "from");
set_skip_headers = add_list(set_skip_headers, "date");
set_skip_headers = add_list(set_skip_headers, "subject");
/*
* Did they decide to use stdin by specifying it on the command line ?
* If not then check and see if that is the default they wanted from
* the options.h or environment values.
*/
if (!use_stdin) {
if (optind < argc && set_increment == -1 && !set_mbox) {
set_mbox = strsav(argv[optind]);
}
else if (!set_mbox || !strcasecmp(set_mbox, "NONE"))
use_stdin = TRUE;
else
use_stdin = FALSE;
}
else {
if (set_mbox)
free(set_mbox);
set_mbox = NULL;
}
/*
** Deprecated options
*/
if (set_showhr) {
fprintf (stderr, "The \"showhr\" option has been deprecated. Ignoring it.\n");
set_showhr = FALSE;
}
if (set_usetable) {
fprintf (stderr, "The \"usetable\" option has been deprecated. Ignoring it.\n");
set_usetable = FALSE;
}
/*
* Read the contents of the file into the variables to be used
* in printing out the pages.
*/
ihtmlheaderfile = expand_contents(set_ihtmlheader);
ihtmlfooterfile = expand_contents(set_ihtmlfooter);
ihtmlheadfile = expand_contents(set_ihtmlhead);
ihtmlhelpupfile = expand_contents(set_ihtmlhelpup);
ihtmlhelplowfile = expand_contents(set_ihtmlhelplow);
ihtmlnavbar2upfile = expand_contents(set_ihtmlnavbar2up);
mhtmlheaderfile = expand_contents(set_mhtmlheader);
mhtmlfooterfile = expand_contents(set_mhtmlfooter);
if (set_dir)
set_dir = strreplace(set_dir, dirpath(set_dir));
/*
* Default names for directories and labels need to be figured out.
*/
if (use_stdin && (!set_dir || !strcasecmp(set_dir, "NONE")))
set_dir = strreplace(set_dir, DIRNAME);
if (!set_dir || !strcasecmp(set_dir, "NONE"))
set_dir = strreplace(set_dir, (strrchr(set_mbox, '/')) ? strrchr(set_mbox, '/') + 1 : set_mbox);
if (set_dir[strlen(set_dir) - 1] != PATH_SEPARATOR)
trio_asprintf(&set_dir, "%s%c", set_dir, PATH_SEPARATOR);
if (!set_label || !strcasecmp(set_label, "NONE"))
set_label = set_mbox ? (strreplace(set_label, (strrchr(set_mbox, '/')) ? strrchr(set_mbox, '/') + 1 : set_mbox)) : "stdin";
/*
* Which index file will be called "index.html"?
*/
index_name[1][DATE_INDEX] = setindex(set_defaultindex, "date", set_htmlsuffix);
index_name[1][THREAD_INDEX] = setindex(set_defaultindex, "thread", set_htmlsuffix);
index_name[1][SUBJECT_INDEX] = setindex(set_defaultindex, "subject", set_htmlsuffix);
index_name[1][AUTHOR_INDEX] = setindex(set_defaultindex, "author", set_htmlsuffix);
if (set_attachmentsindex) {
index_name[1][ATTACHMENT_INDEX]
= setindex(set_defaultindex, "attachment", set_htmlsuffix);
}
if (set_folder_by_date || set_msgsperfolder) {
index_name[0][DATE_INDEX] = setindex(set_default_top_index, "date", set_htmlsuffix);
index_name[0][THREAD_INDEX] = setindex(set_default_top_index, "thread", set_htmlsuffix);
index_name[0][SUBJECT_INDEX] = setindex(set_default_top_index, "subject", set_htmlsuffix);
index_name[0][AUTHOR_INDEX] = setindex(set_default_top_index, "author", set_htmlsuffix);
if (set_attachmentsindex) {
index_name[0][ATTACHMENT_INDEX] = setindex(set_default_top_index, "attachment", set_htmlsuffix);
}
index_name[0][FOLDERS_INDEX] = setindex(set_default_top_index, "folders", set_htmlsuffix);
}
else {
index_name[0][DATE_INDEX] = index_name[1][DATE_INDEX];
index_name[0][THREAD_INDEX] = index_name[1][THREAD_INDEX];
index_name[0][AUTHOR_INDEX] = index_name[1][AUTHOR_INDEX];
index_name[0][SUBJECT_INDEX] = index_name[1][SUBJECT_INDEX];
index_name[0][ATTACHMENT_INDEX] = index_name[1][ATTACHMENT_INDEX];
}
init_index_names();
if (set_msgsperfolder && set_folder_by_date) {
progerr("msgsperfolder and folder_by_date may not be used at the same time!");
}
/*
* General settings for mail command and rewriting.
*/
if (!set_domainaddr || !strcasecmp(set_domainaddr, "NONE"))
use_domainaddr = 0;
else
use_domainaddr = 1;
if (!set_mailto || !strcasecmp(set_mailto, "NONE"))
use_mailto = 0;
else
use_mailto = 1;
if (!set_mailcommand || !strcasecmp(set_mailcommand, "NONE"))
use_mailcommand = 0;
else
use_mailcommand = 1;
#ifndef HAVE_LIBFNV
/* the nonsequential mode won't work unless we compiled the FNV hash library
(./configure --enable-libfnv) */
if (set_nonsequential)
progerr("the nonsequential mode is only available if you enabled the\n compilation" "of the fnv hash library. Try doing a\n\t./configure --enable-libfnv\n" "and recompile if you want to use this option.");
#endif /* HAVE_LIBFNV */
/*
* A little performance speed up. The following was being done
* over and over in the write functions. This way it is done once.
* A bigger win on larger archives.
*/
if (set_hmail && !strcasecmp(set_hmail, "NONE")) {
free(set_hmail);
set_hmail = NULL;
}
if (set_archives && !strcasecmp(set_archives, "NONE")) {
free(set_archives);
set_archives = NULL;
}
if (set_custom_archives && !strcasecmp(set_custom_archives, "NONE")) {
free(set_custom_archives);
set_custom_archives = NULL;
}
if (set_about && !strcasecmp(set_about, "NONE")) {
free(set_about);
set_about = NULL;
}
/* Simply show what the values of the variables are and exit */
if (cmd_show_variables) {
if (!set_mbox)
set_mbox = "NONE";
MakeConfig(TRUE);
free(configfile);
return (0);
}
/* Injecting a little sanity... */
if (use_mbox && use_stdin) {
cmderr(lang[MSG_CANNOT_READ_FROM_BOTH_FILE_AND_STDIN]);
}
if (set_append && use_mbox) {
cmderr(lang[MSG_CANNOT_BOTH_READ_AND_WRITE_TO_MBOX]);
}
gettimezone();
getthisyear();
/*
* MIME processing requires the files be created as they
* are read in loadheaders() so assure the directories are
* there first...
*/
checkdir(set_dir);
/*
* Let's do it.
*/
if (set_uselock)
lock_archive(set_dir);
if (set_increment == -1) {
int save_append = set_append;
set_append = 0;
if (set_mbox_shortened)
progerr("can not use increment = -1 option with mbox_shortened option\n");
amount_new = parsemail(set_mbox, use_stdin, 1, -1, set_dir, set_inlinehtml, 0);
set_increment = !matches_existing(set_startmsgnum);
if (set_increment && set_folder_by_date && !set_usegdbm)
progerr("folder_by_date with incremental update requires usegdbm option");
reinit_structs();
set_append = save_append;
}
if (set_increment) {
int num_displayable;
if (set_linkquotes)
replylist = NULL;
/* we have to start with the msgnum - 1 so that the rest of the
code works ok when there are no old headers. */
max_msgnum = set_startmsgnum - 1;
num_displayable = loadoldheaders(set_dir);
amount_old = max_msgnum + 1; /* counts gaps as messages */
/* start numbering at this number */
amount_new = num_displayable + parsemail(set_mbox, use_stdin, set_readone, set_increment, set_dir, set_inlinehtml, amount_old);
if (set_linkquotes)
analyze_headers(max_msgnum + 1);
/* write the index of msgno/msgid_hash filenames */
if (set_nonsequential)
write_messageindex(0, max_msgnum + 1);
writearticles(amount_old, max_msgnum + 1);
/* JK: in function of other hypermail configuration options,
delete_incremental will continuous escape and add more markup
to non-deleted messages that are replies to deleted messages.
Thus, a setup option to disable it */
if (set_delete_incremental && deletedlist)
update_deletions(amount_old);
if (set_show_msg_links) {
fixnextheader(set_dir, amount_old, -1);
for (i = amount_old; i <= max_msgnum; ++i) {
if (set_showreplies)
fixreplyheader(set_dir, i, 0, amount_old);
fixthreadheader(set_dir, i, amount_old);
}
}
}
else {
if (set_mbox_shortened) {
if (!set_usegdbm) progerr("mbox_shortened option requires that the usegdbm option be on");
max_msgnum = set_startmsgnum - 1;
loadoldheaders(set_dir);
}
amount_new = parsemail(set_mbox, use_stdin, set_readone, set_increment, set_dir,
set_inlinehtml, set_startmsgnum); /* number from 0 */
if (!set_mbox_shortened && !matches_existing(0)) {
progerr("First message in mailbox does not "
"match first message in archive\n"
"or obsolete gdbm file present.\n"
"Maybe you want to enable the mbox_shortened option?\n");
}
if (set_linkquotes)
analyze_headers(max_msgnum + 1);
/* write the index of msgno/msgid_hash filenames */
if (set_nonsequential)
write_messageindex(0, max_msgnum + 1);
writearticles(0, max_msgnum + 1);
}
if (amount_new) { /* Always write the index files */
if (set_linkquotes) {
threadlist = NULL;
threadlist_end = NULL;
printedthreadlist = NULL;
for (i = 0; i <= max_msgnum; ++i) {
struct emailinfo *ep;
if (hashnumlookup(i, &ep)) {
ep->flags &= ~USED_THREAD;
#ifdef FASTREPLYCODE
ep->isreply = 0;
#endif
}
threadlist_by_msgnum[i] = NULL;
} /* redo threading with more complete info than in 1st pass */
crossindexthread1(datelist);
for (i = 0; i <= max_msgnum; ++i) {
struct emailinfo *ep, *etmp;
hashnumlookup(i, &ep);
etmp = nextinthread(i);
if (etmp && ep->initial_next_in_thread != etmp->msgnum)
fixthreadheader(set_dir, etmp->msgnum, amount_new);
/* if (ep->flags & THREADING_ALTERED) */
}
}
count_deleted(max_msgnum + 1);
if (show_index[0][DATE_INDEX])
writedates(amount_new, NULL);
if (show_index[0][THREAD_INDEX])
writethreads(amount_new, NULL);
if (show_index[0][SUBJECT_INDEX])
writesubjects(amount_new, NULL);
if (show_index[0][AUTHOR_INDEX])
writeauthors(amount_new, NULL);
if (set_attachmentsindex) {
writeattachments(amount_new, NULL);
}
if (set_writehaof)
writehaof(amount_new, NULL);
if (set_folder_by_date || set_msgsperfolder)
write_toplevel_indices(amount_new);
if (set_monthly_index || set_yearly_index)
write_summary_indices(amount_new);
if (set_latest_folder)
symlink_latest();
}
else {
printf("No mails to output!\n");
}
if (set_uselock)
unlock_archive();
if (configfile)
free(configfile);
if (ihtmlheaderfile)
free(ihtmlheaderfile);
if (ihtmlfooterfile)
free(ihtmlfooterfile);
if (ihtmlheadfile)
free(ihtmlheadfile);
if (ihtmlhelpupfile)
free(ihtmlhelpupfile);
if (ihtmlhelplowfile)
free(ihtmlhelplowfile);
if (ihtmlnavbar2upfile)
free(ihtmlnavbar2upfile);
if (mhtmlheaderfile)
free(mhtmlheaderfile);
if (mhtmlfooterfile)
free(mhtmlfooterfile);
return (0);
}
cms::Message *
OutputPlugin::createMessage(edg_wll_JobStat &state_out)
{
cms::TextMessage *cms_msg = session->createTextMessage();
char *s;
unsigned int i;
std::ostringstream body;
bool first = true;
body << "{";
/* jobid */
s = glite_jobid_unparse(state_out.jobId);
if(s) {
if (first) { first = false; } else { body << ", "; }
body << "\"jobid\" : \"" << s << "\"";
free(s);
}
/* ownerDn */
if(state_out.owner) {
if (first) { first = false; } else { body << ", "; }
body << "\"ownerDn\" : \"" << state_out.owner << "\"";
// cms_msg->setStringProperty("ownerDn", val);
}
/* voname */
s = edg_wll_JDLField(&state_out,"VirtualOrganisation");
if(s) {
if (first) { first = false; } else { body << ", "; }
body << "\"VirtualOrganisation\" : \"" << s << "\"";
free(s);
}
/* bkHost */
glite_jobid_getServerParts(state_out.jobId, &s, &i);
if(s) {
if (first) { first = false; } else { body << ", "; }
body << "\"bkHost\" : \"" << s << "\"";
free(s);
}
/* networkServer */
/* TODO: XXX cut out hostname */
if(state_out.network_server) {
if (first) { first = false; } else { body << ", "; }
body << "\"networkHost\" : \"" << state_out.network_server << "\"";
}
timeval2str(&state_out.lastUpdateTime, &s);
if(s) {
if (first) { first = false; } else { body << ", "; }
body << "\"lastUpdateTime\" : \"" << s << "\"";
free(s);
}
/* stateName */
s = edg_wll_StatToString(state_out.state);
if(s) {
if (first) { first = false; } else { body << ", "; }
body << "\"stateName\" : \"" << s << "\"";
free(s);
}
timeval2str(&state_out.stateEnterTime, &s);
if(s) {
if (first) { first = false; } else { body << ", "; }
body << "\"stateStartTime\" : \"" << s << "\"";
free(s);
}
/* condorId */
if(state_out.condorId) {
if (first) { first = false; } else { body << ", "; }
body << "\"condorId\" : \"" << state_out.condorId << "\"";
}
/* destSite */
if(state_out.destination) {
if (first) { first = false; } else { body << ", "; }
if (trio_asprintf(&s, "%|Js", state_out.destination) == -1) s = NULL;
body << "\"destSite\" : \"" << s << "\"";
free(s);
}
/* exitCode */
if (first) { first = false; } else { body << ", "; }
body << "\"exitCode\" : " << state_out.exit_code;
/* doneCode */
if (first) { first = false; } else { body << ", "; }
body << "\"doneCode\" : " << state_out.done_code;
/* statusReason */
if(state_out.reason) {
if (first) { first = false; } else { body << ", "; }
if (trio_asprintf(&s, "%|Js", state_out.reason) == -1) s = NULL;
body << "\"statusReason\" : \"" << s << "\"";
free(s);
}
/* summaries */
if(state_out.history) {
if (first) { first = false; } else { body << ", "; }
body << "\"history\" : " << state_out.history;
}
body << "}";
cms_msg->setText(body.str().c_str());
cms_msg->setStringProperty("Content-type", "text/javascript");
return cms_msg;
}
void print_main_header(FILE *fp, bool index_header, char *label, char *name,
char *email, char *subject, char *charset,
char *date, char *filename, int is_deleted)
{
char *title;
char *rp;
char *rp2;
/* @@ JK: Don't know what to do with US-ASCII. If there's no charset,
assume the default one is ISO-8859-1 */
if (charset && *charset)
rp = charset;
else
rp = "ISO-8859-1";
fprintf(fp,
"<?xml version=\"1.0\" encoding=\"%s\"?>\n"
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\"\n"
" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n",
rp);
fprintf(fp, "<html xmlns=\"http://www.w3.org/1999/xhtml\" lang=\"%s\">\n", set_language);
fprintf(fp, "<head>\n");
if (charset && *charset) {
/* charset info "as early as possible within the HEAD of the document"
*/
fprintf(fp, "<meta http-equiv=\"Content-Type\""
" content=\"text/html; charset=%s\" />\n", charset);
}
fprintf(fp, "<meta name=\"generator\" content=\"%s %s, see %s\" />\n",
PROGNAME, VERSION, HMURL);
/*
* Strip off any trailing whitespace in TITLE so weblint is happy.
*/
/* trio_asprintf(&title, "%s: %s", label, rp = convchars(subject, charset)); */
rp = convchars(subject, charset);
if (name && date) {
/* assume that this is the title of a message and not the title of an index */
rp2 = convchars(name, charset);
trio_asprintf(&title, "%s %s %s %s %s (%s)", rp,
lang[MSG_FROM_TITLE], rp2, lang[MSG_ON_TITLE], date, label);
free(rp2);
}
else
trio_asprintf(&title, "%s: %s", label, rp);
free(rp);
rp = title + (strlen(title) - 1);
while (isspace(*rp))
*rp-- = '\0';
/*
* Assure the title meets HTML recommendations of no longer
* than 64 characters. Truncate it if needed.
*
* JK 13/Aug/2003: This more a style suggestion given in:
* http://www.w3.org/Provider/Style/TITLE.html
* As the title is truncated regardless of its contents, it can
* generate invalid HTML if the cut happens in the middle
* of an entity. Dom suggested not enforcing this rule of
* thumb so strictly in this case, so I commented it out.
*/
/*
if (strlen(title) > 64)
*(title+64) = '\0';
*/
fprintf(fp, "<title>%s</title>\n", title);
free(title);
if (name && email){
fprintf(fp, "<meta name=\"Author\" content=\"%s (%s)\" />\n",convchars(name,charset),obfuscate_email_address(email));
}
fprintf(fp, "<meta name=\"Subject\" content=\"%s\" />\n", rp =
convchars(subject, charset));
free(rp);
if (date)
fprintf(fp, "<meta name=\"Date\" content=\"%s\" />\n",date);
if (use_mailto)
fprintf(fp, "<link rev=\"made\" href=\"mailto:%s\" />\n", set_mailto);
/* to avoid bots */
if (is_deleted){
fprintf(fp,"<meta name=\"ROBOTS\" content=\"noindex\" />\n");
}
/* print the css url according to the type of header */
if (index_header && set_icss_url && *set_icss_url) {
fprintf(fp, "<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\" />\n",
set_icss_url);
} else if (!index_header && set_mcss_url && *set_mcss_url) {
fprintf(fp, "<link rel=\"stylesheet\" href=\"%s\" type=\"text/css\" />\n",
set_mcss_url);
} else {
/*
* if style sheets are not specified, emit a default one.
*/
/* @@ JK: the old css */
#if 0
fprintf(fp, "<style type=\"text/css\">\n");
fprintf(fp, "body {color: black; background: #ffffff}\n");
fprintf(fp, "h1.center {text-align: center}\n");
fprintf(fp, "div.center {text-align: center}\n");
fprintf(fp, ".quotelev1 {color : #990099}\n");
fprintf(fp, ".quotelev2 {color : #ff7700}\n");
fprintf(fp, ".quotelev3 {color : #007799}\n");
fprintf(fp, ".quotelev4 {color : #95c500}\n");
fprintf(fp, ".headers {background : #e0e0d0}\n");
fprintf(fp, ".links {background : #f8f8e0}\n");
fprintf(fp, "</style>\n");
#endif
/* @@ JK: the new css */
fprintf (fp, "<style type=\"text/css\">\n");
fprintf (fp,"/*<![CDATA[*/\n");
fprintf (fp, "/* To be incorporated in the main stylesheet, don't code it in hypermail! */\n");
fprintf (fp, "body {color: black; background: #ffffff}\n");
fprintf (fp, "dfn {font-weight: bold;}\n");
fprintf (fp, "pre { background-color:inherit;}\n");
fprintf (fp, ".head { border-bottom:1px solid black;}\n");
fprintf (fp, ".foot { border-top:1px solid black;}\n");
fprintf (fp, "th {font-style:italic;}\n");
fprintf (fp, "table { margin-left:2em;}");
/* JK: This was the WAI rule before */
/* fprintf (fp, "#body {background-color:#fff;}\n"); */
fprintf (fp, "map ul {list-style:none;}\n");
fprintf (fp, "#mid { font-size:0.9em;}\n");
fprintf (fp, "#received { float:right;}\n");
fprintf (fp, "address { font-style:inherit ;}\n");
fprintf (fp, "/*]]>*/\n");
fprintf(fp, ".quotelev1 {color : #990099}\n");
fprintf(fp, ".quotelev2 {color : #ff7700}\n");
fprintf(fp, ".quotelev3 {color : #007799}\n");
fprintf(fp, ".quotelev4 {color : #95c500}\n");
fprintf (fp, ".period {font-weight: bold}\n");
fprintf (fp, "</style>\n");
}
if (ihtmlheadfile)
fprintf (fp, "%s", ihtmlheadfile);
fprintf(fp, "</head>\n");
fprintf(fp, "<body>\n");
}
int purge_one(edg_wll_Context ctx,edg_wll_JobStat *stat,int dump, int purge, int purge_from_proxy_only)
{
char *dbjob = NULL;
char *stmt = NULL;
glite_lbu_Statement q = NULL;
int ret,dumped = 0;
char *res[10];
char *prefix = NULL, *suffix = NULL, *root = NULL;
char *prefix_id = NULL, *suffix_id = NULL;
int sql_retval;
glite_jobid_const_t job = stat->jobId;
edg_wll_JobStat new_stat;
edg_wll_ResetError(ctx);
if ( !purge && dump < 0 ) return 0;
do {
if (edg_wll_Transaction(ctx)) goto err;
switch (edg_wll_jobMembership(ctx, job)) {
case DB_PROXY_JOB:
if (!ctx->isProxy) {
/* should not happen */
goto commit;
}
/* continue */
break;
case DB_SERVER_JOB:
if (purge_from_proxy_only) {
/* no action needed */
goto commit;
}
if (ctx->isProxy) {
/* should not happen */
goto commit;
}
/* continue */
break;
case DB_PROXY_JOB+DB_SERVER_JOB:
if (ctx->isProxy) {
purge = 0;
if (unset_proxy_flag(ctx, job) < 0) {
goto rollback;
}
}
else {
purge = 0;
/* if server&proxy DB is shared ... */
if (is_job_local(ctx,job) && purge_from_proxy_only) {
if (unset_proxy_flag(ctx, job) < 0) {
goto rollback;
}
}
else {
if (unset_server_flag(ctx, job) < 0) {
goto rollback;
}
}
}
break;
case 0:
// Zombie job (server=0, proxy=0)? should not happen;
// clear it to keep DB healthy
break;
default:
goto rollback;
break;
}
dbjob = glite_jobid_getUnique(job); /* XXX: strict jobid already checked */
if ( purge )
{
enum edg_wll_StatJobtype jobtype = get_job_type(ctx, job);
// get job prefix/suffix before its state is deleted
if ( jobtype == EDG_WLL_NUMBER_OF_JOBTYPES) goto rollback;
if (get_jobid_suffix(ctx, job, jobtype, &root, &suffix)
|| get_jobid_prefix(ctx, job, jobtype, &prefix)) {
glite_common_log(LOG_CATEGORY_CONTROL,
LOG_PRIORITY_WARN,
"[%d] unknown job type %d of job %s",
getpid(), jobtype, dbjob);
edg_wll_ResetError(ctx);
}
// notifications
memcpy(&new_stat, stat, sizeof new_stat);
new_stat.state = EDG_WLL_JOB_PURGED;
edg_wll_NotifMatch(ctx, stat, &new_stat);
}
if ( purge )
{
edg_wll_jobsconnection_purgeall(ctx, job);
}
if ( purge )
{
trio_asprintf(&stmt,"delete from jobs where jobid = '%|Ss'",dbjob);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,NULL) < 0) goto rollback;
free(stmt); stmt = NULL;
trio_asprintf(&stmt,"delete from states where jobid = '%|Ss'",dbjob);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,NULL) < 0) goto rollback;
free(stmt); stmt = NULL;
trio_asprintf(&stmt,"delete from status_tags where jobid = '%|Ss'",dbjob);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,NULL) < 0) goto rollback;
free(stmt); stmt = NULL;
}
if ( purge && prefix && suffix )
{
/* Store zombie prefix */
// See if that prefix is already stored in the database
trio_asprintf(&stmt,"select prefix_id from zombie_prefixes where prefix = '%|Ss'", prefix);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
sql_retval = edg_wll_ExecSQL(ctx,stmt,&q);
free(stmt); stmt = NULL;
if (sql_retval < 0) goto rollback;
if (sql_retval == 0) { //prefix does not exist yet
glite_lbu_FreeStmt(&q);
trio_asprintf(&stmt,"insert into zombie_prefixes (prefix) VALUES ('%|Ss')", prefix);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,&q) <= 0) goto rollback;
free(stmt); stmt = NULL;
glite_lbu_FreeStmt(&q);
// The record should exist now, however we need to look up the prefix_id
trio_asprintf(&stmt,"select prefix_id from zombie_prefixes where prefix = '%|Ss'", prefix);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,&q) <= 0) goto rollback;
free(stmt); stmt = NULL;
}
ret = edg_wll_FetchRow(ctx,q, 1, NULL, &prefix_id);
glite_lbu_FreeStmt(&q);
/* Store zombie suffix */
// See if that suffix is already stored in the database
trio_asprintf(&stmt,"select suffix_id from zombie_suffixes where suffix = '%|Ss'", suffix);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
sql_retval = edg_wll_ExecSQL(ctx,stmt,&q);
free(stmt); stmt = NULL;
if (sql_retval < 0) goto rollback;
if (sql_retval == 0) { //suffix does not exist yet
glite_lbu_FreeStmt(&q);
trio_asprintf(&stmt,"insert into zombie_suffixes (suffix) VALUES ('%|Ss')", suffix);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,&q) <= 0) goto rollback;
free(stmt); stmt = NULL;
glite_lbu_FreeStmt(&q);
// The record should exist now, however we need to look up the suffix_id
trio_asprintf(&stmt,"select suffix_id from zombie_suffixes where suffix = '%|Ss'", suffix);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,&q) <= 0) goto rollback;
free(stmt); stmt = NULL;
}
ret = edg_wll_FetchRow(ctx,q, 1, NULL, &suffix_id);
glite_lbu_FreeStmt(&q);
/* Store zombie job */
trio_asprintf(&stmt,"insert into zombie_jobs (jobid, prefix_id, suffix_id)"
" VALUES ('%|Ss', '%|Ss', '%|Ss')", root, prefix_id, suffix_id);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,&q) < 0) {
if (edg_wll_Error(ctx, NULL, NULL) == EEXIST) {
/* job already among zombies */
/* print warning but continue */
/* erasing other jobs */
char *et, *ed, *msg, *job_s;
edg_wll_Error(ctx, &et, &ed);
job_s = glite_jobid_unparse(job);
asprintf(&msg,"Warning: erasing job %s that already existed in this LB "
"(reused jobid or corruped DB) (%s: %s)",job_s,et,ed);
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_WARN, "[%d] %s", getpid(), msg);
free(et); free(ed); free(msg); free(job_s);
edg_wll_ResetError(ctx);
}
else goto rollback;
}
glite_lbu_FreeStmt(&q);
free(stmt); stmt = NULL;
}
if (dump >= 0)
trio_asprintf(&stmt,
"select event,code,prog,host,u.cert_subj,time_stamp,usec,level,arrived,seqcode "
"from events e,users u "
"where e.jobid='%|Ss' "
"and u.userid=e.userid "
"order by event", dbjob);
else
trio_asprintf(&stmt,"select event from events "
"where jobid='%|Ss' "
"order by event", dbjob);
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, stmt);
if (edg_wll_ExecSQL(ctx,stmt,&q) < 0) goto rollback;
free(stmt); stmt = NULL;
dumped = 1;
while ((ret = edg_wll_FetchRow(ctx,q,sizofa(res),NULL,res)) > 0) {
int event, ret_dump = 0, i;
event = atoi(res[0]);
if (dump >= 0) {
assert(ret == 10);
ret_dump = dump_events( ctx, job, dump, (char **) &res);
}
for (i=0; i<sizofa(res); i++) free(res[i]);
if (dump >= 0 && ret_dump) goto rollback;
if ( purge )
if (edg_wll_delete_event(ctx,dbjob,event)) goto rollback;
}
glite_lbu_FreeStmt(&q);
if (ret < 0) goto rollback;
commit:
rollback:;
} while (edg_wll_TransNeedRetry(ctx));
err:
free(root);
free(suffix);
free(prefix);
free(prefix_id);
free(suffix_id);
free(dbjob);
free(stmt);
glite_lbu_FreeStmt(&q);
return edg_wll_Error(ctx,NULL,NULL);
}
void print_all_threads(FILE *fp, int year, int month, struct emailinfo *email)
{
int level = 0;
int newlevel;
int i;
int prev = -1;
int hide_level = 0;
int thread_file_depth = (year == -1 &&
month == -1 ? set_thread_file_depth : 0);
static int reply_list_count = 0;
int stack[MAXSTACK + 1]; /* should be dynamic - this will do for now */
FILE *fp_stack[MAXSTACK + 1];
int num_replies[MAXSTACK + 1];
char *filename_stack[MAXSTACK + 1];
char *subject_stack[MAXSTACK + 1];
struct emailsubdir *subdir = email ? email->subdir : NULL;
struct emailinfo *last_email;
FILE *fp_body = NULL;
char *filenameb = NULL;
int threadnum = 0;
bool is_first = TRUE;
struct reply *rp = threadlist;
last_email = rp->data;
if (!last_email && rp->msgnum == -1 && set_files_by_thread) {
progerr("files_by_thread error start with rp->msgnum == -1");
}
for (i = 0; i <= MAXSTACK; i++)
num_replies[i] = num_open_li[i] = 0;
while (rp != NULL) {
#if DEBUG_THREAD
fprintf(stderr, "print_all_threads: message %d prev %d level %d\n",
rp->msgnum, prev, level);
#endif
if (rp->msgnum == -1) {
level =
finish_thread_levels(&fp, level, 0, num_replies, fp_stack,
filename_stack, subject_stack,
thread_file_depth, email, last_email,
filenameb, fp_body);
filenameb = NULL;
rp = rp->next;
continue;
}
else if(level == 0 && subdir && rp->data->subdir != subdir) {
rp = rp->next;
continue;
}
#if DEBUG_THREAD
fprintf(stderr, "print_all_threads: %d: %s\n", rp->msgnum,
rp->data->name);
#endif
if (prev == -1) {
level =
finish_thread_levels(&fp, level, 0, num_replies, fp_stack,
filename_stack, subject_stack,
thread_file_depth, email, rp->data,
filenameb, fp_body);
filenameb = NULL;
stack[level] = rp->msgnum;
}
else if (hide_level) {
; /* don't change level */
}
else if (rp->frommsgnum == prev) {
if (level < MAXSTACK)
level++;
else
fprintf(stderr, "thread level too deep - sticking at %d\n",
MAXSTACK);
stack[level] = rp->msgnum;
num_replies[level] = 0;
if (!set_indextable) {
if (level < set_thrdlevels) {
if (level > thread_file_depth) {
fprintf(fp, "<ul>\n");
}
else if (level < MAXSTACK) {
char *filename;
char subject[TITLESTRLEN];
trio_asprintf(&filename_stack[level],
"%u%s", reply_list_count,
index_name[subdir != NULL][THREAD_INDEX]);
filename = htmlfilename(filename_stack[level], email, "");
/* AUDIT biege: What about using remove() to handle direc.c too? */
unlink(filename); /* so chmod won't fail if someone else owned it */
fp_stack[level - 1] = fp;
if ((fp = fopen(filename, "w")) == NULL) {
snprintf(errmsg,sizeof(errmsg),"Couldn't write \"%s\".",
filename);
progerr(errmsg);
}
sprintf(subject, "thread index level %d", level + 1);
subject_stack[level] = strsav(subject);
print_index_header(fp, set_label, set_dir,
subject, filename);
fprintf(fp, "<ul>\n");
free(filename);
++reply_list_count;
}
}
else {
/* if we go over the thread limit, we just close the last open li */
if (!set_indextable && num_open_li[level - 1] != 0) {
fprintf (fp, "</li>\n");
num_open_li[level - 1]--;
}
}
}
}
else {
/* There are (I think) some optimisations possible here.
* 1. could start loop at level-1
* Previous branch is just a special case of this branch -
* possibly more efficient - probably not worth worrying about.
* Paul 12-may-1999
*/
for (i = level; i >= 0; i--) {
if (stack[i] == rp->frommsgnum) {
break;
}
}
newlevel = i + 1;
if (newlevel == level) {
/* same level, close the previous item */
if (!set_indextable && num_open_li[level] != 0) {
fprintf (fp, "</li>\n");
num_open_li[level]--;
}
}
else if (newlevel > level) {
/* I don't think this branch will be used - do the right thing anyway */
#if DEBUG_THREAD
fprintf(stderr,
"print_all_threads: unexpected: message %d - level changing from %d to %d\n",
rp->msgnum, level, newlevel);
#endif
if (newlevel >= MAXSTACK) {
fprintf(stderr,
"thread level too deep - sticking at %d\n",
MAXSTACK);
newlevel = MAXSTACK;
}
if (!set_indextable) {
while (level < newlevel) {
if (level < set_thrdlevels) {
fprintf(fp, "<li><ul>\n");
++num_open_li[level];
}
level++;
}
}
}
else {
level =
finish_thread_levels(&fp, level, newlevel, num_replies,
fp_stack, filename_stack,
subject_stack, thread_file_depth,
email, rp->data, filenameb, fp_body);
if (newlevel == 0) filenameb = NULL;
}
stack[newlevel] = rp->msgnum;
}
if (set_files_by_thread && level == 0) {
char thread_id[256];
if (filenameb && last_email) {
finish_thread_file(fp_body, last_email, filenameb);
filenameb = NULL;
}
sprintf(thread_id, "thread_body%d", ++threadnum);
filenameb = htmlfilename(thread_id, email, set_htmlsuffix);
if ((fp_body = fopen(filenameb, "w")) == NULL) {
snprintf(errmsg, sizeof(errmsg), "Couldn't write \"%s\".",
filenameb);
progerr(errmsg);
}
print_index_header(fp_body, set_label, set_dir,
lang[MSG_BY_THREAD], filenameb);
fprint_menu0(fp_body, rp->data, PAGE_TOP);
}
/* Now print this mail */
if ((year == -1 || year_of_datenum(rp->data->date) == year)
&& (month == -1 || month_of_datenum(rp->data->date) == month)
&& !rp->data->is_deleted) {
format_thread_info(fp, rp->data, level, num_replies,
email, fp_body, threadnum, is_first);
if (is_first)
is_first = FALSE;
}
prev = rp->msgnum;
hide_level = (rp->data->is_deleted && rp->frommsgnum != rp->msgnum);
last_email = rp->data;
rp = rp->next;
}
if (!set_indextable && num_open_li[0] != 0)
fprintf (fp, "</li>\n");
if (set_files_by_thread && filenameb && last_email) {
finish_thread_file(fp_body, last_email, filenameb);
filenameb = NULL;
}
}
static char *url_replying_to(struct emailinfo *email, char *line1, /* first line of quoted text, with html */
const char *line2, /* first line of quoted text, w/o html */
const struct body *bp, int quote_num, int *quoting_msgnum, int count_quoted_lines, int maybe_reply)
{
String_Match match_info;
char *p;
int subjmatch = 0;
char *anchor;
struct emailinfo *ep;
int statusnum = hashreplynumlookup(*quoting_msgnum, email->inreplyto, email->subject,
&subjmatch);
hashnumlookup(*quoting_msgnum, &ep);
trio_asprintf(&anchor, "%.4dqlink%d", *quoting_msgnum, quote_num);
if (statusnum != -1) {
struct emailinfo *ep2;
hashnumlookup(statusnum, &ep2);
if (add_anchor(statusnum, *quoting_msgnum, quote_num, anchor, line1, 0, count_quoted_lines, NULL)) {
char *path = get_path(ep, ep2);
char *buf;
trio_asprintf(&buf, "%s%.4d.%s#%s", path, statusnum, set_htmlsuffix, anchor);
if (maybe_reply)
set_new_reply_to(statusnum, strlen(line2));
if (*path)
free(path);
free(anchor);
return buf;
}
if (strlen(line2) > 6 && (p = strstr(line2, "..."))) {
char *parsed;
char *tptr = (char *)emalloc(p - line2 + 1 + strlen(p + 3)); /* AUDIT biege: IOF unlikely */
strncpy(tptr, line2, p - line2);
strcpy(tptr + (p - line2), p + 3);
parsed = ConvURLsString(tptr, email->msgid, email->subject, email->charset);
free(tptr);
tptr = stripwhitespace(parsed ? parsed : "");
if (parsed)
free(parsed);
if (add_anchor(statusnum, *quoting_msgnum, quote_num, anchor, tptr, 1, count_quoted_lines, NULL)) {
char *path = get_path(ep, ep2);
char *buf;
trio_asprintf(&buf, "%s%.4d.%s#%s", path, statusnum, set_htmlsuffix, anchor);
free(tptr);
if (maybe_reply)
set_new_reply_to(statusnum, strlen(buf));
if (*path)
free(path);
free(anchor);
return buf;
}
free(tptr);
}
}
{
int i;
struct Push full_line;
struct Push exact_line;
INIT_PUSH(full_line);
INIT_PUSH(exact_line);
PushString(&full_line, p = stripwhitespace(line2));
free(p);
PushString(&exact_line, line2);
for (i = 1; i < count_quoted_lines && (bp = bp->next); ++i) {
char *stripped = unquote_and_strip(bp->line);
PushByte(&full_line, '\n');
PushString(&full_line, p = stripwhitespace(stripped));
free(p);
free(stripped);
PushString(&exact_line, unquote(bp->line));
}
search_for_quote(PUSH_STRING(full_line), PUSH_STRING(exact_line), *quoting_msgnum, &match_info);
free(PUSH_STRING(full_line));
free(PUSH_STRING(exact_line));
}
if (match_info.msgnum >= 0) {
char *parsed = ConvURLsString(match_info.last_matched_string, email->msgid,
email->subject, email->charset);
if (parsed) {
char *parsed2 = stripwhitespace(parsed);
free(parsed);
if (add_anchor(match_info.msgnum, *quoting_msgnum, quote_num, anchor, parsed2, 1, count_quoted_lines, &match_info)) {
struct emailinfo *ep2;
char *path;
char *buf;
hashnumlookup(match_info.msgnum, &ep2);
path = get_path(ep, ep2);
trio_asprintf(&buf, "%s%.4d.%s#%s", path, match_info.msgnum, set_htmlsuffix, anchor);
set_new_reply_to(match_info.msgnum, match_info.match_len_bytes);
free(parsed2);
if (*path)
free(path);
free(anchor);
return buf;
}
free(parsed2);
}
if (match_info.last_matched_string)
free(match_info.last_matched_string);
}
if (count_quoted_lines < 3 && strcmp(get_quote_prefix(), ">")
&& strcmp(get_quote_prefix(), " >")) /* was quote_prefix guess shaky? */
*quoting_msgnum = -1; /* msg probably doesn't have any quotes */
free(anchor);
return NULL;
}
int handle_quoted_text(FILE *fp, struct emailinfo *email, const struct body *bp, char *line, int inquote, int quote_num, bool replace_quoted, int maybe_reply)
{
char *url1;
int quoting_msgnum = email->msgnum;
const struct body *last_quoted_line = bp;
int count_quoted_lines = 0;
char *fmt2;
char *cvtd_line = ConvURLsString(unquote(line), email->msgid, email->subject, email->charset);
char *buffer1;
trio_asprintf(&fmt2, set_iquotes ? "<em class=\"%s\">%%s</em><br>" : "<span class=\"%s\">%%s</span><br>", find_quote_class(line));
trio_asprintf(&buffer1, fmt2, cvtd_line ? cvtd_line : "");
if (cvtd_line)
free(cvtd_line);
found_quote = (quote_num > 0);
while (last_quoted_line && isquote(last_quoted_line->line)) {
++count_quoted_lines;
last_quoted_line = last_quoted_line->next;
}
cvtd_line = unquote_and_strip(line);
if (strlen(cvtd_line) < 5 && (!replace_quoted || !inquote)) {
char *parsed = ConvURLsString(line, email->msgid, email->subject, email->charset);
if (parsed) {
fprintf(fp, fmt2, parsed);
free(parsed);
}
}
else if ((!inquote || !found_quote)
&& (url1 = url_replying_to(email, buffer1, cvtd_line, bp, ++quote_num, "ing_msgnum, count_quoted_lines, maybe_reply))) {
static const char *fmt1 = "<a href=\"%s\">%s</a>%s<br>\n";
char *tmpline;
char *p2;
bool replacing = replace_quoted && set_quote_link_string && set_quote_link_string[0];
char *part2 = strcasestr(line, "<a href=");
if (!part2) {
part2 = "";
tmpline = strsav(line);
}
else {
tmpline = (char *)emalloc(part2 - line + 1);
strncpy(tmpline, line, part2 - line);
tmpline[part2 - line] = 0;
}
if (set_link_to_replies)
fprintf(fp, "<a name=\"qlink%d\"></a>", quote_num);
p2 = ConvURLsString(part2, email->msgid, email->subject, email->charset);
if (replacing)
fprintf(fp, fmt1, url1, set_quote_link_string, p2 ? p2 : "");
else {
char *tmpptr = convchars(tmpline, email->charset);
if (tmpptr) {
fprintf(fp, fmt1, url1, tmpptr, p2 ? p2 : "");
free(tmpptr);
}
}
free(url1);
free(tmpline);
if (p2)
free(p2);
free(cvtd_line);
free(buffer1);
free(fmt2);
return 1;
}
else if (!replace_quoted || !inquote) {
char *parsed = ConvURLsString(bp->line, email->msgid, email->subject, email->charset);
if (parsed) {
fprintf(fp, quoting_msgnum >= 0 ? fmt2 : "%s<br>\n", parsed);
free(parsed);
}
}
free(cvtd_line);
free(buffer1);
free(fmt2);
return 0;
}
int matches_existing(int msgnum)
{
struct emailinfo *eptr;
if (hashnumlookup(msgnum, &eptr) == NULL)
return -1;
#ifdef GDBM
if (set_usegdbm) {
char *indexname;
GDBM_FILE gp;
int num;
trio_asprintf(&indexname, "%s%s", set_dir, GDBM_INDEX_NAME);
if ((gp = gdbm_open(indexname, 0, GDBM_READER, 0, 0))) {
/* we _can_ read the index */
datum content;
datum key;
int max_num;
key.dptr = (char *)#
key.dsize = (int)sizeof(num);
num = -1;
content = gdbm_fetch(gp, key);
if (!content.dptr)
max_num = -1;
else
max_num = atoi(content.dptr);
if (eptr->msgnum <= max_num) {
char *dp, *dp_end;
char *name = NULL;
char *email = NULL;
char *date = NULL;
char *msgid = NULL;
char *fromdate = NULL;
num = eptr->msgnum;
key.dptr = (char *)#
key.dsize = (int)sizeof(num);
content = gdbm_fetch(gp, key);
if (!(dp = content.dptr)) {
return 1;
}
dp_end = dp + content.dsize;
fromdate = dp;
dp += strlen(dp) + 1;
date = dp;
dp += strlen(dp) + 1;
name = dp;
dp += strlen(dp) + 1;
email = dp;
dp += strlen(dp) + 1;
dp += strlen(dp) + 1;
msgid = dp;
if (strcmp(msgid, eptr->msgid))
return 0;
}
gdbm_close(gp);
} /* end case of able to read gdbm index */
free(indexname);
}
#endif
if (!set_usegdbm) {
int msgids_are_same;
msgids_are_same = parse_old_html(msgnum, eptr, 0, 0, NULL, 1);
return msgids_are_same != 0;
}
return 1;
}
int
glite_wll_perftest_init(const char *host,
const char *user,
const char *testname,
const char *filename,
int n)
{
edg_wll_Context ctx;
if (edg_wll_InitContext(&ctx) != 0) {
fprintf(stderr, "edg_wll_InitContext() failed\n");
return(-1);
}
if(trio_asprintf(&termination_string, EDG_WLL_FORMAT_USERTAG,
PERFTEST_END_TAG_NAME, PERFTEST_END_TAG_VALUE) < 0)
return(-1);
/* set parameters */
if(user)
test_user = strdup(user);
else {
test_user = getenv("PERFTEST_USER");
if(test_user == NULL)
test_user = "******";
}
if(testname)
test_name = strdup(testname);
else {
test_name = getenv("PERFTEST_NAME");
if(test_name == NULL)
test_name = "unspecified";
}
if(host == NULL) {
host = getenv("PERFTEST_HOST");
if(host == NULL)
host = "localhost";
}
{
char *p;
p = strrchr(host, ':');
if(p)
*p = 0;
dest_host = strdup(host);
if(p) {
*p++ = ':';
dest_port = atoi(p);
} else
dest_port = GLITE_JOBID_DEFAULT_PORT;
}
/* reset event source */
cur_event = cur_job = 0;
njobs = n;
/* if we are asked to read events in, read them */
if(filename) {
int fd;
if((fd=open(filename, O_RDONLY)) < 0) {
fprintf(stderr, "glite_wll_perftest_init: Could not open event file %s: %s",
filename, strerror(errno));
return(-1);
}
if((nevents=read_events(fd)) < 0)
return(-1);
close(fd);
fprintf(stderr, "PERFTEST_JOB_SIZE=%d\n", nevents);
fprintf(stderr, "PERFTEST_NUM_JOBS=%d\n", njobs);
fprintf(stderr, "PERFTEST_NUM_SUBJOBS=%d\n", nsubjobs);
}
/* we suppose nsubjobs was filled in by read_events() */
/* generate final_jobid */
do {
glite_jobid_t jobid;
if(glite_wll_perftest_createJobId(dest_host,
dest_port,
test_user,
test_name,
n,
&jobid) != 0) {
fprintf(stderr, "produceJobId: error creating jobid\n");
return(-1);
}
if((final_jobid=edg_wlc_JobIdUnparse(jobid)) == NULL) {
fprintf(stderr, "produceJobId: error unparsing jobid\n");
return(-1);
}
glite_jobid_free(jobid);
} while(0);
/* generate jobids[0..njobs-1, 0..nsubjobs] */
jobids = calloc(njobs*(nsubjobs + 1), sizeof(char*));
if(jobids == NULL) {
fprintf(stderr, "glite_wll_perftest_init: not enough memory for job id's\n");
return(-1);
}
while (--n >= 0) {
glite_jobid_t jobid;
glite_jobid_t *subjobid;
int i;
if(glite_wll_perftest_createJobId(dest_host,
dest_port,
test_user,
test_name,
n,
&jobid) != 0) {
fprintf(stderr, "produceJobId: error creating jobid\n");
return(-1);
}
if((jobids[n*(nsubjobs+1)]=edg_wlc_JobIdUnparse(jobid)) == NULL) {
fprintf(stderr, "produceJobId: error unparsing jobid\n");
return(-1);
}
/* generate subjob ids */
if(nsubjobs > 0) {
if(edg_wll_GenerateSubjobIds(ctx, jobid, nsubjobs, test_name,
&subjobid) < 0) {
fprintf(stderr, "produceJobId: error generating subjob ids\n");
return -1;
}
}
for(i = 1; i <= nsubjobs; i++) {
if((jobids[n*(nsubjobs+1) + i] = edg_wlc_JobIdUnparse(subjobid[i-1])) == NULL) {
fprintf(stderr, "produceJobId: error unparsing jobid\n");
return(-1);
}
glite_jobid_free(subjobid[i-1]);
}
glite_jobid_free(jobid);
}
return(0);
}
/**
* This produces (njobs*nsubjobs*nevents + 1) events, one event for each call.
* For every nevents (one subjob) new jobid is inserted into
* event. The last event is termination - usertag.
*/
int
glite_wll_perftest_produceEventString(char **event, char **jobid)
{
static int first = 1;
char *e;
int len, cur_subjob, jobi;
assert(event != NULL);
if(pthread_mutex_lock(&perftest_lock) < 0)
abort();
/* is there anything to send? */
if(cur_event < -1) {
if(pthread_mutex_unlock(&perftest_lock) < 0)
abort();
return(0);
}
if(cur_event >= 0) {
/* use index to get current subjob */
cur_subjob = events[cur_event].job_index;
/* current job index */
jobi = cur_group*group_size + cur_job;
} else {
cur_subjob = -1;
jobi = -1;
}
/* did we send all events? */
if((cur_event < 0) || (jobi >= njobs)) {
if(cur_event >= 0) {
/* construct registration event (necessary for the termination event to travel through proxy) */
if((len=trio_asprintf(&e, EDG_WLL_FORMAT_COMMON EDG_WLL_FORMAT_USER EDG_WLL_FORMAT_REGJOB "\n",
"now", /* date */
"localhost", /* host */
"highest", /* level */
0, /* priority */
"UserInterface", /* source */
"me again", /* source instance */
"RegJob", /* event */
final_jobid, /* jobid */
"UI=999980:NS=9999999980:WM=999980:BH=9999999980:JSS=999980:LM=999980:LRMS=999980:APP=999980", /* sequence */
"me", /* user */
"[ ]", /* jdl */
"localhost", /* regjob ns */
"", /* parent */
"SIMPLE", /* job type */
0, /* subjobs */
"", /*seed */
"" /* WMS DN */
)) < 0) {
fprintf(stderr, "produceEventString: error creating registration event\n");
if(pthread_mutex_unlock(&perftest_lock) < 0)
abort();
return(-1);
}
/* and refuse to produce more */
cur_job = -1;
cur_event = -1;
cur_subjob = -1;
} else {
/* construct termination event */
if((len=trio_asprintf(&e, EDG_WLL_FORMAT_COMMON EDG_WLL_FORMAT_USER EDG_WLL_FORMAT_USERTAG "\n",
"now", /* date */
"localhost", /* host */
"highest", /* level */
0, /* priority */
"UserInterface", /* source */
"me again", /* source instance */
"UserTag", /* event */
final_jobid, /* jobid */
"UI=999980:NS=9999999980:WM=999980:BH=9999999980:JSS=999980:LM=999980:LRMS=999980:APP=999980", /* sequence */
"me", /* user */
PERFTEST_END_TAG_NAME,
PERFTEST_END_TAG_VALUE)) < 0) {
fprintf(stderr, "produceEventString: error creating termination event\n");
if(pthread_mutex_unlock(&perftest_lock) < 0)
abort();
return(-1);
}
/* and refuse to produce more */
cur_job = -1;
cur_event = -2;
cur_subjob = -1;
}
*jobid = jobids[0];
} else {
char *parent = NULL;
char *seed = NULL;
/* is this the first event? */
if(first) {
struct timeval now;
gettimeofday(&now, NULL);
fprintf(stderr, "PERFTEST_BEGIN_TIMESTAMP=%lu.%06lu\n",
(unsigned long)now.tv_sec,(unsigned long)now.tv_usec);
first = 0;
}
/* fill parent if needed */
if(events[cur_event].need_parent) {
trio_asprintf(&parent, "DG.REGJOB.PARENT=\"%s\"",
(nsubjobs > 0) ? jobids[jobi*(nsubjobs+1)] : "");
}
/* fill seed if needed */
if(events[cur_event].need_seed) {
trio_asprintf(&seed, "DG.REGJOB.SEED=\"%s\"",
test_name);
}
/* return current event with jobid filled in */
if((len=trio_asprintf(&e, "DG.JOBID=\"%s\" %s %s %s",
jobids[jobi*(nsubjobs+1) + cur_subjob],
parent ? parent : "",
seed ? seed : "",
/* nsubjobs, */
events[cur_event].event)) < 0) {
fprintf(stderr, "produceEventString: error generating event\n");
if(pthread_mutex_unlock(&perftest_lock) < 0)
abort();
return(-1);
}
if(parent) free(parent);
if(seed) free(seed);
*jobid = jobids[jobi*(nsubjobs+1) + cur_subjob];
/* advance to the next job and/or event */
if(++cur_job % group_size == 0) {
if(++cur_event >= nevents) {
cur_event = 0;
cur_group++;
}
cur_job = 0;
}
}
*event = e;
if(pthread_mutex_unlock(&perftest_lock) < 0)
abort();
return(len);
}
static void ProcessCommand(const uint8 cmd, const uint32 raw_len, const char **PortDNames, void *PortData[], uint32 PortLen[], int NumPorts)
{
switch(cmd)
{
case 0: break; // No command
default: MDFN_DoSimpleCommand(cmd);
break;
case MDFNNPCMD_INTEGRITY:
SendIntegrity();
break;
case MDFNNPCMD_REQUEST_STATE:
SendState();
break;
case MDFNNPCMD_LOADSTATE:
RecvState(raw_len);
MDFN_DispMessage(_("Remote state loaded."));
break;
case MDFNNPCMD_SERVERTEXT:
{
static const uint32 MaxLength = 2000;
uint8 neobuf[MaxLength + 1];
char *textbuf = NULL;
const uint32 totallen = raw_len;
if(totallen > MaxLength) // Sanity check
{
throw MDFN_Error(0, _("Text length is too long: %u"), totallen);
}
MDFND_RecvData(neobuf, totallen);
neobuf[totallen] = 0;
trio_asprintf(&textbuf, "** %s", neobuf);
MDFND_NetplayText((UTF8*)textbuf, FALSE);
free(textbuf);
}
break;
case MDFNNPCMD_ECHO:
{
uint32 totallen = raw_len;
uint64 then_time;
uint64 now_time;
if(totallen != sizeof(then_time))
{
throw MDFN_Error(0, _("Echo response length is incorrect size: %u"), totallen);
}
MDFND_RecvData(&then_time, sizeof(then_time));
now_time = MDFND_GetTime();
char *textbuf = NULL;
trio_asprintf(&textbuf, _("*** Round-trip time: %llu ms"), (unsigned long long)(now_time - then_time));
MDFND_NetplayText((UTF8*)textbuf, FALSE);
free(textbuf);
}
break;
case MDFNNPCMD_TEXT:
{
static const uint32 MaxLength = 2000;
uint8 neobuf[MaxLength + 1];
const uint32 totallen = raw_len;
uint32 nicklen;
bool NetEcho = false;
char *textbuf = NULL;
if(totallen < 4)
{
throw MDFN_Error(0, _("Text command length is too short: %u"), totallen);
}
if(totallen > MaxLength) // Sanity check
{
throw MDFN_Error(0, _("Text command length is too long: %u"), totallen);
}
MDFND_RecvData(neobuf, totallen);
nicklen = MDFN_de32lsb(neobuf);
if(nicklen > (totallen - 4)) // Sanity check
{
throw MDFN_Error(0, _("Received nickname length is too long: %u"), nicklen);
}
neobuf[totallen] = 0;
if(nicklen)
{
uint8 nickbuf[nicklen + 1];
memcpy(nickbuf, neobuf + 4, nicklen);
nickbuf[nicklen] = 0;
if(OurNick && !strcasecmp(OurNick, (char *)nickbuf))
{
trio_asprintf(&textbuf, "> %s", &neobuf[4 + nicklen]);
NetEcho = true;
}
else
trio_asprintf(&textbuf, "<%s> %s", nickbuf, &neobuf[4 + nicklen]);
}
else
{
trio_asprintf(&textbuf, "* %s", &neobuf[4]);
}
MDFND_NetplayText((UTF8*)textbuf, NetEcho);
free(textbuf);
}
break;
case MDFNNPCMD_NICKCHANGED:
{
static const uint32 MaxLength = 2000;
uint8 neobuf[MaxLength + 1];
uint8 *newnick;
char *textbuf = NULL;
const uint32 len = raw_len;
if(len > MaxLength) // Sanity check
{
throw MDFN_Error(0, _("Nickname change length is too long: %u"), len);
}
MDFND_RecvData(neobuf, len);
neobuf[len] = 0;
newnick = (uint8*)strchr((char*)neobuf, '\n');
if(newnick)
{
bool IsMeow = FALSE;
*newnick = 0;
newnick++;
if(OurNick)
{
if(!strcasecmp((char*)neobuf, (char*)OurNick))
{
free(OurNick);
OurNick = strdup((char*)newnick);
textbuf = trio_aprintf(_("* You are now known as <%s>."), newnick);
IsMeow = TRUE;
}
}
if(!textbuf)
textbuf = trio_aprintf(_("* <%s> is now known as <%s>"), neobuf, newnick);
MDFND_NetplayText((UTF8*)textbuf, IsMeow);
free(textbuf);
}
}
break;
case MDFNNPCMD_CTRL_CHANGE:
{
const uint32 len = raw_len;
//
// Joined = true;
SendCommand(MDFNNPCMD_CTRL_CHANGE_ACK, len);
//
//
LocalInputStateSize = 0;
LocalPlayersMask = len;
for(int x = 0; x < MDFNGameInfo->InputInfo->InputPorts; x++)
{
if(LocalPlayersMask & (1 << x))
LocalInputStateSize += PortLen[x];
}
}
break;
case MDFNNPCMD_CTRLR_SWAP_NOTIF:
{
const uint32 cm = raw_len;
char textbuf[512];
trio_snprintf(textbuf, sizeof(textbuf), _("* All instances of controllers %u and %u have been swapped."), ((cm & 0xFF) + 1), ((cm >> 8) & 0xFF) + 1);
MDFND_NetplayText((UTF8*)textbuf, false);
}
break;
case MDFNNPCMD_CTRLR_TAKE_NOTIF:
case MDFNNPCMD_CTRLR_DROP_NOTIF:
case MDFNNPCMD_CTRLR_DUPE_NOTIF:
{
static const uint32 MaxNicknameLength = 1000;
static const uint32 MaxLength = 12 + MaxNicknameLength;
const char *fstr = NULL;
const uint32 len = raw_len;
uint8 ntf_buf[MaxLength + 1];
char *textbuf = NULL;
if(len < 12)
throw MDFN_Error(0, _("Take/drop/dupe notification is too short: %u"), len);
if(len > MaxLength)
throw MDFN_Error(0, _("Take/drop/dupe notification is too long: %u"), len);
MDFND_RecvData(ntf_buf, len);
ntf_buf[len] = 0;
switch(cmd)
{
case MDFNNPCMD_CTRLR_TAKE_NOTIF:
fstr = _("* <%s> took all instances of %s, and is now %s.");
break;
case MDFNNPCMD_CTRLR_DUPE_NOTIF:
fstr = _("* <%s> took copies of %s, and is now %s.");
break;
case MDFNNPCMD_CTRLR_DROP_NOTIF:
fstr = _("* <%s> dropped %s, and is now %s.");
break;
}
trio_asprintf(&textbuf, fstr, ntf_buf + 12, GenerateMPSString(MDFN_de32lsb(&ntf_buf[0]), true).c_str(), GenerateMPSString(MDFN_de32lsb(&ntf_buf[4]), false).c_str());
MDFND_NetplayText((UTF8*)textbuf, false);
free(textbuf);
}
break;
case MDFNNPCMD_YOUJOINED:
case MDFNNPCMD_YOULEFT:
case MDFNNPCMD_PLAYERLEFT:
case MDFNNPCMD_PLAYERJOINED:
{
static const uint32 MaxLength = 2000;
uint8 neobuf[MaxLength + 1];
char *textbuf = NULL;
uint32 mps;
std::string mps_string;
const uint32 len = raw_len;
if(len < 8)
{
throw MDFN_Error(0, _("Join/Left length is too short: %u"), len);
}
if(len > MaxLength) // Sanity check
{
throw MDFN_Error(0, _("Join/Left length is too long: %u"), len);
}
MDFND_RecvData(neobuf, len);
neobuf[len] = 0; // NULL-terminate the string
mps = MDFN_de32lsb(&neobuf[0]);
mps_string = GenerateMPSString(mps);
if(cmd == MDFNNPCMD_YOULEFT)
{
// Uhm, not supported yet!
LocalPlayersMask = 0;
LocalInputStateSize = 0;
Joined = FALSE;
}
else if(cmd == MDFNNPCMD_YOUJOINED)
{
if(OurNick) // This shouldn't happen, really...
{
free(OurNick);
OurNick = NULL;
}
OurNick = strdup((char*)neobuf + 8);
trio_asprintf(&textbuf, _("* You, %s, have connected as: %s"), neobuf + 8, mps_string.c_str());
LocalPlayersMask = mps;
LocalInputStateSize = 0;
for(int x = 0; x < MDFNGameInfo->InputInfo->InputPorts; x++)
{
if(LocalPlayersMask & (1U << x))
LocalInputStateSize += PortLen[x];
}
Joined = TRUE;
SendCommand(MDFNNPCMD_SETFPS, MDFNGameInfo->fps);
}
else if(cmd == MDFNNPCMD_PLAYERLEFT)
{
trio_asprintf(&textbuf, _("* %s(%s) has left"), neobuf + 8, mps_string.c_str());
}
else
{
trio_asprintf(&textbuf, _("* %s has connected as: %s"), neobuf + 8, mps_string.c_str());
}
MDFND_NetplayText((UTF8*)textbuf, FALSE);
free(textbuf);
}
break;
}
}
int find_max_msgnum()
{
DIR *dir;
#ifdef HAVE_DIRENT_H
struct dirent *entry;
#else
struct direct *entry;
#endif
int max_num = -1;
int num;
char *s_dir = strsav(set_dir);
int len = (int)strlen(s_dir);
if (len > 0 && s_dir[len - 1] == PATH_SEPARATOR)
s_dir[len - 1] = 0;
dir = opendir(s_dir);
if (dir == NULL)
return -1;
#ifdef GDBM
if (set_folder_by_date && set_usegdbm) {
return loadoldheadersfromGDBMindex(set_dir, 1) - 1;
}
#endif
if (set_msgsperfolder) {
int max_folder = -1;
char *tmpptr;
while ((entry = readdir(dir))) {
const char *p = entry->d_name;
while (isdigit(*p))
++p;
if (!*p && p > entry->d_name) {
num = atoi(entry->d_name);
if (num > max_folder) {
char *full_path;
trio_asprintf(&full_path, "%s%d", set_dir, num);
if (isdir(full_path))
max_folder = num;
free(full_path);
}
}
}
closedir(dir);
trio_asprintf(&tmpptr, "%s%d", set_dir, max_folder);
free(s_dir);
s_dir = tmpptr;
if (max_folder == -1)
return -1;
dir = opendir(s_dir);
if (dir == NULL) {
snprintf(errmsg, sizeof(errmsg), "internal error find_max_msgnum opening \"%s\".", s_dir);
progerr(errmsg);
}
}
while ((entry = readdir(dir))) {
const char *p = entry->d_name;
while (isdigit(*p))
++p;
if (*p == '.' && p >= entry->d_name + 4) {
++p;
if (!strcmp(p, set_htmlsuffix)) {
num = atoi(entry->d_name);
if (num > max_num)
max_num = num;
}
}
}
closedir(dir);
free(s_dir);
return max_num;
}
int edg_wll_NotifMatch(edg_wll_Context ctx, const edg_wll_JobStat *oldstat, const edg_wll_JobStat *stat)
{
edg_wll_NotifId nid = NULL;
char *jobq,*ju = NULL,*jobc[6];
glite_lbu_Statement jobs = NULL;
int ret,flags;
size_t i;
time_t expires,now = time(NULL);
char *cond_where = NULL;
char *cond_and_where = NULL;
edg_wll_JobStat newstat = *stat; // shallow copy
edg_wll_JobStat* statcopy[2][2][2];
int m, a, h;
edg_wll_Event* events = NULL;
memset(statcopy, 0, sizeof(statcopy));
edg_wll_ResetError(ctx);
if (ctx->notif_index) {
edg_wll_IColumnRec *notif_index_cols = ctx->notif_index_cols;
for (i=0; notif_index_cols[i].qrec.attr; i++) {
char *val = NULL;
if (notif_index_cols[i].qrec.attr != EDG_WLL_QUERY_ATTR_JDL_ATTR) {
val = edg_wll_StatToSQL(stat,notif_index_cols[i].qrec.attr);
assert(val != (char *) -1);
}
else { // Special Treatment for JDL attributes
val = edg_wll_JDLStatToSQL(stat,notif_index_cols[i].qrec);
}
if (val) {
char *aux;
if (!cond_where) cond_where = strdup("");
trio_asprintf(&aux, "%s or %s = %s",cond_where,
notif_index_cols[i].colname,val);
free(cond_where);
cond_where = aux;
free(val);
}
else if (notif_index_cols[i].qrec.attr == EDG_WLL_QUERY_ATTR_JDL_ATTR) {
char *aux;
if (!cond_and_where) cond_and_where = strdup("");
trio_asprintf(&aux, "%s AND %s is NULL",cond_and_where,
notif_index_cols[i].colname);
free(cond_and_where);
cond_and_where = aux;
free(val);
}
}
}
if ( (ret = edg_wll_NotifIdCreate(ctx->srvName, ctx->srvPort, &nid)) )
{
edg_wll_SetError(ctx, ret, "edg_wll_NotifMatch()");
goto err;
}
trio_asprintf(&jobq,
"select distinct n.notifid,n.destination,n.valid,u.cert_subj,n.conditions,n.flags "
"from notif_jobs j,users u,notif_registrations n "
"where j.notifid=n.notifid and n.userid=u.userid "
" and (j.jobid = '%|Ss' or j.jobid = '%|Ss' %s) %s",
ju = edg_wlc_JobIdGetUnique(stat->jobId),NOTIF_ALL_JOBS,cond_where ? cond_where : "",cond_and_where ? cond_and_where : "");
free(ju); ju = NULL;
free(cond_where); cond_where = NULL;
free(cond_and_where); cond_and_where = NULL;
glite_common_log_msg(LOG_CATEGORY_LB_SERVER_DB, LOG_PRIORITY_DEBUG, jobq);
if (edg_wll_ExecSQL(ctx,jobq,&jobs) < 0) goto err;
statcopy[0][0][0]=&newstat;
while ((ret = edg_wll_FetchRow(ctx,jobs,sizeof(jobc)/sizeof(jobc[0]),NULL,jobc)) > 0) {
flags = atoi(jobc[5]);
if (now > (expires = glite_lbu_StrToTime(jobc[2]))) {
edg_wll_NotifExpired(ctx,jobc[0]);
glite_common_log(LOG_CATEGORY_LB_SERVER, LOG_PRIORITY_DEBUG, "[%d] NOTIFY:%s expired at %s UTC",
getpid(),jobc[0],asctime(gmtime(&expires)));
}
else if (notif_match_conditions(ctx,oldstat,&newstat,jobc[4],flags))
{
char *errt, *errd;
char *dest;
int authz_flags;
ret = edg_wll_NotifCheckAuthz(ctx, &newstat, flags, jobc[3], &authz_flags);
if (ret != 1) {
char *ju;
glite_common_log(LOG_CATEGORY_CONTROL, LOG_PRIORITY_INFO,
"[%d] authorization failed when sending notification for job %s",
getpid(),
ju = glite_jobid_getUnique(newstat.jobId));
free(ju);
for (i=0; i<sizeof(jobc)/sizeof(jobc[0]); i++) free(jobc[i]);
continue;
}
m = (authz_flags & STATUS_FOR_MONITORING) == STATUS_FOR_MONITORING;
a = (authz_flags & READ_ANONYMIZED) == READ_ANONYMIZED;
h = (flags & EDG_WLL_NOTIF_HISTORY) == EDG_WLL_NOTIF_HISTORY;
if (!statcopy[m][a][h]) {
statcopy[m][a][h]=(edg_wll_JobStat*)calloc(sizeof(edg_wll_JobStat),1);
edg_wll_CpyStatus(&newstat, statcopy[m][a][h]);
glite_common_log(LOG_CATEGORY_LB_SERVER, LOG_PRIORITY_DEBUG, "NOTIFY: Populating status copy for flag combination [%d][%d][%d]", m, a, h);
if (authz_flags & STATUS_FOR_MONITORING)
blacken_fields(statcopy[m][a][h], authz_flags);
if (authz_flags & READ_ANONYMIZED)
anonymize_stat(ctx, statcopy[m][a][h]);
if (flags & EDG_WLL_NOTIF_HISTORY) {
if (!events) {
glite_common_log(LOG_CATEGORY_LB_SERVER, LOG_PRIORITY_DEBUG, "NOTIFY: extracting event history for job %s", jobc[0]);
if (!(events = fetch_history(ctx, statcopy[m][a][h]))) {
edg_wll_Error(ctx, &errt, &errd);
glite_common_log(LOG_CATEGORY_LB_SERVER, LOG_PRIORITY_ERROR, "NOTIFY: query events for %s failed, %s: %s", jobc[0], errt, errd);
free(errt);
free(errd);
edg_wll_ResetError(ctx);
continue;
}
}
collate_history(ctx, statcopy[m][a][h], events, authz_flags);
}
}
glite_common_log(LOG_CATEGORY_LB_SERVER, LOG_PRIORITY_DEBUG, "NOTIFY: %s, job %s", jobc[0], ju = edg_wlc_JobIdGetUnique(newstat.jobId));
free(ju); ju = NULL;
dest = jobc[1];
if ( edg_wll_NotifIdSetUnique(&nid, jobc[0]) )
{
free(dest);
goto err;
}
/* XXX: only temporary hack!!!
*/
ctx->p_instance = strdup("");
if ( edg_wll_NotifJobStatus(ctx, nid, dest, jobc[3], atoi(jobc[5]), expires, *statcopy[m][a][h], authz_flags) )
{
for (i=0; i<sizeof(jobc)/sizeof(jobc[0]); i++) free(jobc[i]);
goto err;
}
}
if (! strncmp(jobc[1], "x-msg", 5))
edg_wll_ServerStatisticsIncrement(ctx, SERVER_STATS_NOTIF_MSG_SENT);
else
edg_wll_ServerStatisticsIncrement(ctx, SERVER_STATS_NOTIF_LEGACY_SENT);
for (i=0; i<sizeof(jobc)/sizeof(jobc[0]); i++) free(jobc[i]);
}
if (ret < 0) goto err;
err:
for ( m = 0; m < 2 ; m++ )
for ( a = 0; a < 2 ; a++ )
for ( h = 0; h < 2 ; h++ )
if (statcopy[m][a][h] && (m || a || h)) {
edg_wll_FreeStatus(statcopy[m][a][h]);
free(statcopy[m][a][h]);
}
free(ctx->p_instance); ctx->p_instance = NULL;
if ( nid ) edg_wll_NotifIdFree(nid);
free(jobq);
glite_lbu_FreeStmt(&jobs);
free(cond_where);
free(cond_and_where);
return edg_wll_Error(ctx,NULL,NULL);
}
