← Back to branch summary

~ubuntu-branches/ubuntu/wily/dovecot/wily

« back to all changes in this revision

Viewing changes to src/lib-dict/dict.c

  • Committer: Package Import Robot
  • Author(s): Jaldhar H. Vyas
  • Date: 2013-09-09 00:57:32 UTC
  • mfrom: (1.13.11)
  • mto: (4.8.5 experimental) (1.16.1)
  • mto: This revision was merged to the branch mainline in revision 97.
  • Revision ID: package-import@ubuntu.com-20130909005732-dn1eell8srqbhh0e
Tags: upstream-2.2.5
Import upstream version 2.2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib-dict/dict.c
1
 
/* Copyright (c) 2005-2012 Dovecot authors, see the included COPYING file */
 
1
/* Copyright (c) 2005-2013 Dovecot authors, see the included COPYING file */
2
2
 
3
3
#include "lib.h"
4
4
#include "array.h"
6
6
#include "dict-sql.h"
7
7
#include "dict-private.h"
8
8
 
9
 
static ARRAY_DEFINE(dict_drivers, struct dict *);
 
9
static ARRAY(struct dict *) dict_drivers;
10
10
static struct dict_iterate_context dict_iter_unsupported;
11
11
 
12
12
static struct dict *dict_driver_lookup(const char *name)
37
37
void dict_driver_unregister(struct dict *driver)
38
38
{
39
39
        struct dict *const *dicts;
40
 
        unsigned int idx = -1U;
 
40
        unsigned int idx = UINT_MAX;
41
41
 
42
42
        array_foreach(&dict_drivers, dicts) {
43
43
                if (*dicts == driver) {
45
45
                        break;
46
46
                }
47
47
        }
48
 
        i_assert(idx != -1U);
 
48
        i_assert(idx != UINT_MAX);
49
49
        array_delete(&dict_drivers, idx, 1);
50
50
 
51
51
        if (array_count(&dict_drivers) == 0)
57
57
        dict_driver_register(&dict_driver_client);
58
58
        dict_driver_register(&dict_driver_file);
59
59
        dict_driver_register(&dict_driver_memcached);
 
60
        dict_driver_register(&dict_driver_memcached_ascii);
60
61
        dict_driver_register(&dict_driver_redis);
61
62
}
62
63
 
65
66
        dict_driver_unregister(&dict_driver_client);
66
67
        dict_driver_unregister(&dict_driver_file);
67
68
        dict_driver_unregister(&dict_driver_memcached);
 
69
        dict_driver_unregister(&dict_driver_memcached_ascii);
68
70
        dict_driver_unregister(&dict_driver_redis);
69
71
}
70
72
 
71
 
struct dict *dict_init(const char *uri, enum dict_data_type value_type,
72
 
                       const char *username, const char *base_dir)
 
73
int dict_init(const char *uri, enum dict_data_type value_type,
 
74
              const char *username, const char *base_dir, struct dict **dict_r,
 
75
              const char **error_r)
73
76
{
74
77
        struct dict *dict;
75
 
        const char *p, *name;
 
78
        const char *p, *name, *error;
76
79
 
77
80
        i_assert(username != NULL);
78
81
 
79
82
        p = strchr(uri, ':');
80
83
        if (p == NULL) {
81
 
                i_error("Dictionary URI is missing ':': %s", uri);
82
 
                return NULL;
83
 
        }
84
 
 
85
 
        T_BEGIN {
86
 
                name = t_strdup_until(uri, p);
87
 
                dict = dict_driver_lookup(name);
88
 
                if (dict == NULL)
89
 
                        i_error("Unknown dict module: %s", name);
90
 
        } T_END;
91
 
 
92
 
        return dict == NULL ? NULL :
93
 
                dict->v.init(dict, p+1, value_type, username, base_dir);
 
84
                *error_r = t_strdup_printf("Dictionary URI is missing ':': %s",
 
85
                                           uri);
 
86
                return -1;
 
87
        }
 
88
 
 
89
        name = t_strdup_until(uri, p);
 
90
        dict = dict_driver_lookup(name);
 
91
        if (dict == NULL) {
 
92
                *error_r = t_strdup_printf("Unknown dict module: %s", name);
 
93
                return -1;
 
94
        }
 
95
        if (dict->v.init(dict, p+1, value_type, username, base_dir,
 
96
                         dict_r, &error) < 0) {
 
97
                *error_r = t_strdup_printf("dict %s: %s", name, error);
 
98
                return -1;
 
99
        }
 
100
        return 0;
94
101
}
95
102
 
96
103
void dict_deinit(struct dict **_dict)
212
219
        ctx->changed = TRUE;
213
220
}
214
221
 
 
222
void dict_append(struct dict_transaction_context *ctx,
 
223
                 const char *key, const char *value)
 
224
{
 
225
        i_assert(dict_key_prefix_is_valid(key));
 
226
 
 
227
        ctx->dict->v.append(ctx, key, value);
 
228
        ctx->changed = TRUE;
 
229
}
 
230
 
215
231
void dict_atomic_inc(struct dict_transaction_context *ctx,
216
232
                     const char *key, long long diff)
217
233
{