← Back to branch summary

~ubuntu-branches/debian/sid/openchange/sid

« back to all changes in this revision

Viewing changes to mapiproxy/libmapistore/mapistore_backend_defaults.c

  • Committer: Package Import Robot
  • Author(s): Jelmer Vernooij
  • Date: 2012-04-12 20:07:57 UTC
  • mfrom: (11 sid)
  • mto: This revision was merged to the branch mainline in revision 12.
  • Revision ID: package-import@ubuntu.com-20120412200757-k933d9trljmxj1l4
Tags: 1:1.0-4
* openchangeserver: Add dependency on openchangeproxy.
* Rebuild against newer version of Samba 4.
* Use dpkg-buildflags.
* Migrate to Git, update Vcs-Git header.
* Switch to debhelper 9.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mapiproxy/libmapistore/mapistore_backend_defaults.c
3
3
 
4
4
   OpenChange Project
5
5
 
6
 
   Copyright (C) Julien Kerihuel 2011
 
6
   Copyright (C) Julien Kerihuel 2011-2012
7
7
 
8
8
   This program is free software; you can redistribute it and/or modify
9
9
   it under the terms of the GNU General Public License as published by
22
22
#include "mapistore_errors.h"
23
23
#include "mapistore.h"
24
24
#include "mapistore_private.h"
25
 
#include "mapistore_backend.h"
26
 
#include "mapistore_common.h"
27
25
 
28
26
/**
29
27
   \file mapistore_backend_defaults.c
32
30
 */
33
31
 
34
32
 
35
 
static enum MAPISTORE_ERROR mapistore_op_defaults_init(void)
36
 
{
37
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
38
 
}
39
 
 
40
 
 
41
 
static enum MAPISTORE_ERROR mapistore_op_defaults_create_context(struct mapistore_backend_context *mstoredb_ctx, 
42
 
                                                                 const char *login_user, 
43
 
                                                                 const char *username,
44
 
                                                                 const char *uri, 
45
 
                                                                 void **private_data)
46
 
{
47
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
48
 
}
49
 
 
50
 
 
51
 
static enum MAPISTORE_ERROR mapistore_op_defaults_delete_context(void *private_data)
52
 
{
53
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
54
 
}
55
 
 
56
 
 
57
 
static enum MAPISTORE_ERROR mapistore_op_defaults_release_record(void *private_data, 
58
 
                                                                 const char *uri, 
59
 
                                                                 uint8_t type)
60
 
{
61
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
62
 
}
63
 
 
64
 
 
65
 
static enum MAPISTORE_ERROR mapistore_op_defaults_get_path(void *private_data, 
66
 
                                                           const char *uri,  
67
 
                                                           uint8_t type, 
68
 
                                                           char **path)
69
 
{
70
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
71
 
}
72
 
 
73
 
 
74
 
static enum MAPISTORE_ERROR mapistore_op_defaults_mkdir(void *private_data,
75
 
                                                        const char *parent_uri,
76
 
                                                        const char *folder_name,
77
 
                                                        const char *folder_desc,
78
 
                                                        enum FOLDER_TYPE folder_type,
79
 
                                                        char **folder_uri)
80
 
{
81
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
82
 
}
83
 
 
84
 
 
85
 
static enum MAPISTORE_ERROR mapistore_op_defaults_rmdir(void *private_data, 
86
 
                                                        const char *parent_uri, 
87
 
                                                        const char *folder_uri)
88
 
{
89
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
90
 
}
91
 
 
92
 
 
93
 
static enum MAPISTORE_ERROR mapistore_op_defaults_opendir(void *private_data, 
94
 
                                                          const char *parent_uri, 
95
 
                                                          const char *folder_uri)
96
 
{
97
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
98
 
}
99
 
 
100
 
 
101
 
static enum MAPISTORE_ERROR mapistore_op_defaults_closedir(void *private_data,
102
 
                                                           const char *folder_uri)
103
 
{
104
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
105
 
}
106
 
 
107
 
 
108
 
static enum MAPISTORE_ERROR mapistore_op_defaults_readdir_count(void *private_data, 
109
 
                                                                const char *folder_uri,
110
 
                                                                enum MAPISTORE_TABLE_TYPE table_type,
111
 
                                                                uint32_t *RowCount)
112
 
{
113
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
114
 
}
115
 
 
116
 
 
117
 
static enum MAPISTORE_ERROR mapistore_op_defaults_get_table_property(void *private_data, 
118
 
                                                                     const char *folder_uri,
119
 
                                                                     enum MAPISTORE_TABLE_TYPE table_type, 
120
 
                                                                     uint32_t pos,
121
 
                                                                     enum MAPITAGS proptag,
122
 
                                                                     void **data)
123
 
{
124
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
125
 
}
126
 
 
127
 
 
128
 
static enum MAPISTORE_ERROR mapistore_op_defaults_openmessage(void *private_data,
129
 
                                                              const char *folder_uri,
130
 
                                                              const char *message_uri,
131
 
                                                              struct mapistore_message *msg)
132
 
{
133
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
134
 
}
135
 
 
136
 
 
137
 
static enum MAPISTORE_ERROR mapistore_op_defaults_createmessage(void *private_data, 
138
 
                                                                const char *folder_uri,
139
 
                                                                char **message_uri,
140
 
                                                                bool *uri_register)
141
 
{
142
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
143
 
}
144
 
 
145
 
 
146
 
static enum MAPISTORE_ERROR mapistore_op_defaults_savechangesmessage(void *private_data, 
147
 
                                                                     const char *message_uri,
148
 
                                                                     uint8_t flags)
149
 
{
150
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
151
 
}
152
 
 
153
 
 
154
 
static enum MAPISTORE_ERROR mapistore_op_defaults_submitmessage(void *private_data, 
155
 
                                                                const char *message_uri,
156
 
                                                                uint8_t flags)
157
 
{
158
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
159
 
}
160
 
 
161
 
 
162
 
static enum MAPISTORE_ERROR mapistore_op_defaults_deletemessage(void *private_data, 
163
 
                                                                const char *message_uri, 
164
 
                                                                enum MAPISTORE_DELETION_TYPE deletion_type)
165
 
{
166
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
167
 
}
168
 
 
169
 
 
170
 
static enum MAPISTORE_ERROR mapistore_op_defaults_get_uri_by_name(void *private_data, 
171
 
                                                                  const char *parent_uri,
172
 
                                                                  const char *foldername, 
173
 
                                                                  char **uri)
174
 
{
175
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
176
 
}
177
 
 
178
 
 
179
 
static enum MAPISTORE_ERROR mapistore_op_defaults_getprops(void *private_data, 
180
 
                                                           const char *uri, 
181
 
                                                           uint8_t type,
182
 
                                                           struct SPropTagArray *SPropTagArray, 
183
 
                                                           struct SRow *aRow)
184
 
{
185
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
186
 
}
187
 
 
188
 
 
189
 
static enum MAPISTORE_ERROR mapistore_op_defaults_setprops(void *private_data, 
190
 
                                                           const char *uri,
191
 
                                                           uint8_t type,
192
 
                                                           struct SRow *aRow)
193
 
{
194
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
195
 
}
196
 
 
197
 
 
198
 
static enum MAPISTORE_ERROR mapistore_op_defaults_db_create_uri(TALLOC_CTX *mem_ctx, 
199
 
                                                                uint32_t index, 
200
 
                                                                const char *username,
201
 
                                                                char **mapistore_uri)
202
 
{
203
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
204
 
}
205
 
 
206
 
 
207
 
static enum MAPISTORE_ERROR mapistore_op_defaults_provision_namedprops(TALLOC_CTX *mem_ctx, char **ldif,
208
 
                                                                       enum MAPISTORE_NAMEDPROPS_PROVISION_TYPE *ntype)
209
 
{
210
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
211
 
}
212
 
 
213
 
 
214
 
static enum MAPISTORE_ERROR mapistore_op_defaults_db_mkdir(void *private_data, enum MAPISTORE_DFLT_FOLDERS system_idx,
215
 
                                                           const char *mapistore_uri, const char *folder_name)
216
 
{
217
 
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
218
 
}
219
 
 
220
 
/**
221
 
 \brief Set default implementations for all the backend methods
222
 
 
223
 
 The default implementations just fail (returning MAPISTORE_ERR_NOT_IMPLEMENTED), but
224
 
 that is a lot better than forgetting to implement one and having the backend crash. You should
225
 
 call this function before setting any of your own values.
226
 
 
227
 
 \param backend the backend to set the defaults on
228
 
 
229
 
 \return MAPISTORE_SUCCESS on success, otherwise a MAPISTORE_ERROR value
230
 
*/
231
 
 
232
 
enum MAPISTORE_ERROR mapistore_backend_init_defaults(struct mapistore_backend *backend)
 
33
static enum mapistore_error mapistore_op_defaults_init(void)
 
34
{
 
35
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));     
 
36
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
37
}
 
38
 
 
39
static enum mapistore_error mapistore_op_defaults_list_contexts(const char *owner, struct tdb_wrap *indexing,
 
40
                                                                TALLOC_CTX *mem_ctx, 
 
41
                                                                struct mapistore_contexts_list **contexts_listp)
 
42
{
 
43
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
44
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
45
}
 
46
 
 
47
static enum mapistore_error mapistore_op_defaults_create_context(TALLOC_CTX *mem_ctx, 
 
48
                                                                 struct mapistore_connection_info *conn_info,
 
49
                                                                 struct tdb_wrap *indexing_ctx,
 
50
                                                                 const char *uri, void **ctx)
 
51
{
 
52
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
53
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
54
}
 
55
 
 
56
static enum mapistore_error mapistore_op_defaults_create_root_folder(const char *username, 
 
57
                                                                     enum mapistore_context_role ctx_role, 
 
58
                                                                     uint64_t fid, 
 
59
                                                                     const char *name,
 
60
                                                                     TALLOC_CTX *mem_ctx,
 
61
                                                                     char **mapistore_urip)
 
62
{
 
63
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
64
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
65
}
 
66
 
 
67
static enum mapistore_error mapistore_op_defaults_get_path(void *ctx_obj, TALLOC_CTX *mem_ctx,
 
68
                                                           uint64_t fmid, char **path)
 
69
{
 
70
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
71
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
72
}
 
73
 
 
74
static enum mapistore_error mapistore_op_defaults_get_root_folder(void *backend_object,
 
75
                                                                  TALLOC_CTX *mem_ctx,
 
76
                                                                  uint64_t fid,
 
77
                                                                  void **root_folder_object)
 
78
{
 
79
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
80
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
81
}
 
82
 
 
83
static enum mapistore_error mapistore_op_defaults_open_folder(void *folder_object,
 
84
                                                              TALLOC_CTX *mem_ctx,
 
85
                                                              uint64_t fid,
 
86
                                                              void **child_folder_object)
 
87
{
 
88
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
89
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
90
}
 
91
 
 
92
static enum mapistore_error mapistore_op_defaults_create_folder(void *folder_object,
 
93
                                                                TALLOC_CTX *mem_ctx,
 
94
                                                                uint64_t fid,
 
95
                                                                struct SRow *aRow,
 
96
                                                                void **child_folder_object)
 
97
{
 
98
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
99
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
100
}
 
101
 
 
102
static enum mapistore_error mapistore_op_defaults_delete_folder(void *folder_object)
 
103
{
 
104
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
105
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
106
}
 
107
 
 
108
static enum mapistore_error mapistore_op_defaults_open_message(void *folder_object,
 
109
                                                               TALLOC_CTX *mem_ctx,
 
110
                                                               uint64_t mid,
 
111
                                                               bool rw,
 
112
                                                               void **message_object)
 
113
{
 
114
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
115
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
116
}
 
117
 
 
118
static enum mapistore_error mapistore_op_defaults_create_message(void *folder_object,
 
119
                                                                 TALLOC_CTX *mem_ctx,
 
120
                                                                 uint64_t mid,
 
121
                                                                 uint8_t associated,
 
122
                                                                 void **message_object)
 
123
{
 
124
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
125
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
126
}
 
127
 
 
128
static enum mapistore_error mapistore_op_defaults_delete_message(void *folder_object,
 
129
                                                                 uint64_t mid,
 
130
                                                                 uint8_t flags)
 
131
{
 
132
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
133
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
134
}
 
135
 
 
136
static enum mapistore_error mapistore_op_defaults_move_copy_messages(void *target_folder,
 
137
                                                                     void *source_folder,
 
138
                                                                     uint32_t mid_count,
 
139
                                                                     uint64_t *source_mids,
 
140
                                                                     uint64_t *target_mids,
 
141
                                                                     struct Binary_r **target_change_keys,
 
142
                                                                     uint8_t want_copy)
 
143
{
 
144
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
145
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
146
}
 
147
 
 
148
static enum mapistore_error mapistore_op_defaults_get_deleted_fmids(void *folder_object,
 
149
                                                                    TALLOC_CTX *mem_ctx,
 
150
                                                                    enum mapistore_table_type table_type,
 
151
                                                                    uint64_t change_num,
 
152
                                                                    struct I8Array_r **fmidsp,
 
153
                                                                    uint64_t *cnp)
 
154
{
 
155
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
156
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
157
}
 
158
 
 
159
static enum mapistore_error mapistore_op_defaults_get_child_count(void *folder_object,
 
160
                                                                  enum mapistore_table_type table_type,
 
161
                                                                  uint32_t *RowCount)
 
162
{
 
163
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
164
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
165
}
 
166
 
 
167
static enum mapistore_error mapistore_op_defaults_open_table(void *folder_object,
 
168
                                                             TALLOC_CTX *mem_ctx,
 
169
                                                             enum mapistore_table_type table_type,
 
170
                                                             uint32_t handle_id,
 
171
                                                             void **table_object,
 
172
                                                             uint32_t *row_count)
 
173
{
 
174
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
175
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
176
}
 
177
 
 
178
static enum mapistore_error mapistore_op_defaults_modify_permissions(void *folder_object,
 
179
                                                                     uint8_t flags,
 
180
                                                                     uint16_t pcount,
 
181
                                                                     struct PermissionData *permissions)
 
182
{
 
183
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
184
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
185
}
 
186
 
 
187
static enum mapistore_error mapistore_op_defaults_get_message_data(void *message_object,
 
188
                                                                   TALLOC_CTX *mem_ctx,
 
189
                                                                   struct mapistore_message **msg)
 
190
{
 
191
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
192
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
193
}
 
194
 
 
195
static enum mapistore_error mapistore_op_defaults_modify_recipients(void *message_object,
 
196
                                                                    struct SPropTagArray *columns,
 
197
                                                                    uint16_t count,
 
198
                                                                    struct mapistore_message_recipient *recipients)
 
199
{
 
200
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
201
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
202
}
 
203
 
 
204
static enum mapistore_error mapistore_op_defaults_set_read_flag(void *message_object, uint8_t flag)
 
205
{
 
206
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
207
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
208
}
 
209
 
 
210
static enum mapistore_error mapistore_op_defaults_save(void *message_object)
 
211
{
 
212
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
213
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
214
}
 
215
 
 
216
static enum mapistore_error mapistore_op_defaults_submit(void *message_object, enum SubmitFlags flags)
 
217
{
 
218
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
219
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
220
}
 
221
 
 
222
static enum mapistore_error mapistore_op_defaults_open_attachment(void *message_object,
 
223
                                                                  TALLOC_CTX *mem_ctx,
 
224
                                                                  uint32_t aid,
 
225
                                                                  void **attachment_object)
 
226
{
 
227
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
228
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
229
}
 
230
 
 
231
static enum mapistore_error mapistore_op_defaults_create_attachment(void *message_object,
 
232
                                                                    TALLOC_CTX *mem_ctx,
 
233
                                                                    void **attachment_object,
 
234
                                                                    uint32_t *aid)
 
235
{
 
236
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
237
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
238
}
 
239
 
 
240
static enum mapistore_error mapistore_op_defaults_get_attachment_table(void *message_object,
 
241
                                                                       TALLOC_CTX *mem_ctx,
 
242
                                                                       void **table_object,
 
243
                                                                       uint32_t *row_count)
 
244
{
 
245
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
246
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
247
}
 
248
 
 
249
static enum mapistore_error mapistore_op_defaults_open_embedded_message(void *message_object,
 
250
                                                                        TALLOC_CTX *mem_ctx,
 
251
                                                                        void **embedded_message_object,
 
252
                                                                        uint64_t *mid,
 
253
                                                                        struct mapistore_message **msg)
 
254
{
 
255
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
256
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
257
}
 
258
 
 
259
static enum mapistore_error mapistore_op_defaults_get_available_properties(void *x_object,
 
260
                                                                           TALLOC_CTX *mem_ctx,
 
261
                                                                           struct SPropTagArray **propertiesp)
 
262
{
 
263
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
264
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
265
}
 
266
 
 
267
static enum mapistore_error mapistore_op_defaults_set_columns(void *table_object,
 
268
                                                              uint16_t count,
 
269
                                                              enum MAPITAGS *properties)
 
270
{
 
271
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
272
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
273
}
 
274
 
 
275
static enum mapistore_error mapistore_op_defaults_set_restrictions(void *table_object,
 
276
                                                                   struct mapi_SRestriction *restrictions,
 
277
                                                                   uint8_t *table_status)
 
278
{
 
279
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
280
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
281
}
 
282
 
 
283
static enum mapistore_error mapistore_op_defaults_set_sort_order(void *table_object,
 
284
                                                                 struct SSortOrderSet *sort_order,
 
285
                                                                 uint8_t *table_status)
 
286
{
 
287
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
288
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
289
}
 
290
 
 
291
static enum mapistore_error mapistore_op_defaults_get_row(void *table_object,
 
292
                                                          TALLOC_CTX *mem_ctx,
 
293
                                                          enum mapistore_query_type query_type,
 
294
                                                          uint32_t rowid,
 
295
                                                          struct mapistore_property_data **data)
 
296
{
 
297
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
298
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
299
}
 
300
 
 
301
static enum mapistore_error mapistore_op_defaults_get_row_count(void *table_object,
 
302
                                                                enum mapistore_query_type query_type,
 
303
                                                                uint32_t *row_countp)
 
304
{
 
305
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
306
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
307
}
 
308
 
 
309
static enum mapistore_error mapistore_op_defaults_handle_destructor(void *table_object,
 
310
                                                                    uint32_t handle_id)
 
311
{
 
312
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
313
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
314
}
 
315
 
 
316
static enum mapistore_error mapistore_op_defaults_get_properties(void *x_object,
 
317
                                                                 TALLOC_CTX *mem_ctx,
 
318
                                                                 uint16_t count,
 
319
                                                                 enum MAPITAGS *properties,
 
320
                                                                 struct mapistore_property_data *data)
 
321
{
 
322
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
323
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
324
}
 
325
 
 
326
static enum mapistore_error mapistore_op_defaults_set_properties(void *x_object,
 
327
                                                                 struct SRow *aRow)
 
328
{
 
329
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
330
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
331
}
 
332
 
 
333
static enum mapistore_error mapistore_op_defaults_generate_uri(TALLOC_CTX *mem_ctx,
 
334
                                                               const char *username,
 
335
                                                               const char *folder,
 
336
                                                               const char *message,
 
337
                                                               const char *root_uri,
 
338
                                                               char **uri)
 
339
{
 
340
        DEBUG(3, ("[%s:%d] MAPISTORE defaults - MAPISTORE_ERR_NOT_IMPLEMENTED\n", __FUNCTION__, __LINE__));
 
341
        return MAPISTORE_ERR_NOT_IMPLEMENTED;
 
342
}
 
343
 
 
344
extern enum mapistore_error mapistore_backend_init_defaults(struct mapistore_backend *backend)
233
345
{
234
346
        /* Sanity checks */
235
347
        MAPISTORE_RETVAL_IF(!backend, MAPISTORE_ERR_INVALID_PARAMETER, NULL);
236
348
 
237
 
        /* Backend information */
238
 
        backend->name = NULL;
239
 
        backend->description = NULL;
240
 
        backend->uri_namespace = NULL;
241
 
 
242
 
        /* Backend semantics */
243
 
        backend->init = mapistore_op_defaults_init;
244
 
        backend->create_context = mapistore_op_defaults_create_context;
245
 
        backend->delete_context = mapistore_op_defaults_delete_context;
246
 
        backend->release_record = mapistore_op_defaults_release_record;
247
 
        backend->get_path = mapistore_op_defaults_get_path;
248
 
 
249
 
        /* Folder semantics */
250
 
        backend->op_mkdir = mapistore_op_defaults_mkdir;
251
 
        backend->op_rmdir = mapistore_op_defaults_rmdir;
252
 
        backend->op_opendir = mapistore_op_defaults_opendir;
253
 
        backend->op_closedir = mapistore_op_defaults_closedir;
254
 
        backend->op_readdir_count = mapistore_op_defaults_readdir_count;
255
 
        backend->op_get_table_property = mapistore_op_defaults_get_table_property;
256
 
        backend->op_get_uri_by_name = mapistore_op_defaults_get_uri_by_name;
257
 
 
258
 
        /* Message semantics */
259
 
        backend->op_openmessage = mapistore_op_defaults_openmessage;
260
 
        backend->op_createmessage = mapistore_op_defaults_createmessage;
261
 
        backend->op_savechangesmessage = mapistore_op_defaults_savechangesmessage;
262
 
        backend->op_submitmessage = mapistore_op_defaults_submitmessage;
263
 
        backend->op_deletemessage = mapistore_op_defaults_deletemessage;
264
 
 
265
 
        /* Common semantics */
266
 
        backend->op_getprops = mapistore_op_defaults_getprops;
267
 
        backend->op_setprops = mapistore_op_defaults_setprops;
268
 
 
269
 
        /* MAPIStoreDB/Store semantics */
270
 
        backend->op_db_create_uri = mapistore_op_defaults_db_create_uri;
271
 
        backend->op_db_provision_namedprops = mapistore_op_defaults_provision_namedprops;
272
 
        backend->op_db_mkdir = mapistore_op_defaults_db_mkdir;
 
349
        /* Backend operations */
 
350
        backend->backend.name = NULL;
 
351
        backend->backend.description = NULL;
 
352
        backend->backend.namespace = NULL;
 
353
        backend->backend.init = mapistore_op_defaults_init;
 
354
        backend->backend.list_contexts = mapistore_op_defaults_list_contexts;
 
355
        backend->backend.create_context = mapistore_op_defaults_create_context;
 
356
        backend->backend.create_root_folder = mapistore_op_defaults_create_root_folder;
 
357
 
 
358
        /* context operations */
 
359
        backend->context.get_path = mapistore_op_defaults_get_path;
 
360
        backend->context.get_root_folder = mapistore_op_defaults_get_root_folder;
 
361
 
 
362
        /* oxcfold semantics */
 
363
        backend->folder.open_folder = mapistore_op_defaults_open_folder;
 
364
        backend->folder.create_folder = mapistore_op_defaults_create_folder;
 
365
        backend->folder.delete = mapistore_op_defaults_delete_folder;
 
366
        backend->folder.open_message = mapistore_op_defaults_open_message;
 
367
        backend->folder.create_message = mapistore_op_defaults_create_message;
 
368
        backend->folder.delete_message = mapistore_op_defaults_delete_message;
 
369
        backend->folder.move_copy_messages = mapistore_op_defaults_move_copy_messages;
 
370
        backend->folder.get_deleted_fmids = mapistore_op_defaults_get_deleted_fmids;
 
371
        backend->folder.get_child_count = mapistore_op_defaults_get_child_count;
 
372
        backend->folder.open_table = mapistore_op_defaults_open_table;
 
373
        backend->folder.modify_permissions = mapistore_op_defaults_modify_permissions;
 
374
 
 
375
        /* oxcmsg operations */
 
376
        backend->message.get_message_data = mapistore_op_defaults_get_message_data;
 
377
        backend->message.modify_recipients = mapistore_op_defaults_modify_recipients;
 
378
        backend->message.set_read_flag = mapistore_op_defaults_set_read_flag;
 
379
        backend->message.save = mapistore_op_defaults_save;
 
380
        backend->message.submit = mapistore_op_defaults_submit;
 
381
        backend->message.open_attachment = mapistore_op_defaults_open_attachment;
 
382
        backend->message.create_attachment = mapistore_op_defaults_create_attachment;
 
383
        backend->message.get_attachment_table = mapistore_op_defaults_get_attachment_table;
 
384
        backend->message.open_embedded_message = mapistore_op_defaults_open_embedded_message;
 
385
 
 
386
        /* oxctabl operations */
 
387
        backend->table.get_available_properties = mapistore_op_defaults_get_available_properties;
 
388
        backend->table.set_columns = mapistore_op_defaults_set_columns;
 
389
        backend->table.set_restrictions = mapistore_op_defaults_set_restrictions;
 
390
        backend->table.set_sort_order = mapistore_op_defaults_set_sort_order;
 
391
        backend->table.get_row = mapistore_op_defaults_get_row;
 
392
        backend->table.get_row_count = mapistore_op_defaults_get_row_count;
 
393
        backend->table.handle_destructor = mapistore_op_defaults_handle_destructor;
 
394
 
 
395
        /* oxcprpt operations */
 
396
        backend->properties.get_available_properties = mapistore_op_defaults_get_available_properties;
 
397
        backend->properties.get_properties = mapistore_op_defaults_get_properties;
 
398
        backend->properties.set_properties = mapistore_op_defaults_set_properties;
 
399
 
 
400
        /* manager operations */
 
401
        backend->manager.generate_uri = mapistore_op_defaults_generate_uri;
273
402
 
274
403
        return MAPISTORE_SUCCESS;
275
404
}