//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimSummaryCaseCollection::nameAndItemCount() const
{
size_t itemCount = m_cases.size();
if (itemCount > 20)
{
return QString("%1 (%2)").arg(m_name()).arg(itemCount);
}
return m_name();
}
err_t Object::setProperty(const StringW& name, const Var& src)
{
InternedStringW m_name(name, INTERNED_STRING_OPTION_LOOKUP);
if (m_name.isEmpty())
{
// Return error if the property name isn't valid. We are going to create
// new InternedStringW so we must be sure that the internal hash table used
// to store interned strings won't be polluted by strings we actually don't
// need.
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
// Create a new InternedStringW.
FOG_RETURN_ON_ERROR(m_name.set(name));
}
else
{
// We know that there is a InternedStringW, so try Object::_setProperty().
err_t err = _setProperty(m_name, src);
// If something bad happened (for example wrong argument type) then we
// report it immediately.
if (err != ERR_PROPERTY_NOT_FOUND)
return err;
// We are going to set dynamic property (this means that it can be created)
// so we must be sure that the property name is valid.
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
}
// Set dynamic property.
return Object_setDynamicProperty(this, m_name, src);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellLogFile::readFile(QString* errorMessage)
{
if (!m_wellLogDataFile.p())
{
m_wellLogDataFile = new RigWellLogFile;
}
m_name = QFileInfo(m_fileName).fileName();
if (!m_wellLogDataFile->open(m_fileName, errorMessage))
{
m_wellLogDataFile = nullptr;
return false;
}
m_wellName = m_wellLogDataFile->wellName();
QDateTime date = RiaDateStringParser::parseDateString(m_wellLogDataFile->date());
m_lasFileHasValidDate = isDateValid(date);
if (m_lasFileHasValidDate)
{
m_date = date;
}
else if(!isDateValid(m_date()))
{
QMessageBox msgBox;
QString message = QString("The LAS-file '%1' contains no recognizable date. Please assign a date in the LAS-file property panel")
.arg(m_name());
msgBox.setText(message);
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.exec();
m_date = DEFAULT_DATE_TIME;
}
m_wellLogChannelNames.deleteAllChildObjects();
QStringList wellLogNames = m_wellLogDataFile->wellLogChannelNames();
for (int logIdx = 0; logIdx < wellLogNames.size(); logIdx++)
{
RimWellLogFileChannel* wellLog = new RimWellLogFileChannel();
wellLog->setName(wellLogNames[logIdx]);
m_wellLogChannelNames.push_back(wellLog);
}
RimWellPath* wellPath;
firstAncestorOrThisOfType(wellPath);
if (wellPath)
{
if (wellPath->filepath().isEmpty())
{
wellPath->setName(m_wellName);
}
}
return true;
}
static void
copy_mime_draft (int out)
{
int msgnum;
char buffer[BUFSIZ];
snprintf (buffer, sizeof(buffer), "#forw [forwarded message%s] +%s",
mp->numsel == 1 ? "" : "s", mp->foldpath);
write (out, buffer, strlen (buffer));
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++)
if (is_selected (mp, msgnum)) {
snprintf (buffer, sizeof(buffer), " %s", m_name (msgnum));
write (out, buffer, strlen (buffer));
}
write (out, "\n", 1);
}
err_t Object::getProperty(const StringW& name, Var& dst) const
{
InternedStringW m_name(name, INTERNED_STRING_OPTION_LOOKUP);
if (m_name.isEmpty())
{
FOG_RETURN_ON_ERROR(Object_validatePropertyName(name));
// If the property name is valid then we must ERR_PROPERTY_NOT_FOUND.
return ERR_PROPERTY_NOT_FOUND;
}
else
{
err_t err = _getProperty(m_name, dst);
// If the property doesn't exist try dynamically added properties.
if (err == ERR_PROPERTY_NOT_FOUND)
err = Object_getDynamicProperty(this, m_name, dst);
return err;
}
}
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);
}
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;
}
// Put out instance of ModuleInfo for this Module
void Module::genmoduleinfo()
{
// resolve ModuleInfo
if (!moduleinfo)
{
error("object.d is missing the ModuleInfo struct");
fatal();
}
// check for patch
else
{
unsigned sizeof_ModuleInfo = 16 * Target::ptrsize;
if (sizeof_ModuleInfo != moduleinfo->structsize)
{
error("object.d ModuleInfo class is incorrect");
fatal();
}
}
// use the RTTIBuilder
RTTIBuilder b(moduleinfo);
// some types
LLType* moduleinfoTy = moduleinfo->type->irtype->getLLType();
LLType* classinfoTy = ClassDeclaration::classinfo->type->irtype->getLLType();
// importedModules[]
std::vector<LLConstant*> importInits;
LLConstant* importedModules = 0;
llvm::ArrayType* importedModulesTy = 0;
for (size_t i = 0; i < aimports.dim; i++)
{
Module *m = static_cast<Module *>(aimports.data[i]);
if (!m->needModuleInfo() || m == this)
continue;
// declare the imported module info
std::string m_name("_D");
m_name.append(m->mangle());
m_name.append("12__ModuleInfoZ");
llvm::GlobalVariable* m_gvar = gIR->module->getGlobalVariable(m_name);
if (!m_gvar) m_gvar = new llvm::GlobalVariable(*gIR->module, moduleinfoTy, false, llvm::GlobalValue::ExternalLinkage, NULL, m_name);
importInits.push_back(m_gvar);
}
// has import array?
if (!importInits.empty())
{
importedModulesTy = llvm::ArrayType::get(getPtrToType(moduleinfoTy), importInits.size());
importedModules = LLConstantArray::get(importedModulesTy, importInits);
}
// localClasses[]
LLConstant* localClasses = 0;
llvm::ArrayType* localClassesTy = 0;
ClassDeclarations aclasses;
//printf("members->dim = %d\n", members->dim);
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *member;
member = static_cast<Dsymbol *>(members->data[i]);
//printf("\tmember '%s'\n", member->toChars());
member->addLocalClass(&aclasses);
}
// fill inits
std::vector<LLConstant*> classInits;
for (size_t i = 0; i < aclasses.dim; i++)
{
ClassDeclaration* cd = static_cast<ClassDeclaration*>(aclasses.data[i]);
cd->codegen(Type::sir);
if (cd->isInterfaceDeclaration())
{
Logger::println("skipping interface '%s' in moduleinfo", cd->toPrettyChars());
continue;
}
else if (cd->sizeok != 1)
{
Logger::println("skipping opaque class declaration '%s' in moduleinfo", cd->toPrettyChars());
continue;
}
Logger::println("class: %s", cd->toPrettyChars());
LLConstant *c = DtoBitCast(cd->ir.irAggr->getClassInfoSymbol(), classinfoTy);
classInits.push_back(c);
}
// has class array?
if (!classInits.empty())
{
localClassesTy = llvm::ArrayType::get(classinfoTy, classInits.size());
localClasses = LLConstantArray::get(localClassesTy, classInits);
}
// These must match the values in druntime/src/object_.d
#define MIstandalone 4
#define MItlsctor 8
#define MItlsdtor 0x10
#define MIctor 0x20
#define MIdtor 0x40
#define MIxgetMembers 0x80
#define MIictor 0x100
#define MIunitTest 0x200
#define MIimportedModules 0x400
#define MIlocalClasses 0x800
#define MInew 0x80000000 // it's the "new" layout
llvm::Function* fsharedctor = build_module_shared_ctor();
llvm::Function* fshareddtor = build_module_shared_dtor();
llvm::Function* funittest = build_module_unittest();
llvm::Function* fctor = build_module_ctor();
llvm::Function* fdtor = build_module_dtor();
unsigned flags = MInew;
if (fctor)
flags |= MItlsctor;
if (fdtor)
flags |= MItlsdtor;
if (fsharedctor)
flags |= MIctor;
if (fshareddtor)
flags |= MIdtor;
#if 0
if (fgetmembers)
flags |= MIxgetMembers;
if (fictor)
flags |= MIictor;
#endif
if (funittest)
flags |= MIunitTest;
if (importedModules)
flags |= MIimportedModules;
if (localClasses)
flags |= MIlocalClasses;
if (!needmoduleinfo)
flags |= MIstandalone;
b.push_uint(flags); // flags
b.push_uint(0); // index
if (fctor)
b.push(fctor);
if (fdtor)
b.push(fdtor);
if (fsharedctor)
b.push(fsharedctor);
if (fshareddtor)
b.push(fshareddtor);
#if 0
if (fgetmembers)
b.push(fgetmembers);
if (fictor)
b.push(fictor);
#endif
if (funittest)
b.push(funittest);
if (importedModules) {
b.push_size(importInits.size());
b.push(importedModules);
}
if (localClasses) {
b.push_size(classInits.size());
b.push(localClasses);
}
// Put out module name as a 0-terminated string.
const char *name = toPrettyChars();
const size_t len = strlen(name) + 1;
llvm::IntegerType *it = llvm::IntegerType::getInt8Ty(gIR->context());
llvm::ArrayType *at = llvm::ArrayType::get(it, len);
b.push(toConstantArray(it, at, name, len, false));
// create and set initializer
b.finalize(moduleInfoType, moduleInfoSymbol());
// build the modulereference and ctor for registering it
LLFunction* mictor = build_module_reference_and_ctor(moduleInfoSymbol());
AppendFunctionToLLVMGlobalCtorsDtors(mictor, 65535, true);
}
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 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)
{
int publicsw = -1, zerosw = 1, seqp = 0, vecp = 0;
int quietsw = 0;
int lo, hi, msgnum;
char *maildir, *folder = NULL, buf[100];
char *cp, **argp, **arguments;
char *seqs[NUMATTRS + 1], *vec[MAXARGS];
struct msgs_array msgs = { 0, 0, NULL };
struct msgs *mp;
register FILE *fp;
done=putzero_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 == '-') {
if (*++cp == '-') {
vec[vecp++] = --cp;
goto pattern;
}
switch (smatch (cp, switches)) {
case AMBIGSW:
ambigsw (cp, switches);
listsw = 0; /* HACK */
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);
listsw = 0; /* HACK */
done (1);
case VERSIONSW:
print_version(invo_name);
listsw = 0; /* HACK */
done (1);
case CCSW:
case DATESW:
case FROMSW:
case SUBJSW:
case TOSW:
case DATFDSW:
case AFTRSW:
case BEFRSW:
case SRCHSW:
vec[vecp++] = --cp;
pattern:
if (!(cp = *argp++))/* allow -xyz arguments */
adios (NULL, "missing argument to %s", argp[-2]);
vec[vecp++] = cp;
continue;
case OTHRSW:
adios (NULL, "internal error!");
case ANDSW:
case ORSW:
case NOTSW:
case LBRSW:
case RBRSW:
vec[vecp++] = --cp;
continue;
case SEQSW:
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
/* check if too many sequences specified */
if (seqp >= NUMATTRS)
adios (NULL, "too many sequences (more than %d) specified", NUMATTRS);
if (!seq_nameok (cp))
done (1);
seqs[seqp++] = cp;
continue;
case PUBLSW:
publicsw = 1;
continue;
case NPUBLSW:
publicsw = 0;
continue;
case ZEROSW:
zerosw++;
continue;
case NZEROSW:
zerosw = 0;
continue;
case LISTSW:
listsw = 1;
continue;
case NLISTSW:
listsw = 0;
continue;
case QUIETSW:
quietsw = 1;
continue;
}
}
if (*cp == '+' || *cp == '@') {
if (folder)
adios (NULL, "only one folder at a time!");
else
folder = pluspath (cp);
} else
app_msgarg(&msgs, cp);
}
vec[vecp] = NULL;
if (!context_find ("path"))
free (path ("./", TFOLDER));
/*
* If we didn't specify which messages to search,
* then search the whole folder.
*/
if (!msgs.size)
app_msgarg(&msgs, "all");
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 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 we aren't saving the results to a sequence,
* we default to list the results.
*/
if (listsw == -1)
listsw = !seqp;
if (publicsw == 1 && is_readonly(mp))
adios (NULL, "folder %s is read-only, so -public not allowed", folder);
if (!pcompile (vec, NULL))
done (1);
lo = mp->lowsel;
hi = mp->hghsel;
/* If printing message numbers to standard out, force line buffering on.
*/
if (listsw)
setvbuf (stdout, NULL, _IOLBF, 0);
/*
* Scan through all the SELECTED messages and check for a
* match. If the message does not match, then unselect it.
*/
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected (mp, msgnum)) {
if ((fp = fopen (cp = m_name (msgnum), "r")) == NULL)
admonish (cp, "unable to read message");
if (fp && pmatches (fp, msgnum, 0L, 0L)) {
if (msgnum < lo)
lo = msgnum;
if (msgnum > hi)
hi = msgnum;
if (listsw)
printf ("%s\n", m_name (msgnum));
} else {
/* if it doesn't match, then unselect it */
unset_selected (mp, msgnum);
mp->numsel--;
}
if (fp)
fclose (fp);
}
}
mp->lowsel = lo;
mp->hghsel = hi;
if (mp->numsel <= 0 && !quietsw)
adios (NULL, "no messages match specification");
seqs[seqp] = NULL;
/*
* Add the matching messages to sequences
*/
for (seqp = 0; seqs[seqp]; seqp++)
if (!seq_addsel (mp, seqs[seqp], publicsw, zerosw))
done (1);
/*
* Print total matched if not printing each matched message number.
*/
if (!listsw) {
printf ("%d hit%s\n", mp->numsel, mp->numsel == 1 ? "" : "s");
}
context_replace (pfolder, folder); /* update current folder */
seq_save (mp); /* synchronize message sequences */
context_save (); /* save the context file */
folder_free (mp); /* free folder/message structure */
done (0);
return 1;
}
static void
copy_draft (int out, char *digest, char *file, int volume, int issue, int dashstuff)
{
int fd,i, msgcnt, msgnum;
int len, buflen;
register char *bp, *msgnam;
char buffer[BUFSIZ];
msgcnt = 1;
for (msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected (mp, msgnum)) {
if (digest) {
strncpy (buffer, msgnum == mp->lowsel ? delim3 : delim4,
sizeof(buffer));
} else {
/* Get buffer ready to go */
bp = buffer;
buflen = sizeof(buffer);
strncpy (bp, "\n-------", buflen);
len = strlen (bp);
bp += len;
buflen -= len;
if (msgnum == mp->lowsel) {
snprintf (bp, buflen, " Forwarded Message%s",
mp->numsel > 1 ? "s" : "");
} else {
snprintf (bp, buflen, " Message %d", msgcnt);
}
len = strlen (bp);
bp += len;
buflen -= len;
strncpy (bp, "\n\n", buflen);
}
write (out, buffer, strlen (buffer));
if ((fd = open (msgnam = m_name (msgnum), O_RDONLY)) == NOTOK) {
admonish (msgnam, "unable to read message");
continue;
}
/*
* Copy the message. Add RFC934 quoting (dashstuffing)
* unless given the -nodashstuffing flag.
*/
if (dashstuff >= 0)
cpydgst (fd, out, msgnam, file);
else
cpydata (fd, out, msgnam, file);
close (fd);
msgcnt++;
}
}
if (digest) {
strncpy (buffer, delim4, sizeof(buffer));
} else {
snprintf (buffer, sizeof(buffer), "\n------- End of Forwarded Message%s\n",
mp->numsel > 1 ? "s" : "");
}
write (out, buffer, strlen (buffer));
if (digest) {
snprintf (buffer, sizeof(buffer), "End of %s Digest [Volume %d Issue %d]\n",
digest, volume, issue);
i = strlen (buffer);
for (bp = buffer + i; i > 1; i--)
*bp++ = '*';
*bp++ = '\n';
*bp = 0;
write (out, buffer, strlen (buffer));
}
}
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 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
what_now (char *ed, int nedit, int use, char *file, char *altmsg, int dist,
struct msgs *mp, char *text, int inplace, char *cwd)
{
int found, k, msgnum, vecp;
int len, buflen;
register char *bp;
char buffer[BUFSIZ], *vec[MAXARGS];
vecp = 0;
vec[vecp++] = r1bindex (whatnowproc, '/');
vec[vecp] = NULL;
m_putenv ("mhdraft", file);
if (mp)
m_putenv ("mhfolder", mp->foldpath);
else
unputenv ("mhfolder");
if (altmsg) {
if (mp == NULL || *altmsg == '/' || cwd == NULL)
m_putenv ("mhaltmsg", altmsg);
else {
snprintf (buffer, sizeof(buffer), "%s/%s", mp->foldpath, altmsg);
m_putenv ("mhaltmsg", buffer);
}
} else {
unputenv ("mhaltmsg");
}
if ((bp = getenv ("mhaltmsg")))/* XXX */
m_putenv ("editalt", bp);
snprintf (buffer, sizeof(buffer), "%d", dist);
m_putenv ("mhdist", buffer);
if (nedit) {
unputenv ("mheditor");
} else {
m_putenv ("mheditor", ed ? ed : (ed = context_find ("editor"))
? ed : defaulteditor);
}
snprintf (buffer, sizeof(buffer), "%d", use);
m_putenv ("mhuse", buffer);
unputenv ("mhmessages");
unputenv ("mhannotate");
unputenv ("mhinplace");
if (text && mp && !is_readonly(mp)) {
found = 0;
bp = buffer;
buflen = sizeof(buffer);
for (msgnum = mp->lowmsg; msgnum <= mp->hghmsg; msgnum++) {
if (is_selected(mp, msgnum)) {
snprintf (bp, buflen, "%s%s", found ? " " : "", m_name (msgnum));
len = strlen (bp);
bp += len;
buflen -= len;
for (k = msgnum + 1; k <= mp->hghmsg && is_selected(mp, k); k++)
continue;
if (--k > msgnum) {
snprintf (bp, buflen, "-%s", m_name (k));
len = strlen (bp);
bp += len;
buflen -= len;
}
msgnum = k + 1;
found++;
}
}
if (found) {
m_putenv ("mhmessages", buffer);
m_putenv ("mhannotate", text);
snprintf (buffer, sizeof(buffer), "%d", inplace);
m_putenv ("mhinplace", buffer);
}
}
context_save (); /* save the context file */
fflush (stdout);
if (cwd)
chdir (cwd);
/*
* If the "whatnowproc" is the nmh command "whatnow",
* we run it internally, rather than exec'ing it.
*/
if (strcmp (vec[0], "whatnow") == 0) {
WhatNow (vecp, vec);
done (0);
}
execvp (whatnowproc, vec);
fprintf (stderr, "unable to exec ");
perror (whatnowproc);
return 0;
}
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)
{
int msgp = 0, distsw = 0, vecp;
int isdf = 0, mime = 0;
int msgnum, status;
char *cp, *dfolder = NULL, *maildir = NULL;
char buf[BUFSIZ], **ap, **argp, **arguments, *program;
char *msgs[MAXARGS], **vec;
struct msgs *mp;
struct stat st;
if (nmh_init(argv[0], 1)) { return 1; }
arguments = getarguments (invo_name, argc, argv, 1);
argp = arguments;
vec = argsplit(postproc, &program, &vecp);
vec[vecp++] = "-library";
vec[vecp++] = getcpy (m_maildir (""));
if ((cp = context_find ("fileproc"))) {
vec[vecp++] = "-fileproc";
vec[vecp++] = cp;
}
if ((cp = context_find ("mhlproc"))) {
vec[vecp++] = "-mhlproc";
vec[vecp++] = cp;
}
if ((cp = context_find ("credentials"))) {
/* post doesn't read context so need to pass credentials. */
vec[vecp++] = "-credentials";
vec[vecp++] = cp;
}
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 [file] [switches]", invo_name);
print_help (buf, switches, 1);
done (0);
case VERSIONSW:
print_version(invo_name);
done (0);
case DRAFTSW:
msgs[msgp++] = draft;
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 (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
msgs[msgp++] = cp;
continue;
case NDFLDSW:
dfolder = NULL;
isdf = NOTOK;
continue;
case PUSHSW:
pushsw++;
continue;
case NPUSHSW:
pushsw = 0;
continue;
case SPLITSW:
if (!(cp = *argp++) || sscanf (cp, "%d", &splitsw) != 1)
adios (NULL, "missing argument to %s", argp[-2]);
continue;
case UNIQSW:
unique++;
continue;
case NUNIQSW:
unique = 0;
continue;
case FORWSW:
forwsw++;
continue;
case NFORWSW:
forwsw = 0;
continue;
case VERBSW:
verbsw++;
vec[vecp++] = --cp;
continue;
case NVERBSW:
verbsw = 0;
vec[vecp++] = --cp;
continue;
case MIMESW:
mime++;
vec[vecp++] = --cp;
continue;
case NMIMESW:
mime = 0;
vec[vecp++] = --cp;
continue;
case DEBUGSW:
debugsw++; /* fall */
case NFILTSW:
case FRMTSW:
case NFRMTSW:
case BITSTUFFSW:
case NBITSTUFFSW:
case MSGDSW:
case NMSGDSW:
case WATCSW:
case NWATCSW:
case SNOOPSW:
case SASLSW:
case NOSASLSW:
case TLSSW:
case INITTLSSW:
case NTLSSW:
vec[vecp++] = --cp;
continue;
case ALIASW:
case FILTSW:
case WIDTHSW:
case CLIESW:
case SERVSW:
case SASLMECHSW:
case SASLMXSSFSW:
case USERSW:
case PORTSW:
case MTSSW:
case MESSAGEIDSW:
vec[vecp++] = --cp;
if (!(cp = *argp++) || *cp == '-')
adios (NULL, "missing argument to %s", argp[-2]);
vec[vecp++] = cp;
continue;
case ATTACHSW:
advise(NULL, "The -attach switch is deprecated");
continue;
case NOATTACHSW:
advise(NULL, "The -noattach switch is deprecated");
continue;
case ATTACHFORMATSW:
advise(NULL, "The -attachformat switch is deprecated");
continue;
}
} else {
msgs[msgp++] = cp;
}
}
/*
* check for "Aliasfile:" profile entry
*/
if ((cp = context_find ("Aliasfile"))) {
char *dp = NULL;
for (ap = brkstring(dp = getcpy(cp), " ", "\n"); ap && *ap; ap++) {
vec[vecp++] = "-alias";
vec[vecp++] = *ap;
}
}
if (dfolder == NULL) {
if (msgp == 0) {
msgs[msgp++] = getcpy (m_draft (NULL, NULL, 1, &isdf));
if (stat (msgs[0], &st) == NOTOK)
adios (msgs[0], "unable to stat draft file");
cp = concat ("Use \"", msgs[0], "\"? ", NULL);
for (status = LISTDSW; status != YESW;) {
if (!(argp = getans (cp, anyl)))
done (1);
switch (status = smatch (*argp, anyl)) {
case NOSW:
done (0);
case YESW:
break;
case LISTDSW:
showfile (++argp, msgs[0]);
break;
default:
advise (NULL, "say what?");
break;
}
}
} else {
for (msgnum = 0; msgnum < msgp; msgnum++)
msgs[msgnum] = getcpy (m_maildir (msgs[msgnum]));
}
} else {
if (!context_find ("path"))
free (path ("./", TFOLDER));
if (!msgp)
msgs[msgp++] = "cur";
maildir = m_maildir (dfolder);
if (chdir (maildir) == NOTOK)
adios (maildir, "unable to change directory to");
/* read folder and create message structure */
if (!(mp = folder_read (dfolder, 1)))
adios (NULL, "unable to read folder %s", dfolder);
/* check for empty folder */
if (mp->nummsg == 0)
adios (NULL, "no messages in %s", dfolder);
/* parse all the message ranges/sequences and set SELECTED */
for (msgnum = 0; msgnum < msgp; msgnum++)
if (!m_convert (mp, msgs[msgnum]))
done (1);
seq_setprev (mp); /* set the previous-sequence */
for (msgp = 0, msgnum = mp->lowsel; msgnum <= mp->hghsel; msgnum++) {
if (is_selected (mp, msgnum)) {
msgs[msgp++] = getcpy (m_name (msgnum));
unset_exists (mp, msgnum);
}
}
mp->msgflags |= SEQMOD;
seq_save (mp);
}
#ifdef WHATNOW
go_to_it:
#endif /* WHATNOW */
if ((cp = getenv ("SIGNATURE")) == NULL || *cp == 0)
if ((cp = context_find ("signature")) && *cp)
m_putenv ("SIGNATURE", cp);
for (msgnum = 0; msgnum < msgp; msgnum++)
if (stat (msgs[msgnum], &st) == NOTOK)
adios (msgs[msgnum], "unable to stat draft file");
if ((annotext = getenv ("mhannotate")) == NULL || *annotext == 0)
annotext = NULL;
if (annotext && ((cp = getenv ("mhinplace")) != NULL && *cp != 0))
inplace = atoi (cp);
if ((altmsg = getenv ("mhaltmsg")) == NULL || *altmsg == 0)
altmsg = NULL; /* used by dist interface - see below */
if ((cp = getenv ("mhdist"))
&& *cp
&& (distsw = atoi (cp))
&& altmsg) {
vec[vecp++] = "-dist";
if ((cp = m_mktemp2(altmsg, invo_name, NULL, NULL)) == NULL) {
adios(NULL, "unable to create temporary file in %s",
get_temp_dir());
}
distfile = getcpy (cp);
(void) m_unlink(distfile);
if (link (altmsg, distfile) == NOTOK) {
/* Cygwin with FAT32 filesystem produces EPERM. */
if (errno != EXDEV && errno != EPERM
#ifdef EISREMOTE
&& errno != EISREMOTE
#endif /* EISREMOTE */
)
adios (distfile, "unable to link %s to", altmsg);
free (distfile);
if ((cp = m_mktemp2(NULL, invo_name, NULL, NULL)) == NULL) {
adios(NULL, "unable to create temporary file in %s",
get_temp_dir());
}
distfile = getcpy (cp);
{
int in, out;
struct stat st;
if ((in = open (altmsg, O_RDONLY)) == NOTOK)
adios (altmsg, "unable to open");
fstat(in, &st);
if ((out = creat (distfile, (int) st.st_mode & 0777)) == NOTOK)
adios (distfile, "unable to write");
cpydata (in, out, altmsg, distfile);
close (in);
close (out);
}
}
} else {
distfile = NULL;
}
if (altmsg == NULL || stat (altmsg, &st) == NOTOK) {
st.st_mtime = 0;
st.st_dev = 0;
st.st_ino = 0;
}
if (pushsw)
push ();
status = 0;
closefds (3);
for (msgnum = 0; msgnum < msgp; msgnum++) {
switch (sendsbr (vec, vecp, program, msgs[msgnum], &st, 1)) {
case DONE:
done (++status);
case NOTOK:
status++; /* fall */
case OK:
break;
}
}
context_save (); /* save the context file */
done (status);
return 1;
}
