/**
* mutt_envlist_unset - Unset an environment variable
* @param name Variable to unset
* @retval true Success: Variable unset
* @retval false Error: Variable doesn't exist
*/
bool mutt_envlist_unset(const char *name)
{
if (!name || !name[0])
return false;
char **envp = EnvList;
int count = 0;
while (envp && *envp)
{
size_t len = mutt_str_startswith(*envp, name, CASE_MATCH);
if ((len != 0) && ((*envp)[len] == '='))
{
/* shuffle down */
char **save = envp++;
while (*envp)
{
*save++ = *envp++;
count++;
}
*save = NULL;
mutt_mem_realloc(&EnvList, sizeof(char *) * (count + 1));
return true;
}
envp++;
count++;
}
return false;
}
/**
* mutt_push_macro_event - Add the character/operation to the macro buffer
* @param ch Character to add
* @param op Operation to add
*
* Adds the ch/op to the macro buffer.
* This should be used for macros, push, and exec commands only.
*/
void mutt_push_macro_event(int ch, int op)
{
struct Event tmp;
tmp.ch = ch;
tmp.op = op;
if (MacroBufferCount >= MacroBufferLen)
mutt_mem_realloc(&MacroEvents, (MacroBufferLen += 128) * sizeof(struct Event));
MacroEvents[MacroBufferCount++] = tmp;
}
/**
* mutt_unget_event - Return a keystroke to the input buffer
* @param ch Key press
* @param op Operation, e.g. OP_DELETE
*
* This puts events into the `UngetKeyEvents` buffer
*/
void mutt_unget_event(int ch, int op)
{
struct Event tmp;
tmp.ch = ch;
tmp.op = op;
if (UngetCount >= UngetLen)
mutt_mem_realloc(&UngetKeyEvents, (UngetLen += 16) * sizeof(struct Event));
UngetKeyEvents[UngetCount++] = tmp;
}
/**
* mhs_alloc - Allocate more memory for sequences
* @param mhs Existing sequences
* @param i Number required
*
* @note Memory is allocated in blocks of 128.
*/
static void mhs_alloc(struct MhSequences *mhs, int i)
{
if ((i <= mhs->max) && mhs->flags)
return;
const int newmax = i + 128;
int j = mhs->flags ? mhs->max + 1 : 0;
mutt_mem_realloc(&mhs->flags, sizeof(mhs->flags[0]) * (newmax + 1));
while (j <= newmax)
mhs->flags[j++] = 0;
mhs->max = newmax;
}
/**
* crypt_fetch_signatures - Create an array of an emails parts
* @param[out] signatures Array of Body parts
* @param[in] a Body part to examine
* @param[out] n Cumulative count of parts
*/
static void crypt_fetch_signatures(struct Body ***signatures, struct Body *a, int *n)
{
if (!WithCrypto)
return;
for (; a; a = a->next)
{
if (a->type == TYPE_MULTIPART)
crypt_fetch_signatures(signatures, a->parts, n);
else
{
if ((*n % 5) == 0)
mutt_mem_realloc(signatures, (*n + 6) * sizeof(struct Body **));
(*signatures)[(*n)++] = a;
}
}
}
/**
* mutt_envlist_set - Set an environment variable
* @param name Name of the variable
* @param value New value
* @param overwrite Should the variable be overwritten?
* @retval true Success: variable set, or overwritten
* @retval false Variable exists and overwrite was false
*
* It's broken out because some other parts of neomutt (filter.c) need to
* set/overwrite environment variables in EnvList before calling exec().
*/
bool mutt_envlist_set(const char *name, const char *value, bool overwrite)
{
char **envp = EnvList;
char work[1024];
int count;
/* Look for current slot to overwrite */
count = 0;
while (envp && *envp)
{
size_t len = mutt_str_startswith(*envp, name, CASE_MATCH);
if ((len != 0) && ((*envp)[len] == '='))
{
if (!overwrite)
return false;
break;
}
envp++;
count++;
}
/* Format var=value string */
snprintf(work, sizeof(work), "%s=%s", NONULL(name), NONULL(value));
if (envp && *envp)
{
/* slot found, overwrite */
mutt_str_replace(envp, work);
}
else
{
/* not found, add new slot */
mutt_mem_realloc(&EnvList, sizeof(char *) * (count + 2));
EnvList[count] = mutt_str_strdup(work);
EnvList[count + 1] = NULL;
}
return true;
}
/**
* crypt_get_keys - Check we have all the keys we need
* @param[in] msg Message with addresses to match
* @param[out] keylist Keys needed
* @param[in] oppenc_mode If true, use opportunistic encryption
* @retval 0 Success
* @retval -1 Error
*
* Do a quick check to make sure that we can find all of the
* encryption keys if the user has requested this service.
* Return the list of keys in KEYLIST.
* If oppenc_mode is true, only keys that can be determined without
* prompting will be used.
*/
int crypt_get_keys(struct Email *msg, char **keylist, bool oppenc_mode)
{
struct Address *addrlist = NULL, *last = NULL;
const char *fqdn = mutt_fqdn(true);
char *self_encrypt = NULL;
/* Do a quick check to make sure that we can find all of the encryption
* keys if the user has requested this service. */
if (!WithCrypto)
return 0;
if (WithCrypto & APPLICATION_PGP)
OptPgpCheckTrust = true;
last = mutt_addr_append(&addrlist, msg->env->to, false);
last = mutt_addr_append(last ? &last : &addrlist, msg->env->cc, false);
mutt_addr_append(last ? &last : &addrlist, msg->env->bcc, false);
if (fqdn)
mutt_addr_qualify(addrlist, fqdn);
addrlist = mutt_addrlist_dedupe(addrlist);
*keylist = NULL;
if (oppenc_mode || (msg->security & SEC_ENCRYPT))
{
if (((WithCrypto & APPLICATION_PGP) != 0) && (msg->security & APPLICATION_PGP))
{
*keylist = crypt_pgp_find_keys(addrlist, oppenc_mode);
if (!*keylist)
{
mutt_addr_free(&addrlist);
return -1;
}
OptPgpCheckTrust = false;
if (C_PgpSelfEncrypt || (C_PgpEncryptSelf == MUTT_YES))
self_encrypt = C_PgpDefaultKey;
}
if (((WithCrypto & APPLICATION_SMIME) != 0) && (msg->security & APPLICATION_SMIME))
{
*keylist = crypt_smime_find_keys(addrlist, oppenc_mode);
if (!*keylist)
{
mutt_addr_free(&addrlist);
return -1;
}
if (C_SmimeSelfEncrypt || (C_SmimeEncryptSelf == MUTT_YES))
self_encrypt = C_SmimeDefaultKey;
}
}
if (!oppenc_mode && self_encrypt && *self_encrypt)
{
const size_t keylist_size = mutt_str_strlen(*keylist);
mutt_mem_realloc(keylist, keylist_size + mutt_str_strlen(self_encrypt) + 2);
sprintf(*keylist + keylist_size, " %s", self_encrypt);
}
mutt_addr_free(&addrlist);
return 0;
}
