← Back to branch summary

~ubuntu-branches/ubuntu/maverick/evolution-data-server/maverick-proposed

« back to all changes in this revision

Viewing changes to libdb/dist/template/db_server_proc

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-05-17 17:02:06 UTC
  • mfrom: (1.1.79 upstream) (1.6.12 experimental)
  • Revision ID: james.westby@ubuntu.com-20100517170206-4ufr52vwrhh26yh0
Tags: 2.30.1-1ubuntu1
https://launchpad.net/bugs/42199
https://launchpad.net/bugs/229669
https://launchpad.net/bugs/173703
https://launchpad.net/bugs/360344
https://launchpad.net/bugs/508494
* Merge from debian experimental. Remaining change:
  (LP: #42199, #229669, #173703, #360344, #508494)
  + debian/control:
    - add Vcs-Bzr tag
    - don't use libgnome
    - Use Breaks instead of Conflicts against evolution 2.25 and earlier.
  + debian/evolution-data-server.install,
    debian/patches/45_libcamel_providers_version.patch:
    - use the upstream versioning, not a Debian-specific one 
  + debian/libedata-book1.2-dev.install, debian/libebackend-1.2-dev.install,
    debian/libcamel1.2-dev.install, debian/libedataserverui1.2-dev.install:
    - install html documentation
  + debian/rules:
    - don't build documentation it's shipped with the tarball

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdb/dist/template/db_server_proc
1
 
/* Do not edit: automatically built by gen_rpc.awk. */
2
 
#include "db_config.h"
3
 
 
4
 
#ifndef NO_SYSTEM_INCLUDES
5
 
#include <sys/types.h>
6
 
 
7
 
#include <rpc/rpc.h>
8
 
 
9
 
#include <string.h>
10
 
#endif
11
 
 
12
 
#include "db_int.h"
13
 
#include "dbinc_auto/db_server.h"
14
 
#include "dbinc/db_server_int.h"
15
 
#include "dbinc_auto/rpc_server_ext.h"
16
 
 
17
 
/* BEGIN __env_cachesize_proc */
18
 
void
19
 
__env_cachesize_proc(dbenvcl_id, gbytes, bytes,
20
 
                ncache, replyp)
21
 
        long dbenvcl_id;
22
 
        u_int32_t gbytes;
23
 
        u_int32_t bytes;
24
 
        u_int32_t ncache;
25
 
        __env_cachesize_reply *replyp;
26
 
/* END __env_cachesize_proc */
27
 
{
28
 
        int ret;
29
 
        DB_ENV * dbenv;
30
 
        ct_entry *dbenv_ctp;
31
 
 
32
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
33
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
34
 
 
35
 
        /*
36
 
         * XXX Code goes here
37
 
         */
38
 
 
39
 
        replyp->status = ret;
40
 
        return;
41
 
}
42
 
 
43
 
/* BEGIN __env_close_proc */
44
 
void
45
 
__env_close_proc(dbenvcl_id, flags, replyp)
46
 
        long dbenvcl_id;
47
 
        u_int32_t flags;
48
 
        __env_close_reply *replyp;
49
 
/* END __env_close_proc */
50
 
{
51
 
        int ret;
52
 
        DB_ENV * dbenv;
53
 
        ct_entry *dbenv_ctp;
54
 
 
55
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
56
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
57
 
 
58
 
        /*
59
 
         * XXX Code goes here
60
 
         */
61
 
 
62
 
        replyp->status = ret;
63
 
        return;
64
 
}
65
 
 
66
 
/* BEGIN __env_create_proc */
67
 
void
68
 
__env_create_proc(timeout, replyp)
69
 
        u_int32_t timeout;
70
 
        __env_create_reply *replyp;
71
 
/* END __env_create_proc */
72
 
{
73
 
        int ret;
74
 
 
75
 
 
76
 
        /*
77
 
         * XXX Code goes here
78
 
         */
79
 
 
80
 
        replyp->status = ret;
81
 
        return;
82
 
}
83
 
 
84
 
/* BEGIN __env_dbremove_proc */
85
 
void
86
 
__env_dbremove_proc(dbenvcl_id, txnpcl_id, name,
87
 
                subdb, flags, replyp)
88
 
        long dbenvcl_id;
89
 
        long txnpcl_id;
90
 
        char *name;
91
 
        char *subdb;
92
 
        u_int32_t flags;
93
 
        __env_dbremove_reply *replyp;
94
 
/* END __env_dbremove_proc */
95
 
{
96
 
        int ret;
97
 
        DB_ENV * dbenv;
98
 
        ct_entry *dbenv_ctp;
99
 
        DB_TXN * txnp;
100
 
        ct_entry *txnp_ctp;
101
 
 
102
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
103
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
104
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
105
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
106
 
 
107
 
        /*
108
 
         * XXX Code goes here
109
 
         */
110
 
 
111
 
        replyp->status = ret;
112
 
        return;
113
 
}
114
 
 
115
 
/* BEGIN __env_dbrename_proc */
116
 
void
117
 
__env_dbrename_proc(dbenvcl_id, txnpcl_id, name,
118
 
                subdb, newname, flags, replyp)
119
 
        long dbenvcl_id;
120
 
        long txnpcl_id;
121
 
        char *name;
122
 
        char *subdb;
123
 
        char *newname;
124
 
        u_int32_t flags;
125
 
        __env_dbrename_reply *replyp;
126
 
/* END __env_dbrename_proc */
127
 
{
128
 
        int ret;
129
 
        DB_ENV * dbenv;
130
 
        ct_entry *dbenv_ctp;
131
 
        DB_TXN * txnp;
132
 
        ct_entry *txnp_ctp;
133
 
 
134
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
135
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
136
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
137
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
138
 
 
139
 
        /*
140
 
         * XXX Code goes here
141
 
         */
142
 
 
143
 
        replyp->status = ret;
144
 
        return;
145
 
}
146
 
 
147
 
/* BEGIN __env_encrypt_proc */
148
 
void
149
 
__env_encrypt_proc(dbenvcl_id, passwd, flags, replyp)
150
 
        long dbenvcl_id;
151
 
        char *passwd;
152
 
        u_int32_t flags;
153
 
        __env_encrypt_reply *replyp;
154
 
/* END __env_encrypt_proc */
155
 
{
156
 
        int ret;
157
 
        DB_ENV * dbenv;
158
 
        ct_entry *dbenv_ctp;
159
 
 
160
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
161
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
162
 
 
163
 
        /*
164
 
         * XXX Code goes here
165
 
         */
166
 
 
167
 
        replyp->status = ret;
168
 
        return;
169
 
}
170
 
 
171
 
/* BEGIN __env_flags_proc */
172
 
void
173
 
__env_flags_proc(dbenvcl_id, flags, onoff, replyp)
174
 
        long dbenvcl_id;
175
 
        u_int32_t flags;
176
 
        u_int32_t onoff;
177
 
        __env_flags_reply *replyp;
178
 
/* END __env_flags_proc */
179
 
{
180
 
        int ret;
181
 
        DB_ENV * dbenv;
182
 
        ct_entry *dbenv_ctp;
183
 
 
184
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
185
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
186
 
 
187
 
        /*
188
 
         * XXX Code goes here
189
 
         */
190
 
 
191
 
        replyp->status = ret;
192
 
        return;
193
 
}
194
 
 
195
 
/* BEGIN __env_open_proc */
196
 
void
197
 
__env_open_proc(dbenvcl_id, home, flags,
198
 
                mode, replyp)
199
 
        long dbenvcl_id;
200
 
        char *home;
201
 
        u_int32_t flags;
202
 
        u_int32_t mode;
203
 
        __env_open_reply *replyp;
204
 
/* END __env_open_proc */
205
 
{
206
 
        int ret;
207
 
        DB_ENV * dbenv;
208
 
        ct_entry *dbenv_ctp;
209
 
 
210
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
211
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
212
 
 
213
 
        /*
214
 
         * XXX Code goes here
215
 
         */
216
 
 
217
 
        replyp->status = ret;
218
 
        return;
219
 
}
220
 
 
221
 
/* BEGIN __env_remove_proc */
222
 
void
223
 
__env_remove_proc(dbenvcl_id, home, flags, replyp)
224
 
        long dbenvcl_id;
225
 
        char *home;
226
 
        u_int32_t flags;
227
 
        __env_remove_reply *replyp;
228
 
/* END __env_remove_proc */
229
 
{
230
 
        int ret;
231
 
        DB_ENV * dbenv;
232
 
        ct_entry *dbenv_ctp;
233
 
 
234
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
235
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
236
 
 
237
 
        /*
238
 
         * XXX Code goes here
239
 
         */
240
 
 
241
 
        replyp->status = ret;
242
 
        return;
243
 
}
244
 
 
245
 
/* BEGIN __txn_abort_proc */
246
 
void
247
 
__txn_abort_proc(txnpcl_id, replyp)
248
 
        long txnpcl_id;
249
 
        __txn_abort_reply *replyp;
250
 
/* END __txn_abort_proc */
251
 
{
252
 
        int ret;
253
 
        DB_TXN * txnp;
254
 
        ct_entry *txnp_ctp;
255
 
 
256
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
257
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
258
 
 
259
 
        /*
260
 
         * XXX Code goes here
261
 
         */
262
 
 
263
 
        replyp->status = ret;
264
 
        return;
265
 
}
266
 
 
267
 
/* BEGIN __txn_begin_proc */
268
 
void
269
 
__txn_begin_proc(dbenvcl_id, parentcl_id,
270
 
                flags, replyp)
271
 
        long dbenvcl_id;
272
 
        long parentcl_id;
273
 
        u_int32_t flags;
274
 
        __txn_begin_reply *replyp;
275
 
/* END __txn_begin_proc */
276
 
{
277
 
        int ret;
278
 
        DB_ENV * dbenv;
279
 
        ct_entry *dbenv_ctp;
280
 
        DB_TXN * parent;
281
 
        ct_entry *parent_ctp;
282
 
 
283
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
284
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
285
 
        ACTIVATE_CTP(parent_ctp, parentcl_id, CT_TXN);
286
 
        parent = (DB_TXN *)parent_ctp->ct_anyp;
287
 
 
288
 
        /*
289
 
         * XXX Code goes here
290
 
         */
291
 
 
292
 
        replyp->status = ret;
293
 
        return;
294
 
}
295
 
 
296
 
/* BEGIN __txn_commit_proc */
297
 
void
298
 
__txn_commit_proc(txnpcl_id, flags, replyp)
299
 
        long txnpcl_id;
300
 
        u_int32_t flags;
301
 
        __txn_commit_reply *replyp;
302
 
/* END __txn_commit_proc */
303
 
{
304
 
        int ret;
305
 
        DB_TXN * txnp;
306
 
        ct_entry *txnp_ctp;
307
 
 
308
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
309
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
310
 
 
311
 
        /*
312
 
         * XXX Code goes here
313
 
         */
314
 
 
315
 
        replyp->status = ret;
316
 
        return;
317
 
}
318
 
 
319
 
/* BEGIN __txn_discard_proc */
320
 
void
321
 
__txn_discard_proc(txnpcl_id, flags, replyp)
322
 
        long txnpcl_id;
323
 
        u_int32_t flags;
324
 
        __txn_discard_reply *replyp;
325
 
/* END __txn_discard_proc */
326
 
{
327
 
        int ret;
328
 
        DB_TXN * txnp;
329
 
        ct_entry *txnp_ctp;
330
 
 
331
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
332
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
333
 
 
334
 
        /*
335
 
         * XXX Code goes here
336
 
         */
337
 
 
338
 
        replyp->status = ret;
339
 
        return;
340
 
}
341
 
 
342
 
/* BEGIN __txn_prepare_proc */
343
 
void
344
 
__txn_prepare_proc(txnpcl_id, gid, replyp)
345
 
        long txnpcl_id;
346
 
        u_int8_t *gid;
347
 
        __txn_prepare_reply *replyp;
348
 
/* END __txn_prepare_proc */
349
 
{
350
 
        int ret;
351
 
        DB_TXN * txnp;
352
 
        ct_entry *txnp_ctp;
353
 
 
354
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
355
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
356
 
 
357
 
        /*
358
 
         * XXX Code goes here
359
 
         */
360
 
 
361
 
        replyp->status = ret;
362
 
        return;
363
 
}
364
 
 
365
 
/* BEGIN __txn_recover_proc */
366
 
void
367
 
__txn_recover_proc(dbenvcl_id, count,
368
 
                flags, replyp, freep)
369
 
        long dbenvcl_id;
370
 
        u_int32_t count;
371
 
        u_int32_t flags;
372
 
        __txn_recover_reply *replyp;
373
 
        int * freep;
374
 
/* END __txn_recover_proc */
375
 
{
376
 
        int ret;
377
 
        DB_ENV * dbenv;
378
 
        ct_entry *dbenv_ctp;
379
 
 
380
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
381
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
382
 
 
383
 
        /*
384
 
         * XXX Code goes here
385
 
         */
386
 
 
387
 
        replyp->status = ret;
388
 
        return;
389
 
}
390
 
 
391
 
/* BEGIN __db_associate_proc */
392
 
void
393
 
__db_associate_proc(dbpcl_id, txnpcl_id, sdbpcl_id,
394
 
                flags, replyp)
395
 
        long dbpcl_id;
396
 
        long txnpcl_id;
397
 
        long sdbpcl_id;
398
 
        u_int32_t flags;
399
 
        __db_associate_reply *replyp;
400
 
/* END __db_associate_proc */
401
 
{
402
 
        int ret;
403
 
        DB * dbp;
404
 
        ct_entry *dbp_ctp;
405
 
        DB_TXN * txnp;
406
 
        ct_entry *txnp_ctp;
407
 
        DB * sdbp;
408
 
        ct_entry *sdbp_ctp;
409
 
 
410
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
411
 
        dbp = (DB *)dbp_ctp->ct_anyp;
412
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
413
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
414
 
        ACTIVATE_CTP(sdbp_ctp, sdbpcl_id, CT_DB);
415
 
        sdbp = (DB *)sdbp_ctp->ct_anyp;
416
 
 
417
 
        /*
418
 
         * XXX Code goes here
419
 
         */
420
 
 
421
 
        replyp->status = ret;
422
 
        return;
423
 
}
424
 
 
425
 
/* BEGIN __db_bt_maxkey_proc */
426
 
void
427
 
__db_bt_maxkey_proc(dbpcl_id, maxkey, replyp)
428
 
        long dbpcl_id;
429
 
        u_int32_t maxkey;
430
 
        __db_bt_maxkey_reply *replyp;
431
 
/* END __db_bt_maxkey_proc */
432
 
{
433
 
        int ret;
434
 
        DB * dbp;
435
 
        ct_entry *dbp_ctp;
436
 
 
437
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
438
 
        dbp = (DB *)dbp_ctp->ct_anyp;
439
 
 
440
 
        /*
441
 
         * XXX Code goes here
442
 
         */
443
 
 
444
 
        replyp->status = ret;
445
 
        return;
446
 
}
447
 
 
448
 
/* BEGIN __db_bt_minkey_proc */
449
 
void
450
 
__db_bt_minkey_proc(dbpcl_id, minkey, replyp)
451
 
        long dbpcl_id;
452
 
        u_int32_t minkey;
453
 
        __db_bt_minkey_reply *replyp;
454
 
/* END __db_bt_minkey_proc */
455
 
{
456
 
        int ret;
457
 
        DB * dbp;
458
 
        ct_entry *dbp_ctp;
459
 
 
460
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
461
 
        dbp = (DB *)dbp_ctp->ct_anyp;
462
 
 
463
 
        /*
464
 
         * XXX Code goes here
465
 
         */
466
 
 
467
 
        replyp->status = ret;
468
 
        return;
469
 
}
470
 
 
471
 
/* BEGIN __db_close_proc */
472
 
void
473
 
__db_close_proc(dbpcl_id, flags, replyp)
474
 
        long dbpcl_id;
475
 
        u_int32_t flags;
476
 
        __db_close_reply *replyp;
477
 
/* END __db_close_proc */
478
 
{
479
 
        int ret;
480
 
        DB * dbp;
481
 
        ct_entry *dbp_ctp;
482
 
 
483
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
484
 
        dbp = (DB *)dbp_ctp->ct_anyp;
485
 
 
486
 
        /*
487
 
         * XXX Code goes here
488
 
         */
489
 
 
490
 
        replyp->status = ret;
491
 
        return;
492
 
}
493
 
 
494
 
/* BEGIN __db_create_proc */
495
 
void
496
 
__db_create_proc(dbenvcl_id, flags, replyp)
497
 
        long dbenvcl_id;
498
 
        u_int32_t flags;
499
 
        __db_create_reply *replyp;
500
 
/* END __db_create_proc */
501
 
{
502
 
        int ret;
503
 
        DB_ENV * dbenv;
504
 
        ct_entry *dbenv_ctp;
505
 
 
506
 
        ACTIVATE_CTP(dbenv_ctp, dbenvcl_id, CT_ENV);
507
 
        dbenv = (DB_ENV *)dbenv_ctp->ct_anyp;
508
 
 
509
 
        /*
510
 
         * XXX Code goes here
511
 
         */
512
 
 
513
 
        replyp->status = ret;
514
 
        return;
515
 
}
516
 
 
517
 
/* BEGIN __db_del_proc */
518
 
void
519
 
__db_del_proc(dbpcl_id, txnpcl_id, keydlen,
520
 
                keydoff, keyulen, keyflags, keydata,
521
 
                keysize, flags, replyp)
522
 
        long dbpcl_id;
523
 
        long txnpcl_id;
524
 
        u_int32_t keydlen;
525
 
        u_int32_t keydoff;
526
 
        u_int32_t keyulen;
527
 
        u_int32_t keyflags;
528
 
        void *keydata;
529
 
        u_int32_t keysize;
530
 
        u_int32_t flags;
531
 
        __db_del_reply *replyp;
532
 
/* END __db_del_proc */
533
 
{
534
 
        int ret;
535
 
        DB * dbp;
536
 
        ct_entry *dbp_ctp;
537
 
        DB_TXN * txnp;
538
 
        ct_entry *txnp_ctp;
539
 
 
540
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
541
 
        dbp = (DB *)dbp_ctp->ct_anyp;
542
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
543
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
544
 
 
545
 
        /*
546
 
         * XXX Code goes here
547
 
         */
548
 
 
549
 
        replyp->status = ret;
550
 
        return;
551
 
}
552
 
 
553
 
/* BEGIN __db_encrypt_proc */
554
 
void
555
 
__db_encrypt_proc(dbpcl_id, passwd, flags, replyp)
556
 
        long dbpcl_id;
557
 
        char *passwd;
558
 
        u_int32_t flags;
559
 
        __db_encrypt_reply *replyp;
560
 
/* END __db_encrypt_proc */
561
 
{
562
 
        int ret;
563
 
        DB * dbp;
564
 
        ct_entry *dbp_ctp;
565
 
 
566
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
567
 
        dbp = (DB *)dbp_ctp->ct_anyp;
568
 
 
569
 
        /*
570
 
         * XXX Code goes here
571
 
         */
572
 
 
573
 
        replyp->status = ret;
574
 
        return;
575
 
}
576
 
 
577
 
/* BEGIN __db_extentsize_proc */
578
 
void
579
 
__db_extentsize_proc(dbpcl_id, extentsize, replyp)
580
 
        long dbpcl_id;
581
 
        u_int32_t extentsize;
582
 
        __db_extentsize_reply *replyp;
583
 
/* END __db_extentsize_proc */
584
 
{
585
 
        int ret;
586
 
        DB * dbp;
587
 
        ct_entry *dbp_ctp;
588
 
 
589
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
590
 
        dbp = (DB *)dbp_ctp->ct_anyp;
591
 
 
592
 
        /*
593
 
         * XXX Code goes here
594
 
         */
595
 
 
596
 
        replyp->status = ret;
597
 
        return;
598
 
}
599
 
 
600
 
/* BEGIN __db_flags_proc */
601
 
void
602
 
__db_flags_proc(dbpcl_id, flags, replyp)
603
 
        long dbpcl_id;
604
 
        u_int32_t flags;
605
 
        __db_flags_reply *replyp;
606
 
/* END __db_flags_proc */
607
 
{
608
 
        int ret;
609
 
        DB * dbp;
610
 
        ct_entry *dbp_ctp;
611
 
 
612
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
613
 
        dbp = (DB *)dbp_ctp->ct_anyp;
614
 
 
615
 
        /*
616
 
         * XXX Code goes here
617
 
         */
618
 
 
619
 
        replyp->status = ret;
620
 
        return;
621
 
}
622
 
 
623
 
/* BEGIN __db_get_proc */
624
 
void
625
 
__db_get_proc(dbpcl_id, txnpcl_id, keydlen,
626
 
                keydoff, keyulen, keyflags, keydata,
627
 
                keysize, datadlen, datadoff, dataulen,
628
 
                dataflags, datadata, datasize, flags, replyp, freep)
629
 
        long dbpcl_id;
630
 
        long txnpcl_id;
631
 
        u_int32_t keydlen;
632
 
        u_int32_t keydoff;
633
 
        u_int32_t keyulen;
634
 
        u_int32_t keyflags;
635
 
        void *keydata;
636
 
        u_int32_t keysize;
637
 
        u_int32_t datadlen;
638
 
        u_int32_t datadoff;
639
 
        u_int32_t dataulen;
640
 
        u_int32_t dataflags;
641
 
        void *datadata;
642
 
        u_int32_t datasize;
643
 
        u_int32_t flags;
644
 
        __db_get_reply *replyp;
645
 
        int * freep;
646
 
/* END __db_get_proc */
647
 
{
648
 
        int ret;
649
 
        DB * dbp;
650
 
        ct_entry *dbp_ctp;
651
 
        DB_TXN * txnp;
652
 
        ct_entry *txnp_ctp;
653
 
 
654
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
655
 
        dbp = (DB *)dbp_ctp->ct_anyp;
656
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
657
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
658
 
 
659
 
        /*
660
 
         * XXX Code goes here
661
 
         */
662
 
 
663
 
        replyp->status = ret;
664
 
        return;
665
 
}
666
 
 
667
 
/* BEGIN __db_h_ffactor_proc */
668
 
void
669
 
__db_h_ffactor_proc(dbpcl_id, ffactor, replyp)
670
 
        long dbpcl_id;
671
 
        u_int32_t ffactor;
672
 
        __db_h_ffactor_reply *replyp;
673
 
/* END __db_h_ffactor_proc */
674
 
{
675
 
        int ret;
676
 
        DB * dbp;
677
 
        ct_entry *dbp_ctp;
678
 
 
679
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
680
 
        dbp = (DB *)dbp_ctp->ct_anyp;
681
 
 
682
 
        /*
683
 
         * XXX Code goes here
684
 
         */
685
 
 
686
 
        replyp->status = ret;
687
 
        return;
688
 
}
689
 
 
690
 
/* BEGIN __db_h_nelem_proc */
691
 
void
692
 
__db_h_nelem_proc(dbpcl_id, nelem, replyp)
693
 
        long dbpcl_id;
694
 
        u_int32_t nelem;
695
 
        __db_h_nelem_reply *replyp;
696
 
/* END __db_h_nelem_proc */
697
 
{
698
 
        int ret;
699
 
        DB * dbp;
700
 
        ct_entry *dbp_ctp;
701
 
 
702
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
703
 
        dbp = (DB *)dbp_ctp->ct_anyp;
704
 
 
705
 
        /*
706
 
         * XXX Code goes here
707
 
         */
708
 
 
709
 
        replyp->status = ret;
710
 
        return;
711
 
}
712
 
 
713
 
/* BEGIN __db_key_range_proc */
714
 
void
715
 
__db_key_range_proc(dbpcl_id, txnpcl_id, keydlen,
716
 
                keydoff, keyulen, keyflags, keydata,
717
 
                keysize, flags, replyp)
718
 
        long dbpcl_id;
719
 
        long txnpcl_id;
720
 
        u_int32_t keydlen;
721
 
        u_int32_t keydoff;
722
 
        u_int32_t keyulen;
723
 
        u_int32_t keyflags;
724
 
        void *keydata;
725
 
        u_int32_t keysize;
726
 
        u_int32_t flags;
727
 
        __db_key_range_reply *replyp;
728
 
/* END __db_key_range_proc */
729
 
{
730
 
        int ret;
731
 
        DB * dbp;
732
 
        ct_entry *dbp_ctp;
733
 
        DB_TXN * txnp;
734
 
        ct_entry *txnp_ctp;
735
 
 
736
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
737
 
        dbp = (DB *)dbp_ctp->ct_anyp;
738
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
739
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
740
 
 
741
 
        /*
742
 
         * XXX Code goes here
743
 
         */
744
 
 
745
 
        replyp->status = ret;
746
 
        return;
747
 
}
748
 
 
749
 
/* BEGIN __db_lorder_proc */
750
 
void
751
 
__db_lorder_proc(dbpcl_id, lorder, replyp)
752
 
        long dbpcl_id;
753
 
        u_int32_t lorder;
754
 
        __db_lorder_reply *replyp;
755
 
/* END __db_lorder_proc */
756
 
{
757
 
        int ret;
758
 
        DB * dbp;
759
 
        ct_entry *dbp_ctp;
760
 
 
761
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
762
 
        dbp = (DB *)dbp_ctp->ct_anyp;
763
 
 
764
 
        /*
765
 
         * XXX Code goes here
766
 
         */
767
 
 
768
 
        replyp->status = ret;
769
 
        return;
770
 
}
771
 
 
772
 
/* BEGIN __db_open_proc */
773
 
void
774
 
__db_open_proc(dbpcl_id, txnpcl_id, name,
775
 
                subdb, type, flags, mode, replyp)
776
 
        long dbpcl_id;
777
 
        long txnpcl_id;
778
 
        char *name;
779
 
        char *subdb;
780
 
        u_int32_t type;
781
 
        u_int32_t flags;
782
 
        u_int32_t mode;
783
 
        __db_open_reply *replyp;
784
 
/* END __db_open_proc */
785
 
{
786
 
        int ret;
787
 
        DB * dbp;
788
 
        ct_entry *dbp_ctp;
789
 
        DB_TXN * txnp;
790
 
        ct_entry *txnp_ctp;
791
 
 
792
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
793
 
        dbp = (DB *)dbp_ctp->ct_anyp;
794
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
795
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
796
 
 
797
 
        /*
798
 
         * XXX Code goes here
799
 
         */
800
 
 
801
 
        replyp->status = ret;
802
 
        return;
803
 
}
804
 
 
805
 
/* BEGIN __db_pagesize_proc */
806
 
void
807
 
__db_pagesize_proc(dbpcl_id, pagesize, replyp)
808
 
        long dbpcl_id;
809
 
        u_int32_t pagesize;
810
 
        __db_pagesize_reply *replyp;
811
 
/* END __db_pagesize_proc */
812
 
{
813
 
        int ret;
814
 
        DB * dbp;
815
 
        ct_entry *dbp_ctp;
816
 
 
817
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
818
 
        dbp = (DB *)dbp_ctp->ct_anyp;
819
 
 
820
 
        /*
821
 
         * XXX Code goes here
822
 
         */
823
 
 
824
 
        replyp->status = ret;
825
 
        return;
826
 
}
827
 
 
828
 
/* BEGIN __db_pget_proc */
829
 
void
830
 
__db_pget_proc(dbpcl_id, txnpcl_id, skeydlen,
831
 
                skeydoff, skeyulen, skeyflags, skeydata,
832
 
                skeysize, pkeydlen, pkeydoff, pkeyulen,
833
 
                pkeyflags, pkeydata, pkeysize, datadlen,
834
 
                datadoff, dataulen, dataflags, datadata,
835
 
                datasize, flags, replyp, freep)
836
 
        long dbpcl_id;
837
 
        long txnpcl_id;
838
 
        u_int32_t skeydlen;
839
 
        u_int32_t skeydoff;
840
 
        u_int32_t skeyulen;
841
 
        u_int32_t skeyflags;
842
 
        void *skeydata;
843
 
        u_int32_t skeysize;
844
 
        u_int32_t pkeydlen;
845
 
        u_int32_t pkeydoff;
846
 
        u_int32_t pkeyulen;
847
 
        u_int32_t pkeyflags;
848
 
        void *pkeydata;
849
 
        u_int32_t pkeysize;
850
 
        u_int32_t datadlen;
851
 
        u_int32_t datadoff;
852
 
        u_int32_t dataulen;
853
 
        u_int32_t dataflags;
854
 
        void *datadata;
855
 
        u_int32_t datasize;
856
 
        u_int32_t flags;
857
 
        __db_pget_reply *replyp;
858
 
        int * freep;
859
 
/* END __db_pget_proc */
860
 
{
861
 
        int ret;
862
 
        DB * dbp;
863
 
        ct_entry *dbp_ctp;
864
 
        DB_TXN * txnp;
865
 
        ct_entry *txnp_ctp;
866
 
 
867
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
868
 
        dbp = (DB *)dbp_ctp->ct_anyp;
869
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
870
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
871
 
 
872
 
        /*
873
 
         * XXX Code goes here
874
 
         */
875
 
 
876
 
        replyp->status = ret;
877
 
        return;
878
 
}
879
 
 
880
 
/* BEGIN __db_put_proc */
881
 
void
882
 
__db_put_proc(dbpcl_id, txnpcl_id, keydlen,
883
 
                keydoff, keyulen, keyflags, keydata,
884
 
                keysize, datadlen, datadoff, dataulen,
885
 
                dataflags, datadata, datasize, flags, replyp, freep)
886
 
        long dbpcl_id;
887
 
        long txnpcl_id;
888
 
        u_int32_t keydlen;
889
 
        u_int32_t keydoff;
890
 
        u_int32_t keyulen;
891
 
        u_int32_t keyflags;
892
 
        void *keydata;
893
 
        u_int32_t keysize;
894
 
        u_int32_t datadlen;
895
 
        u_int32_t datadoff;
896
 
        u_int32_t dataulen;
897
 
        u_int32_t dataflags;
898
 
        void *datadata;
899
 
        u_int32_t datasize;
900
 
        u_int32_t flags;
901
 
        __db_put_reply *replyp;
902
 
        int * freep;
903
 
/* END __db_put_proc */
904
 
{
905
 
        int ret;
906
 
        DB * dbp;
907
 
        ct_entry *dbp_ctp;
908
 
        DB_TXN * txnp;
909
 
        ct_entry *txnp_ctp;
910
 
 
911
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
912
 
        dbp = (DB *)dbp_ctp->ct_anyp;
913
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
914
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
915
 
 
916
 
        /*
917
 
         * XXX Code goes here
918
 
         */
919
 
 
920
 
        replyp->status = ret;
921
 
        return;
922
 
}
923
 
 
924
 
/* BEGIN __db_re_delim_proc */
925
 
void
926
 
__db_re_delim_proc(dbpcl_id, delim, replyp)
927
 
        long dbpcl_id;
928
 
        u_int32_t delim;
929
 
        __db_re_delim_reply *replyp;
930
 
/* END __db_re_delim_proc */
931
 
{
932
 
        int ret;
933
 
        DB * dbp;
934
 
        ct_entry *dbp_ctp;
935
 
 
936
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
937
 
        dbp = (DB *)dbp_ctp->ct_anyp;
938
 
 
939
 
        /*
940
 
         * XXX Code goes here
941
 
         */
942
 
 
943
 
        replyp->status = ret;
944
 
        return;
945
 
}
946
 
 
947
 
/* BEGIN __db_re_len_proc */
948
 
void
949
 
__db_re_len_proc(dbpcl_id, len, replyp)
950
 
        long dbpcl_id;
951
 
        u_int32_t len;
952
 
        __db_re_len_reply *replyp;
953
 
/* END __db_re_len_proc */
954
 
{
955
 
        int ret;
956
 
        DB * dbp;
957
 
        ct_entry *dbp_ctp;
958
 
 
959
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
960
 
        dbp = (DB *)dbp_ctp->ct_anyp;
961
 
 
962
 
        /*
963
 
         * XXX Code goes here
964
 
         */
965
 
 
966
 
        replyp->status = ret;
967
 
        return;
968
 
}
969
 
 
970
 
/* BEGIN __db_re_pad_proc */
971
 
void
972
 
__db_re_pad_proc(dbpcl_id, pad, replyp)
973
 
        long dbpcl_id;
974
 
        u_int32_t pad;
975
 
        __db_re_pad_reply *replyp;
976
 
/* END __db_re_pad_proc */
977
 
{
978
 
        int ret;
979
 
        DB * dbp;
980
 
        ct_entry *dbp_ctp;
981
 
 
982
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
983
 
        dbp = (DB *)dbp_ctp->ct_anyp;
984
 
 
985
 
        /*
986
 
         * XXX Code goes here
987
 
         */
988
 
 
989
 
        replyp->status = ret;
990
 
        return;
991
 
}
992
 
 
993
 
/* BEGIN __db_remove_proc */
994
 
void
995
 
__db_remove_proc(dbpcl_id, name, subdb,
996
 
                flags, replyp)
997
 
        long dbpcl_id;
998
 
        char *name;
999
 
        char *subdb;
1000
 
        u_int32_t flags;
1001
 
        __db_remove_reply *replyp;
1002
 
/* END __db_remove_proc */
1003
 
{
1004
 
        int ret;
1005
 
        DB * dbp;
1006
 
        ct_entry *dbp_ctp;
1007
 
 
1008
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1009
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1010
 
 
1011
 
        /*
1012
 
         * XXX Code goes here
1013
 
         */
1014
 
 
1015
 
        replyp->status = ret;
1016
 
        return;
1017
 
}
1018
 
 
1019
 
/* BEGIN __db_rename_proc */
1020
 
void
1021
 
__db_rename_proc(dbpcl_id, name, subdb,
1022
 
                newname, flags, replyp)
1023
 
        long dbpcl_id;
1024
 
        char *name;
1025
 
        char *subdb;
1026
 
        char *newname;
1027
 
        u_int32_t flags;
1028
 
        __db_rename_reply *replyp;
1029
 
/* END __db_rename_proc */
1030
 
{
1031
 
        int ret;
1032
 
        DB * dbp;
1033
 
        ct_entry *dbp_ctp;
1034
 
 
1035
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1036
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1037
 
 
1038
 
        /*
1039
 
         * XXX Code goes here
1040
 
         */
1041
 
 
1042
 
        replyp->status = ret;
1043
 
        return;
1044
 
}
1045
 
 
1046
 
/* BEGIN __db_stat_proc */
1047
 
void
1048
 
__db_stat_proc(dbpcl_id, flags, replyp, freep)
1049
 
        long dbpcl_id;
1050
 
        u_int32_t flags;
1051
 
        __db_stat_reply *replyp;
1052
 
        int * freep;
1053
 
/* END __db_stat_proc */
1054
 
{
1055
 
        int ret;
1056
 
        DB * dbp;
1057
 
        ct_entry *dbp_ctp;
1058
 
 
1059
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1060
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1061
 
 
1062
 
        /*
1063
 
         * XXX Code goes here
1064
 
         */
1065
 
 
1066
 
        replyp->status = ret;
1067
 
        return;
1068
 
}
1069
 
 
1070
 
/* BEGIN __db_sync_proc */
1071
 
void
1072
 
__db_sync_proc(dbpcl_id, flags, replyp)
1073
 
        long dbpcl_id;
1074
 
        u_int32_t flags;
1075
 
        __db_sync_reply *replyp;
1076
 
/* END __db_sync_proc */
1077
 
{
1078
 
        int ret;
1079
 
        DB * dbp;
1080
 
        ct_entry *dbp_ctp;
1081
 
 
1082
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1083
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1084
 
 
1085
 
        /*
1086
 
         * XXX Code goes here
1087
 
         */
1088
 
 
1089
 
        replyp->status = ret;
1090
 
        return;
1091
 
}
1092
 
 
1093
 
/* BEGIN __db_truncate_proc */
1094
 
void
1095
 
__db_truncate_proc(dbpcl_id, txnpcl_id,
1096
 
                flags, replyp)
1097
 
        long dbpcl_id;
1098
 
        long txnpcl_id;
1099
 
        u_int32_t flags;
1100
 
        __db_truncate_reply *replyp;
1101
 
/* END __db_truncate_proc */
1102
 
{
1103
 
        int ret;
1104
 
        DB * dbp;
1105
 
        ct_entry *dbp_ctp;
1106
 
        DB_TXN * txnp;
1107
 
        ct_entry *txnp_ctp;
1108
 
 
1109
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1110
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1111
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
1112
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
1113
 
 
1114
 
        /*
1115
 
         * XXX Code goes here
1116
 
         */
1117
 
 
1118
 
        replyp->status = ret;
1119
 
        return;
1120
 
}
1121
 
 
1122
 
/* BEGIN __db_cursor_proc */
1123
 
void
1124
 
__db_cursor_proc(dbpcl_id, txnpcl_id,
1125
 
                flags, replyp)
1126
 
        long dbpcl_id;
1127
 
        long txnpcl_id;
1128
 
        u_int32_t flags;
1129
 
        __db_cursor_reply *replyp;
1130
 
/* END __db_cursor_proc */
1131
 
{
1132
 
        int ret;
1133
 
        DB * dbp;
1134
 
        ct_entry *dbp_ctp;
1135
 
        DB_TXN * txnp;
1136
 
        ct_entry *txnp_ctp;
1137
 
 
1138
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1139
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1140
 
        ACTIVATE_CTP(txnp_ctp, txnpcl_id, CT_TXN);
1141
 
        txnp = (DB_TXN *)txnp_ctp->ct_anyp;
1142
 
 
1143
 
        /*
1144
 
         * XXX Code goes here
1145
 
         */
1146
 
 
1147
 
        replyp->status = ret;
1148
 
        return;
1149
 
}
1150
 
 
1151
 
/* BEGIN __db_join_proc */
1152
 
void
1153
 
__db_join_proc(dbpcl_id, curs, curslen,
1154
 
                flags, replyp)
1155
 
        long dbpcl_id;
1156
 
        u_int32_t * curs;
1157
 
        u_int32_t curslen;
1158
 
        u_int32_t flags;
1159
 
        __db_join_reply *replyp;
1160
 
/* END __db_join_proc */
1161
 
{
1162
 
        int ret;
1163
 
        DB * dbp;
1164
 
        ct_entry *dbp_ctp;
1165
 
 
1166
 
        ACTIVATE_CTP(dbp_ctp, dbpcl_id, CT_DB);
1167
 
        dbp = (DB *)dbp_ctp->ct_anyp;
1168
 
 
1169
 
        /*
1170
 
         * XXX Code goes here
1171
 
         */
1172
 
 
1173
 
        replyp->status = ret;
1174
 
        return;
1175
 
}
1176
 
 
1177
 
/* BEGIN __dbc_close_proc */
1178
 
void
1179
 
__dbc_close_proc(dbccl_id, replyp)
1180
 
        long dbccl_id;
1181
 
        __dbc_close_reply *replyp;
1182
 
/* END __dbc_close_proc */
1183
 
{
1184
 
        int ret;
1185
 
        DBC * dbc;
1186
 
        ct_entry *dbc_ctp;
1187
 
 
1188
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1189
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1190
 
 
1191
 
        /*
1192
 
         * XXX Code goes here
1193
 
         */
1194
 
 
1195
 
        replyp->status = ret;
1196
 
        return;
1197
 
}
1198
 
 
1199
 
/* BEGIN __dbc_count_proc */
1200
 
void
1201
 
__dbc_count_proc(dbccl_id, flags, replyp)
1202
 
        long dbccl_id;
1203
 
        u_int32_t flags;
1204
 
        __dbc_count_reply *replyp;
1205
 
/* END __dbc_count_proc */
1206
 
{
1207
 
        int ret;
1208
 
        DBC * dbc;
1209
 
        ct_entry *dbc_ctp;
1210
 
 
1211
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1212
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1213
 
 
1214
 
        /*
1215
 
         * XXX Code goes here
1216
 
         */
1217
 
 
1218
 
        replyp->status = ret;
1219
 
        return;
1220
 
}
1221
 
 
1222
 
/* BEGIN __dbc_del_proc */
1223
 
void
1224
 
__dbc_del_proc(dbccl_id, flags, replyp)
1225
 
        long dbccl_id;
1226
 
        u_int32_t flags;
1227
 
        __dbc_del_reply *replyp;
1228
 
/* END __dbc_del_proc */
1229
 
{
1230
 
        int ret;
1231
 
        DBC * dbc;
1232
 
        ct_entry *dbc_ctp;
1233
 
 
1234
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1235
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1236
 
 
1237
 
        /*
1238
 
         * XXX Code goes here
1239
 
         */
1240
 
 
1241
 
        replyp->status = ret;
1242
 
        return;
1243
 
}
1244
 
 
1245
 
/* BEGIN __dbc_dup_proc */
1246
 
void
1247
 
__dbc_dup_proc(dbccl_id, flags, replyp)
1248
 
        long dbccl_id;
1249
 
        u_int32_t flags;
1250
 
        __dbc_dup_reply *replyp;
1251
 
/* END __dbc_dup_proc */
1252
 
{
1253
 
        int ret;
1254
 
        DBC * dbc;
1255
 
        ct_entry *dbc_ctp;
1256
 
 
1257
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1258
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1259
 
 
1260
 
        /*
1261
 
         * XXX Code goes here
1262
 
         */
1263
 
 
1264
 
        replyp->status = ret;
1265
 
        return;
1266
 
}
1267
 
 
1268
 
/* BEGIN __dbc_get_proc */
1269
 
void
1270
 
__dbc_get_proc(dbccl_id, keydlen, keydoff,
1271
 
                keyulen, keyflags, keydata, keysize,
1272
 
                datadlen, datadoff, dataulen, dataflags,
1273
 
                datadata, datasize, flags, replyp, freep)
1274
 
        long dbccl_id;
1275
 
        u_int32_t keydlen;
1276
 
        u_int32_t keydoff;
1277
 
        u_int32_t keyulen;
1278
 
        u_int32_t keyflags;
1279
 
        void *keydata;
1280
 
        u_int32_t keysize;
1281
 
        u_int32_t datadlen;
1282
 
        u_int32_t datadoff;
1283
 
        u_int32_t dataulen;
1284
 
        u_int32_t dataflags;
1285
 
        void *datadata;
1286
 
        u_int32_t datasize;
1287
 
        u_int32_t flags;
1288
 
        __dbc_get_reply *replyp;
1289
 
        int * freep;
1290
 
/* END __dbc_get_proc */
1291
 
{
1292
 
        int ret;
1293
 
        DBC * dbc;
1294
 
        ct_entry *dbc_ctp;
1295
 
 
1296
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1297
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1298
 
 
1299
 
        /*
1300
 
         * XXX Code goes here
1301
 
         */
1302
 
 
1303
 
        replyp->status = ret;
1304
 
        return;
1305
 
}
1306
 
 
1307
 
/* BEGIN __dbc_pget_proc */
1308
 
void
1309
 
__dbc_pget_proc(dbccl_id, skeydlen, skeydoff,
1310
 
                skeyulen, skeyflags, skeydata, skeysize,
1311
 
                pkeydlen, pkeydoff, pkeyulen, pkeyflags,
1312
 
                pkeydata, pkeysize, datadlen, datadoff,
1313
 
                dataulen, dataflags, datadata, datasize,
1314
 
                flags, replyp, freep)
1315
 
        long dbccl_id;
1316
 
        u_int32_t skeydlen;
1317
 
        u_int32_t skeydoff;
1318
 
        u_int32_t skeyulen;
1319
 
        u_int32_t skeyflags;
1320
 
        void *skeydata;
1321
 
        u_int32_t skeysize;
1322
 
        u_int32_t pkeydlen;
1323
 
        u_int32_t pkeydoff;
1324
 
        u_int32_t pkeyulen;
1325
 
        u_int32_t pkeyflags;
1326
 
        void *pkeydata;
1327
 
        u_int32_t pkeysize;
1328
 
        u_int32_t datadlen;
1329
 
        u_int32_t datadoff;
1330
 
        u_int32_t dataulen;
1331
 
        u_int32_t dataflags;
1332
 
        void *datadata;
1333
 
        u_int32_t datasize;
1334
 
        u_int32_t flags;
1335
 
        __dbc_pget_reply *replyp;
1336
 
        int * freep;
1337
 
/* END __dbc_pget_proc */
1338
 
{
1339
 
        int ret;
1340
 
        DBC * dbc;
1341
 
        ct_entry *dbc_ctp;
1342
 
 
1343
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1344
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1345
 
 
1346
 
        /*
1347
 
         * XXX Code goes here
1348
 
         */
1349
 
 
1350
 
        replyp->status = ret;
1351
 
        return;
1352
 
}
1353
 
 
1354
 
/* BEGIN __dbc_put_proc */
1355
 
void
1356
 
__dbc_put_proc(dbccl_id, keydlen, keydoff,
1357
 
                keyulen, keyflags, keydata, keysize,
1358
 
                datadlen, datadoff, dataulen, dataflags,
1359
 
                datadata, datasize, flags, replyp, freep)
1360
 
        long dbccl_id;
1361
 
        u_int32_t keydlen;
1362
 
        u_int32_t keydoff;
1363
 
        u_int32_t keyulen;
1364
 
        u_int32_t keyflags;
1365
 
        void *keydata;
1366
 
        u_int32_t keysize;
1367
 
        u_int32_t datadlen;
1368
 
        u_int32_t datadoff;
1369
 
        u_int32_t dataulen;
1370
 
        u_int32_t dataflags;
1371
 
        void *datadata;
1372
 
        u_int32_t datasize;
1373
 
        u_int32_t flags;
1374
 
        __dbc_put_reply *replyp;
1375
 
        int * freep;
1376
 
/* END __dbc_put_proc */
1377
 
{
1378
 
        int ret;
1379
 
        DBC * dbc;
1380
 
        ct_entry *dbc_ctp;
1381
 
 
1382
 
        ACTIVATE_CTP(dbc_ctp, dbccl_id, CT_CURSOR);
1383
 
        dbc = (DBC *)dbc_ctp->ct_anyp;
1384
 
 
1385
 
        /*
1386
 
         * XXX Code goes here
1387
 
         */
1388
 
 
1389
 
        replyp->status = ret;
1390
 
        return;
1391
 
}
1392