← Back to branch summary

~ubuntu-branches/ubuntu/quantal/dovecot/quantal

« back to all changes in this revision

Viewing changes to sieve/src/lib-sieve/plugins/variables/ext-variables-namespaces.c

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2010-06-29 09:21:32 UTC
  • mfrom: (4.1.14 sid)
  • Revision ID: james.westby@ubuntu.com-20100629092132-q4pr5lfuvmjqou19
Tags: 1:1.2.12-1ubuntu1
https://launchpad.net/bugs/597818
* Merge from Debian Unstable, remaining changes:
  + Add mail-stack-delivery as per server-maverick-mail-integration spec:
   - Update debian/rules
   - Convert existing package to a dummy package and add new binary in debian/control
   - Update maintainer scripts.
   - Move previously installed backups and config files to new package name
     space in preinst
   - Add new debian/mail-stack-delivery.prerm to handle downgrades
   - Rename debian/dovecot-postfix.* to debian/mail-stack-delivery.*
  + Use Snakeoil SSL certificates by default.
    - debian/control: Depend on ssl-cert.
    - debian/patches/ssl-cert-snakeoil.dpatch: Change default SSL cert paths to snakeoil.
    - debian/dovecot-common.postinst: Relax grep for SSL_* a bit.
  + Add autopkgtest to debian/tests/*.
  + Add ufw integration:
    - Created debian/dovecot-common.ufw.profile.
    - debian/rules: install profile.
    - debian/control: suggest ufw.
  + debian/{control,rules}: enable PIE hardening.
  + debian/control: Update Vcs-* headers.
  + Add SMTP-AUTH support for Outlook (login auth mechanism) 
  + debian/dovecot-common.dirs: Added usr/share/doc/dovecot-common
  + debian/patches/fix-dovecot-config-parser.patch: Fix ordering of external config 
    files. (LP: #597818)

Show diffs side-by-side

added added

removed removed

Lines of Context:
sieve/src/lib-sieve/plugins/variables/ext-variables-namespaces.c
19
19
void sieve_variables_namespace_register
20
20
(const struct sieve_extension *var_ext, struct sieve_validator *valdtr,
21
21
        const struct sieve_extension *ext,
22
 
        const struct sieve_variables_namespace_def *nspc_def) 
 
22
        const struct sieve_variables_namespace_def *nspc_def)
23
23
{
24
 
        struct ext_variables_validator_context *ctx = 
 
24
        struct ext_variables_validator_context *ctx =
25
25
                ext_variables_validator_context_get(var_ext, valdtr);
26
 
        
 
26
 
27
27
        sieve_validator_object_registry_add(ctx->namespaces, ext, &nspc_def->obj_def);
28
28
}
29
29
 
30
30
bool ext_variables_namespace_exists
31
31
(const struct sieve_extension *var_ext, struct sieve_validator *valdtr,
32
 
        const char *identifier) 
 
32
        const char *identifier)
33
33
{
34
 
        struct ext_variables_validator_context *ctx = 
 
34
        struct ext_variables_validator_context *ctx =
35
35
                ext_variables_validator_context_get(var_ext, valdtr);
36
36
 
37
37
        return sieve_validator_object_registry_find
40
40
 
41
41
const struct sieve_variables_namespace *ext_variables_namespace_create_instance
42
42
(const struct sieve_extension *var_ext, struct sieve_validator *valdtr,
43
 
        struct sieve_command *cmd, const char *identifier) 
 
43
        struct sieve_command *cmd, const char *identifier)
44
44
{
45
 
        struct ext_variables_validator_context *ctx = 
 
45
        struct ext_variables_validator_context *ctx =
46
46
                ext_variables_validator_context_get(var_ext, valdtr);
47
47
        struct sieve_object object;
48
48
        struct sieve_variables_namespace *nspc;
71
71
};
72
72
 
73
73
static bool arg_namespace_generate
74
 
(const struct sieve_codegen_env *cgenv, struct sieve_ast_argument *arg, 
 
74
(const struct sieve_codegen_env *cgenv, struct sieve_ast_argument *arg,
75
75
        struct sieve_command *context ATTR_UNUSED);
76
76
 
77
 
const struct sieve_argument_def namespace_argument = { 
78
 
        "@namespace", 
 
77
const struct sieve_argument_def namespace_argument = {
 
78
        "@namespace",
79
79
        NULL, NULL, NULL, NULL,
80
 
        arg_namespace_generate 
 
80
        arg_namespace_generate
81
81
};
82
82
 
83
83
bool ext_variables_namespace_argument_activate
84
84
(const struct sieve_extension *this_ext, struct sieve_validator *valdtr,
85
 
        struct sieve_ast_argument *arg, struct sieve_command *cmd, 
 
85
        struct sieve_ast_argument *arg, struct sieve_command *cmd,
86
86
        ARRAY_TYPE(sieve_variable_name) *var_name, bool assignment)
87
87
{
88
88
        pool_t pool = sieve_command_pool(cmd);
95
95
        nspc = ext_variables_namespace_create_instance
96
96
                (this_ext, valdtr, cmd, str_c(name_element->identifier));
97
97
        if ( nspc == NULL ) {
98
 
                sieve_argument_validate_error(valdtr, arg, 
99
 
                        "referring to variable in unknown namespace '%s'", 
 
98
                sieve_argument_validate_error(valdtr, arg,
 
99
                        "referring to variable in unknown namespace '%s'",
100
100
                        str_c(name_element->identifier));
101
101
                return FALSE;
102
102
        }
110
110
        var = p_new(pool, struct arg_namespace_variable, 1);
111
111
        var->namespace = nspc;
112
112
        var->data = var_data;
113
 
        
 
113
 
114
114
        arg->argument = sieve_argument_create(ast, &namespace_argument, this_ext, 0);
115
115
        arg->argument->data = (void *) var;
116
 
        
 
116
 
117
117
        return TRUE;
118
118
}
119
119
 
120
120
struct sieve_ast_argument *ext_variables_namespace_argument_create
121
 
(const struct sieve_extension *this_ext, 
122
 
        struct sieve_validator *valdtr, struct sieve_ast_argument *parent_arg, 
 
121
(const struct sieve_extension *this_ext,
 
122
        struct sieve_validator *valdtr, struct sieve_ast_argument *parent_arg,
123
123
        struct sieve_command *cmd, ARRAY_TYPE(sieve_variable_name) *var_name)
124
124
{
125
125
        struct sieve_ast *ast = parent_arg->ast;
127
127
 
128
128
        new_arg = sieve_ast_argument_create(ast, sieve_ast_argument_line(parent_arg));
129
129
        new_arg->type = SAAT_STRING;
130
 
        
 
130
 
131
131
        if ( !ext_variables_namespace_argument_activate
132
132
                (this_ext, valdtr, new_arg, cmd, var_name, FALSE) )
133
133
                return NULL;
134
 
        
 
134
 
135
135
        return new_arg;
136
136
}
137
137
 
138
138
static bool arg_namespace_generate
139
 
(const struct sieve_codegen_env *cgenv, struct sieve_ast_argument *arg, 
 
139
(const struct sieve_codegen_env *cgenv, struct sieve_ast_argument *arg,
140
140
        struct sieve_command *cmd)
141
141
{
142
142
        struct sieve_argument *argument = arg->argument;
143
 
        struct arg_namespace_variable *var = 
 
143
        struct arg_namespace_variable *var =
144
144
                (struct arg_namespace_variable *) argument->data;
145
145
        const struct sieve_variables_namespace *nspc = var->namespace;
146
146
 
154
154
 * Namespace variable operands
155
155
 */
156
156
 
157
 
const struct sieve_operand_class sieve_variables_namespace_operand_class = 
 
157
const struct sieve_operand_class sieve_variables_namespace_operand_class =
158
158
        { "variable-namespace" };
159
159
 
160
160
static bool opr_namespace_variable_read
164
164
        (const struct sieve_dumptime_env *denv, const struct sieve_operand *operand,
165
165
                sieve_size_t *address, const char *field_name);
166
166
 
167
 
static const struct sieve_opr_string_interface namespace_variable_interface = { 
 
167
static const struct sieve_opr_string_interface namespace_variable_interface = {
168
168
        opr_namespace_variable_dump,
169
169
        opr_namespace_variable_read
170
170
};
171
 
                
172
 
const struct sieve_operand_def namespace_variable_operand = { 
173
 
        "namespace", 
174
 
        &variables_extension, 
 
171
 
 
172
const struct sieve_operand_def namespace_variable_operand = {
 
173
        "namespace",
 
174
        &variables_extension,
175
175
        EXT_VARIABLES_OPERAND_NAMESPACE_VARIABLE,
176
176
        &string_class,
177
177
        &namespace_variable_interface
181
181
(struct sieve_binary *sbin, const struct sieve_extension *var_ext,
182
182
        const struct sieve_extension *ext,
183
183
        const struct sieve_variables_namespace_def *nspc_def)
184
 
{ 
 
184
{
185
185
        sieve_operand_emit(sbin, var_ext, &namespace_variable_operand);
186
186
        sieve_opr_object_emit(sbin, ext, &nspc_def->obj_def);
187
187
}
188
188
 
189
189
static bool opr_namespace_variable_read
190
 
(const struct sieve_runtime_env *renv, 
 
190
(const struct sieve_runtime_env *renv,
191
191
        const struct sieve_operand *operand ATTR_UNUSED,
192
192
        sieve_size_t *address, string_t **str)
193
193
{
201
201
 
202
202
        if ( nspc.def == NULL || nspc.def->read_variable == NULL )
203
203
                return FALSE;
204
 
                
 
204
 
205
205
 
206
206
        return nspc.def->read_variable(renv, &nspc, address, str);
207
207
}
208
208
 
209
209
static bool opr_namespace_variable_dump
210
 
(const struct sieve_dumptime_env *denv, 
 
210
(const struct sieve_dumptime_env *denv,
211
211
        const struct sieve_operand *operand ATTR_UNUSED,
212
212
        sieve_size_t *address, const char *field_name)
213
213
{
214
214
        struct sieve_variables_namespace nspc;
215
 
        struct sieve_operand oprnd; 
 
215
        struct sieve_operand oprnd;
216
216
 
217
217
        if ( !sieve_operand_read(denv->sbin, address, &oprnd) ) {
218
218
                return FALSE;
219
219
        }
220
220
 
221
221
        if ( !sieve_opr_object_read_data
222
 
                (denv->sbin, &oprnd, &sieve_variables_namespace_operand_class, address, 
 
222
                (denv->sbin, &oprnd, &sieve_variables_namespace_operand_class, address,
223
223
                        &nspc.object) ) {
224
224
                return FALSE;
225
225
  }