/**
* \brief This function prints the messages associated with each error flag.
* \param all_flags The array that will hold all of the error flags from the run
*/
void printFlags(int **all_flags){
int noError = 0;
int i,j;
// Print System errors, if needed.
for(j = 0; j < SYS_ERR_SIZE; j++){
//printf("Error flag[0][%d] = %d\n", j, all_flags[0][j]);
if(all_flags[0][j] > 0){
EmitLog(MyRank, SCHEDULER_THREAD, build_msg(0,j), all_flags[0][j], PRINT_ALWAYS);
} else {
noError++;
}
}
// Print Plan errors
for(i = 1; i < ERR_FLAG_SIZE; i++){
for(j = 0; j < plan_list[i - 1]->esize + GEN_SIZE; j++){
//printf("Error flag[%d][%d] = %d\n", i, j, all_flags[i][j]);
if(all_flags[i][j] > 0){
EmitLog(MyRank, SCHEDULER_THREAD, build_msg(i,j), all_flags[i][j], PRINT_ALWAYS);
} else {
noError++;
}
}
}
/*
if (noError == ERR_FLAG_SIZE) {
EmitLog(MyRank, SCHEDULER_THREAD, "No flagged errors have occured in this time period.", -1, PRINT_ALWAYS);
}
*/
} /* printFlags */
static int warn_and_interrupt(struct asfd *asfd, struct sbuf *sb,
struct cntr *cntr, enum protocol protocol,
const char *text, const char *param)
{
return restore_interrupt(asfd, sb, build_msg(text, param), cntr,
protocol);
}
HRESULT send_email(UINT8 *jpeg_data, DWORD sz)
{
CURL *curl = curl_easy_init();
if (!curl) {
aslog::error(L"curl_easy_init failed");
return MAKE_HRESULT(SEVERITY_ERROR, FACILITY_ITF, 0xFF00);
}
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
CComPtr<IStream> stream = SHCreateMemStream(NULL, 0);
build_msg(stream, jpeg_data, sz);
curl_easy_setopt(curl, CURLOPT_READFUNCTION, payload_source);
curl_easy_setopt(curl, CURLOPT_READDATA, stream.p);
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
curl_easy_setopt(curl, CURLOPT_URL, g_smtpURL);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
curl_easy_setopt(curl, CURLOPT_USERNAME, g_smtpUser);
curl_easy_setopt(curl, CURLOPT_PASSWORD, g_smtpPass);
curl_easy_setopt(curl, CURLOPT_MAIL_FROM, g_smtpFrom);
struct curl_slist *recipients = NULL;
recipients = curl_slist_append(recipients, g_smtpTo);
curl_easy_setopt(curl, CURLOPT_MAIL_RCPT, recipients);
char errbufA[CURL_ERROR_SIZE];
errbufA[0] = 0;
curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, errbufA);
CURLcode res = curl_easy_perform(curl);
if (res != CURLE_OK) {
wchar_t errbufW[CURL_ERROR_SIZE];
MultiByteToWideChar(CP_UTF8, 0, errbufA, CURL_ERROR_SIZE, errbufW, CURL_ERROR_SIZE);
aslog::error(L"Mail sending failed: %s", errbufW);
}
curl_slist_free_all(recipients);
curl_easy_cleanup(curl);
return S_OK;
}
int send_r(int sk, int stream, int order, int send_size, int assoc_i)
{
int error = 0;
struct msghdr outmsg;
struct iovec iov;
char *message = NULL;
int msglen = 0;
char outcmsg[CMSG_SPACE(sizeof(struct sctp_sndrcvinfo))];
struct cmsghdr *cmsg;
struct sctp_sndrcvinfo *sinfo;
if (send_size > 0) {
message = build_msg(send_size);
msglen = strlen(message) + 1;
iov.iov_base = message;
iov.iov_len = msglen;
}
else {
if (do_exit) {
exit(1);
} else {
goto error_out;
}
}
outmsg.msg_name = &s_rem;
outmsg.msg_namelen = sizeof(struct sockaddr_storage);
outmsg.msg_iov = &iov;
outmsg.msg_iovlen = 1;
outmsg.msg_control = outcmsg;
outmsg.msg_controllen = sizeof(outcmsg);
outmsg.msg_flags = 0;
cmsg = CMSG_FIRSTHDR(&outmsg);
cmsg->cmsg_level = IPPROTO_SCTP;
cmsg->cmsg_type = SCTP_SNDRCV;
cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
outmsg.msg_controllen = cmsg->cmsg_len;
sinfo = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
memset(sinfo, 0, sizeof(struct sctp_sndrcvinfo));
sinfo->sinfo_ppid = rand();
sinfo->sinfo_stream = stream;
sinfo->sinfo_flags = 0;
if (!order)
sinfo->sinfo_flags = SCTP_UNORDERED;
if (timetolive)
sinfo->sinfo_timetolive = timetolive;
DEBUG_PRINT(DEBUG_MIN, "\tsendmsg(sk=%d, assoc=%d) %4d bytes.\n",
sk, assoc_i, send_size);
DEBUG_PRINT(DEBUG_MAX, "\t SNDRCV");
if (DEBUG_MAX == debug_level) {
printf("(stream=%u ", sinfo->sinfo_stream);
printf("flags=0x%x ", sinfo->sinfo_flags);
printf("ppid=%u\n", sinfo->sinfo_ppid);
}
/* Send to our neighbor. */
error = sendmsg(sk, &outmsg, MSG_WAITALL);
if (error != msglen) {
fprintf(stderr, "\n\t\t*** sendmsg: %s ***\n\n",
strerror(errno));
fflush(stdout);
if (do_exit) {
exit(1);
} else {
if (!drain)
goto error_out;
}
}
if (send_size > 0) free(message);
return 0;
error_out:
if (send_size > 0) free(message);
return -1;
} /* send_r() */
static int restore_special(struct asfd *asfd, struct sbuf *sb,
const char *fname, enum action act, struct cntr *cntr,
enum protocol protocol)
{
int ret=0;
char *rpath=NULL;
#ifdef HAVE_WIN32
logw(asfd, cntr, "Cannot restore special files to Windows: %s\n", fname);
goto end;
#else
struct stat statp=sb->statp;
if(act==ACTION_VERIFY)
{
cntr_add(cntr, CMD_SPECIAL, 1);
return 0;
}
if(build_path(fname, "", &rpath, NULL))
{
// failed - do a warning
if(restore_interrupt(asfd, sb,
build_msg("build path failed: %s", fname),
cntr, protocol))
ret=-1;
goto end;
}
if(S_ISFIFO(statp.st_mode))
{
if(mkfifo(rpath, statp.st_mode) && errno!=EEXIST)
do_logw(asfd, cntr,
"Cannot make fifo: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
}
else if(S_ISSOCK(statp.st_mode))
{
if(mksock(rpath))
do_logw(asfd, cntr,
"Cannot make socket: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
}
#ifdef S_IFDOOR // Solaris high speed RPC mechanism
else if (S_ISDOOR(statp.st_mode))
do_logw(asfd, cntr,
"Skipping restore of door file: %s\n", fname);
#endif
#ifdef S_IFPORT // Solaris event port for handling AIO
else if (S_ISPORT(statp.st_mode))
do_logw(asfd, cntr,
"Skipping restore of event port file: %s\n", fname);
#endif
else if(mknod(fname, statp.st_mode, statp.st_rdev) && errno!=EEXIST)
do_logw(asfd, cntr, "Cannot make node: %s\n", strerror(errno));
else
{
attribs_set(asfd, rpath, &statp, sb->winattr, cntr);
cntr_add(cntr, CMD_SPECIAL, 1);
}
#endif
end:
free_w(&rpath);
return ret;
}
static void do_logw(struct asfd *asfd, struct cntr *cntr,
const char *text, const char *param)
{
logw(asfd, cntr, "%s", build_msg(text, param));
}
static int warn_and_interrupt(struct asfd *asfd, struct sbuf *sb,
struct conf **confs, const char *text, const char *param)
{
return restore_interrupt(asfd, sb, build_msg(text, param), confs);
}
