/usr/include/dovecot/sieve/sieve-binary-private.h is in dovecot-dev 1:2.2.9-1ubuntu2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 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 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 | /* Copyright (c) 2002-2013 Pigeonhole authors, see the included COPYING file
*/
#ifndef __SIEVE_BINARY_PRIVATE_H
#define __SIEVE_BINARY_PRIVATE_H
#include "sieve-common.h"
#include "sieve-binary.h"
#include "sieve-extensions.h"
#include <sys/stat.h>
/*
* Binary file
*/
struct sieve_binary_file {
pool_t pool;
const char *path;
struct sieve_instance *svinst;
struct stat st;
int fd;
off_t offset;
const void *(*load_data)
(struct sieve_binary_file *file, off_t *offset, size_t size);
buffer_t *(*load_buffer)
(struct sieve_binary_file *file, off_t *offset, size_t size);
};
bool sieve_binary_file_open
(struct sieve_binary_file *file, struct sieve_instance *svinst,
const char *path, enum sieve_error *error_r);
void sieve_binary_file_close(struct sieve_binary_file **file);
/*
* Internal structures
*/
/* Extension registration */
struct sieve_binary_extension_reg {
/* The identifier of the extension within this binary */
int index;
/* Global extension object */
const struct sieve_extension *extension;
/* Extension to the binary; typically used to manage extension-specific blocks
* in the binary and as a means to get a binary_free notification to release
* references held by extensions.
*/
const struct sieve_binary_extension *binext;
/* Context data associated to the binary by this extension */
void *context;
/* Main block for this extension */
unsigned int block_id;
};
/* Block */
struct sieve_binary_block {
struct sieve_binary *sbin;
unsigned int id;
int ext_index;
buffer_t *data;
uoff_t offset;
};
/*
* Binary object
*/
struct sieve_binary {
pool_t pool;
int refcount;
struct sieve_instance *svinst;
struct sieve_script *script;
struct sieve_binary_file *file;
/* When the binary is loaded into memory or when it is being constructed by
* the generator, extensions can be associated to the binary. The extensions
* array is a sequential list of all linked extensions. The extension_index
* array is a mapping ext_id -> binary_extension. This is used to obtain the
* index code associated with an extension for this particular binary. The
* linked_extensions list all extensions linked to this binary object other
* than the preloaded language features implemented as 'extensions'.
*
* All arrays refer to the same extension registration objects. Upon loading
* a binary, the 'require'd extensions will sometimes need to associate
* context data to the binary object in memory. This is stored in these
* registration objects as well.
*/
ARRAY(struct sieve_binary_extension_reg *) extensions;
ARRAY(struct sieve_binary_extension_reg *) extension_index;
ARRAY(struct sieve_binary_extension_reg *) linked_extensions;
/* Attributes of a loaded binary */
const char *path;
/* Blocks */
ARRAY(struct sieve_binary_block *) blocks;
};
struct sieve_binary *sieve_binary_create
(struct sieve_instance *svinst, struct sieve_script *script);
/* Blocks management */
static inline struct sieve_binary_block *sieve_binary_block_index
(struct sieve_binary *sbin, unsigned int id)
{
struct sieve_binary_block * const *sblock;
if ( id >= array_count(&sbin->blocks) )
return NULL;
sblock = array_idx(&sbin->blocks, id);
if ( *sblock == NULL ) {
return NULL;
}
return *sblock;
}
static inline size_t _sieve_binary_block_get_size
(const struct sieve_binary_block *sblock)
{
return buffer_get_used_size(sblock->data);
}
struct sieve_binary_block *sieve_binary_block_create_id
(struct sieve_binary *sbin, unsigned int id);
buffer_t *sieve_binary_block_get_buffer
(struct sieve_binary_block *sblock);
/* Extension registration */
static inline struct sieve_binary_extension_reg *
sieve_binary_extension_create_reg
(struct sieve_binary *sbin, const struct sieve_extension *ext)
{
int index = array_count(&sbin->extensions);
struct sieve_binary_extension_reg *ereg;
if ( ext->id < 0 ) return NULL;
ereg = p_new(sbin->pool, struct sieve_binary_extension_reg, 1);
ereg->index = index;
ereg->extension = ext;
array_idx_set(&sbin->extensions, (unsigned int) index, &ereg);
array_idx_set(&sbin->extension_index, (unsigned int) ext->id, &ereg);
return ereg;
}
static inline struct sieve_binary_extension_reg *sieve_binary_extension_get_reg
(struct sieve_binary *sbin, const struct sieve_extension *ext, bool create)
{
struct sieve_binary_extension_reg *reg = NULL;
if ( ext->id >= 0 && ext->id < (int) array_count(&sbin->extension_index) ) {
struct sieve_binary_extension_reg * const *ereg =
array_idx(&sbin->extension_index, (unsigned int) ext->id);
reg = *ereg;
}
/* Register if not known */
if ( reg == NULL && create )
return sieve_binary_extension_create_reg(sbin, ext);
return reg;
}
static inline int sieve_binary_extension_register
(struct sieve_binary *sbin, const struct sieve_extension *ext,
struct sieve_binary_extension_reg **reg_r)
{
struct sieve_binary_extension_reg *ereg;
if ( (ereg=sieve_binary_extension_get_reg(sbin, ext, FALSE)) == NULL ) {
ereg = sieve_binary_extension_create_reg(sbin, ext);
if ( ereg == NULL ) return -1;
array_append(&sbin->linked_extensions, &ereg, 1);
}
if ( reg_r != NULL ) *reg_r = ereg;
return ereg->index;
}
/* Load/Save */
bool sieve_binary_load_block(struct sieve_binary_block *);
#endif /* __SIEVE_BINARY_PRIVATE_H */
|