static
dased (int vecp, char **vec)
{
int sd;
struct TSAPstart tss;
struct TSAPstart *ts = &tss;
struct TSAPdisconnect tds;
struct TSAPdisconnect *td = &tds;
if (TInit (vecp, vec, ts, td) == NOTOK)
ts_adios (td, "T-CONNECT.INDICATION failed");
sd = ts -> ts_sd;
advise (LLOG_NOTICE, NULLCP, "T-CONNECT.INDICATION: <%d, %s, %s, %d, %d>",
ts -> ts_sd, taddr2str (&ts -> ts_calling),
taddr2str (&ts -> ts_called), ts -> ts_expedited,
ts -> ts_tsdusize);
if (TConnResponse (sd, NULLTA, 0, NULLCP, 0, NULLQOS, td) == NOTOK)
ts_adios (td, "T-CONNECT.RESPONSE failed");
if ((ps = ps_alloc (dg_open)) == NULLPS)
adios (NULLCP, "ps_alloc: out of memory");
if (dg_setup (ps, sd, MAXDGRAM, ts_read, ts_write, NULLIFP) == NOTOK)
adios (NULLCP, "dg_setup: %s", ps_error (ps -> ps_errno));
for (;;) {
struct type_DASE_Query__REQ *req;
PE pe;
if ((pe = ps2pe (ps)) == NULLPE) {
if (ps -> ps_errno == PS_ERR_NONE) {
advise (LLOG_NOTICE, NULLCP, "T-DISCONNECT.INDICATION");
break;
} else
adios (NULLCP, "ps2pe: %s", ps_error (ps -> ps_errno));
}
if (decode_DASE_Query__REQ (pe, 1, NULLIP, NULLVP, &req) == NOTOK)
adios (NULLCP, "decode_DASE_Query__REQ: %s", PY_pepy);
PLOGP (pgm_log,DASE_Message, pe, "message", 1);
dase_aux (req);
free_DASE_Query__REQ (req);
pe_free (pe);
}
if (isbound) {
if (debug)
advise (LLOG_DEBUG, NULLCP, "unbound from directory");
ds_unbind ();
isbound = 0;
}
exit (0);
}
static int pLOOP () {
struct record rcs,
*rc = &rcs;
initrc (rc);
for (;;)
switch (peer2rc (rc)) {
case RC_QRY:
pQRY (rc->rc_data);
break;
case RC_CMD:
pCMD (rc->rc_data);
break;
case RC_FIN:
done (0);
case RC_XXX:
adios (NULL, "%s", rc->rc_data);
default:
fmt2peer (RC_ERR, "pLOOP protocol screw-up");
done (1);
}
}
static int
show_switch (CT ct, int serial, int alternate)
{
switch (ct->c_type) {
case CT_MULTIPART:
return show_multi (ct, serial, alternate);
case CT_MESSAGE:
switch (ct->c_subtype) {
case MESSAGE_PARTIAL:
return show_partial (ct, serial, alternate);
case MESSAGE_EXTERNAL:
return show_external (ct, serial, alternate);
case MESSAGE_RFC822:
default:
return show_message_rfc822 (ct, serial, alternate);
}
case CT_TEXT:
return show_text (ct, serial, alternate);
case CT_AUDIO:
case CT_IMAGE:
case CT_VIDEO:
case CT_APPLICATION:
return show_content (ct, serial, alternate);
default:
adios (NULL, "unknown content type %d", ct->c_type);
}
return 0; /* NOT REACHED */
}
/*ARGSUSED*/
int
vt_sync ( /*Send TELNET SYNC signal (test for UDQ & typed data)*/
char **vec
)
{
PE udqp;
TEXT_UPDATE ud;
char mask, image;
mask = SYNC;
sync_image ^= SYNC;
image = sync_image;
bzero( (char *) &ud, sizeof ud);
ud.echo_sw = cur_emode;
ud.type_sw = CTRL_OBJ;
ud.updates.co_list.co_name = "SY";
ud.updates.co_list.co_type = 1;
ud.updates.co_list.co_cmd.bool_update.value = ℑ
ud.updates.co_list.co_cmd.bool_update.val_count = SYNC_SIZE;
ud.updates.co_list.co_cmd.bool_update.mask = &mask;
ud.updates.co_list.co_cmd.bool_update.mask_count = SYNC_SIZE;
if(build_UDQPDU_UDQpdu(&udqp,1,NULL,NULLCP,(PEPYPARM) &ud) == NOTOK)
adios(NULLCP,"UDQ build failure");
udqp->pe_context = 1;
do_event(VDATreq_u,udqp);
pe_free(udqp);
return OK;
}
init_mib () {
register struct nlist *nz;
if (nlist (VMUNIX, nl) == NOTOK)
adios (VMUNIX, "unable to nlist");
for (nz = nl; nz -> n_name; nz++)
if (nz -> n_value == 0)
advise (LLOG_EXCEPTIONS, NULLCP, "\"%s\" not in %s (warning)",
nz -> n_name, VMUNIX);
if ((kd = open ("/dev/kmem", O_RDONLY)) == NOTOK)
adios ("/dev/kmem", "unable to read");
wd = NOTOK;
if ((nullSpecific = text2oid ("0.0")) == NULLOID)
adios (NULLCP, "text2oid (\"0.0\") failed!");
}
int
vfgets (FILE *in, char **bp)
{
int toggle;
char *cp, *dp, *ep, *fp;
static int len = 0;
static char *pp = NULL;
if (pp == NULL)
pp = mh_xmalloc ((size_t) (len = BUFSIZ));
for (ep = (cp = pp) + len - 1;;) {
if (fgets (cp, ep - cp + 1, in) == NULL) {
if (cp != pp) {
*bp = pp;
return 0;
}
return (ferror (in) && !feof (in) ? -1 : 1);
}
if ((dp = cp + strlen (cp) - 2) < cp || *dp != QUOTE) {
wrong_guess:
if (cp > ++dp)
adios (NULL, "vfgets() botch -- you lose big");
if (*dp == '\n') {
*bp = pp;
return 0;
} else {
cp = ++dp;
}
} else {
for (fp = dp - 1, toggle = 0; fp >= cp; fp--) {
if (*fp != QUOTE)
break;
else
toggle = !toggle;
}
if (toggle)
goto wrong_guess;
if (*++dp == '\n') {
*--dp = 0;
cp = dp;
} else {
cp = ++dp;
}
}
if (cp >= ep) {
int curlen = cp - pp;
dp = mh_xrealloc (pp, (size_t) (len += BUFSIZ));
cp = dp + curlen;
ep = (pp = dp) + len - 1;
}
}
}
int main(int argc, char *argv[])
{
// Application variable
MPI_Init(&argc, &argv);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
std::vector<float> myFloats = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const std::size_t Nx = myFloats.size();
try
{
adios2::ADIOS adios(MPI_COMM_WORLD, adios2::DebugON);
adios2::IO &dataManIO = adios.DeclareIO("WANIO");
dataManIO.SetEngine("DataManWriter");
dataManIO.SetParameters({{"peer-to-peer", "yes"},
{"real_time", "yes"},
{"compress", "no"},
{"method", "dump"}});
// Define variable and local size
auto bpFloats =
dataManIO.DefineVariable<float>("bpFloats", {}, {}, {Nx});
// Create engine smart pointer to DataMan Engine due to polymorphism,
// Open returns a smart pointer to Engine containing the Derived class
adios2::Engine &dataManWriter =
dataManIO.Open("myFloats.bp", adios2::Mode::Write);
dataManWriter.PutSync<float>(bpFloats, myFloats.data());
dataManWriter.Close();
}
catch (std::invalid_argument &e)
{
std::cout << "Invalid argument exception, STOPPING PROGRAM from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::ios_base::failure &e)
{
std::cout
<< "IO System base failure exception, STOPPING PROGRAM from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::exception &e)
{
std::cout << "Exception, STOPPING PROGRAM from rank " << rank << "\n";
std::cout << e.what() << "\n";
}
MPI_Finalize();
return 0;
}
static struct nexus *
newnexus (int (*action)())
{
register struct nexus *p;
if ((p = (struct nexus *) calloc ((size_t) 1, sizeof *p)) == NULL)
adios (NULL, "unable to allocate component storage");
p->n_action = action;
return p;
}
static int pINI () {
int i,
vrsn;
char *bp;
struct record rcs,
*rc = &rcs;
initrc (rc);
switch (peer2rc (rc)) {
case RC_INI:
bp = rc->rc_data;
while (isspace (*bp))
bp++;
if (sscanf (bp, "%d", &vrsn) != 1) {
bad_init: ;
fmt2peer (RC_ERR, "bad init \"%s\"", rc->rc_data);
done (1);
}
if (vrsn != RC_VRSN) {
fmt2peer (RC_ERR, "version %d unsupported", vrsn);
done (1);
}
while (*bp && !isspace (*bp))
bp++;
while (isspace (*bp))
bp++;
if (sscanf (bp, "%d", &numwins) != 1 || numwins <= 0)
goto bad_init;
if (numwins > NWIN)
numwins = NWIN;
for (i = 1; i <= numwins; i++) {
while (*bp && !isspace (*bp))
bp++;
while (isspace (*bp))
bp++;
if (sscanf (bp, "%d", &windows[i]) != 1 || windows[i] <= 0)
goto bad_init;
}
rc2peer (RC_ACK, 0, NULL);
return OK;
case RC_XXX:
adios (NULL, "%s", rc->rc_data);
default:
fmt2peer (RC_ERR, "pINI protocol screw-up");
done (1); /* NOTREACHED */
}
}
int
main (int argc, char **argv)
{
int fd1, fd2;
char *cp, buffer[BUFSIZ];
char **argp, **arguments;
#ifdef LOCALE
setlocale(LC_ALL, "");
#endif
invo_name = r1bindex (argv[0], '/');
/* foil search of user profile/context */
if (context_foil (NULL) == -1)
done (1);
arguments = getarguments (invo_name, argc, argv, 0);
argp = arguments;
while ((cp = *argp++))
if (*cp == '-')
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buffer, sizeof(buffer), "%s [switches]", invo_name);
print_help (buffer, switches, 0);
done (1);
case VERSIONSW:
print_version(invo_name);
done (1);
case READSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if ((fd1 = atoi (cp)) < 1)
adios (NULL, "bad argument %s %s", argp[-2], cp);
continue;
case WRITESW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if ((fd2 = atoi (cp)) < 1)
adios (NULL, "bad argument %s %s", argp[-2], cp);
continue;
}
else
adios (NULL, "usage: %s [switches]", invo_name);
rcinit (fd1, fd2);
pINI ();
pLOOP ();
return done (0);
}
static void
DisplayMsgHeader (CT ct, char *form)
{
pid_t child_id;
int i, vecp;
char **vec;
char *file;
vec = argsplit(mhlproc, &file, &vecp);
vec[vecp++] = getcpy("-form");
vec[vecp++] = getcpy(form);
vec[vecp++] = getcpy("-nobody");
vec[vecp++] = getcpy(ct->c_file);
/*
* If we've specified -(no)moreproc,
* then just pass that along.
*/
if (nomore) {
vec[vecp++] = getcpy("-nomoreproc");
} else if (progsw) {
vec[vecp++] = getcpy("-moreproc");
vec[vecp++] = getcpy(progsw);
}
vec[vecp] = NULL;
fflush (stdout);
for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
sleep (5);
switch (child_id) {
case NOTOK:
adios ("fork", "unable to");
/* NOTREACHED */
case OK:
execvp (file, vec);
fprintf (stderr, "unable to exec ");
perror (mhlproc);
_exit (-1);
/* NOTREACHED */
default:
xpid = -child_id;
break;
}
arglist_free(file, vec);
}
int
Cat (char *s1, char *s2)
{
int len = strlen(s1) + strlen(s2) + 1;
char *s;
nleft -= len;
if (nleft <= 0 || ++eargc >= GAVSIZ)
yyerror("Arguments too long");
eargv[eargc] = 0;
eargv[eargc - 1] = s = malloc((unsigned)len);
if (s == NULL)
adios (NULLCP, "ran out of memory");
while (*s++ = *s1++ & TRIM)
;
s--;
while (*s++ = *s2++ & TRIM)
;
}
void
context_save (void)
{
int action;
register struct node *np;
FILE *out;
sigset_t set, oset;
/* No context in use -- silently ignore any changes! */
if (!ctxpath)
return;
if (!(ctxflags & CTXMOD))
return;
ctxflags &= ~CTXMOD;
if ((action = m_chkids ()) > 0)
return; /* child did it for us */
/* block a few signals */
sigemptyset (&set);
sigaddset (&set, SIGHUP);
sigaddset (&set, SIGINT);
sigaddset (&set, SIGQUIT);
sigaddset (&set, SIGTERM);
sigprocmask (SIG_BLOCK, &set, &oset);
if (!(out = lkfopendata (ctxpath, "w")))
adios (ctxpath, "unable to write");
for (np = m_defs; np; np = np->n_next)
if (np->n_context)
fprintf (out, "%s: %s\n", np->n_name, np->n_field);
lkfclosedata (out, ctxpath);
sigprocmask (SIG_SETMASK, &oset, &set); /* reset the signal mask */
if (action == 0)
/* This must be _exit(), not exit(), because the child didn't
call unregister_for_removal() in m_chkids(). */
_exit (0); /* we are child, time to die */
}
int
main (int argc, char **argv)
{
int anot = 0, inplace = 1, mime = 0;
int issue = 0, volume = 0, dashstuff = 0;
int nedit = 0, nwhat = 0, i, in;
int out, isdf = 0, msgnum = 0;
int outputlinelen = OUTPUTLINELEN;
int dat[5];
char *cp, *cwd, *maildir, *dfolder = NULL;
char *dmsg = NULL, *digest = NULL, *ed = NULL;
char *file = NULL, *filter = NULL, *folder = NULL, *fwdmsg = NULL;
char *from = NULL, *to = NULL, *cc = NULL, *subject = NULL, *fcc = NULL;
char *form = NULL, buf[BUFSIZ], value[10];
char **argp, **arguments;
struct stat st;
struct msgs_array msgs = { 0, 0, NULL };
int buildsw = 0;
if (nmh_init(argv[0], 1)) { return 1; }
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
invo_name);
print_help (buf, switches, 1);
done (0);
case VERSIONSW:
print_version(invo_name);
done (0);
case ANNOSW:
anot++;
continue;
case NANNOSW:
anot = 0;
continue;
case EDITRSW:
if (!(ed = *argp++) || *ed == '-')
adios (NULL, "missing argument to %s", argp[-2]);
nedit = 0;
continue;
case NEDITSW:
nedit++;
continue;
case WHATSW:
if (!(whatnowproc = *argp++) || *whatnowproc == '-')
adios (NULL, "missing argument to %s", argp[-2]);
nwhat = 0;
continue;
case BILDSW:
buildsw++; /* fall... */
case NWHATSW:
nwhat++;
continue;
case FILESW:
if (file)
adios (NULL, "only one file at a time!");
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
file = path (cp, TFILE);
continue;
case FILTSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
filter = getcpy (etcpath (cp));
mime = 0;
continue;
case FORMSW:
if (!(form = *argp++) || *form == '-')
adios (NULL, "missing argument to %s", argp[-2]);
continue;
case FRMTSW:
filter = getcpy (etcpath (mhlforward));
continue;
case NFRMTSW:
filter = NULL;
continue;
case INPLSW:
inplace++;
continue;
case NINPLSW:
inplace = 0;
continue;
case MIMESW:
mime++;
filter = NULL;
continue;
case NMIMESW:
mime = 0;
continue;
case DGSTSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
digest = getcpy(cp);
mime = 0;
continue;
case ISSUESW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if ((issue = atoi (cp)) < 1)
adios (NULL, "bad argument %s %s", argp[-2], cp);
continue;
case VOLUMSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if ((volume = atoi (cp)) < 1)
adios (NULL, "bad argument %s %s", argp[-2], cp);
continue;
case DFOLDSW:
if (dfolder)
adios (NULL, "only one draft folder at a time!");
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
dfolder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
*cp != '@' ? TFOLDER : TSUBCWF);
continue;
case DMSGSW:
if (dmsg)
adios (NULL, "only one draft message at a time!");
if (!(dmsg = *argp++) || *dmsg == '-')
adios (NULL, "missing argument to %s", argp[-2]);
continue;
case NDFLDSW:
dfolder = NULL;
isdf = NOTOK;
continue;
case BITSTUFFSW:
dashstuff = 1; /* trinary logic */
continue;
case NBITSTUFFSW:
dashstuff = -1; /* trinary logic */
continue;
case FROMSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
from = addlist(from, cp);
continue;
case TOSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
to = addlist(to, cp);
continue;
case CCSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
cc = addlist(cc, cp);
continue;
case FCCSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
fcc = addlist(fcc, cp);
continue;
case SUBJECTSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
subject = getcpy(cp);
continue;
case WIDTHSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if ((outputlinelen = atoi(cp)) < 10)
adios (NULL, "impossible width %d", outputlinelen);
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else {
app_msgarg(&msgs, cp);
}
}
cwd = getcpy (pwd ());
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (file && (msgs.size || folder))
adios (NULL, "can't mix files and folders/msgs");
try_it_again:
strncpy (drft, buildsw ? m_maildir ("draft")
: m_draft (dfolder, NULL, NOUSE, &isdf), sizeof(drft));
/* Check if a draft already exists */
if (!buildsw && stat (drft, &st) != NOTOK) {
printf ("Draft \"%s\" exists (%ld bytes).", drft, (long) st.st_size);
for (i = LISTDSW; i != YESW;) {
if (!(argp = getans ("\nDisposition? ", isdf ? aqrnl : aqrl)))
done (1);
switch (i = smatch (*argp, isdf ? aqrnl : aqrl)) {
case NOSW:
done (0);
case NEWSW:
dmsg = NULL;
goto try_it_again;
case YESW:
break;
case LISTDSW:
showfile (++argp, drft);
break;
case REFILSW:
if (refile (++argp, drft) == 0)
i = YESW;
break;
default:
advise (NULL, "say what?");
break;
}
}
}
if (file) {
/*
* Forwarding a file.
*/
anot = 0; /* don't want to annotate a file */
} else {
/*
* Forwarding a message.
*/
if (!msgs.size)
app_msgarg(&msgs, "cur");
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder, 1)))
adios (NULL, "unable to read folder %s", folder);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", folder);
/* parse all the message ranges/sequences and set SELECTED */
for (msgnum = 0; msgnum < msgs.size; msgnum++)
if (!m_convert (mp, msgs.msgs[msgnum]))
done (1);
seq_setprev (mp); /* set the previous sequence */
/*
* Find the first message in our set and use it as the input
* for the component scanner
*/
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
if (is_selected (mp, msgnum)) {
fwdmsg = strdup(m_name(msgnum));
break;
}
if (! fwdmsg)
adios (NULL, "Unable to find input message");
}
if (filter && access (filter, R_OK) == NOTOK)
adios (filter, "unable to read");
/*
* Open form (component) file.
*/
if (digest) {
if (issue == 0) {
snprintf (buf, sizeof(buf), IFORMAT, digest);
if (volume == 0
&& (cp = context_find (buf))
&& ((issue = atoi (cp)) < 0))
issue = 0;
issue++;
}
if (volume == 0) {
snprintf (buf, sizeof(buf), VFORMAT, digest);
if ((cp = context_find (buf)) == NULL || (volume = atoi (cp)) <= 0)
volume = 1;
}
if (!form)
form = digestcomps;
} else {
if (!form)
form = forwcomps;
}
dat[0] = digest ? issue : msgnum;
dat[1] = volume;
dat[2] = 0;
dat[3] = outputlinelen;
dat[4] = 0;
in = build_form (form, digest, dat, from, to, cc, fcc, subject,
file ? file : fwdmsg);
if ((out = creat (drft, m_gmprot ())) == NOTOK)
adios (drft, "unable to create");
/*
* copy the components into the draft
*/
cpydata (in, out, form, drft);
close (in);
if (file) {
/* just copy the file into the draft */
if ((in = open (file, O_RDONLY)) == NOTOK)
adios (file, "unable to open");
cpydata (in, out, file, drft);
close (in);
close (out);
} else {
/*
* If filter file is defined, then format the
* messages into the draft using mhlproc.
*/
if (filter)
mhl_draft (out, digest, volume, issue, drft, filter, dashstuff);
else if (mime)
copy_mime_draft (out);
else
copy_draft (out, digest, drft, volume, issue, dashstuff);
close (out);
if (digest) {
snprintf (buf, sizeof(buf), IFORMAT, digest);
snprintf (value, sizeof(value), "%d", issue);
context_replace (buf, getcpy (value));
snprintf (buf, sizeof(buf), VFORMAT, digest);
snprintf (value, sizeof(value), "%d", volume);
context_replace (buf, getcpy (value));
}
context_replace (pfolder, folder); /* update current folder */
seq_setcur (mp, mp->lowsel); /* update current message */
seq_save (mp); /* synchronize sequences */
context_save (); /* save the context file */
}
if (nwhat)
done (0);
what_now (ed, nedit, NOUSE, drft, NULL, 0, mp,
anot ? "Forwarded" : NULL, inplace, cwd, 0);
done (1);
return 1;
}
int
main (int argc, char **argv)
{
int sizesw = 1, headsw = 1;
int *icachesw;
char *cp, buf[BUFSIZ];
char buffer[BUFSIZ], *compfile = NULL;
char **argp, **arguments;
CT ct, cts[2];
FILE *fp = NULL;
FILE *fp_out = NULL;
done=unlink_done;
#ifdef LOCALE
setlocale(LC_ALL, "");
#endif
invo_name = r1bindex (argv[0], '/');
/* read user profile/context */
context_read();
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
while ((cp = *argp++)) {
if (cp[0] == '-' && cp[1] == '\0') {
if (compfile)
adios (NULL, "cannot specify both standard input and a file");
else
compfile = cp;
listsw = 0; /* turn off -list if using standard in/out */
verbosw = 0; /* turn off -verbose listings */
break;
}
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [switches] file", invo_name);
print_help (buf, switches, 1);
done (1);
case VERSIONSW:
print_version(invo_name);
done (1);
case RCACHESW:
icachesw = &rcachesw;
goto do_cache;
case WCACHESW:
icachesw = &wcachesw;
do_cache: ;
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
switch (*icachesw = smatch (cp, caches)) {
case AMBIGSW:
ambigsw (cp, caches);
done (1);
case UNKWNSW:
adios (NULL, "%s unknown", cp);
default:
break;
}
continue;
case CHECKSW:
checksw++;
continue;
case NCHECKSW:
checksw = 0;
continue;
case EBCDICSW:
ebcdicsw++;
continue;
case NEBCDICSW:
ebcdicsw = 0;
continue;
case HEADSW:
headsw++;
continue;
case NHEADSW:
headsw = 0;
continue;
case LISTSW:
listsw++;
continue;
case NLISTSW:
listsw = 0;
continue;
case RFC934SW:
rfc934sw++;
continue;
case NRFC934SW:
rfc934sw = 0;
continue;
case SIZESW:
sizesw++;
continue;
case NSIZESW:
sizesw = 0;
continue;
case CONTENTIDSW:
contentidsw = 1;
continue;
case NCONTENTIDSW:
contentidsw = 0;
continue;
case VERBSW:
verbosw++;
continue;
case NVERBSW:
verbosw = 0;
continue;
case DEBUGSW:
debugsw = 1;
continue;
}
}
if (compfile)
adios (NULL, "only one composition file allowed");
else
compfile = cp;
}
set_endian ();
if ((cp = getenv ("MM_NOASK")) && !strcmp (cp, "1"))
listsw = 0;
/*
* Check if we've specified an additional profile
*/
if ((cp = getenv ("MHBUILD"))) {
if ((fp = fopen (cp, "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
} else {
admonish ("", "unable to read $MHBUILD profile (%s)", cp);
}
}
/*
* Read the standard profile setup
*/
if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
}
/* Check for public cache location */
if ((cache_public = context_find (nmhcache)) && *cache_public != '/')
cache_public = NULL;
/* Check for private cache location */
if (!(cache_private = context_find (nmhprivcache)))
cache_private = ".cache";
cache_private = getcpy (m_maildir (cache_private));
/*
* Check for storage directory. If defined, we
* will store temporary files there. Else we
* store them in standard nmh directory.
*/
if ((cp = context_find (nmhstorage)) && *cp)
tmp = concat (cp, "/", invo_name, NULL);
else
tmp = add (m_maildir (invo_name), NULL);
if (!context_find ("path"))
free (path ("./", TFOLDER));
/* Check if we have a file to process */
if (!compfile)
adios (NULL, "need to specify a %s composition file", invo_name);
/*
* Process the composition file from standard input.
*/
if (compfile[0] == '-' && compfile[1] == '\0') {
/* copy standard input to temporary file */
strncpy (infile, m_mktemp(invo_name, NULL, &fp), sizeof(infile));
while (fgets (buffer, BUFSIZ, stdin))
fputs (buffer, fp);
fclose (fp);
unlink_infile = 1;
/* build the content structures for MIME message */
ct = build_mime (infile);
cts[0] = ct;
cts[1] = NULL;
/* output MIME message to this temporary file */
strncpy (outfile, m_mktemp(invo_name, NULL, &fp_out), sizeof(outfile));
unlink_outfile = 1;
/* output the message */
output_message_fp (ct, fp_out, outfile);
fclose(fp_out);
/* output the temp file to standard output */
if ((fp = fopen (outfile, "r")) == NULL)
adios (outfile, "unable to open");
while (fgets (buffer, BUFSIZ, fp))
fputs (buffer, stdout);
fclose (fp);
unlink (infile);
unlink_infile = 0;
unlink (outfile);
unlink_outfile = 0;
free_content (ct);
done (0);
}
/*
* Process the composition file from a file.
*/
/* build the content structures for MIME message */
ct = build_mime (compfile);
cts[0] = ct;
cts[1] = NULL;
/* output MIME message to this temporary file */
strncpy(outfile, m_mktemp2(compfile, invo_name, NULL, &fp_out),
sizeof(outfile));
unlink_outfile = 1;
/* output the message */
output_message_fp (ct, fp_out, outfile);
fclose(fp_out);
/*
* List the message info
*/
if (listsw)
list_all_messages (cts, headsw, sizesw, verbosw, debugsw);
/* Rename composition draft */
snprintf (buffer, sizeof(buffer), "%s.orig", m_backup (compfile));
if (rename (compfile, buffer) == NOTOK) {
adios (compfile, "unable to rename comp draft %s to", buffer);
}
/* Rename output file to take its place */
if (rename (outfile, compfile) == NOTOK) {
advise (outfile, "unable to rename output %s to", compfile);
rename (buffer, compfile);
done (1);
}
unlink_outfile = 0;
free_content (ct);
done (0);
return 1;
}
static void
mhl_draft (int out, char *digest, int volume, int issue,
char *file, char *filter, int dashstuff)
{
pid_t child_id;
int i, msgnum, pd[2];
char buf1[BUFSIZ];
char buf2[BUFSIZ];
char *program;
struct msgs_array vec = { 0, 0, NULL };
if (pipe (pd) == NOTOK)
adios ("pipe", "unable to create");
argsplit_msgarg(&vec, mhlproc, &program);
for (i = 0; (child_id = fork()) == NOTOK && i < 5; i++)
sleep (5);
switch (child_id) {
case NOTOK:
adios ("fork", "unable to");
case OK:
close (pd[0]);
dup2 (pd[1], 1);
close (pd[1]);
i = 1;
app_msgarg(&vec, "-forwall");
app_msgarg(&vec, "-form");
app_msgarg(&vec, filter);
if (digest) {
app_msgarg(&vec, "-digest");
app_msgarg(&vec, digest);
app_msgarg(&vec, "-issue");
snprintf (buf1, sizeof(buf1), "%d", issue);
app_msgarg(&vec, buf1);
app_msgarg(&vec, "-volume");
snprintf (buf2, sizeof(buf2), "%d", volume);
app_msgarg(&vec, buf2);
}
/*
* Are we dashstuffing (quoting) the lines that begin
* with `-'. We use the mhl default (don't add any flag)
* unless the user has specified a specific flag.
*/
if (dashstuff > 0)
app_msgarg(&vec, "-dashstuffing");
else if (dashstuff < 0)
app_msgarg(&vec, "-nodashstuffing");
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected (mp, msgnum))
app_msgarg(&vec, getcpy (m_name (msgnum)));
}
app_msgarg(&vec, NULL);
execvp (program, vec.msgs);
fprintf (stderr, "unable to exec ");
perror (mhlproc);
_exit (-1);
default:
close (pd[1]);
cpydata (pd[0], out, vec.msgs[0], file);
close (pd[0]);
pidXwait(child_id, mhlproc);
break;
}
}
int
main (int argc, char **argv)
{
int addsw = 0, deletesw = 0, debugsw = 0;
int listsw = 0, publicsw = -1, zerosw = 0, msgnum;
unsigned int seqp = 0;
char *cp, *maildir, *folder = NULL, buf[BUFSIZ];
char **argp, **arguments;
svector_t seqs = svector_create (0);
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp;
if (nmh_init(argv[0], 1)) { return 1; }
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
/*
* Parse arguments
*/
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown\n", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
invo_name);
print_help (buf, switches, 1);
done (0);
case VERSIONSW:
print_version(invo_name);
done (0);
case ADDSW:
addsw++;
deletesw = listsw = 0;
continue;
case DELSW:
deletesw++;
addsw = listsw = 0;
continue;
case LSTSW:
listsw++;
addsw = deletesw = 0;
continue;
case SEQSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
svector_push_back (seqs, cp);
seqp++;
continue;
case PUBLSW:
publicsw = 1;
continue;
case NPUBLSW:
publicsw = 0;
continue;
case DEBUGSW:
debugsw++;
continue;
case ZEROSW:
zerosw++;
continue;
case NZEROSW:
zerosw = 0;
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else
app_msgarg(&msgs, cp);
}
/*
* If we haven't specified -add, -delete, or -list,
* then use -add if a sequence was specified, else
* use -list.
*/
if (!addsw && !deletesw && !listsw) {
if (seqp)
addsw++;
else
listsw++;
}
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (!msgs.size)
app_msgarg(&msgs, listsw ? "all" :"cur");
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder, 1)))
adios (NULL, "unable to read folder %s", folder);
/* print some general debugging info */
if (debugsw)
print_debug(mp);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", folder);
/* parse all the message ranges/sequences and set SELECTED */
for (msgnum = 0; msgnum < msgs.size; msgnum++)
if (!m_convert (mp, msgs.msgs[msgnum]))
done (1);
if (publicsw == 1 && is_readonly(mp))
adios (NULL, "folder %s is read-only, so -public not allowed", folder);
/*
* Make sure at least one sequence has been
* specified if we are adding or deleting.
*/
if (seqp == 0 && (addsw || deletesw))
adios (NULL, "-%s requires at least one -sequence argument",
addsw ? "add" : "delete");
/* Adding messages to sequences */
if (addsw) {
for (seqp = 0; seqp < svector_size (seqs); seqp++)
if (!seq_addsel (mp, svector_at (seqs, seqp), publicsw, zerosw))
done (1);
}
/* Deleting messages from sequences */
if (deletesw) {
for (seqp = 0; seqp < svector_size (seqs); seqp++)
if (!seq_delsel (mp, svector_at (seqs, seqp), publicsw, zerosw))
done (1);
}
/* Listing messages in sequences */
if (listsw) {
if (seqp) {
/* print the sequences given */
for (seqp = 0; seqp < svector_size (seqs); seqp++)
seq_print (mp, svector_at (seqs, seqp));
} else {
/* else print them all */
seq_printall (mp);
}
/* print debugging info about SELECTED messages */
if (debugsw)
seq_printdebug (mp);
}
svector_free (seqs);
seq_save (mp); /* synchronize message sequences */
context_replace (pfolder, folder); /* update current folder */
context_save (); /* save the context file */
folder_free (mp); /* free folder/message structure */
done (0);
return 1;
}
int
scan (FILE *inb, int innum, int outnum, char *nfs, int width, int curflg,
int unseen, char *folder, long size, int noisy)
{
int i, compnum, encrypted, state;
char *cp, *tmpbuf, *startbody, **nxtbuf;
char *saved_c_text = NULL;
struct comp *cptr;
struct comp **savecomp;
char *scnmsg = NULL;
FILE *scnout = NULL;
char name[NAMESZ];
int bufsz;
static int rlwidth, slwidth;
static size_t scanl_size;
/* first-time only initialization */
if (!scanl) {
if (width == 0) {
if ((width = sc_width ()) < WIDTH/2)
width = WIDTH/2;
else if (width > MAXSCANL)
width = MAXSCANL;
}
dat[3] = slwidth = width;
/* Arbitrarily allocate 20 * slwidth to provide room for lots
of escape sequences. */
scanl_size = SCAN_CHARWIDTH * (20 * slwidth + 2);
scanl = (char *) mh_xmalloc (scanl_size);
if (outnum)
umask(~m_gmprot());
/* Compile format string */
ncomps = fmt_compile (nfs, &fmt, 1) + 2;
bodycomp = fmt_findcomp("body");
datecomp = fmt_findcomp("date");
cptr = fmt_findcomp("folder");
if (cptr && folder)
cptr->c_text = getcpy(folder);
if (fmt_addcompentry("encrypted")) {
ncomps++;
}
cptr = fmt_findcomp("dtimenow");
if (cptr)
cptr->c_text = getcpy(dtimenow (0));
/*
* In other programs I got rid of this complicated buffer switching,
* but since scan reads lots of messages at once and this complicated
* memory management, I decided to keep it; otherwise there was
* the potential for a lot of malloc() and free()s, and I could
* see the malloc() pool really getting fragmented. Maybe it
* wouldn't be an issue in practice; perhaps this will get
* revisited someday.
*
* So, some notes for what's going on:
*
* nxtbuf is an array of pointers that contains malloc()'d buffers
* to hold our component text. used_buf is an array of struct comp
* pointers that holds pointers to component structures we found while
* processing a message.
*
* We read in the message with m_getfld(), using "tmpbuf" as our
* input buffer. tmpbuf is set at the start of message processing
* to the first buffer in our buffer pool (nxtbuf).
*
* Every time we find a component we care about, we set that component's
* text buffer to the current value of tmpbuf, and then switch tmpbuf
* to the next buffer in our pool. We also add that component to
* our used_buf pool.
*
* When we're done, we go back and zero out all of the component
* text buffer pointers that we saved in used_buf.
*
* Note that this means c_text memory is NOT owned by the fmt_module
* and it's our responsibility to free it.
*/
nxtbuf = compbuffers = (char **) calloc((size_t) ncomps, sizeof(char *));
if (nxtbuf == NULL)
adios (NULL, "unable to allocate component buffers");
used_buf = (struct comp **) calloc((size_t) (ncomps+1),
sizeof(struct comp *));
if (used_buf == NULL)
adios (NULL, "unable to allocate component buffer stack");
used_buf += ncomps+1; *--used_buf = 0;
rlwidth = bodycomp && (width > SBUFSIZ) ? width : SBUFSIZ;
for (i = ncomps; i--; )
*nxtbuf++ = mh_xmalloc(rlwidth);
}
/*
* each-message initialization
*/
nxtbuf = compbuffers;
savecomp = used_buf;
tmpbuf = *nxtbuf++;
startbody = NULL;
dat[0] = innum ? innum : outnum;
dat[1] = curflg;
dat[4] = unseen;
/*
* Get the first field. If the message is non-empty
* and we're doing an "inc", open the output file.
*/
bufsz = rlwidth;
m_getfld_state_reset (&gstate);
if ((state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb)) == FILEEOF) {
if (ferror(inb)) {
advise("read", "unable to"); /* "read error" */
return SCNFAT;
} else {
return SCNEOF;
}
}
if (outnum) {
if (outnum > 0) {
scnmsg = m_name (outnum);
if (*scnmsg == '?') /* msg num out of range */
return SCNNUM;
} else {
scnmsg = "/dev/null";
}
if ((scnout = fopen (scnmsg, "w")) == NULL)
adios (scnmsg, "unable to write");
}
/* scan - main loop */
for (compnum = 1; ;
bufsz = rlwidth, state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb)) {
switch (state) {
case FLD:
case FLDPLUS:
compnum++;
if (outnum) {
FPUTS (name);
if ( putc (':', scnout) == EOF) DIEWRERR();
FPUTS (tmpbuf);
}
/*
* if we're interested in this component, save a pointer
* to the component text, then start using our next free
* buffer as the component temp buffer (buffer switching
* saves an extra copy of the component text).
*/
if ((cptr = fmt_findcasecomp(name))) {
if (! cptr->c_text) {
cptr->c_text = tmpbuf;
for (cp = tmpbuf + strlen (tmpbuf) - 1;
cp >= tmpbuf; cp--)
if (isspace ((unsigned char) *cp))
*cp = 0;
else
break;
*--savecomp = cptr;
tmpbuf = *nxtbuf++;
}
}
while (state == FLDPLUS) {
bufsz = rlwidth;
state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb);
if (outnum)
FPUTS (tmpbuf);
}
break;
case BODY:
compnum = -1;
/*
* A slight hack ... if we have less than rlwidth characters
* in the buffer, call m_getfld again.
*/
if ((i = strlen(tmpbuf)) < rlwidth) {
bufsz = rlwidth - i;
state = m_getfld (&gstate, name, tmpbuf + i, &bufsz, inb);
}
if (! outnum) {
state = FILEEOF; /* stop now if scan cmd */
if (bodycomp && startbody == NULL)
startbody = tmpbuf;
goto finished;
}
if (putc ('\n', scnout) == EOF) DIEWRERR();
FPUTS (tmpbuf);
/*
* The previous code here used to call m_getfld() using
* pointers to the underlying output stdio buffers to
* avoid the extra copy. Tests by Markus Schnalke show
* no noticable performance loss on larger mailboxes
* if we incur an extra copy, and messing around with
* internal stdio buffers is becoming more and more
* unportable as times go on. So from now on just deal
* with the overhead of an extra copy.
*
* Subtle change - with the previous code tmpbuf wasn't
* used, so we could reuse it for the {body} component.
* Now since we're using tmpbuf as our read buffer we
* need to save the beginning of the body for later.
* See the above (and below) use of startbody.
*/
body:;
if (bodycomp && startbody == NULL) {
startbody = tmpbuf;
tmpbuf = *nxtbuf++;
}
while (state == BODY) {
bufsz = rlwidth;
state = m_getfld (&gstate, name, tmpbuf, &bufsz, inb);
FPUTS(tmpbuf);
}
goto finished;
case LENERR:
case FMTERR:
if (innum)
fprintf (stderr, "??Format error (message %d) in ",
outnum ? outnum : innum);
else
fprintf (stderr, "??Format error in ");
fprintf (stderr, "component %d\n", compnum);
if (outnum) {
FPUTS ("\n\nBAD MSG:\n");
FPUTS (name);
if (putc ('\n', scnout) == EOF) DIEWRERR();
state = BODY;
goto body;
}
/* fall through */
case FILEEOF:
goto finished;
default:
adios (NULL, "getfld() returned %d", state);
}
}
/*
* format and output the scan line.
*/
finished:
if (ferror(inb)) {
advise("read", "unable to"); /* "read error" */
return SCNFAT;
}
/* Save and restore buffer so we don't trash our dynamic pool! */
if (bodycomp) {
saved_c_text = bodycomp->c_text;
bodycomp->c_text = startbody;
}
if (size)
dat[2] = size;
else if (outnum > 0)
{
dat[2] = ftell(scnout);
if (dat[2] == EOF) DIEWRERR();
}
if ((datecomp && !datecomp->c_text) || (!size && !outnum)) {
struct stat st;
fstat (fileno(inb), &st);
if (!size && !outnum)
dat[2] = st.st_size;
if (datecomp) {
if (! datecomp->c_text) {
if (datecomp->c_tws == NULL)
datecomp->c_tws = (struct tws *)
calloc((size_t) 1, sizeof(*datecomp->c_tws));
if (datecomp->c_tws == NULL)
adios (NULL, "unable to allocate tws buffer");
*datecomp->c_tws = *dlocaltime ((time_t *) &st.st_mtime);
datecomp->c_flags |= CF_DATEFAB|CF_TRUE;
} else {
datecomp->c_flags &= ~CF_DATEFAB;
}
}
}
fmt_scan (fmt, scanl, scanl_size, slwidth, dat, NULL);
if (bodycomp)
bodycomp->c_text = saved_c_text;
if (noisy)
fputs (scanl, stdout);
cptr = fmt_findcomp ("encrypted");
encrypted = cptr && cptr->c_text;
/* return dynamically allocated buffers to pool */
while ((cptr = *savecomp++)) {
cptr->c_text = NULL;
}
if (outnum && (ferror(scnout) || fclose (scnout) == EOF))
DIEWRERR();
return (state != FILEEOF ? SCNERR : encrypted ? SCNENC : SCNMSG);
}
void
ruserpass(char *host, char **aname, char **apass)
{
char *hdir, buf[BUFSIZ];
int t, usedefault = 0;
struct stat stb;
hdir = getenv("HOME");
if (hdir == NULL)
hdir = ".";
snprintf(buf, sizeof(buf), "%s/.netrc", hdir);
cfile = fopen(buf, "r");
if (cfile == NULL) {
if (errno != ENOENT)
perror(buf);
goto done;
}
while ((t = token())) {
switch(t) {
case DEFAULT:
usedefault = 1;
/* FALL THROUGH */
case MACH:
if (!usedefault) {
if (token() != ID)
continue;
/*
* Allow match either for user's host name.
*/
if (mh_strcasecmp(host, tokval) == 0)
goto match;
continue;
}
match:
while ((t = token()) && t != MACH && t != DEFAULT) {
switch(t) {
case LOGIN:
if (token() && *aname == 0) {
*aname = mh_xmalloc((size_t) strlen(tokval) + 1);
strcpy(*aname, tokval);
}
break;
case PASSWD:
if (fstat(fileno(cfile), &stb) >= 0 &&
(stb.st_mode & 077) != 0) {
/* We make this a fatal error to force the user to correct it */
advise(NULL, "Error - ~/.netrc file must not be world or group readable.");
adios(NULL, "Remove password or correct file permissions.");
}
if (token() && *apass == 0) {
*apass = mh_xmalloc((size_t) strlen(tokval) + 1);
strcpy(*apass, tokval);
}
break;
case ACCOUNT:
break;
case MACDEF:
goto done_close;
break;
default:
fprintf(stderr, "Unknown .netrc keyword %s\n", tokval);
break;
}
}
goto done;
}
}
done_close:
fclose(cfile);
done:
if (!*aname) {
char tmp[80];
char *myname;
if ((myname = getlogin()) == NULL) {
struct passwd *pp;
if ((pp = getpwuid (getuid())) != NULL)
myname = pp->pw_name;
}
printf("Name (%s:%s): ", host, myname);
fgets(tmp, sizeof(tmp) - 1, stdin);
tmp[strlen(tmp) - 1] = '\0';
if (*tmp != '\0') {
myname = tmp;
}
*aname = mh_xmalloc((size_t) strlen(myname) + 1);
strcpy (*aname, myname);
}
if (!*apass) {
char prompt[256];
char *mypass;
snprintf(prompt, sizeof(prompt), "Password (%s:%s): ", host, *aname);
mypass = nmh_getpass(prompt);
if (*mypass == '\0') {
mypass = *aname;
}
*apass = mh_xmalloc((size_t) strlen(mypass) + 1);
strcpy (*apass, mypass);
}
}
int
main(int argc, char **argv)
{
int i;
char *cp, *maildir, *folder = NULL;
char **argp;
char **arguments, buf[BUFSIZ];
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp;
if (nmh_init(argv[0], 1)) { return 1; }
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
/*
* Parse arguments
*/
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
invo_name);
print_help (buf, switches, 1);
done (0);
case VERSIONSW:
print_version(invo_name);
done (0);
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else
app_msgarg(&msgs, cp);
}
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
/* If no messages are given, print folder pathname */
if (!msgs.size) {
printf ("%s\n", maildir);
done (0);
}
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder, 1)))
adios (NULL, "unable to read folder %s", folder);
/*
* We need to make sure there is message status space
* for all the message numbers from 1 to "new" since
* mhpath can select empty slots. If we are adding
* space at the end, we go ahead and add 10 slots.
*/
if (mp->hghmsg >= mp->hghoff) {
if (!(mp = folder_realloc (mp, 1, mp->hghmsg + 10)))
adios (NULL, "unable to allocate folder storage");
} else if (mp->lowoff > 1) {
if (!(mp = folder_realloc (mp, 1, mp->hghoff)))
adios (NULL, "unable to allocate folder storage");
}
mp->msgflags |= ALLOW_NEW; /* allow the "new" sequence */
/* parse all the message ranges/sequences and set SELECTED */
for (i = 0; i < msgs.size; i++)
if (!m_convert (mp, msgs.msgs[i]))
done (1);
seq_setprev (mp); /* set the previous-sequence */
/* print the path of all selected messages */
for (i = mp->lowsel; i <= mp->hghsel; i++)
if (is_selected (mp, i))
printf ("%s/%s\n", mp->foldpath, m_name (i));
seq_save (mp); /* synchronize message sequences */
context_save (); /* save the context file */
folder_free (mp); /* free folder/message structure */
done (0);
return 1;
}
int main(int argc, char *argv[])
{
MPI_Init(&argc, &argv);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
/** Application variable */
std::vector<float> myFloats = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> myInts = {0, -1, -2, -3, -4, -5, -6, -7, -8, -9};
const std::size_t Nx = myFloats.size();
try
{
/** ADIOS class factory of IO class objects, DebugON is recommended */
adios2::ADIOS adios(MPI_COMM_WORLD, adios2::DebugON);
/*** IO class object: settings and factory of Settings: Variables,
* Parameters, Transports, and Execution: Engines */
adios2::IO &bpIO = adios.DeclareIO("BPFile_N2N");
/// Setting flush policy
// the user can set the memory explicitly for ADIOS (more advance users)
bpIO.SetSingleParameter("MaxBufferSize", "100Mb");
// or by number of steps (naively trying to allocate "N=3" steps before
// flushing
// bpIO.SetSingleParameter("StepsToBuffer", "3");
/** global array : name, { shape (total) }, { start (local) }, {
* count
* (local) }, all are constant dimensions */
adios2::Variable<float> &bpFloats = bpIO.DefineVariable<float>(
"bpFloats", {size * Nx}, {rank * Nx}, {Nx}, adios2::ConstantDims);
adios2::Variable<int> &bpInts = bpIO.DefineVariable<int>(
"bpInts", {size * Nx}, {rank * Nx}, {Nx}, adios2::ConstantDims);
/** Engine derived class, spawned to start IO operations */
/** Deferred Mode: Write buffering will be done at Put(), the user makes
* the commitment that pointers passed at Write won't be reused */
auto bpWriter = bpIO.Open("myVector.bp",
adios2::Mode::Write | adios2::Mode::Deferred);
// default = 0, in bp1 format this is translated to 1, but user should
// be able to start at any step
bpWriter.SetStep(1);
/** Write variable for buffering */
for (unsigned int t = 0; t < 100; ++t)
{
bpWriter.Write<float>(bpFloats, myFloats.data());
bpWriter.Write<int>(bpInts, myInts.data());
bpWriter.Advance(); // advances step
if (t % 10 == 0) // checkpoint/restart every 10 steps, force flush
{
bpWriter.Flush();
}
}
/** Engine becomes unreachable after Close */
bpWriter.Close();
}
catch (std::invalid_argument &e)
{
std::cout << "Invalid argument exception, STOPPING PROGRAM from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::ios_base::failure &e)
{
std::cout << "IO System base failure exception, STOPPING PROGRAM "
"from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::exception &e)
{
std::cout << "Exception, STOPPING PROGRAM from rank " << rank << "\n";
std::cout << e.what() << "\n";
}
MPI_Finalize();
return 0;
}
void
adios (char *what, char *fmt)
{
adios (what, fmt);
}
int main(int argc, char *argv[])
{
MPI_Init(&argc, &argv);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
/** Application variable */
std::vector<float> myFloats = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
std::vector<int> myInts = {0, -1, -2, -3, -4, -5, -6, -7, -8, -9};
const std::size_t Nx = myFloats.size();
try
{
/** ADIOS class factory of IO class objects, DebugON is recommended */
adios2::ADIOS adios(MPI_COMM_WORLD, adios2::DebugON);
/*** IO class object: settings and factory of Settings: Variables,
* Parameters, Transports, and Execution: Engines */
adios2::IO &bpIO = adios.DeclareIO("BPFile_N2N");
/** global array : name, { shape (total) }, { start (local) }, {
* count
* (local) }, all are constant dimensions */
adios2::Variable<float> &bpFloats = bpIO.DefineVariable<float>(
"bpFloats", {size * Nx}, {rank * Nx}, {Nx}, adios2::ConstantDims);
adios2::Variable<int> &bpInts = bpIO.DefineVariable<int>(
"bpInts", {size * Nx}, {rank * Nx}, {Nx}, adios2::ConstantDims);
/** Engine derived class, spawned to start IO operations */
/** Deferred Mode: Write buffering will be done at Flush().
* The user must be the one enforcing the commitment that pointers
* passed at Write won't be reused between Write and Flush */
auto bpWriter = bpIO.Open("myVector.bp",
adios2::Mode::Write | adios2::Mode::Deferred);
for (unsigned int t = 0; t < 100; ++t)
{
/** Write variable for buffering */
bpWriter.Write<float>(bpFloats, myFloats.data());
bpWriter.Write<int>(bpInts, myInts.data());
bpWriter.Flush();
}
/** Create bp file, engine becomes unreachable after this*/
bpWriter.Close();
}
catch (std::invalid_argument &e)
{
std::cout << "Invalid argument exception, STOPPING PROGRAM from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::ios_base::failure &e)
{
std::cout << "IO System base failure exception, STOPPING PROGRAM "
"from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::exception &e)
{
std::cout << "Exception, STOPPING PROGRAM from rank " << rank << "\n";
std::cout << e.what() << "\n";
}
MPI_Finalize();
return 0;
}
static int putaux (char* src, char* dst, int append, int fd, PE pe,struct vfsmap*vf, int size)
#endif
{
int n;
int cc,
effector,
gd,
nc,
reason,
result;
PE de,
param;
#ifdef BRIDGE
char line[BUFSIZ];
#endif
struct FADUidentity faduids;
struct FADUidentity *faduid = &faduids;
struct FTAMgroup ftgs;
struct FTAMgroup *ftg = &ftgs;
struct FTAMindication ftis;
struct FTAMindication *fti = &ftis;
struct FTAMabort *fta = &fti -> fti_abort;
FILE *fp;
pe -> pe_context = vf -> vf_id;
param = NULLPE;
if (vf -> vf_parameter
&& enc_f (vf -> vf_number, &_ZDOCS_mod, ¶m, 1, 0, NULLCP,
vf -> vf_parameter) == NOTOK) {
advise (NULLCP, "unable to build document type parameter: %s",
PY_pepy);
return NOTOK;
}
bzero ((char *) ftg, sizeof *ftg);
ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
ftg -> ftg_threshold = 0;
if (omode == FOVER_SELECT)
append = 1;
if (units & FUNIT_LIMITED) {
ftg -> ftg_flags |= FTG_CREATE;
{
struct FTAMcreate *ftce = &ftg -> ftg_create;
struct FTAMattributes *fa = &ftce -> ftce_attrs;
ftce -> ftce_override = append ? FOVER_SELECT : omode;
fa -> fa_present = FA_FILENAME;
fa -> fa_nfile = 0;
fa -> fa_files[fa -> fa_nfile++] = dst;
fa -> fa_present |= FA_ACTIONS;
fa -> fa_permitted = FA_PERM_READ | FA_PERM_REPLACE
| FA_PERM_EXTEND | FA_PERM_READATTR
| FA_PERM_CHNGATTR | FA_PERM_DELETE
| FA_PERM_TRAV;
fa -> fa_present |= FA_CONTENTS;
fa -> fa_contents = vf -> vf_oid;
fa -> fa_parameter = param;
ftce -> ftce_access = append ? FA_PERM_EXTEND : FA_PERM_REPLACE;
FCINIT (&ftce -> ftce_conctl);
}
} else {
ftg -> ftg_flags |= FTG_SELECT;
{
struct FTAMselect *ftse = &ftg -> ftg_select;
struct FTAMattributes *fa = &ftse -> ftse_attrs;
if (!append && omode == FOVER_FAIL) {
advise (NULLCP,
"lack of limited-file-management conflicts with setting of \"override\" variable");
return NOTOK;
}
fa -> fa_present = FA_FILENAME;
fa -> fa_nfile = 0;
fa -> fa_files[fa -> fa_nfile++] = dst;
ftse -> ftse_access = append ? FA_PERM_EXTEND : FA_PERM_REPLACE;
FCINIT (&ftse -> ftse_conctl);
}
}
ftg -> ftg_threshold++;
ftg -> ftg_flags |= FTG_OPEN;
{
struct FTAMopen *ftop = &ftg -> ftg_open;
ftop -> ftop_contents = vf -> vf_oid;
ftop -> ftop_parameter = param;
FCINIT (&ftop -> ftop_conctl);
if (append) {
ftop -> ftop_mode = FA_PERM_EXTEND;
if (concurrency)
ftop -> ftop_conctl.fc_extendlock = FLOCK_EXCLUSIVE;
} else {
ftop -> ftop_mode = FA_PERM_REPLACE;
if (concurrency)
ftop -> ftop_conctl.fc_replacelock = FLOCK_EXCLUSIVE;
}
}
ftg -> ftg_threshold++;
result = FBulkBeginRequest (ftamfd, ftg, fti);
if (param)
pe_free (param);
if (result == NOTOK) {
ftam_advise (fta, "F-BULK-BEGIN.REQUEST");
return NOTOK;
}
ftg = &fti -> fti_group;
if (ftg -> ftg_flags & FTG_SELECT) {
struct FTAMselect *ftse = &ftg -> ftg_select;
ftam_diag (ftse -> ftse_diags, ftse -> ftse_ndiag, 1,
ftse -> ftse_action);
if (ftse -> ftse_state != FSTATE_SUCCESS)
goto you_lose;
} else if (ftg -> ftg_flags & FTG_CREATE) {
struct FTAMcreate *ftce = &ftg -> ftg_create;
ftam_diag (ftce -> ftce_diags, ftce -> ftce_ndiag, 1,
ftce -> ftce_action);
if (ftce -> ftce_state != FSTATE_SUCCESS)
goto you_lose;
}
if (ftg -> ftg_flags & FTG_OPEN) {
struct FTAMopen *ftop = &ftg -> ftg_open;
ftam_diag (ftop -> ftop_diags, ftop -> ftop_ndiag, 1,
ftop -> ftop_action);
if (ftop -> ftop_state != FSTATE_SUCCESS)
goto you_lose;
for (myvf = vfs; myvf -> vf_entry; myvf++)
if (oid_cmp (myvf -> vf_oid, ftop -> ftop_contents) == 0)
break;
switch (myvf - vfs) {
case VFS_UTF:
pe -> pe_id = (PElementID)
((struct type_DOCS_FTAM__1__Parameters *)
myvf -> vf_parameter)
-> universal__class__number;
/* and fall... */
case VFS_UBF:
effector = 1;
if (ftop -> ftop_parameter && myvf -> vf_number >= 0) {
caddr_t parm = NULL;
if (dec_f (myvf -> vf_number, &_ZDOCS_mod,
ftop -> ftop_parameter, 1, NULLIP, NULLVP,
&parm) == NOTOK)
advise (NULLCP,
"unable to parse document type parameter: %s",
PY_pepy);
else
switch (myvf - vfs) {
case VFS_UTF: {
struct type_DOCS_FTAM__1__Parameters *p1 =
(struct type_DOCS_FTAM__1__Parameters *)
parm;
if (p1 -> optionals
& opt_DOCS_FTAM__1__Parameters_universal__class__number)
pe -> pe_id = (PElementID)
p1 -> universal__class__number;
else
pe -> pe_id = PE_DEFN_GFXS;
switch (pe -> pe_id) {
case PE_DEFN_GFXS:
if (getenv ("HP-FTAM")) {
effector = 1;
break;
} /* else fall... */
case PE_DEFN_PRTS:
case PE_DEFN_VISS:
effector = 0;
break;
case PE_DEFN_T61S:
case PE_DEFN_VTXS:
case PE_DEFN_IA5S:
case PE_DEFN_GENS:
effector = 1;
break;
default:
break;
}
}
break;
case VFS_UBF:
default:
break;
}
if (parm)
fre_obj (parm,
_ZDOCS_mod.md_dtab[myvf -> vf_number],
&_ZDOCS_mod, 1);
}
if (debug)
advise (NULLCP, "effector=%d id=0x%x",
effector, pe -> pe_id);
if (myvf != vf || watch) {
advise (NULLCP, "%s transfer", myvf -> vf_text);
vf = myvf;
}
break;
default:
vf = &vfs[VFS_UBF];
advise (NULLCP, "document type mismatch; assuming %s (%s)",
vf -> vf_text, vf -> vf_entry);
break;
}
}
myvf = vf;
FTGFREE (ftg);
faduid -> fa_type = FA_FIRSTLAST;
faduid -> fa_firstlast = FA_FIRST;
if (FReadWriteRequest (ftamfd, append ? FA_OPS_EXTEND : FA_OPS_REPLACE,
faduid, myvf -> vf_context, NOTOK, 0, fti) == NOTOK) {
ftam_advise (fta, "F-READWRITE.REQUEST");
return NOTOK;
}
switch (myvf - vfs) {
case VFS_UTF:
if ((gd = dup (fd)) == NOTOK || (fp = fdopen (gd, "r")) == NULL) {
if (gd != NOTOK)
close (gd);
#ifdef BRIDGE
advise (dst, gd != NOTOK ? "fdopen failed" : "unable to dup");
#else
advise (src, gd != NOTOK ? "fdopen failed on"
: "unable to dup");
#endif
reason = FS_ACC_LCL;
goto do_cancel;
}
break;
case VFS_UBF:
default:
fp = NULL;
break;
}
cc = 0;
if (verbose)
timer (cc, NULLCP);
if (hash)
marks = BUFSIZ - 1;
#ifdef BRIDGE
line[0] = '\0';
#endif
for (;;) {
char *bp,
*ep;
if (!interrupted) {
int nfds;
fd_set wfds;
nfds = 0;
FD_ZERO (&wfds);
/* interrupt causes EINTR */
if (FSelectMask (ftamfd, &wfds, &nfds, fti) == OK)
xselect (nfds, NULLFD, &wfds, NULLFD, NOTOK);
}
if (interrupted) {
advise (NULLCP, "cancelling transfer");
reason = FS_GEN_INITIATOR;
errno = EINTR;
goto do_cancel;
}
for (ep = (bp = (char *) pe -> pe_prim) + size - (fp ? 2 : 0), nc = 0;
bp < ep; ) {
if (fp) {
char *cp;
#ifdef BRIDGE
if (strlen (line) || fgets (line, BUFSIZ, fp)) {
if ((int)(strlen(line) + 1) < (ep - bp - 1)) {
strcpy (bp, line);
line[0] = NULL;
} else
break;
} else {
#else
if (fgets (bp, ep - bp + 1, fp) == NULL) {
#endif
n = (ferror (fp) && !feof (fp)) ? NOTOK : OK;
break;
}
cp = bp + strlen (bp) - 1;
if (!effector) {
if (*cp == '\n') {
#ifndef BRIDGE
*cp = NULL;
#else
if (cp > bp) {
if (*--cp == '\r')
*cp = NULL;
else
*++cp = NULL;
} else
*cp = NULL;
#endif
n = cp - bp;
bp = cp;
} else { /* XXX: losing! */
n = cp - bp + 1;
bp = cp + 1;
}
} else {
if (*cp == '\n') {
#ifndef BRIDGE
*cp++ = '\r';
#endif
*cp++ = '\n';
n = cp - bp;
bp = cp;
nc++;
continue;
}
n = cp - bp + 1;
bp = cp + 1;
}
}
else {
#ifdef BRIDGE
switch (n = read (fd, bp, ep - bp)) {
#else
switch (n = read (fd, bp, ep - bp)) {
#endif
case NOTOK:
case OK:
break;
default:
bp += n;
continue;
}
}
break;
}
if (n == NOTOK || (n = bp - (char *) pe -> pe_prim) == 0)
break;
pe -> pe_len = n;
if (fp && !effector) {
if ((de = pe_cpy (pe)) == NULLPE) {
reason = FS_ACC_LCL;
errno = ENOMEM;
goto do_cancel;
}
} else
de = pe;
if (debug) {
if (fp) {
WATCHP (DOCS_FTAM__1__Datatype1, de, 0);
} else
WATCHP (DOCS_FTAM__3__Datatype1, de, 0);
}
switch (de2fadu (de, pe != de ? 1 : 0)) {
case NOTOK:
if (fp)
fclose (fp);
return NOTOK;
case OK:
default:
if (verbose || hash)
cc += (n - nc), nc = 0;
if (hash) {
if (hash > 1)
printf ("%d\r", cc);
else
for (; marks < cc; marks += BUFSIZ)
putchar ('#');
fflush (stdout);
}
break;
case DONE:
de2fadu (NULLPE, 0);
if (fp)
fclose (fp);
goto done_transfer;
}
}
if (verbose)
timer (cc, "sent");
if (fp)
fclose (fp);
if (n == NOTOK) {
struct FTAMdiagnostic diags[NFDIAG];
struct FTAMdiagnostic *dp;
#ifdef BRIDGE
advise (dst, "error reading");
#else
advise (src, "error reading");
#endif
reason = FS_ACC_LCLDEV;
do_cancel:
;
dp = diags;
dp -> ftd_type = DIAG_PERM;
dp -> ftd_identifier = reason;
dp -> ftd_observer = dp -> ftd_source = EREF_IFSU;
dp -> ftd_delay = DIAG_NODELAY;
strcpy (dp -> ftd_data, sys_errname (errno));
dp -> ftd_cc = strlen (dp -> ftd_data);
dp++;
de2fadu (NULLPE, 0);
if (FCancelRequest (ftamfd, FACTION_PERM, NULLPE, diags, dp - diags,
fti) == NOTOK) {
ftam_advise (fta, "F-CANCEL.REQUEST");
return NOTOK;
}
if (fti -> fti_type == FTI_CANCEL) {
struct FTAMcancel *ftcn = &fti -> fti_cancel;
ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
ftcn -> ftcn_action);
FTCNFREE (ftcn);
}
goto done_transfer;
}
if (n == OK)
n = de2fadu (NULLPE, 1);
if (FDataEndRequest (ftamfd, FACTION_SUCCESS, (struct FTAMdiagnostic *) 0,
0, fti) == NOTOK) {
ftam_advise (fta, "F-DATA-END.REQUEST");
return NOTOK;
}
if (FTransEndRequest (ftamfd, NULLPE, fti) == NOTOK) {
ftam_advise (fta, "F-TRANSFER-END.REQUEST");
return NOTOK;
}
switch (fti -> fti_type) {
case FTI_TRANSEND: {
struct FTAMtransend *ftre = &fti -> fti_transend;
ftam_diag (ftre -> ftre_diags, ftre -> ftre_ndiag, 1,
ftre -> ftre_action);
FTREFREE (ftre);
}
break;
case FTI_CANCEL: {
struct FTAMcancel *ftcn = &fti -> fti_cancel;
advise (NULLCP, "data transfer canceled!");
ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
ftcn -> ftcn_action);
FTCNFREE (ftcn);
if (FCancelResponse (ftamfd, FACTION_SUCCESS, NULLPE,
(struct FTAMdiagnostic *) 0, 0, fti) == NOTOK) {
ftam_advise (fta, "F-CANCEL.RESPONSE");
return NOTOK;
}
}
break;
default:
adios (NULLCP, "unexpected indication type=%d", fti -> fti_type);
}
done_transfer:
;
ftg = &ftgs;
bzero ((char *) ftg, sizeof *ftg);
ftg -> ftg_flags |= FTG_BEGIN | FTG_END;
ftg -> ftg_threshold = 0;
ftg -> ftg_flags |= FTG_CLOSE;
ftg -> ftg_threshold++;
ftg -> ftg_flags |= FTG_DESELECT;
ftg -> ftg_threshold++;
if (FBulkEndRequest (ftamfd, ftg, fti) == NOTOK) {
ftam_advise (fta, "F-BULK-END.REQUEST");
return NOTOK;
}
ftg = &fti -> fti_group;
if (ftg -> ftg_flags & FTG_CLOSE) {
struct FTAMclose *ftcl = &ftg -> ftg_close;
ftam_diag (ftcl -> ftcl_diags, ftcl -> ftcl_ndiag, 1,
ftcl -> ftcl_action);
}
if (ftg -> ftg_flags & FTG_DESELECT) {
struct FTAMdeselect *ftde = &ftg -> ftg_deselect;
ftam_diag (ftde -> ftde_diags, ftde -> ftde_ndiag, 1,
ftde -> ftde_action);
ftam_chrg (&ftde -> ftde_charges);
}
FTGFREE (ftg);
return OK;
you_lose:
;
FTGFREE (ftg);
return NOTOK;
}
/* */
int de2fadu (pe, concat)
PE pe;
int concat;
{
int result;
struct FTAMindication ftis;
struct FTAMindication *fti = &ftis;
struct FTAMabort *fta = &fti -> fti_abort;
static int ninfo = 0;
static int size = 0;
static PE info[NPDATA];
if (pe == NULLPE) {
result = OK;
if (concat
&& ninfo > 0
&& FDataRequest (ftamfd, info, ninfo, fti) == NOTOK) {
ftam_advise (fta, "F-DATA.REQUEST");
result = NOTOK;
}
while (ninfo > 0)
pe_free (info[--ninfo]);
size = 0;
return result;
}
if (concat) {
int flush,
n;
if (size + (n = ps_get_abs (pe) + MAGIC_OCTET2) >= fadusize
&& ninfo > 0) {
if (debug)
advise (NULLCP,
"de2fadu flushing on %d FADUs, estimated size %d/%d",
ninfo, size, fadusize);
if ((result = de2fadu (NULLPE, 1)) != OK)
return result;
flush = 1;
} else
flush = 0;
info[ninfo++] = pe;
size += n;
if (ninfo < NPDATA && size < fadusize) {
if (!flush)
return OK;
} else {
if ((result = FDataRequest (ftamfd, info, ninfo, fti)) == NOTOK)
ftam_advise (fta, "F-DATA.REQUEST");
while (ninfo > 0)
pe_free (info[--ninfo]);
size = 0;
if (result == NOTOK)
return result;
}
} else if (FDataRequest (ftamfd, &pe, 1, fti) == NOTOK) {
ftam_advise (fta, "F-DATA.REQUEST");
return NOTOK;
}
if (FWaitRequest (ftamfd, OK, fti) == NOTOK) {
if (fta -> fta_peer
|| fta -> fta_action != FACTION_TRANS
|| fta -> fta_ndiag < 1
|| fta -> fta_diags[0].ftd_type != DIAG_TRANS
|| fta -> fta_diags[0].ftd_identifier != FS_PRO_TIMEOUT) {
ftam_advise (fta, "F-WAIT.REQUEST");
return NOTOK;
}
return OK;
}
if (fti -> fti_type == FTI_CANCEL) {
struct FTAMcancel *ftcn = &fti -> fti_cancel;
advise (NULLCP, "data transfer cancelled!");
ftam_diag (ftcn -> ftcn_diags, ftcn -> ftcn_ndiag, 1,
ftcn -> ftcn_action);
FTCNFREE (ftcn);
if (FCancelResponse (ftamfd, FACTION_SUCCESS, NULLPE,
(struct FTAMdiagnostic *) 0, 0, fti) == NOTOK) {
ftam_advise (fta, "F-CANCEL.RESPONSE");
return NOTOK;
}
}
return DONE;
}
int
main (int argc, char **argv)
{
int anot = 0, inplace = 1, nedit = 0;
int nwhat = 0, i, in, isdf = 0, out;
char *cp, *cwd, *maildir, *msgnam, *dfolder = NULL;
char *dmsg = NULL, *ed = NULL, *file = NULL, *folder = NULL;
char *form = NULL, *msg = NULL, buf[BUFSIZ], drft[BUFSIZ];
char **argp, **arguments;
struct msgs *mp = NULL;
struct stat st;
#ifdef LOCALE
setlocale(LC_ALL, "");
#endif
invo_name = r1bindex (argv[0], '/');
/* read user profile/context */
context_read();
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msg] [switches]",
invo_name);
print_help (buf, switches, 1);
done (1);
case VERSIONSW:
print_version(invo_name);
done (1);
case ANNOSW:
anot++;
continue;
case NANNOSW:
anot = 0;
continue;
case EDITRSW:
if (!(ed = *argp++) || *ed == '-')
adios (NULL, "missing argument to %s", argp[-2]);
nedit = 0;
continue;
case NEDITSW:
nedit++;
continue;
case WHATSW:
if (!(whatnowproc = *argp++) || *whatnowproc == '-')
adios (NULL, "missing argument to %s", argp[-2]);
nwhat = 0;
continue;
case NWHATSW:
nwhat++;
continue;
case FILESW:
if (file)
adios (NULL, "only one file at a time!");
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
file = path (cp, TFILE);
continue;
case FORMSW:
if (!(form = *argp++) || *form == '-')
adios (NULL, "missing argument to %s", argp[-2]);
continue;
case INPLSW:
inplace++;
continue;
case NINPLSW:
inplace = 0;
continue;
case DFOLDSW:
if (dfolder)
adios (NULL, "only one draft folder at a time!");
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
dfolder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
*cp != '@' ? TFOLDER : TSUBCWF);
continue;
case DMSGSW:
if (dmsg)
adios (NULL, "only one draft message at a time!");
if (!(dmsg = *argp++) || *dmsg == '-')
adios (NULL, "missing argument to %s", argp[-2]);
continue;
case NDFLDSW:
dfolder = NULL;
isdf = NOTOK;
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else {
if (msg)
adios (NULL, "only one message at a time!");
else
msg = cp;
}
}
cwd = getcpy (pwd ());
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (file && (msg || folder))
adios (NULL, "can't mix files and folders/msgs");
in = open_form(&form, distcomps);
try_it_again:
strncpy (drft, m_draft (dfolder, dmsg, NOUSE, &isdf), sizeof(drft));
/* Check if draft already exists */
if (stat (drft, &st) != NOTOK) {
printf ("Draft \"%s\" exists (%ld bytes).", drft, (long) st.st_size);
for (i = LISTDSW; i != YESW;) {
if (!(argp = getans ("\nDisposition? ", isdf ? aqrnl : aqrl)))
done (1);
switch (i = smatch (*argp, isdf ? aqrnl : aqrl)) {
case NOSW:
done (0);
case NEWSW:
dmsg = NULL;
goto try_it_again;
case YESW:
break;
case LISTDSW:
showfile (++argp, drft);
break;
case REFILSW:
if (refile (++argp, drft) == 0)
i = YESW;
break;
default:
advise (NULL, "say what?");
break;
}
}
}
if ((out = creat (drft, m_gmprot ())) == NOTOK)
adios (drft, "unable to create");
cpydata (in, out, form, drft);
close (in);
close (out);
if (file) {
/*
* Dist a file
*/
anot = 0; /* don't want to annotate a file */
} else {
/*
* Dist a message
*/
if (!msg)
msg = "cur";
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder)))
adios (NULL, "unable to read folder %s", folder);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", folder);
/* parse the message range/sequence/name and set SELECTED */
if (!m_convert (mp, msg))
done (1);
seq_setprev (mp); /* set the previous-sequence */
if (mp->numsel > 1)
adios (NULL, "only one message at a time!");
}
msgnam = file ? file : getcpy (m_name (mp->lowsel));
if ((in = open (msgnam, O_RDONLY)) == NOTOK)
adios (msgnam, "unable to open message");
if (!file) {
context_replace (pfolder, folder);/* update current folder */
seq_setcur (mp, mp->lowsel); /* update current message */
seq_save (mp); /* synchronize sequences */
context_save (); /* save the context file */
}
if (nwhat)
done (0);
what_now (ed, nedit, NOUSE, drft, msgnam, 1, mp,
anot ? "Resent" : NULL, inplace, cwd);
done (1);
return 1;
}
char *
m_draft (char *folder, char *msg, int use, int *isdf)
{
register char *cp;
register struct msgs *mp;
static char buffer[BUFSIZ];
if (*isdf == -1 || folder == NULL || *folder == '\0') {
if (*isdf == -1 || (cp = context_find ("Draft-Folder")) == NULL) {
*isdf = 0;
return m_maildir (msg && *msg ? msg : draft);
} else {
folder = path (*cp == '+' || *cp == '@' ? cp + 1 : cp,
*cp != '@' ? TFOLDER : TSUBCWF);
}
}
*isdf = 1;
chdir (m_maildir (""));
strncpy (buffer, m_maildir (folder), sizeof(buffer));
create_folder (buffer, 0, done);
if (chdir (buffer) == -1)
adios (buffer, "unable to change directory to");
if (!(mp = folder_read (folder)))
adios (NULL, "unable to read folder %s", folder);
/*
* Make sure we have enough message status space for all
* the message numbers from 1 to "new", since we might
* select an empty slot. If we add more space at the
* end, go ahead and add 10 additional slots.
*/
if (mp->hghmsg >= mp->hghoff) {
if (!(mp = folder_realloc (mp, 1, mp->hghmsg + 10)))
adios (NULL, "unable to allocate folder storage");
} else if (mp->lowoff > 1) {
if (!(mp = folder_realloc (mp, 1, mp->hghoff)))
adios (NULL, "unable to allocate folder storage");
}
mp->msgflags |= ALLOW_NEW; /* allow the "new" sequence */
/*
* If we have been give a valid message name, then use that.
* Else, if we are given the "use" option, then use the
* current message. Else, use special sequence "new".
*/
if (!m_convert (mp, msg && *msg ? msg : use ? "cur" : "new"))
done (1);
seq_setprev (mp);
if (mp->numsel > 1)
adios (NULL, "only one message draft at a time!");
snprintf (buffer, sizeof(buffer), "%s/%s", mp->foldpath, m_name (mp->lowsel));
cp = buffer;
seq_setcur (mp, mp->lowsel);/* set current message for folder */
seq_save (mp); /* synchronize message sequences */
folder_free (mp); /* free folder/message structure */
return cp;
}
int
main (int argc, char **argv)
{
int msgnum, *icachesw;
char *cp, *file = NULL, *outfile = NULL, *folder = NULL;
char *maildir, buf[100], **argp;
char **arguments;
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp = NULL;
CT ct, *ctp;
FILE *fp;
if (nmh_init(argv[0], 1)) { return 1; }
done=freects_done;
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
/*
* Parse arguments
*/
while ((cp = *argp++)) {
if (*cp == '-') {
switch (smatch (++cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
done (1);
case UNKWNSW:
adios (NULL, "-%s unknown", cp);
case HELPSW:
snprintf (buf, sizeof(buf), "%s [+folder] [msgs] [switches]",
invo_name);
print_help (buf, switches, 1);
done (0);
case VERSIONSW:
print_version(invo_name);
done (0);
case AUTOSW:
autosw++;
continue;
case NAUTOSW:
autosw = 0;
continue;
case RCACHESW:
icachesw = &rcachesw;
goto do_cache;
case WCACHESW:
icachesw = &wcachesw;
do_cache:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
switch (*icachesw = smatch (cp, caches)) {
case AMBIGSW:
ambigsw (cp, caches);
done (1);
case UNKWNSW:
adios (NULL, "%s unknown", cp);
default:
break;
}
continue;
case CHECKSW:
checksw++;
continue;
case NCHECKSW:
checksw = 0;
continue;
case PARTSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if (npart >= NPARTS)
adios (NULL, "too many parts (starting with %s), %d max",
cp, NPARTS);
parts[npart++] = cp;
continue;
case TYPESW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if (ntype >= NTYPES)
adios (NULL, "too many types (starting with %s), %d max",
cp, NTYPES);
types[ntype++] = cp;
continue;
case FILESW:
if (!(cp = *argp++) || (*cp == '-' && cp[1]))
adios (NULL, "missing argument to %s", argp[-2]);
file = *cp == '-' ? cp : path (cp, TFILE);
continue;
case OUTFILESW:
if (!(cp = *argp++) || (*cp == '-' && cp[1]))
adios (NULL, "missing argument to %s", argp[-2]);
outfile = *cp == '-' ? cp : path (cp, TFILE);
continue;
case VERBSW:
verbosw = 1;
continue;
case NVERBSW:
verbosw = 0;
continue;
case CLOBBERSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
if (save_clobber_policy (cp)) {
adios (NULL, "invalid argument, %s, to %s", argp[-1],
argp[-2]);
}
continue;
case DEBUGSW:
debugsw = 1;
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else
app_msgarg(&msgs, cp);
}
/* null terminate the list of acceptable parts/types */
parts[npart] = NULL;
types[ntype] = NULL;
/*
* Check if we've specified an additional profile
*/
if ((cp = getenv ("MHSTORE"))) {
if ((fp = fopen (cp, "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
} else {
admonish ("", "unable to read $MHSTORE profile (%s)", cp);
}
}
/*
* Read the standard profile setup
*/
if ((fp = fopen (cp = etcpath ("mhn.defaults"), "r"))) {
readconfig ((struct node **) 0, fp, cp, 0);
fclose (fp);
}
/* Check for public cache location */
if ((cache_public = context_find (nmhcache)) && *cache_public != '/')
cache_public = NULL;
/* Check for private cache location */
if (!(cache_private = context_find (nmhprivcache)))
cache_private = ".cache";
cache_private = getcpy (m_maildir (cache_private));
/*
* Cache the current directory before we do any chdirs()'s.
*/
cwd = getcpy (pwd());
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (file && msgs.size)
adios (NULL, "cannot specify msg and file at same time!");
/*
* check if message is coming from file
*/
if (file) {
if (!(cts = (CT *) calloc ((size_t) 2, sizeof(*cts))))
adios (NULL, "out of memory");
ctp = cts;
if ((ct = parse_mime (file))) {
*ctp++ = ct;
if (outfile) {
ct->c_storage = outfile;
}
}
} else {
/*
* message(s) are coming from a folder
*/
if (!msgs.size)
app_msgarg(&msgs, "cur");
if (!folder)
folder = getfolder (1);
maildir = m_maildir (folder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (folder, 1)))
adios (NULL, "unable to read folder %s", folder);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", folder);
/* parse all the message ranges/sequences and set SELECTED */
for (msgnum = 0; msgnum < msgs.size; msgnum++)
if (!m_convert (mp, msgs.msgs[msgnum]))
done (1);
seq_setprev (mp); /* set the previous-sequence */
if (!(cts = (CT *) calloc ((size_t) (mp->numsel + 1), sizeof(*cts))))
adios (NULL, "out of memory");
ctp = cts;
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected(mp, msgnum)) {
char *msgnam;
msgnam = m_name (msgnum);
if ((ct = parse_mime (msgnam))) {
*ctp++ = ct;
if (outfile) {
ct->c_storage = add (outfile, NULL);
}
}
}
}
}
if (!*cts)
done (1);
userrs = 1;
SIGNAL (SIGQUIT, quitser);
SIGNAL (SIGPIPE, pipeser);
/*
* Get the associated umask for the relevant contents.
*/
for (ctp = cts; *ctp; ctp++) {
struct stat st;
ct = *ctp;
if (type_ok (ct, 1) && !ct->c_umask) {
if (stat (ct->c_file, &st) != NOTOK)
ct->c_umask = ~(st.st_mode & 0777);
else
ct->c_umask = ~m_gmprot();
}
}
/*
* Store the message content
*/
store_all_messages (cts);
/* Now free all the structures for the content */
for (ctp = cts; *ctp; ctp++)
free_content (*ctp);
free ((char *) cts);
cts = NULL;
/* If reading from a folder, do some updating */
if (mp) {
context_replace (pfolder, folder);/* update current folder */
seq_setcur (mp, mp->hghsel); /* update current message */
seq_save (mp); /* synchronize sequences */
context_save (); /* save the context file */
}
done (files_not_clobbered);
return 1;
}
int main(int argc, char *argv[])
{
MPI_Init(&argc, &argv);
int rank, size;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &size);
// Application variable
std::vector<float> myFloats = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const std::size_t Nx = myFloats.size();
try
{
/** ADIOS class factory of IO class objects, DebugON (default) is
* recommended */
adios2::ADIOS adios(MPI_COMM_WORLD, adios2::DebugON);
/*** IO class object: settings and factory of Settings: Variables,
* Parameters, Transports, and Execution: Engines */
adios2::IO &bpIO = adios.DeclareIO("BPFile_N2N");
bpIO.SetParameters({{"Threads", "2"}});
/** global array: name, { shape (total dimensions) }, { start
* (local) },
* { count (local) }, all are constant dimensions */
const unsigned int variablesSize = 1;
std::vector<adios2::Variable<float> *> bpFloats(variablesSize);
adios2::Variable<std::string> &bpString =
bpIO.DefineVariable<std::string>("bpString");
for (unsigned int v = 0; v < variablesSize; ++v)
{
std::string namev("bpFloats");
if (v < 10)
{
namev += "00";
}
else if (v < 100)
{
namev += "0";
}
namev += std::to_string(v);
bpFloats[v] = &bpIO.DefineVariable<float>(
namev, {size * Nx}, {rank * Nx}, {Nx}, adios2::ConstantDims);
}
/** global single value variable: name */
adios2::Variable<unsigned int> &bpTimeStep =
bpIO.DefineVariable<unsigned int>("timeStep");
/** Engine derived class, spawned to start IO operations */
adios2::Engine &bpWriter =
bpIO.Open("myVector.bp", adios2::Mode::Write);
for (unsigned int timeStep = 0; timeStep < 3; ++timeStep)
{
// bpWriter.BeginStep();
if (rank == 0) // global single value, only saved by rank 0
{
bpWriter.PutSync<unsigned int>(bpTimeStep, timeStep);
}
// template type is optional, but recommended
for (unsigned int v = 0; v < variablesSize; ++v)
{
myFloats[0] = static_cast<float>(v + timeStep);
bpWriter.PutSync(*bpFloats[v], myFloats.data());
}
const std::string myString(
"Hello from rank: " + std::to_string(rank) + " and timestep: " +
std::to_string(timeStep));
bpWriter.PutSync(bpString, myString);
bpWriter.EndStep();
}
bpWriter.Close();
}
catch (std::invalid_argument &e)
{
std::cout << "Invalid argument exception, STOPPING PROGRAM from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::ios_base::failure &e)
{
std::cout << "IO System base failure exception, STOPPING PROGRAM "
"from rank "
<< rank << "\n";
std::cout << e.what() << "\n";
}
catch (std::exception &e)
{
std::cout << "Exception, STOPPING PROGRAM from rank " << rank << "\n";
std::cout << e.what() << "\n";
}
MPI_Finalize();
return 0;
}
int main(int argc, char *argv[])
{
// Application variable
std::vector<float> myFloats = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
const std::size_t Nx = myFloats.size();
try
{
/** ADIOS class factory of IO class objects, DebugON is recommended */
adios2::ADIOS adios(adios2::DebugON);
/*** IO class object: settings and factory of Settings: Variables,
* Parameters, Transports, and Execution: Engines */
adios2::IO &bpIO = adios.DeclareIO("BPFile_N2N");
/** name, { shape (total dimensions) }, { start (local) }, { count
* {local} } */
adios2::Variable<float> &bpFloats = bpIO.DefineVariable<float>(
"bpFloats", {}, {}, {Nx}, adios2::ConstantDims);
adios2::Variable<unsigned int> &bpTimeStep =
bpIO.DefineVariable<unsigned int>("timeStep");
/** Engine derived class, spawned to start IO operations */
adios2::Engine &bpWriter =
bpIO.Open("myVector.bp", adios2::Mode::Write);
for (unsigned int timeStep = 0; timeStep < 10; ++timeStep)
{
bpWriter.BeginStep();
// template type is optional but recommended
bpWriter.PutSync<unsigned int>(bpTimeStep, timeStep);
// modifying data
myFloats[0] = static_cast<float>(timeStep);
bpWriter.PutSync<float>(bpFloats, myFloats.data());
bpWriter.EndStep();
}
bpWriter.Close();
}
catch (std::invalid_argument &e)
{
std::cout << "Invalid argument exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
catch (std::ios_base::failure &e)
{
std::cout << "IO System base failure exception, STOPPING PROGRAM\n";
std::cout << e.what() << "\n";
}
catch (std::exception &e)
{
std::cout << "Exception, STOPPING PROGRAM from rank\n";
std::cout << e.what() << "\n";
}
return 0;
}
static void
seq_public (struct msgs *mp, int lockflag)
{
int state;
char *cp, seqfile[PATH_MAX];
char name[NAMESZ], field[BUFSIZ];
FILE *fp;
m_getfld_state_t gstate = 0;
/*
* If mh_seq == NULL or if *mh_seq == '\0' (the user has defined
* the "mh-sequences" profile entry, but left it empty),
* then just return, and do not initialize any public sequences.
*/
if (mh_seq == NULL || *mh_seq == '\0')
return;
/* get filename of sequence file */
snprintf (seqfile, sizeof(seqfile), "%s/%s", mp->foldpath, mh_seq);
if ((fp = lkfopendata (seqfile, lockflag ? "r+" : "r")) == NULL)
return;
/* Use m_getfld to scan sequence file */
for (;;) {
int fieldsz = sizeof field;
switch (state = m_getfld (&gstate, name, field, &fieldsz, fp)) {
case FLD:
case FLDPLUS:
if (state == FLDPLUS) {
cp = getcpy (field);
while (state == FLDPLUS) {
fieldsz = sizeof field;
state = m_getfld (&gstate, name, field, &fieldsz, fp);
cp = add (field, cp);
}
seq_init (mp, getcpy (name), trimcpy (cp));
free (cp);
} else {
seq_init (mp, getcpy (name), trimcpy (field));
}
continue;
case BODY:
lkfclosedata (fp, seqfile);
adios (NULL, "no blank lines are permitted in %s", seqfile);
/* fall */
case FILEEOF:
break;
default:
lkfclosedata (fp, seqfile);
adios (NULL, "%s is poorly formatted", seqfile);
}
break; /* break from for loop */
}
m_getfld_state_destroy (&gstate);
if (lockflag) {
mp->seqhandle = fp;
mp->seqname = getcpy(seqfile);
} else {
lkfclosedata (fp, seqfile);
}
}
