Blame view

mailbox2/dattribute.c 6.08 KB
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
/* GNU mailutils - a suite of utilities for electronic mail
   Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Library Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif

#include <mailutils/error.h>
31
#include <mailutils/sys/dattribute.h>
32

33 34
int
_attribute_default_ref (attribute_t attribute)
35
{
36
  struct _attribute_default *da = (struct _attribute_default *)attribute;
37 38 39
  return mu_refcount_inc (da->refcount);
}

40 41
void
_attribute_default_destroy (attribute_t *pattribute)
42
{
43
  struct _attribute_default *da = (struct _attribute_default *)*pattribute;
44 45 46 47 48 49 50
  if (mu_refcount_dec (da->refcount) == 0)
    {
      mu_refcount_destroy (&da->refcount);
      free (da);
    }
}

51 52
int
_attribute_default_get_flags (attribute_t attribute, int *pflags)
53
{
54
  struct _attribute_default *da = (struct _attribute_default *)attribute;
55 56 57 58 59 60 61
  mu_refcount_lock (da->refcount);
  if (pflags)
    *pflags = da->flags;
  mu_refcount_unlock (da->refcount);
  return 0;
}

62 63
int
_attribute_default_set_flags (attribute_t attribute, int flags)
64
{
65
  struct _attribute_default *da = (struct _attribute_default *)attribute;
66 67 68 69 70 71
  mu_refcount_lock (da->refcount);
  da->flags |= (flags | MU_ATTRIBUTE_MODIFIED);
  mu_refcount_unlock (da->refcount);
  return 0;
}

72 73
int
_attribute_default_unset_flags (attribute_t attribute, int flags)
74
{
75
  struct _attribute_default *da = (struct _attribute_default *)attribute;
76 77 78 79 80 81 82 83 84
  mu_refcount_lock (da->refcount);
  da->flags &= ~flags;
  /* If Modified was being unset do not reset it.  */
  if (!(flags & MU_ATTRIBUTE_MODIFIED))
    da->flags |= MU_ATTRIBUTE_MODIFIED;
  mu_refcount_unlock (da->refcount);
  return 0;
}

85 86
int
_attribute_default_clear_flags (attribute_t attribute)
87
{
88
  struct _attribute_default *da = (struct _attribute_default *)attribute;
89 90 91 92 93 94
  mu_refcount_lock (da->refcount);
  da->flags = 0;
  mu_refcount_unlock (da->refcount);
  return 0;
}

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138
int
_attribute_default_get_userflags (attribute_t attribute, int *puserflags)
{
  struct _attribute_default *da = (struct _attribute_default *)attribute;
  mu_refcount_lock (da->refcount);
  if (puserflags)
    *puserflags = da->userflags;
  mu_refcount_unlock (da->refcount);
  return 0;
}

int
_attribute_default_set_userflags (attribute_t attribute, int userflags)
{
  struct _attribute_default *da = (struct _attribute_default *)attribute;
  mu_refcount_lock (da->refcount);
  da->userflags |= (userflags | MU_ATTRIBUTE_MODIFIED);
  mu_refcount_unlock (da->refcount);
  return 0;
}

int
_attribute_default_unset_userflags (attribute_t attribute, int userflags)
{
  struct _attribute_default *da = (struct _attribute_default *)attribute;
  mu_refcount_lock (da->refcount);
  da->userflags &= ~userflags;
  /* If Modified was being unset do not reset it.  */
  if (!(userflags & MU_ATTRIBUTE_MODIFIED))
    da->userflags |= MU_ATTRIBUTE_MODIFIED;
  mu_refcount_unlock (da->refcount);
  return 0;
}

int
_attribute_default_clear_userflags (attribute_t attribute)
{
  struct _attribute_default *da = (struct _attribute_default *)attribute;
  mu_refcount_lock (da->refcount);
  da->userflags = 0;
  mu_refcount_unlock (da->refcount);
  return 0;
}

139
static struct _attribute_vtable _attribute_default_vtable =
140
{
141 142
  _attribute_default_ref,
  _attribute_default_destroy,
143

144 145 146
  _attribute_default_get_flags,
  _attribute_default_set_flags,
  _attribute_default_unset_flags,
147 148 149 150 151 152
  _attribute_default_clear_flags,

  _attribute_default_get_userflags,
  _attribute_default_set_userflags,
  _attribute_default_unset_userflags,
  _attribute_default_clear_userflags
153 154 155
};

int
156
_attribute_default_ctor (struct _attribute_default *da)
157
{
158 159 160 161 162 163 164 165 166
  mu_refcount_create (&(da->refcount));
  if (da->refcount == NULL)
    return MU_ERROR_NO_MEMORY;
  da->flags = 0;
  da->base.vtable = &_attribute_default_vtable;
  return 0;
}

void
167
_attribute_default_dtor (attribute_t attribute)
168
{
169 170 171
  struct _attribute_default *da = (struct _attribute_default *)attribute;
  if (da)
    mu_refcount_destroy (&da->refcount);
172 173 174 175 176 177 178 179
}

int
attribute_default_create (attribute_t *pattribute)
{
  struct _attribute_default *da;
  int status;

180 181
  if (pattribute == NULL)
    return MU_ERROR_INVALID_PARAMETER;
182

183 184 185 186
  da = calloc (1, sizeof *da);
  if (da == NULL)
    return MU_ERROR_NO_MEMORY;

187 188
  status = _attribute_default_ctor (da);
  if (status != 0)
189 190
    {
      free (da);
191
      return status;
192 193 194 195
    }
  *pattribute = &da->base;
  return 0;
}
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230

int
attribute_status_create (attribute_t *pattribute, const char *field)
{
  struct _attribute_default *da;
  int status;
  char *colon;

  if (pattribute == NULL || field == NULL)
    return MU_ERROR_INVALID_PARAMETER;

  da = calloc (1, sizeof *da);
  if (da == NULL)
    return MU_ERROR_NO_MEMORY;

  status = _attribute_default_ctor (da);
  if (status != 0)
    {
      free (da);
      return status;
    }
  *pattribute = &da->base;

  colon = strchr (field, ':');
  if (colon)
    field = ++colon;

  for (; *field; field++)
    {
      switch (*field)
	{
	case 'O':
	case 'o':
	  attribute_set_seen (*pattribute);
	  break;
231 232 233 234 235 236

	case 'r':
	case 'R':
	  attribute_set_read (*pattribute);
	  break;

237 238 239 240
	case 'a':
	case 'A':
	  attribute_set_answered (*pattribute);
	  break;
241

242 243 244 245
	case 'd':
	case 'D':
	  attribute_set_deleted (*pattribute);
	  break;
246 247 248 249 250 251 252 253 254 255 256

	case 't':
	case 'T':
	  attribute_set_draft (*pattribute);
	  break;

	case 'f':
	case 'F':
	  attribute_set_flagged (*pattribute);
	  break;

257 258 259 260 261
	}
    }
  attribute_unset_modified (*pattribute);
  return 0;
}