attach.c

Go to the documentation of this file.

 
#include "config.h"
#include <string.h>
#include "mutt/lib.h"
#include "email/lib.h"
#include "attach.h"
 
struct AttachPtr *mutt_aptr_new(void)
{
  return mutt_mem_calloc(1, sizeof(struct AttachPtr));
}
 
void mutt_aptr_free(struct AttachPtr **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AttachPtr *aptr = *ptr;
  FREE(&aptr->tree);
 
  FREE(ptr);
}
 
void mutt_actx_add_attach(struct AttachCtx *actx, struct AttachPtr *attach)
{
  const int grow = 5;
 
  if (!actx || !attach)
    return;
 
  if (actx->idxlen == actx->idxmax)
  {
    actx->idxmax += grow;
    mutt_mem_realloc(&actx->idx, actx->idxmax * sizeof(struct AttachPtr *));
    mutt_mem_realloc(&actx->v2r, actx->idxmax * sizeof(short));
 
    memset(&actx->idx[actx->idxlen], 0, grow * sizeof(struct AttachPtr *));
    memset(&actx->v2r[actx->idxlen], 0, grow * sizeof(short));
  }
 
  actx->idx[actx->idxlen++] = attach;
}
 
void mutt_actx_ins_attach(struct AttachCtx *actx, struct AttachPtr *attach, int aidx)
{
  if (!actx || !attach)
    return;
 
  if ((aidx < 0) || (aidx > actx->idxmax))
    return;
 
  if (actx->idxlen == actx->idxmax)
  {
    actx->idxmax += 5;
    mutt_mem_realloc(&actx->idx, sizeof(struct AttachPtr *) * actx->idxmax);
    mutt_mem_realloc(&actx->v2r, sizeof(short) * actx->idxmax);
    for (int i = actx->idxlen; i < actx->idxmax; i++)
      actx->idx[i] = NULL;
  }
 
  actx->idxlen++;
 
  for (int i = actx->idxlen - 1; i > aidx; i--)
    actx->idx[i] = actx->idx[i - 1];
 
  actx->idx[aidx] = attach;
}
 
void mutt_actx_add_fp(struct AttachCtx *actx, FILE *fp_new)
{
  if (!actx || !fp_new)
    return;
 
  if (actx->fp_len == actx->fp_max)
  {
    actx->fp_max += 5;
    mutt_mem_realloc(&actx->fp_idx, sizeof(FILE *) * actx->fp_max);
    for (int i = actx->fp_len; i < actx->fp_max; i++)
      actx->fp_idx[i] = NULL;
  }
 
  actx->fp_idx[actx->fp_len++] = fp_new;
}
 
void mutt_actx_add_body(struct AttachCtx *actx, struct Body *b)
{
  if (!actx || !b)
    return;
 
  if (actx->body_len == actx->body_max)
  {
    actx->body_max += 5;
    mutt_mem_realloc(&actx->body_idx, sizeof(struct Body *) * actx->body_max);
    for (int i = actx->body_len; i < actx->body_max; i++)
      actx->body_idx[i] = NULL;
  }
 
  actx->body_idx[actx->body_len++] = b;
}
 
void mutt_actx_entries_free(struct AttachCtx *actx)
{
  if (!actx)
    return;
 
  for (int i = 0; i < actx->idxlen; i++)
  {
    if (actx->idx[i]->body)
      actx->idx[i]->body->aptr = NULL;
    mutt_aptr_free(&actx->idx[i]);
  }
  actx->idxlen = 0;
  actx->vcount = 0;
 
  for (int i = 0; i < actx->fp_len; i++)
    mutt_file_fclose(&actx->fp_idx[i]);
  actx->fp_len = 0;
 
  for (int i = 0; i < actx->body_len; i++)
    mutt_body_free(&actx->body_idx[i]);
  actx->body_len = 0;
}
 
struct AttachCtx *mutt_actx_new(void)
{
  return mutt_mem_calloc(1, sizeof(struct AttachCtx));
}
 
void mutt_actx_free(struct AttachCtx **ptr)
{
  if (!ptr || !*ptr)
    return;
 
  struct AttachCtx *actx = *ptr;
 
  mutt_actx_entries_free(actx);
  FREE(&actx->idx);
  FREE(&actx->v2r);
  FREE(&actx->fp_idx);
  FREE(&actx->body_idx);
  FREE(ptr);
}