1
/* Do not edit: automatically built by gen_rpc.awk. */
4
#ifndef NO_SYSTEM_INCLUDES
12
#include "db_server.h"
15
#include "dbinc/txn.h"
16
#include "dbinc_auto/rpc_client_ext.h"
18
static int __dbcl_noserver __P((DB_ENV *));
21
__dbcl_noserver(dbenv)
24
__db_err(dbenv, "No server environment");
28
static int __dbcl_rpc_illegal __P((DB_ENV *, char *));
31
__dbcl_rpc_illegal(dbenv, name)
35
__db_err(dbenv, "%s method unsupported in RPC environments", name);
40
* PUBLIC: int __dbcl_env_alloc __P((DB_ENV *, void *(*)(size_t),
41
* PUBLIC: void *(*)(void *, size_t), void (*)(void *)));
44
__dbcl_env_alloc(dbenv, func0, func1, func2)
46
void *(*func0) __P((size_t));
47
void *(*func1) __P((void *, size_t));
48
void (*func2) __P((void *));
53
return (__dbcl_rpc_illegal(dbenv, "env_alloc"));
57
* PUBLIC: int __dbcl_set_app_dispatch __P((DB_ENV *, int (*)(DB_ENV *, DBT *,
58
* PUBLIC: DB_LSN *, db_recops)));
61
__dbcl_set_app_dispatch(dbenv, func0)
63
int (*func0) __P((DB_ENV *, DBT *, DB_LSN *, db_recops));
66
return (__dbcl_rpc_illegal(dbenv, "set_app_dispatch"));
70
* PUBLIC: int __dbcl_env_get_cachesize __P((DB_ENV *, u_int32_t *,
71
* PUBLIC: u_int32_t *, int *));
74
__dbcl_env_get_cachesize(dbenv, gbytesp, bytesp, ncachep)
81
__env_get_cachesize_msg msg;
82
__env_get_cachesize_reply *replyp = NULL;
86
if (dbenv == NULL || !RPC_ON(dbenv))
87
return (__dbcl_noserver(dbenv));
89
cl = (CLIENT *)dbenv->cl_handle;
94
msg.dbenvcl_id = dbenv->cl_id;
96
replyp = __db_env_get_cachesize_4003(&msg, cl);
98
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
102
ret = replyp->status;
104
*gbytesp = replyp->gbytes;
106
*bytesp = replyp->bytes;
108
*ncachep = replyp->ncache;
111
xdr_free((xdrproc_t)xdr___env_get_cachesize_reply, (void *)replyp);
116
* PUBLIC: int __dbcl_env_cachesize __P((DB_ENV *, u_int32_t, u_int32_t, int));
119
__dbcl_env_cachesize(dbenv, gbytes, bytes, ncache)
126
__env_cachesize_msg msg;
127
__env_cachesize_reply *replyp = NULL;
131
if (dbenv == NULL || !RPC_ON(dbenv))
132
return (__dbcl_noserver(dbenv));
134
cl = (CLIENT *)dbenv->cl_handle;
139
msg.dbenvcl_id = dbenv->cl_id;
144
replyp = __db_env_cachesize_4003(&msg, cl);
145
if (replyp == NULL) {
146
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
150
ret = replyp->status;
153
xdr_free((xdrproc_t)xdr___env_cachesize_reply, (void *)replyp);
158
* PUBLIC: int __dbcl_env_close __P((DB_ENV *, u_int32_t));
161
__dbcl_env_close(dbenv, flags)
167
__env_close_reply *replyp = NULL;
171
if (dbenv == NULL || !RPC_ON(dbenv))
172
return (__dbcl_noserver(dbenv));
174
cl = (CLIENT *)dbenv->cl_handle;
179
msg.dbenvcl_id = dbenv->cl_id;
182
replyp = __db_env_close_4003(&msg, cl);
183
if (replyp == NULL) {
184
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
188
ret = replyp->status;
191
xdr_free((xdrproc_t)xdr___env_close_reply, (void *)replyp);
196
* PUBLIC: int __dbcl_env_create __P((DB_ENV *, long));
199
__dbcl_env_create(dbenv, timeout)
204
__env_create_msg msg;
205
__env_create_reply *replyp = NULL;
209
if (dbenv == NULL || !RPC_ON(dbenv))
210
return (__dbcl_noserver(dbenv));
212
cl = (CLIENT *)dbenv->cl_handle;
214
msg.timeout = timeout;
216
replyp = __db_env_create_4003(&msg, cl);
217
if (replyp == NULL) {
218
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
222
ret = __dbcl_env_create_ret(dbenv, timeout, replyp);
225
xdr_free((xdrproc_t)xdr___env_create_reply, (void *)replyp);
230
* PUBLIC: int __dbcl_get_data_dirs __P((DB_ENV *, const char ***));
233
__dbcl_get_data_dirs(dbenv, dirpp)
235
const char *** dirpp;
237
COMPQUIET(dirpp, NULL);
238
return (__dbcl_rpc_illegal(dbenv, "get_data_dirs"));
242
* PUBLIC: int __dbcl_set_data_dir __P((DB_ENV *, const char *));
245
__dbcl_set_data_dir(dbenv, dir)
249
COMPQUIET(dir, NULL);
250
return (__dbcl_rpc_illegal(dbenv, "set_data_dir"));
254
* PUBLIC: int __dbcl_env_dbremove __P((DB_ENV *, DB_TXN *, const char *,
255
* PUBLIC: const char *, u_int32_t));
258
__dbcl_env_dbremove(dbenv, txnp, name, subdb, flags)
266
__env_dbremove_msg msg;
267
__env_dbremove_reply *replyp = NULL;
271
if (dbenv == NULL || !RPC_ON(dbenv))
272
return (__dbcl_noserver(dbenv));
274
cl = (CLIENT *)dbenv->cl_handle;
279
msg.dbenvcl_id = dbenv->cl_id;
283
msg.txnpcl_id = txnp->txnid;
287
msg.name = (char *)name;
291
msg.subdb = (char *)subdb;
294
replyp = __db_env_dbremove_4003(&msg, cl);
295
if (replyp == NULL) {
296
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
300
ret = replyp->status;
303
xdr_free((xdrproc_t)xdr___env_dbremove_reply, (void *)replyp);
308
* PUBLIC: int __dbcl_env_dbrename __P((DB_ENV *, DB_TXN *, const char *,
309
* PUBLIC: const char *, const char *, u_int32_t));
312
__dbcl_env_dbrename(dbenv, txnp, name, subdb, newname, flags)
317
const char * newname;
321
__env_dbrename_msg msg;
322
__env_dbrename_reply *replyp = NULL;
326
if (dbenv == NULL || !RPC_ON(dbenv))
327
return (__dbcl_noserver(dbenv));
329
cl = (CLIENT *)dbenv->cl_handle;
334
msg.dbenvcl_id = dbenv->cl_id;
338
msg.txnpcl_id = txnp->txnid;
342
msg.name = (char *)name;
346
msg.subdb = (char *)subdb;
350
msg.newname = (char *)newname;
353
replyp = __db_env_dbrename_4003(&msg, cl);
354
if (replyp == NULL) {
355
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
359
ret = replyp->status;
362
xdr_free((xdrproc_t)xdr___env_dbrename_reply, (void *)replyp);
367
* PUBLIC: int __dbcl_env_get_encrypt_flags __P((DB_ENV *, u_int32_t *));
370
__dbcl_env_get_encrypt_flags(dbenv, flagsp)
375
__env_get_encrypt_flags_msg msg;
376
__env_get_encrypt_flags_reply *replyp = NULL;
380
if (dbenv == NULL || !RPC_ON(dbenv))
381
return (__dbcl_noserver(dbenv));
383
cl = (CLIENT *)dbenv->cl_handle;
388
msg.dbenvcl_id = dbenv->cl_id;
390
replyp = __db_env_get_encrypt_flags_4003(&msg, cl);
391
if (replyp == NULL) {
392
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
396
ret = replyp->status;
398
*flagsp = replyp->flags;
401
xdr_free((xdrproc_t)xdr___env_get_encrypt_flags_reply, (void *)replyp);
406
* PUBLIC: int __dbcl_env_encrypt __P((DB_ENV *, const char *, u_int32_t));
409
__dbcl_env_encrypt(dbenv, passwd, flags)
415
__env_encrypt_msg msg;
416
__env_encrypt_reply *replyp = NULL;
420
if (dbenv == NULL || !RPC_ON(dbenv))
421
return (__dbcl_noserver(dbenv));
423
cl = (CLIENT *)dbenv->cl_handle;
428
msg.dbenvcl_id = dbenv->cl_id;
432
msg.passwd = (char *)passwd;
435
replyp = __db_env_encrypt_4003(&msg, cl);
436
if (replyp == NULL) {
437
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
441
ret = replyp->status;
444
xdr_free((xdrproc_t)xdr___env_encrypt_reply, (void *)replyp);
449
* PUBLIC: int __dbcl_env_set_feedback __P((DB_ENV *, void (*)(DB_ENV *, int,
453
__dbcl_env_set_feedback(dbenv, func0)
455
void (*func0) __P((DB_ENV *, int, int));
458
return (__dbcl_rpc_illegal(dbenv, "env_set_feedback"));
462
* PUBLIC: int __dbcl_env_get_flags __P((DB_ENV *, u_int32_t *));
465
__dbcl_env_get_flags(dbenv, flagsp)
470
__env_get_flags_msg msg;
471
__env_get_flags_reply *replyp = NULL;
475
if (dbenv == NULL || !RPC_ON(dbenv))
476
return (__dbcl_noserver(dbenv));
478
cl = (CLIENT *)dbenv->cl_handle;
483
msg.dbenvcl_id = dbenv->cl_id;
485
replyp = __db_env_get_flags_4003(&msg, cl);
486
if (replyp == NULL) {
487
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
491
ret = replyp->status;
493
*flagsp = replyp->flags;
496
xdr_free((xdrproc_t)xdr___env_get_flags_reply, (void *)replyp);
501
* PUBLIC: int __dbcl_env_flags __P((DB_ENV *, u_int32_t, int));
504
__dbcl_env_flags(dbenv, flags, onoff)
511
__env_flags_reply *replyp = NULL;
515
if (dbenv == NULL || !RPC_ON(dbenv))
516
return (__dbcl_noserver(dbenv));
518
cl = (CLIENT *)dbenv->cl_handle;
523
msg.dbenvcl_id = dbenv->cl_id;
527
replyp = __db_env_flags_4003(&msg, cl);
528
if (replyp == NULL) {
529
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
533
ret = replyp->status;
536
xdr_free((xdrproc_t)xdr___env_flags_reply, (void *)replyp);
541
* PUBLIC: int __dbcl_get_lg_bsize __P((DB_ENV *, u_int32_t *));
544
__dbcl_get_lg_bsize(dbenv, bsizep)
548
COMPQUIET(bsizep, 0);
549
return (__dbcl_rpc_illegal(dbenv, "get_lg_bsize"));
553
* PUBLIC: int __dbcl_set_lg_bsize __P((DB_ENV *, u_int32_t));
556
__dbcl_set_lg_bsize(dbenv, bsize)
561
return (__dbcl_rpc_illegal(dbenv, "set_lg_bsize"));
565
* PUBLIC: int __dbcl_get_lg_dir __P((DB_ENV *, const char * *));
568
__dbcl_get_lg_dir(dbenv, dirp)
573
return (__dbcl_rpc_illegal(dbenv, "get_lg_dir"));
577
* PUBLIC: int __dbcl_set_lg_dir __P((DB_ENV *, const char *));
580
__dbcl_set_lg_dir(dbenv, dir)
584
COMPQUIET(dir, NULL);
585
return (__dbcl_rpc_illegal(dbenv, "set_lg_dir"));
589
* PUBLIC: int __dbcl_get_lg_max __P((DB_ENV *, u_int32_t *));
592
__dbcl_get_lg_max(dbenv, maxp)
597
return (__dbcl_rpc_illegal(dbenv, "get_lg_max"));
601
* PUBLIC: int __dbcl_set_lg_max __P((DB_ENV *, u_int32_t));
604
__dbcl_set_lg_max(dbenv, max)
609
return (__dbcl_rpc_illegal(dbenv, "set_lg_max"));
613
* PUBLIC: int __dbcl_get_lg_regionmax __P((DB_ENV *, u_int32_t *));
616
__dbcl_get_lg_regionmax(dbenv, maxp)
621
return (__dbcl_rpc_illegal(dbenv, "get_lg_regionmax"));
625
* PUBLIC: int __dbcl_set_lg_regionmax __P((DB_ENV *, u_int32_t));
628
__dbcl_set_lg_regionmax(dbenv, max)
633
return (__dbcl_rpc_illegal(dbenv, "set_lg_regionmax"));
637
* PUBLIC: int __dbcl_get_lk_conflicts __P((DB_ENV *, const u_int8_t **,
641
__dbcl_get_lk_conflicts(dbenv, conflicts, modes)
643
const u_int8_t ** conflicts;
646
COMPQUIET(conflicts, 0);
648
return (__dbcl_rpc_illegal(dbenv, "get_lk_conflicts"));
652
* PUBLIC: int __dbcl_set_lk_conflict __P((DB_ENV *, u_int8_t *, int));
655
__dbcl_set_lk_conflict(dbenv, conflicts, modes)
657
u_int8_t * conflicts;
660
COMPQUIET(conflicts, 0);
662
return (__dbcl_rpc_illegal(dbenv, "set_lk_conflict"));
666
* PUBLIC: int __dbcl_get_lk_detect __P((DB_ENV *, u_int32_t *));
669
__dbcl_get_lk_detect(dbenv, detectp)
673
COMPQUIET(detectp, 0);
674
return (__dbcl_rpc_illegal(dbenv, "get_lk_detect"));
678
* PUBLIC: int __dbcl_set_lk_detect __P((DB_ENV *, u_int32_t));
681
__dbcl_set_lk_detect(dbenv, detect)
685
COMPQUIET(detect, 0);
686
return (__dbcl_rpc_illegal(dbenv, "set_lk_detect"));
690
* PUBLIC: int __dbcl_set_lk_max __P((DB_ENV *, u_int32_t));
693
__dbcl_set_lk_max(dbenv, max)
698
return (__dbcl_rpc_illegal(dbenv, "set_lk_max"));
702
* PUBLIC: int __dbcl_get_lk_max_locks __P((DB_ENV *, u_int32_t *));
705
__dbcl_get_lk_max_locks(dbenv, maxp)
710
return (__dbcl_rpc_illegal(dbenv, "get_lk_max_locks"));
714
* PUBLIC: int __dbcl_set_lk_max_locks __P((DB_ENV *, u_int32_t));
717
__dbcl_set_lk_max_locks(dbenv, max)
722
return (__dbcl_rpc_illegal(dbenv, "set_lk_max_locks"));
726
* PUBLIC: int __dbcl_get_lk_max_lockers __P((DB_ENV *, u_int32_t *));
729
__dbcl_get_lk_max_lockers(dbenv, maxp)
734
return (__dbcl_rpc_illegal(dbenv, "get_lk_max_lockers"));
738
* PUBLIC: int __dbcl_set_lk_max_lockers __P((DB_ENV *, u_int32_t));
741
__dbcl_set_lk_max_lockers(dbenv, max)
746
return (__dbcl_rpc_illegal(dbenv, "set_lk_max_lockers"));
750
* PUBLIC: int __dbcl_get_lk_max_objects __P((DB_ENV *, u_int32_t *));
753
__dbcl_get_lk_max_objects(dbenv, maxp)
758
return (__dbcl_rpc_illegal(dbenv, "get_lk_max_objects"));
762
* PUBLIC: int __dbcl_set_lk_max_objects __P((DB_ENV *, u_int32_t));
765
__dbcl_set_lk_max_objects(dbenv, max)
770
return (__dbcl_rpc_illegal(dbenv, "set_lk_max_objects"));
774
* PUBLIC: int __dbcl_get_mp_max_openfd __P((DB_ENV *, int *));
777
__dbcl_get_mp_max_openfd(dbenv, nopenp)
781
COMPQUIET(nopenp, 0);
782
return (__dbcl_rpc_illegal(dbenv, "get_mp_max_openfd"));
786
* PUBLIC: int __dbcl_set_mp_max_openfd __P((DB_ENV *, int));
789
__dbcl_set_mp_max_openfd(dbenv, nopen)
794
return (__dbcl_rpc_illegal(dbenv, "set_mp_max_openfd"));
798
* PUBLIC: int __dbcl_get_mp_max_write __P((DB_ENV *, int *, int *));
801
__dbcl_get_mp_max_write(dbenv, nwritep, nsleepp)
806
COMPQUIET(nwritep, 0);
807
COMPQUIET(nsleepp, 0);
808
return (__dbcl_rpc_illegal(dbenv, "get_mp_max_write"));
812
* PUBLIC: int __dbcl_set_mp_max_write __P((DB_ENV *, int, int));
815
__dbcl_set_mp_max_write(dbenv, nwrite, nsleep)
820
COMPQUIET(nwrite, 0);
821
COMPQUIET(nsleep, 0);
822
return (__dbcl_rpc_illegal(dbenv, "set_mp_max_write"));
826
* PUBLIC: int __dbcl_get_mp_mmapsize __P((DB_ENV *, size_t *));
829
__dbcl_get_mp_mmapsize(dbenv, mmapsizep)
833
COMPQUIET(mmapsizep, 0);
834
return (__dbcl_rpc_illegal(dbenv, "get_mp_mmapsize"));
838
* PUBLIC: int __dbcl_set_mp_mmapsize __P((DB_ENV *, size_t));
841
__dbcl_set_mp_mmapsize(dbenv, mmapsize)
845
COMPQUIET(mmapsize, 0);
846
return (__dbcl_rpc_illegal(dbenv, "set_mp_mmapsize"));
850
* PUBLIC: int __dbcl_env_get_home __P((DB_ENV *, const char * *));
853
__dbcl_env_get_home(dbenv, homep)
855
const char * * homep;
858
__env_get_home_msg msg;
859
__env_get_home_reply *replyp = NULL;
863
if (dbenv == NULL || !RPC_ON(dbenv))
864
return (__dbcl_noserver(dbenv));
866
cl = (CLIENT *)dbenv->cl_handle;
871
msg.dbenvcl_id = dbenv->cl_id;
873
replyp = __db_env_get_home_4003(&msg, cl);
874
if (replyp == NULL) {
875
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
879
ret = replyp->status;
881
*homep = replyp->home;
884
xdr_free((xdrproc_t)xdr___env_get_home_reply, (void *)replyp);
889
* PUBLIC: int __dbcl_env_get_open_flags __P((DB_ENV *, u_int32_t *));
892
__dbcl_env_get_open_flags(dbenv, flagsp)
897
__env_get_open_flags_msg msg;
898
__env_get_open_flags_reply *replyp = NULL;
902
if (dbenv == NULL || !RPC_ON(dbenv))
903
return (__dbcl_noserver(dbenv));
905
cl = (CLIENT *)dbenv->cl_handle;
910
msg.dbenvcl_id = dbenv->cl_id;
912
replyp = __db_env_get_open_flags_4003(&msg, cl);
913
if (replyp == NULL) {
914
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
918
ret = replyp->status;
920
*flagsp = replyp->flags;
923
xdr_free((xdrproc_t)xdr___env_get_open_flags_reply, (void *)replyp);
928
* PUBLIC: int __dbcl_env_open __P((DB_ENV *, const char *, u_int32_t, int));
931
__dbcl_env_open(dbenv, home, flags, mode)
939
__env_open_reply *replyp = NULL;
943
if (dbenv == NULL || !RPC_ON(dbenv))
944
return (__dbcl_noserver(dbenv));
946
cl = (CLIENT *)dbenv->cl_handle;
951
msg.dbenvcl_id = dbenv->cl_id;
955
msg.home = (char *)home;
959
replyp = __db_env_open_4003(&msg, cl);
960
if (replyp == NULL) {
961
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
965
ret = __dbcl_env_open_ret(dbenv, home, flags, mode, replyp);
968
xdr_free((xdrproc_t)xdr___env_open_reply, (void *)replyp);
973
* PUBLIC: int __dbcl_env_paniccall __P((DB_ENV *, void (*)(DB_ENV *, int)));
976
__dbcl_env_paniccall(dbenv, func0)
978
void (*func0) __P((DB_ENV *, int));
981
return (__dbcl_rpc_illegal(dbenv, "env_paniccall"));
985
* PUBLIC: int __dbcl_env_remove __P((DB_ENV *, const char *, u_int32_t));
988
__dbcl_env_remove(dbenv, home, flags)
994
__env_remove_msg msg;
995
__env_remove_reply *replyp = NULL;
999
if (dbenv == NULL || !RPC_ON(dbenv))
1000
return (__dbcl_noserver(dbenv));
1002
cl = (CLIENT *)dbenv->cl_handle;
1007
msg.dbenvcl_id = dbenv->cl_id;
1011
msg.home = (char *)home;
1014
replyp = __db_env_remove_4003(&msg, cl);
1015
if (replyp == NULL) {
1016
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1020
ret = __dbcl_env_remove_ret(dbenv, home, flags, replyp);
1023
xdr_free((xdrproc_t)xdr___env_remove_reply, (void *)replyp);
1028
* PUBLIC: int __dbcl_get_shm_key __P((DB_ENV *, long *));
1031
__dbcl_get_shm_key(dbenv, shm_keyp)
1035
COMPQUIET(shm_keyp, 0);
1036
return (__dbcl_rpc_illegal(dbenv, "get_shm_key"));
1040
* PUBLIC: int __dbcl_set_shm_key __P((DB_ENV *, long));
1043
__dbcl_set_shm_key(dbenv, shm_key)
1047
COMPQUIET(shm_key, 0);
1048
return (__dbcl_rpc_illegal(dbenv, "set_shm_key"));
1052
* PUBLIC: int __dbcl_get_tas_spins __P((DB_ENV *, u_int32_t *));
1055
__dbcl_get_tas_spins(dbenv, tas_spinsp)
1057
u_int32_t * tas_spinsp;
1059
COMPQUIET(tas_spinsp, 0);
1060
return (__dbcl_rpc_illegal(dbenv, "get_tas_spins"));
1064
* PUBLIC: int __dbcl_set_tas_spins __P((DB_ENV *, u_int32_t));
1067
__dbcl_set_tas_spins(dbenv, tas_spins)
1069
u_int32_t tas_spins;
1071
COMPQUIET(tas_spins, 0);
1072
return (__dbcl_rpc_illegal(dbenv, "set_tas_spins"));
1076
* PUBLIC: int __dbcl_get_timeout __P((DB_ENV *, u_int32_t *, u_int32_t));
1079
__dbcl_get_timeout(dbenv, timeoutp, flags)
1081
u_int32_t * timeoutp;
1084
COMPQUIET(timeoutp, 0);
1085
COMPQUIET(flags, 0);
1086
return (__dbcl_rpc_illegal(dbenv, "get_timeout"));
1090
* PUBLIC: int __dbcl_set_timeout __P((DB_ENV *, u_int32_t, u_int32_t));
1093
__dbcl_set_timeout(dbenv, timeout, flags)
1098
COMPQUIET(timeout, 0);
1099
COMPQUIET(flags, 0);
1100
return (__dbcl_rpc_illegal(dbenv, "set_timeout"));
1104
* PUBLIC: int __dbcl_get_tmp_dir __P((DB_ENV *, const char * *));
1107
__dbcl_get_tmp_dir(dbenv, dirp)
1109
const char * * dirp;
1112
return (__dbcl_rpc_illegal(dbenv, "get_tmp_dir"));
1116
* PUBLIC: int __dbcl_set_tmp_dir __P((DB_ENV *, const char *));
1119
__dbcl_set_tmp_dir(dbenv, dir)
1123
COMPQUIET(dir, NULL);
1124
return (__dbcl_rpc_illegal(dbenv, "set_tmp_dir"));
1128
* PUBLIC: int __dbcl_get_tx_max __P((DB_ENV *, u_int32_t *));
1131
__dbcl_get_tx_max(dbenv, maxp)
1136
return (__dbcl_rpc_illegal(dbenv, "get_tx_max"));
1140
* PUBLIC: int __dbcl_set_tx_max __P((DB_ENV *, u_int32_t));
1143
__dbcl_set_tx_max(dbenv, max)
1148
return (__dbcl_rpc_illegal(dbenv, "set_tx_max"));
1152
* PUBLIC: int __dbcl_get_tx_timestamp __P((DB_ENV *, time_t *));
1155
__dbcl_get_tx_timestamp(dbenv, maxp)
1160
return (__dbcl_rpc_illegal(dbenv, "get_tx_timestamp"));
1164
* PUBLIC: int __dbcl_set_tx_timestamp __P((DB_ENV *, time_t *));
1167
__dbcl_set_tx_timestamp(dbenv, max)
1172
return (__dbcl_rpc_illegal(dbenv, "set_tx_timestamp"));
1176
* PUBLIC: int __dbcl_get_verbose __P((DB_ENV *, u_int32_t, int *));
1179
__dbcl_get_verbose(dbenv, which, onoffp)
1184
COMPQUIET(which, 0);
1185
COMPQUIET(onoffp, 0);
1186
return (__dbcl_rpc_illegal(dbenv, "get_verbose"));
1190
* PUBLIC: int __dbcl_set_verbose __P((DB_ENV *, u_int32_t, int));
1193
__dbcl_set_verbose(dbenv, which, onoff)
1198
COMPQUIET(which, 0);
1199
COMPQUIET(onoff, 0);
1200
return (__dbcl_rpc_illegal(dbenv, "set_verbose"));
1204
* PUBLIC: int __dbcl_txn_abort __P((DB_TXN *));
1207
__dbcl_txn_abort(txnp)
1211
__txn_abort_msg msg;
1212
__txn_abort_reply *replyp = NULL;
1217
dbenv = txnp->mgrp->dbenv;
1218
if (dbenv == NULL || !RPC_ON(dbenv))
1219
return (__dbcl_noserver(NULL));
1221
cl = (CLIENT *)dbenv->cl_handle;
1226
msg.txnpcl_id = txnp->txnid;
1228
replyp = __db_txn_abort_4003(&msg, cl);
1229
if (replyp == NULL) {
1230
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1234
ret = __dbcl_txn_abort_ret(txnp, replyp);
1237
xdr_free((xdrproc_t)xdr___txn_abort_reply, (void *)replyp);
1242
* PUBLIC: int __dbcl_txn_begin __P((DB_ENV *, DB_TXN *, DB_TXN **,
1243
* PUBLIC: u_int32_t));
1246
__dbcl_txn_begin(dbenv, parent, txnpp, flags)
1253
__txn_begin_msg msg;
1254
__txn_begin_reply *replyp = NULL;
1258
if (dbenv == NULL || !RPC_ON(dbenv))
1259
return (__dbcl_noserver(dbenv));
1261
cl = (CLIENT *)dbenv->cl_handle;
1266
msg.dbenvcl_id = dbenv->cl_id;
1268
msg.parentcl_id = 0;
1270
msg.parentcl_id = parent->txnid;
1273
replyp = __db_txn_begin_4003(&msg, cl);
1274
if (replyp == NULL) {
1275
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1279
ret = __dbcl_txn_begin_ret(dbenv, parent, txnpp, flags, replyp);
1282
xdr_free((xdrproc_t)xdr___txn_begin_reply, (void *)replyp);
1287
* PUBLIC: int __dbcl_txn_checkpoint __P((DB_ENV *, u_int32_t, u_int32_t,
1288
* PUBLIC: u_int32_t));
1291
__dbcl_txn_checkpoint(dbenv, kbyte, min, flags)
1297
COMPQUIET(kbyte, 0);
1299
COMPQUIET(flags, 0);
1300
return (__dbcl_rpc_illegal(dbenv, "txn_checkpoint"));
1304
* PUBLIC: int __dbcl_txn_commit __P((DB_TXN *, u_int32_t));
1307
__dbcl_txn_commit(txnp, flags)
1312
__txn_commit_msg msg;
1313
__txn_commit_reply *replyp = NULL;
1318
dbenv = txnp->mgrp->dbenv;
1319
if (dbenv == NULL || !RPC_ON(dbenv))
1320
return (__dbcl_noserver(NULL));
1322
cl = (CLIENT *)dbenv->cl_handle;
1327
msg.txnpcl_id = txnp->txnid;
1330
replyp = __db_txn_commit_4003(&msg, cl);
1331
if (replyp == NULL) {
1332
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1336
ret = __dbcl_txn_commit_ret(txnp, flags, replyp);
1339
xdr_free((xdrproc_t)xdr___txn_commit_reply, (void *)replyp);
1344
* PUBLIC: int __dbcl_txn_discard __P((DB_TXN *, u_int32_t));
1347
__dbcl_txn_discard(txnp, flags)
1352
__txn_discard_msg msg;
1353
__txn_discard_reply *replyp = NULL;
1358
dbenv = txnp->mgrp->dbenv;
1359
if (dbenv == NULL || !RPC_ON(dbenv))
1360
return (__dbcl_noserver(NULL));
1362
cl = (CLIENT *)dbenv->cl_handle;
1367
msg.txnpcl_id = txnp->txnid;
1370
replyp = __db_txn_discard_4003(&msg, cl);
1371
if (replyp == NULL) {
1372
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1376
ret = __dbcl_txn_discard_ret(txnp, flags, replyp);
1379
xdr_free((xdrproc_t)xdr___txn_discard_reply, (void *)replyp);
1384
* PUBLIC: int __dbcl_txn_prepare __P((DB_TXN *, u_int8_t *));
1387
__dbcl_txn_prepare(txnp, gid)
1392
__txn_prepare_msg msg;
1393
__txn_prepare_reply *replyp = NULL;
1398
dbenv = txnp->mgrp->dbenv;
1399
if (dbenv == NULL || !RPC_ON(dbenv))
1400
return (__dbcl_noserver(NULL));
1402
cl = (CLIENT *)dbenv->cl_handle;
1407
msg.txnpcl_id = txnp->txnid;
1408
memcpy(msg.gid, gid, 128);
1410
replyp = __db_txn_prepare_4003(&msg, cl);
1411
if (replyp == NULL) {
1412
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1416
ret = replyp->status;
1419
xdr_free((xdrproc_t)xdr___txn_prepare_reply, (void *)replyp);
1424
* PUBLIC: int __dbcl_txn_recover __P((DB_ENV *, DB_PREPLIST *, long, long *,
1425
* PUBLIC: u_int32_t));
1428
__dbcl_txn_recover(dbenv, preplist, count, retp, flags)
1430
DB_PREPLIST * preplist;
1436
__txn_recover_msg msg;
1437
__txn_recover_reply *replyp = NULL;
1441
if (dbenv == NULL || !RPC_ON(dbenv))
1442
return (__dbcl_noserver(dbenv));
1444
cl = (CLIENT *)dbenv->cl_handle;
1449
msg.dbenvcl_id = dbenv->cl_id;
1453
replyp = __db_txn_recover_4003(&msg, cl);
1454
if (replyp == NULL) {
1455
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1459
ret = __dbcl_txn_recover_ret(dbenv, preplist, count, retp, flags, replyp);
1462
xdr_free((xdrproc_t)xdr___txn_recover_reply, (void *)replyp);
1467
* PUBLIC: int __dbcl_txn_stat __P((DB_ENV *, DB_TXN_STAT **, u_int32_t));
1470
__dbcl_txn_stat(dbenv, statp, flags)
1472
DB_TXN_STAT ** statp;
1475
COMPQUIET(statp, 0);
1476
COMPQUIET(flags, 0);
1477
return (__dbcl_rpc_illegal(dbenv, "txn_stat"));
1481
* PUBLIC: int __dbcl_txn_timeout __P((DB_TXN *, u_int32_t, u_int32_t));
1484
__dbcl_txn_timeout(txnp, timeout, flags)
1491
dbenv = txnp->mgrp->dbenv;
1492
COMPQUIET(timeout, 0);
1493
COMPQUIET(flags, 0);
1494
return (__dbcl_rpc_illegal(dbenv, "txn_timeout"));
1498
* PUBLIC: int __dbcl_rep_elect __P((DB_ENV *, int, int, int, u_int32_t, int *,
1499
* PUBLIC: u_int32_t));
1502
__dbcl_rep_elect(dbenv, nsites, nvotes, pri, timeout, idp, flags)
1511
COMPQUIET(nsites, 0);
1512
COMPQUIET(nvotes, 0);
1514
COMPQUIET(timeout, 0);
1516
COMPQUIET(flags, 0);
1517
return (__dbcl_rpc_illegal(dbenv, "rep_elect"));
1521
* PUBLIC: int __dbcl_rep_flush __P((DB_ENV *));
1524
__dbcl_rep_flush(dbenv)
1527
return (__dbcl_rpc_illegal(dbenv, "rep_flush"));
1531
* PUBLIC: int __dbcl_rep_process_message __P((DB_ENV *, DBT *, DBT *, int *,
1532
* PUBLIC: DB_LSN *));
1535
__dbcl_rep_process_message(dbenv, rec, control, idp, ret_lsnp)
1542
COMPQUIET(rec, NULL);
1543
COMPQUIET(control, NULL);
1545
COMPQUIET(ret_lsnp, 0);
1546
return (__dbcl_rpc_illegal(dbenv, "rep_process_message"));
1550
* PUBLIC: int __dbcl_rep_get_limit __P((DB_ENV *, u_int32_t *, u_int32_t *));
1553
__dbcl_rep_get_limit(dbenv, mbytesp, bytesp)
1555
u_int32_t * mbytesp;
1558
COMPQUIET(mbytesp, 0);
1559
COMPQUIET(bytesp, 0);
1560
return (__dbcl_rpc_illegal(dbenv, "rep_get_limit"));
1564
* PUBLIC: int __dbcl_rep_set_limit __P((DB_ENV *, u_int32_t, u_int32_t));
1567
__dbcl_rep_set_limit(dbenv, mbytes, bytes)
1572
COMPQUIET(mbytes, 0);
1573
COMPQUIET(bytes, 0);
1574
return (__dbcl_rpc_illegal(dbenv, "rep_set_limit"));
1578
* PUBLIC: int __dbcl_rep_set_request __P((DB_ENV *, u_int32_t, u_int32_t));
1581
__dbcl_rep_set_request(dbenv, min, max)
1588
return (__dbcl_rpc_illegal(dbenv, "rep_set_request"));
1592
* PUBLIC: int __dbcl_rep_set_rep_transport __P((DB_ENV *, int,
1593
* PUBLIC: int (*)(DB_ENV *, const DBT *, const DBT *, const DB_LSN *, int, u_int32_t)));
1596
__dbcl_rep_set_rep_transport(dbenv, id, func0)
1599
int (*func0) __P((DB_ENV *, const DBT *, const DBT *, const DB_LSN *, int, u_int32_t));
1602
COMPQUIET(func0, 0);
1603
return (__dbcl_rpc_illegal(dbenv, "rep_set_rep_transport"));
1607
* PUBLIC: int __dbcl_rep_start __P((DB_ENV *, DBT *, u_int32_t));
1610
__dbcl_rep_start(dbenv, cdata, flags)
1615
COMPQUIET(cdata, NULL);
1616
COMPQUIET(flags, 0);
1617
return (__dbcl_rpc_illegal(dbenv, "rep_start"));
1621
* PUBLIC: int __dbcl_rep_stat __P((DB_ENV *, DB_REP_STAT **, u_int32_t));
1624
__dbcl_rep_stat(dbenv, statp, flags)
1626
DB_REP_STAT ** statp;
1629
COMPQUIET(statp, 0);
1630
COMPQUIET(flags, 0);
1631
return (__dbcl_rpc_illegal(dbenv, "rep_stat"));
1635
* PUBLIC: int __dbcl_db_alloc __P((DB *, void *(*)(size_t), void *(*)(void *,
1636
* PUBLIC: size_t), void (*)(void *)));
1639
__dbcl_db_alloc(dbp, func0, func1, func2)
1641
void *(*func0) __P((size_t));
1642
void *(*func1) __P((void *, size_t));
1643
void (*func2) __P((void *));
1648
COMPQUIET(func0, 0);
1649
COMPQUIET(func1, 0);
1650
COMPQUIET(func2, 0);
1651
return (__dbcl_rpc_illegal(dbenv, "db_alloc"));
1655
* PUBLIC: int __dbcl_db_associate __P((DB *, DB_TXN *, DB *, int (*)(DB *,
1656
* PUBLIC: const DBT *, const DBT *, DBT *), u_int32_t));
1659
__dbcl_db_associate(dbp, txnp, sdbp, func0, flags)
1663
int (*func0) __P((DB *, const DBT *, const DBT *, DBT *));
1667
__db_associate_msg msg;
1668
__db_associate_reply *replyp = NULL;
1674
if (dbenv == NULL || !RPC_ON(dbenv))
1675
return (__dbcl_noserver(NULL));
1677
cl = (CLIENT *)dbenv->cl_handle;
1679
if (func0 != NULL) {
1680
__db_err(dbenv, "User functions not supported in RPC");
1686
msg.dbpcl_id = dbp->cl_id;
1690
msg.txnpcl_id = txnp->txnid;
1694
msg.sdbpcl_id = sdbp->cl_id;
1697
replyp = __db_db_associate_4003(&msg, cl);
1698
if (replyp == NULL) {
1699
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1703
ret = replyp->status;
1706
xdr_free((xdrproc_t)xdr___db_associate_reply, (void *)replyp);
1711
* PUBLIC: int __dbcl_db_bt_compare __P((DB *, int (*)(DB *, const DBT *,
1712
* PUBLIC: const DBT *)));
1715
__dbcl_db_bt_compare(dbp, func0)
1717
int (*func0) __P((DB *, const DBT *, const DBT *));
1722
COMPQUIET(func0, 0);
1723
return (__dbcl_rpc_illegal(dbenv, "db_bt_compare"));
1727
* PUBLIC: int __dbcl_db_bt_maxkey __P((DB *, u_int32_t));
1730
__dbcl_db_bt_maxkey(dbp, maxkey)
1735
__db_bt_maxkey_msg msg;
1736
__db_bt_maxkey_reply *replyp = NULL;
1742
if (dbenv == NULL || !RPC_ON(dbenv))
1743
return (__dbcl_noserver(NULL));
1745
cl = (CLIENT *)dbenv->cl_handle;
1750
msg.dbpcl_id = dbp->cl_id;
1751
msg.maxkey = maxkey;
1753
replyp = __db_db_bt_maxkey_4003(&msg, cl);
1754
if (replyp == NULL) {
1755
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1759
ret = replyp->status;
1762
xdr_free((xdrproc_t)xdr___db_bt_maxkey_reply, (void *)replyp);
1767
* PUBLIC: int __dbcl_db_get_bt_minkey __P((DB *, u_int32_t *));
1770
__dbcl_db_get_bt_minkey(dbp, minkeyp)
1772
u_int32_t * minkeyp;
1775
__db_get_bt_minkey_msg msg;
1776
__db_get_bt_minkey_reply *replyp = NULL;
1782
if (dbenv == NULL || !RPC_ON(dbenv))
1783
return (__dbcl_noserver(NULL));
1785
cl = (CLIENT *)dbenv->cl_handle;
1790
msg.dbpcl_id = dbp->cl_id;
1792
replyp = __db_db_get_bt_minkey_4003(&msg, cl);
1793
if (replyp == NULL) {
1794
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1798
ret = replyp->status;
1799
if (minkeyp != NULL)
1800
*minkeyp = replyp->minkey;
1803
xdr_free((xdrproc_t)xdr___db_get_bt_minkey_reply, (void *)replyp);
1808
* PUBLIC: int __dbcl_db_bt_minkey __P((DB *, u_int32_t));
1811
__dbcl_db_bt_minkey(dbp, minkey)
1816
__db_bt_minkey_msg msg;
1817
__db_bt_minkey_reply *replyp = NULL;
1823
if (dbenv == NULL || !RPC_ON(dbenv))
1824
return (__dbcl_noserver(NULL));
1826
cl = (CLIENT *)dbenv->cl_handle;
1831
msg.dbpcl_id = dbp->cl_id;
1832
msg.minkey = minkey;
1834
replyp = __db_db_bt_minkey_4003(&msg, cl);
1835
if (replyp == NULL) {
1836
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1840
ret = replyp->status;
1843
xdr_free((xdrproc_t)xdr___db_bt_minkey_reply, (void *)replyp);
1848
* PUBLIC: int __dbcl_db_bt_prefix __P((DB *, size_t(*)(DB *, const DBT *,
1849
* PUBLIC: const DBT *)));
1852
__dbcl_db_bt_prefix(dbp, func0)
1854
size_t (*func0) __P((DB *, const DBT *, const DBT *));
1859
COMPQUIET(func0, 0);
1860
return (__dbcl_rpc_illegal(dbenv, "db_bt_prefix"));
1864
* PUBLIC: int __dbcl_db_set_append_recno __P((DB *, int (*)(DB *, DBT *,
1865
* PUBLIC: db_recno_t)));
1868
__dbcl_db_set_append_recno(dbp, func0)
1870
int (*func0) __P((DB *, DBT *, db_recno_t));
1875
COMPQUIET(func0, 0);
1876
return (__dbcl_rpc_illegal(dbenv, "db_set_append_recno"));
1880
* PUBLIC: int __dbcl_db_get_cachesize __P((DB *, u_int32_t *, u_int32_t *,
1884
__dbcl_db_get_cachesize(dbp, gbytesp, bytesp, ncachep)
1886
u_int32_t * gbytesp;
1893
COMPQUIET(gbytesp, 0);
1894
COMPQUIET(bytesp, 0);
1895
COMPQUIET(ncachep, 0);
1896
return (__dbcl_rpc_illegal(dbenv, "db_get_cachesize"));
1900
* PUBLIC: int __dbcl_db_cachesize __P((DB *, u_int32_t, u_int32_t, int));
1903
__dbcl_db_cachesize(dbp, gbytes, bytes, ncache)
1912
COMPQUIET(gbytes, 0);
1913
COMPQUIET(bytes, 0);
1914
COMPQUIET(ncache, 0);
1915
return (__dbcl_rpc_illegal(dbenv, "db_cachesize"));
1919
* PUBLIC: int __dbcl_db_close __P((DB *, u_int32_t));
1922
__dbcl_db_close(dbp, flags)
1928
__db_close_reply *replyp = NULL;
1934
if (dbenv == NULL || !RPC_ON(dbenv))
1935
return (__dbcl_noserver(NULL));
1937
cl = (CLIENT *)dbenv->cl_handle;
1942
msg.dbpcl_id = dbp->cl_id;
1945
replyp = __db_db_close_4003(&msg, cl);
1946
if (replyp == NULL) {
1947
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1951
ret = __dbcl_db_close_ret(dbp, flags, replyp);
1954
xdr_free((xdrproc_t)xdr___db_close_reply, (void *)replyp);
1959
* PUBLIC: int __dbcl_db_create __P((DB *, DB_ENV *, u_int32_t));
1962
__dbcl_db_create(dbp, dbenv, flags)
1968
__db_create_msg msg;
1969
__db_create_reply *replyp = NULL;
1973
if (dbenv == NULL || !RPC_ON(dbenv))
1974
return (__dbcl_noserver(dbenv));
1976
cl = (CLIENT *)dbenv->cl_handle;
1981
msg.dbenvcl_id = dbenv->cl_id;
1984
replyp = __db_db_create_4003(&msg, cl);
1985
if (replyp == NULL) {
1986
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
1990
ret = __dbcl_db_create_ret(dbp, dbenv, flags, replyp);
1993
xdr_free((xdrproc_t)xdr___db_create_reply, (void *)replyp);
1998
* PUBLIC: int __dbcl_db_del __P((DB *, DB_TXN *, DBT *, u_int32_t));
2001
__dbcl_db_del(dbp, txnp, key, flags)
2009
__db_del_reply *replyp = NULL;
2015
if (dbenv == NULL || !RPC_ON(dbenv))
2016
return (__dbcl_noserver(NULL));
2018
cl = (CLIENT *)dbenv->cl_handle;
2023
msg.dbpcl_id = dbp->cl_id;
2027
msg.txnpcl_id = txnp->txnid;
2028
msg.keydlen = key->dlen;
2029
msg.keydoff = key->doff;
2030
msg.keyulen = key->ulen;
2031
msg.keyflags = key->flags;
2032
msg.keydata.keydata_val = key->data;
2033
msg.keydata.keydata_len = key->size;
2036
replyp = __db_db_del_4003(&msg, cl);
2037
if (replyp == NULL) {
2038
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2042
ret = replyp->status;
2045
xdr_free((xdrproc_t)xdr___db_del_reply, (void *)replyp);
2050
* PUBLIC: int __dbcl_db_dup_compare __P((DB *, int (*)(DB *, const DBT *,
2051
* PUBLIC: const DBT *)));
2054
__dbcl_db_dup_compare(dbp, func0)
2056
int (*func0) __P((DB *, const DBT *, const DBT *));
2061
COMPQUIET(func0, 0);
2062
return (__dbcl_rpc_illegal(dbenv, "db_dup_compare"));
2066
* PUBLIC: int __dbcl_db_get_encrypt_flags __P((DB *, u_int32_t *));
2069
__dbcl_db_get_encrypt_flags(dbp, flagsp)
2074
__db_get_encrypt_flags_msg msg;
2075
__db_get_encrypt_flags_reply *replyp = NULL;
2081
if (dbenv == NULL || !RPC_ON(dbenv))
2082
return (__dbcl_noserver(NULL));
2084
cl = (CLIENT *)dbenv->cl_handle;
2089
msg.dbpcl_id = dbp->cl_id;
2091
replyp = __db_db_get_encrypt_flags_4003(&msg, cl);
2092
if (replyp == NULL) {
2093
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2097
ret = replyp->status;
2099
*flagsp = replyp->flags;
2102
xdr_free((xdrproc_t)xdr___db_get_encrypt_flags_reply, (void *)replyp);
2107
* PUBLIC: int __dbcl_db_encrypt __P((DB *, const char *, u_int32_t));
2110
__dbcl_db_encrypt(dbp, passwd, flags)
2112
const char * passwd;
2116
__db_encrypt_msg msg;
2117
__db_encrypt_reply *replyp = NULL;
2123
if (dbenv == NULL || !RPC_ON(dbenv))
2124
return (__dbcl_noserver(NULL));
2126
cl = (CLIENT *)dbenv->cl_handle;
2131
msg.dbpcl_id = dbp->cl_id;
2135
msg.passwd = (char *)passwd;
2138
replyp = __db_db_encrypt_4003(&msg, cl);
2139
if (replyp == NULL) {
2140
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2144
ret = replyp->status;
2147
xdr_free((xdrproc_t)xdr___db_encrypt_reply, (void *)replyp);
2152
* PUBLIC: int __dbcl_db_get_extentsize __P((DB *, u_int32_t *));
2155
__dbcl_db_get_extentsize(dbp, extentsizep)
2157
u_int32_t * extentsizep;
2160
__db_get_extentsize_msg msg;
2161
__db_get_extentsize_reply *replyp = NULL;
2167
if (dbenv == NULL || !RPC_ON(dbenv))
2168
return (__dbcl_noserver(NULL));
2170
cl = (CLIENT *)dbenv->cl_handle;
2175
msg.dbpcl_id = dbp->cl_id;
2177
replyp = __db_db_get_extentsize_4003(&msg, cl);
2178
if (replyp == NULL) {
2179
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2183
ret = replyp->status;
2184
if (extentsizep != NULL)
2185
*extentsizep = replyp->extentsize;
2188
xdr_free((xdrproc_t)xdr___db_get_extentsize_reply, (void *)replyp);
2193
* PUBLIC: int __dbcl_db_extentsize __P((DB *, u_int32_t));
2196
__dbcl_db_extentsize(dbp, extentsize)
2198
u_int32_t extentsize;
2201
__db_extentsize_msg msg;
2202
__db_extentsize_reply *replyp = NULL;
2208
if (dbenv == NULL || !RPC_ON(dbenv))
2209
return (__dbcl_noserver(NULL));
2211
cl = (CLIENT *)dbenv->cl_handle;
2216
msg.dbpcl_id = dbp->cl_id;
2217
msg.extentsize = extentsize;
2219
replyp = __db_db_extentsize_4003(&msg, cl);
2220
if (replyp == NULL) {
2221
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2225
ret = replyp->status;
2228
xdr_free((xdrproc_t)xdr___db_extentsize_reply, (void *)replyp);
2233
* PUBLIC: int __dbcl_db_fd __P((DB *, int *));
2236
__dbcl_db_fd(dbp, fdp)
2244
return (__dbcl_rpc_illegal(dbenv, "db_fd"));
2248
* PUBLIC: int __dbcl_db_feedback __P((DB *, void (*)(DB *, int, int)));
2251
__dbcl_db_feedback(dbp, func0)
2253
void (*func0) __P((DB *, int, int));
2258
COMPQUIET(func0, 0);
2259
return (__dbcl_rpc_illegal(dbenv, "db_feedback"));
2263
* PUBLIC: int __dbcl_db_get_flags __P((DB *, u_int32_t *));
2266
__dbcl_db_get_flags(dbp, flagsp)
2271
__db_get_flags_msg msg;
2272
__db_get_flags_reply *replyp = NULL;
2278
if (dbenv == NULL || !RPC_ON(dbenv))
2279
return (__dbcl_noserver(NULL));
2281
cl = (CLIENT *)dbenv->cl_handle;
2286
msg.dbpcl_id = dbp->cl_id;
2288
replyp = __db_db_get_flags_4003(&msg, cl);
2289
if (replyp == NULL) {
2290
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2294
ret = replyp->status;
2296
*flagsp = replyp->flags;
2299
xdr_free((xdrproc_t)xdr___db_get_flags_reply, (void *)replyp);
2304
* PUBLIC: int __dbcl_db_flags __P((DB *, u_int32_t));
2307
__dbcl_db_flags(dbp, flags)
2313
__db_flags_reply *replyp = NULL;
2319
if (dbenv == NULL || !RPC_ON(dbenv))
2320
return (__dbcl_noserver(NULL));
2322
cl = (CLIENT *)dbenv->cl_handle;
2327
msg.dbpcl_id = dbp->cl_id;
2330
replyp = __db_db_flags_4003(&msg, cl);
2331
if (replyp == NULL) {
2332
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2336
ret = replyp->status;
2339
xdr_free((xdrproc_t)xdr___db_flags_reply, (void *)replyp);
2344
* PUBLIC: int __dbcl_db_get __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
2347
__dbcl_db_get(dbp, txnp, key, data, flags)
2356
__db_get_reply *replyp = NULL;
2362
if (dbenv == NULL || !RPC_ON(dbenv))
2363
return (__dbcl_noserver(NULL));
2365
cl = (CLIENT *)dbenv->cl_handle;
2370
msg.dbpcl_id = dbp->cl_id;
2374
msg.txnpcl_id = txnp->txnid;
2375
msg.keydlen = key->dlen;
2376
msg.keydoff = key->doff;
2377
msg.keyulen = key->ulen;
2378
msg.keyflags = key->flags;
2379
msg.keydata.keydata_val = key->data;
2380
msg.keydata.keydata_len = key->size;
2381
msg.datadlen = data->dlen;
2382
msg.datadoff = data->doff;
2383
msg.dataulen = data->ulen;
2384
msg.dataflags = data->flags;
2385
msg.datadata.datadata_val = data->data;
2386
msg.datadata.datadata_len = data->size;
2389
replyp = __db_db_get_4003(&msg, cl);
2390
if (replyp == NULL) {
2391
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2395
ret = __dbcl_db_get_ret(dbp, txnp, key, data, flags, replyp);
2398
xdr_free((xdrproc_t)xdr___db_get_reply, (void *)replyp);
2403
* PUBLIC: int __dbcl_db_get_name __P((DB *, const char * *, const char * *));
2406
__dbcl_db_get_name(dbp, filenamep, dbnamep)
2408
const char * * filenamep;
2409
const char * * dbnamep;
2412
__db_get_name_msg msg;
2413
__db_get_name_reply *replyp = NULL;
2419
if (dbenv == NULL || !RPC_ON(dbenv))
2420
return (__dbcl_noserver(NULL));
2422
cl = (CLIENT *)dbenv->cl_handle;
2427
msg.dbpcl_id = dbp->cl_id;
2429
replyp = __db_db_get_name_4003(&msg, cl);
2430
if (replyp == NULL) {
2431
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2435
ret = replyp->status;
2436
if (filenamep != NULL)
2437
*filenamep = replyp->filename;
2438
if (dbnamep != NULL)
2439
*dbnamep = replyp->dbname;
2442
xdr_free((xdrproc_t)xdr___db_get_name_reply, (void *)replyp);
2447
* PUBLIC: int __dbcl_db_get_open_flags __P((DB *, u_int32_t *));
2450
__dbcl_db_get_open_flags(dbp, flagsp)
2455
__db_get_open_flags_msg msg;
2456
__db_get_open_flags_reply *replyp = NULL;
2462
if (dbenv == NULL || !RPC_ON(dbenv))
2463
return (__dbcl_noserver(NULL));
2465
cl = (CLIENT *)dbenv->cl_handle;
2470
msg.dbpcl_id = dbp->cl_id;
2472
replyp = __db_db_get_open_flags_4003(&msg, cl);
2473
if (replyp == NULL) {
2474
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2478
ret = replyp->status;
2480
*flagsp = replyp->flags;
2483
xdr_free((xdrproc_t)xdr___db_get_open_flags_reply, (void *)replyp);
2488
* PUBLIC: int __dbcl_db_get_h_ffactor __P((DB *, u_int32_t *));
2491
__dbcl_db_get_h_ffactor(dbp, ffactorp)
2493
u_int32_t * ffactorp;
2496
__db_get_h_ffactor_msg msg;
2497
__db_get_h_ffactor_reply *replyp = NULL;
2503
if (dbenv == NULL || !RPC_ON(dbenv))
2504
return (__dbcl_noserver(NULL));
2506
cl = (CLIENT *)dbenv->cl_handle;
2511
msg.dbpcl_id = dbp->cl_id;
2513
replyp = __db_db_get_h_ffactor_4003(&msg, cl);
2514
if (replyp == NULL) {
2515
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2519
ret = replyp->status;
2520
if (ffactorp != NULL)
2521
*ffactorp = replyp->ffactor;
2524
xdr_free((xdrproc_t)xdr___db_get_h_ffactor_reply, (void *)replyp);
2529
* PUBLIC: int __dbcl_db_h_ffactor __P((DB *, u_int32_t));
2532
__dbcl_db_h_ffactor(dbp, ffactor)
2537
__db_h_ffactor_msg msg;
2538
__db_h_ffactor_reply *replyp = NULL;
2544
if (dbenv == NULL || !RPC_ON(dbenv))
2545
return (__dbcl_noserver(NULL));
2547
cl = (CLIENT *)dbenv->cl_handle;
2552
msg.dbpcl_id = dbp->cl_id;
2553
msg.ffactor = ffactor;
2555
replyp = __db_db_h_ffactor_4003(&msg, cl);
2556
if (replyp == NULL) {
2557
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2561
ret = replyp->status;
2564
xdr_free((xdrproc_t)xdr___db_h_ffactor_reply, (void *)replyp);
2569
* PUBLIC: int __dbcl_db_h_hash __P((DB *, u_int32_t(*)(DB *, const void *,
2570
* PUBLIC: u_int32_t)));
2573
__dbcl_db_h_hash(dbp, func0)
2575
u_int32_t (*func0) __P((DB *, const void *, u_int32_t));
2580
COMPQUIET(func0, 0);
2581
return (__dbcl_rpc_illegal(dbenv, "db_h_hash"));
2585
* PUBLIC: int __dbcl_db_get_h_nelem __P((DB *, u_int32_t *));
2588
__dbcl_db_get_h_nelem(dbp, nelemp)
2593
__db_get_h_nelem_msg msg;
2594
__db_get_h_nelem_reply *replyp = NULL;
2600
if (dbenv == NULL || !RPC_ON(dbenv))
2601
return (__dbcl_noserver(NULL));
2603
cl = (CLIENT *)dbenv->cl_handle;
2608
msg.dbpcl_id = dbp->cl_id;
2610
replyp = __db_db_get_h_nelem_4003(&msg, cl);
2611
if (replyp == NULL) {
2612
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2616
ret = replyp->status;
2618
*nelemp = replyp->nelem;
2621
xdr_free((xdrproc_t)xdr___db_get_h_nelem_reply, (void *)replyp);
2626
* PUBLIC: int __dbcl_db_h_nelem __P((DB *, u_int32_t));
2629
__dbcl_db_h_nelem(dbp, nelem)
2634
__db_h_nelem_msg msg;
2635
__db_h_nelem_reply *replyp = NULL;
2641
if (dbenv == NULL || !RPC_ON(dbenv))
2642
return (__dbcl_noserver(NULL));
2644
cl = (CLIENT *)dbenv->cl_handle;
2649
msg.dbpcl_id = dbp->cl_id;
2652
replyp = __db_db_h_nelem_4003(&msg, cl);
2653
if (replyp == NULL) {
2654
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2658
ret = replyp->status;
2661
xdr_free((xdrproc_t)xdr___db_h_nelem_reply, (void *)replyp);
2666
* PUBLIC: int __dbcl_db_key_range __P((DB *, DB_TXN *, DBT *, DB_KEY_RANGE *,
2667
* PUBLIC: u_int32_t));
2670
__dbcl_db_key_range(dbp, txnp, key, range, flags)
2674
DB_KEY_RANGE * range;
2678
__db_key_range_msg msg;
2679
__db_key_range_reply *replyp = NULL;
2685
if (dbenv == NULL || !RPC_ON(dbenv))
2686
return (__dbcl_noserver(NULL));
2688
cl = (CLIENT *)dbenv->cl_handle;
2693
msg.dbpcl_id = dbp->cl_id;
2697
msg.txnpcl_id = txnp->txnid;
2698
msg.keydlen = key->dlen;
2699
msg.keydoff = key->doff;
2700
msg.keyulen = key->ulen;
2701
msg.keyflags = key->flags;
2702
msg.keydata.keydata_val = key->data;
2703
msg.keydata.keydata_len = key->size;
2706
replyp = __db_db_key_range_4003(&msg, cl);
2707
if (replyp == NULL) {
2708
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2712
ret = __dbcl_db_key_range_ret(dbp, txnp, key, range, flags, replyp);
2715
xdr_free((xdrproc_t)xdr___db_key_range_reply, (void *)replyp);
2720
* PUBLIC: int __dbcl_db_get_lorder __P((DB *, int *));
2723
__dbcl_db_get_lorder(dbp, lorderp)
2728
__db_get_lorder_msg msg;
2729
__db_get_lorder_reply *replyp = NULL;
2735
if (dbenv == NULL || !RPC_ON(dbenv))
2736
return (__dbcl_noserver(NULL));
2738
cl = (CLIENT *)dbenv->cl_handle;
2743
msg.dbpcl_id = dbp->cl_id;
2745
replyp = __db_db_get_lorder_4003(&msg, cl);
2746
if (replyp == NULL) {
2747
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2751
ret = replyp->status;
2752
if (lorderp != NULL)
2753
*lorderp = replyp->lorder;
2756
xdr_free((xdrproc_t)xdr___db_get_lorder_reply, (void *)replyp);
2761
* PUBLIC: int __dbcl_db_lorder __P((DB *, int));
2764
__dbcl_db_lorder(dbp, lorder)
2769
__db_lorder_msg msg;
2770
__db_lorder_reply *replyp = NULL;
2776
if (dbenv == NULL || !RPC_ON(dbenv))
2777
return (__dbcl_noserver(NULL));
2779
cl = (CLIENT *)dbenv->cl_handle;
2784
msg.dbpcl_id = dbp->cl_id;
2785
msg.lorder = lorder;
2787
replyp = __db_db_lorder_4003(&msg, cl);
2788
if (replyp == NULL) {
2789
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2793
ret = replyp->status;
2796
xdr_free((xdrproc_t)xdr___db_lorder_reply, (void *)replyp);
2801
* PUBLIC: int __dbcl_db_open __P((DB *, DB_TXN *, const char *, const char *,
2802
* PUBLIC: DBTYPE, u_int32_t, int));
2805
__dbcl_db_open(dbp, txnp, name, subdb, type, flags, mode)
2816
__db_open_reply *replyp = NULL;
2822
if (dbenv == NULL || !RPC_ON(dbenv))
2823
return (__dbcl_noserver(NULL));
2825
cl = (CLIENT *)dbenv->cl_handle;
2830
msg.dbpcl_id = dbp->cl_id;
2834
msg.txnpcl_id = txnp->txnid;
2838
msg.name = (char *)name;
2842
msg.subdb = (char *)subdb;
2847
replyp = __db_db_open_4003(&msg, cl);
2848
if (replyp == NULL) {
2849
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2853
ret = __dbcl_db_open_ret(dbp, txnp, name, subdb, type, flags, mode, replyp);
2856
xdr_free((xdrproc_t)xdr___db_open_reply, (void *)replyp);
2861
* PUBLIC: int __dbcl_db_get_pagesize __P((DB *, u_int32_t *));
2864
__dbcl_db_get_pagesize(dbp, pagesizep)
2866
u_int32_t * pagesizep;
2869
__db_get_pagesize_msg msg;
2870
__db_get_pagesize_reply *replyp = NULL;
2876
if (dbenv == NULL || !RPC_ON(dbenv))
2877
return (__dbcl_noserver(NULL));
2879
cl = (CLIENT *)dbenv->cl_handle;
2884
msg.dbpcl_id = dbp->cl_id;
2886
replyp = __db_db_get_pagesize_4003(&msg, cl);
2887
if (replyp == NULL) {
2888
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2892
ret = replyp->status;
2893
if (pagesizep != NULL)
2894
*pagesizep = replyp->pagesize;
2897
xdr_free((xdrproc_t)xdr___db_get_pagesize_reply, (void *)replyp);
2902
* PUBLIC: int __dbcl_db_pagesize __P((DB *, u_int32_t));
2905
__dbcl_db_pagesize(dbp, pagesize)
2910
__db_pagesize_msg msg;
2911
__db_pagesize_reply *replyp = NULL;
2917
if (dbenv == NULL || !RPC_ON(dbenv))
2918
return (__dbcl_noserver(NULL));
2920
cl = (CLIENT *)dbenv->cl_handle;
2925
msg.dbpcl_id = dbp->cl_id;
2926
msg.pagesize = pagesize;
2928
replyp = __db_db_pagesize_4003(&msg, cl);
2929
if (replyp == NULL) {
2930
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
2934
ret = replyp->status;
2937
xdr_free((xdrproc_t)xdr___db_pagesize_reply, (void *)replyp);
2942
* PUBLIC: int __dbcl_db_panic __P((DB *, void (*)(DB_ENV *, int)));
2945
__dbcl_db_panic(dbp, func0)
2947
void (*func0) __P((DB_ENV *, int));
2952
COMPQUIET(func0, 0);
2953
return (__dbcl_rpc_illegal(dbenv, "db_panic"));
2957
* PUBLIC: int __dbcl_db_pget __P((DB *, DB_TXN *, DBT *, DBT *, DBT *,
2958
* PUBLIC: u_int32_t));
2961
__dbcl_db_pget(dbp, txnp, skey, pkey, data, flags)
2971
__db_pget_reply *replyp = NULL;
2977
if (dbenv == NULL || !RPC_ON(dbenv))
2978
return (__dbcl_noserver(NULL));
2980
cl = (CLIENT *)dbenv->cl_handle;
2985
msg.dbpcl_id = dbp->cl_id;
2989
msg.txnpcl_id = txnp->txnid;
2990
msg.skeydlen = skey->dlen;
2991
msg.skeydoff = skey->doff;
2992
msg.skeyulen = skey->ulen;
2993
msg.skeyflags = skey->flags;
2994
msg.skeydata.skeydata_val = skey->data;
2995
msg.skeydata.skeydata_len = skey->size;
2996
msg.pkeydlen = pkey->dlen;
2997
msg.pkeydoff = pkey->doff;
2998
msg.pkeyulen = pkey->ulen;
2999
msg.pkeyflags = pkey->flags;
3000
msg.pkeydata.pkeydata_val = pkey->data;
3001
msg.pkeydata.pkeydata_len = pkey->size;
3002
msg.datadlen = data->dlen;
3003
msg.datadoff = data->doff;
3004
msg.dataulen = data->ulen;
3005
msg.dataflags = data->flags;
3006
msg.datadata.datadata_val = data->data;
3007
msg.datadata.datadata_len = data->size;
3010
replyp = __db_db_pget_4003(&msg, cl);
3011
if (replyp == NULL) {
3012
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3016
ret = __dbcl_db_pget_ret(dbp, txnp, skey, pkey, data, flags, replyp);
3019
xdr_free((xdrproc_t)xdr___db_pget_reply, (void *)replyp);
3024
* PUBLIC: int __dbcl_db_put __P((DB *, DB_TXN *, DBT *, DBT *, u_int32_t));
3027
__dbcl_db_put(dbp, txnp, key, data, flags)
3036
__db_put_reply *replyp = NULL;
3042
if (dbenv == NULL || !RPC_ON(dbenv))
3043
return (__dbcl_noserver(NULL));
3045
cl = (CLIENT *)dbenv->cl_handle;
3050
msg.dbpcl_id = dbp->cl_id;
3054
msg.txnpcl_id = txnp->txnid;
3055
msg.keydlen = key->dlen;
3056
msg.keydoff = key->doff;
3057
msg.keyulen = key->ulen;
3058
msg.keyflags = key->flags;
3059
msg.keydata.keydata_val = key->data;
3060
msg.keydata.keydata_len = key->size;
3061
msg.datadlen = data->dlen;
3062
msg.datadoff = data->doff;
3063
msg.dataulen = data->ulen;
3064
msg.dataflags = data->flags;
3065
msg.datadata.datadata_val = data->data;
3066
msg.datadata.datadata_len = data->size;
3069
replyp = __db_db_put_4003(&msg, cl);
3070
if (replyp == NULL) {
3071
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3075
ret = __dbcl_db_put_ret(dbp, txnp, key, data, flags, replyp);
3078
xdr_free((xdrproc_t)xdr___db_put_reply, (void *)replyp);
3083
* PUBLIC: int __dbcl_db_get_re_delim __P((DB *, int *));
3086
__dbcl_db_get_re_delim(dbp, delimp)
3091
__db_get_re_delim_msg msg;
3092
__db_get_re_delim_reply *replyp = NULL;
3098
if (dbenv == NULL || !RPC_ON(dbenv))
3099
return (__dbcl_noserver(NULL));
3101
cl = (CLIENT *)dbenv->cl_handle;
3106
msg.dbpcl_id = dbp->cl_id;
3108
replyp = __db_db_get_re_delim_4003(&msg, cl);
3109
if (replyp == NULL) {
3110
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3114
ret = replyp->status;
3116
*delimp = replyp->delim;
3119
xdr_free((xdrproc_t)xdr___db_get_re_delim_reply, (void *)replyp);
3124
* PUBLIC: int __dbcl_db_re_delim __P((DB *, int));
3127
__dbcl_db_re_delim(dbp, delim)
3132
__db_re_delim_msg msg;
3133
__db_re_delim_reply *replyp = NULL;
3139
if (dbenv == NULL || !RPC_ON(dbenv))
3140
return (__dbcl_noserver(NULL));
3142
cl = (CLIENT *)dbenv->cl_handle;
3147
msg.dbpcl_id = dbp->cl_id;
3150
replyp = __db_db_re_delim_4003(&msg, cl);
3151
if (replyp == NULL) {
3152
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3156
ret = replyp->status;
3159
xdr_free((xdrproc_t)xdr___db_re_delim_reply, (void *)replyp);
3164
* PUBLIC: int __dbcl_db_get_re_len __P((DB *, u_int32_t *));
3167
__dbcl_db_get_re_len(dbp, lenp)
3172
__db_get_re_len_msg msg;
3173
__db_get_re_len_reply *replyp = NULL;
3179
if (dbenv == NULL || !RPC_ON(dbenv))
3180
return (__dbcl_noserver(NULL));
3182
cl = (CLIENT *)dbenv->cl_handle;
3187
msg.dbpcl_id = dbp->cl_id;
3189
replyp = __db_db_get_re_len_4003(&msg, cl);
3190
if (replyp == NULL) {
3191
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3195
ret = replyp->status;
3197
*lenp = replyp->len;
3200
xdr_free((xdrproc_t)xdr___db_get_re_len_reply, (void *)replyp);
3205
* PUBLIC: int __dbcl_db_re_len __P((DB *, u_int32_t));
3208
__dbcl_db_re_len(dbp, len)
3213
__db_re_len_msg msg;
3214
__db_re_len_reply *replyp = NULL;
3220
if (dbenv == NULL || !RPC_ON(dbenv))
3221
return (__dbcl_noserver(NULL));
3223
cl = (CLIENT *)dbenv->cl_handle;
3228
msg.dbpcl_id = dbp->cl_id;
3231
replyp = __db_db_re_len_4003(&msg, cl);
3232
if (replyp == NULL) {
3233
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3237
ret = replyp->status;
3240
xdr_free((xdrproc_t)xdr___db_re_len_reply, (void *)replyp);
3245
* PUBLIC: int __dbcl_db_re_pad __P((DB *, int));
3248
__dbcl_db_re_pad(dbp, pad)
3253
__db_re_pad_msg msg;
3254
__db_re_pad_reply *replyp = NULL;
3260
if (dbenv == NULL || !RPC_ON(dbenv))
3261
return (__dbcl_noserver(NULL));
3263
cl = (CLIENT *)dbenv->cl_handle;
3268
msg.dbpcl_id = dbp->cl_id;
3271
replyp = __db_db_re_pad_4003(&msg, cl);
3272
if (replyp == NULL) {
3273
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3277
ret = replyp->status;
3280
xdr_free((xdrproc_t)xdr___db_re_pad_reply, (void *)replyp);
3285
* PUBLIC: int __dbcl_db_get_re_pad __P((DB *, int *));
3288
__dbcl_db_get_re_pad(dbp, padp)
3293
__db_get_re_pad_msg msg;
3294
__db_get_re_pad_reply *replyp = NULL;
3300
if (dbenv == NULL || !RPC_ON(dbenv))
3301
return (__dbcl_noserver(NULL));
3303
cl = (CLIENT *)dbenv->cl_handle;
3308
msg.dbpcl_id = dbp->cl_id;
3310
replyp = __db_db_get_re_pad_4003(&msg, cl);
3311
if (replyp == NULL) {
3312
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3316
ret = replyp->status;
3318
*padp = replyp->pad;
3321
xdr_free((xdrproc_t)xdr___db_get_re_pad_reply, (void *)replyp);
3326
* PUBLIC: int __dbcl_db_get_re_source __P((DB *, const char * *));
3329
__dbcl_db_get_re_source(dbp, re_sourcep)
3331
const char * * re_sourcep;
3336
COMPQUIET(re_sourcep, 0);
3337
return (__dbcl_rpc_illegal(dbenv, "db_get_re_source"));
3341
* PUBLIC: int __dbcl_db_re_source __P((DB *, const char *));
3344
__dbcl_db_re_source(dbp, re_source)
3346
const char * re_source;
3351
COMPQUIET(re_source, NULL);
3352
return (__dbcl_rpc_illegal(dbenv, "db_re_source"));
3356
* PUBLIC: int __dbcl_db_remove __P((DB *, const char *, const char *,
3357
* PUBLIC: u_int32_t));
3360
__dbcl_db_remove(dbp, name, subdb, flags)
3367
__db_remove_msg msg;
3368
__db_remove_reply *replyp = NULL;
3374
if (dbenv == NULL || !RPC_ON(dbenv))
3375
return (__dbcl_noserver(NULL));
3377
cl = (CLIENT *)dbenv->cl_handle;
3382
msg.dbpcl_id = dbp->cl_id;
3386
msg.name = (char *)name;
3390
msg.subdb = (char *)subdb;
3393
replyp = __db_db_remove_4003(&msg, cl);
3394
if (replyp == NULL) {
3395
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3399
ret = __dbcl_db_remove_ret(dbp, name, subdb, flags, replyp);
3402
xdr_free((xdrproc_t)xdr___db_remove_reply, (void *)replyp);
3407
* PUBLIC: int __dbcl_db_rename __P((DB *, const char *, const char *,
3408
* PUBLIC: const char *, u_int32_t));
3411
__dbcl_db_rename(dbp, name, subdb, newname, flags)
3415
const char * newname;
3419
__db_rename_msg msg;
3420
__db_rename_reply *replyp = NULL;
3426
if (dbenv == NULL || !RPC_ON(dbenv))
3427
return (__dbcl_noserver(NULL));
3429
cl = (CLIENT *)dbenv->cl_handle;
3434
msg.dbpcl_id = dbp->cl_id;
3438
msg.name = (char *)name;
3442
msg.subdb = (char *)subdb;
3443
if (newname == NULL)
3446
msg.newname = (char *)newname;
3449
replyp = __db_db_rename_4003(&msg, cl);
3450
if (replyp == NULL) {
3451
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3455
ret = __dbcl_db_rename_ret(dbp, name, subdb, newname, flags, replyp);
3458
xdr_free((xdrproc_t)xdr___db_rename_reply, (void *)replyp);
3463
* PUBLIC: int __dbcl_db_stat __P((DB *, DB_TXN *, void *, u_int32_t));
3466
__dbcl_db_stat(dbp, txnp, sp, flags)
3474
__db_stat_reply *replyp = NULL;
3480
if (dbenv == NULL || !RPC_ON(dbenv))
3481
return (__dbcl_noserver(NULL));
3483
cl = (CLIENT *)dbenv->cl_handle;
3488
msg.dbpcl_id = dbp->cl_id;
3492
msg.txnpcl_id = txnp->txnid;
3495
replyp = __db_db_stat_4003(&msg, cl);
3496
if (replyp == NULL) {
3497
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3501
ret = __dbcl_db_stat_ret(dbp, txnp, sp, flags, replyp);
3504
xdr_free((xdrproc_t)xdr___db_stat_reply, (void *)replyp);
3509
* PUBLIC: int __dbcl_db_sync __P((DB *, u_int32_t));
3512
__dbcl_db_sync(dbp, flags)
3518
__db_sync_reply *replyp = NULL;
3524
if (dbenv == NULL || !RPC_ON(dbenv))
3525
return (__dbcl_noserver(NULL));
3527
cl = (CLIENT *)dbenv->cl_handle;
3532
msg.dbpcl_id = dbp->cl_id;
3535
replyp = __db_db_sync_4003(&msg, cl);
3536
if (replyp == NULL) {
3537
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3541
ret = replyp->status;
3544
xdr_free((xdrproc_t)xdr___db_sync_reply, (void *)replyp);
3549
* PUBLIC: int __dbcl_db_truncate __P((DB *, DB_TXN *, u_int32_t *,
3550
* PUBLIC: u_int32_t));
3553
__dbcl_db_truncate(dbp, txnp, countp, flags)
3560
__db_truncate_msg msg;
3561
__db_truncate_reply *replyp = NULL;
3567
if (dbenv == NULL || !RPC_ON(dbenv))
3568
return (__dbcl_noserver(NULL));
3570
cl = (CLIENT *)dbenv->cl_handle;
3575
msg.dbpcl_id = dbp->cl_id;
3579
msg.txnpcl_id = txnp->txnid;
3582
replyp = __db_db_truncate_4003(&msg, cl);
3583
if (replyp == NULL) {
3584
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3588
ret = __dbcl_db_truncate_ret(dbp, txnp, countp, flags, replyp);
3591
xdr_free((xdrproc_t)xdr___db_truncate_reply, (void *)replyp);
3596
* PUBLIC: int __dbcl_db_upgrade __P((DB *, const char *, u_int32_t));
3599
__dbcl_db_upgrade(dbp, fname, flags)
3607
COMPQUIET(fname, NULL);
3608
COMPQUIET(flags, 0);
3609
return (__dbcl_rpc_illegal(dbenv, "db_upgrade"));
3613
* PUBLIC: int __dbcl_db_verify __P((DB *, const char *, const char *, FILE *,
3614
* PUBLIC: u_int32_t));
3617
__dbcl_db_verify(dbp, fname, subdb, outfile, flags)
3627
COMPQUIET(fname, NULL);
3628
COMPQUIET(subdb, NULL);
3629
COMPQUIET(outfile, 0);
3630
COMPQUIET(flags, 0);
3631
return (__dbcl_rpc_illegal(dbenv, "db_verify"));
3635
* PUBLIC: int __dbcl_db_cursor __P((DB *, DB_TXN *, DBC **, u_int32_t));
3638
__dbcl_db_cursor(dbp, txnp, dbcpp, flags)
3645
__db_cursor_msg msg;
3646
__db_cursor_reply *replyp = NULL;
3652
if (dbenv == NULL || !RPC_ON(dbenv))
3653
return (__dbcl_noserver(NULL));
3655
cl = (CLIENT *)dbenv->cl_handle;
3660
msg.dbpcl_id = dbp->cl_id;
3664
msg.txnpcl_id = txnp->txnid;
3667
replyp = __db_db_cursor_4003(&msg, cl);
3668
if (replyp == NULL) {
3669
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3673
ret = __dbcl_db_cursor_ret(dbp, txnp, dbcpp, flags, replyp);
3676
xdr_free((xdrproc_t)xdr___db_cursor_reply, (void *)replyp);
3681
* PUBLIC: int __dbcl_db_join __P((DB *, DBC **, DBC **, u_int32_t));
3684
__dbcl_db_join(dbp, curs, dbcp, flags)
3692
__db_join_reply *replyp = NULL;
3701
if (dbenv == NULL || !RPC_ON(dbenv))
3702
return (__dbcl_noserver(NULL));
3704
cl = (CLIENT *)dbenv->cl_handle;
3709
msg.dbpcl_id = dbp->cl_id;
3710
for (cursi = 0, cursp = curs; *cursp != 0; cursi++, cursp++)
3712
msg.curs.curs_len = cursi;
3713
if ((ret = __os_calloc(dbenv,
3714
msg.curs.curs_len, sizeof(u_int32_t), &msg.curs.curs_val)) != 0)
3716
for (cursq = msg.curs.curs_val, cursp = curs; cursi--; cursq++, cursp++)
3717
*cursq = (*cursp)->cl_id;
3720
replyp = __db_db_join_4003(&msg, cl);
3721
__os_free(dbenv, msg.curs.curs_val);
3722
if (replyp == NULL) {
3723
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3727
ret = __dbcl_db_join_ret(dbp, curs, dbcp, flags, replyp);
3730
xdr_free((xdrproc_t)xdr___db_join_reply, (void *)replyp);
3735
* PUBLIC: int __dbcl_dbc_close __P((DBC *));
3738
__dbcl_dbc_close(dbc)
3742
__dbc_close_msg msg;
3743
__dbc_close_reply *replyp = NULL;
3748
dbenv = dbc->dbp->dbenv;
3749
if (dbenv == NULL || !RPC_ON(dbenv))
3750
return (__dbcl_noserver(NULL));
3752
cl = (CLIENT *)dbenv->cl_handle;
3757
msg.dbccl_id = dbc->cl_id;
3759
replyp = __db_dbc_close_4003(&msg, cl);
3760
if (replyp == NULL) {
3761
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3765
ret = __dbcl_dbc_close_ret(dbc, replyp);
3768
xdr_free((xdrproc_t)xdr___dbc_close_reply, (void *)replyp);
3773
* PUBLIC: int __dbcl_dbc_count __P((DBC *, db_recno_t *, u_int32_t));
3776
__dbcl_dbc_count(dbc, countp, flags)
3778
db_recno_t * countp;
3782
__dbc_count_msg msg;
3783
__dbc_count_reply *replyp = NULL;
3788
dbenv = dbc->dbp->dbenv;
3789
if (dbenv == NULL || !RPC_ON(dbenv))
3790
return (__dbcl_noserver(NULL));
3792
cl = (CLIENT *)dbenv->cl_handle;
3797
msg.dbccl_id = dbc->cl_id;
3800
replyp = __db_dbc_count_4003(&msg, cl);
3801
if (replyp == NULL) {
3802
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3806
ret = __dbcl_dbc_count_ret(dbc, countp, flags, replyp);
3809
xdr_free((xdrproc_t)xdr___dbc_count_reply, (void *)replyp);
3814
* PUBLIC: int __dbcl_dbc_del __P((DBC *, u_int32_t));
3817
__dbcl_dbc_del(dbc, flags)
3823
__dbc_del_reply *replyp = NULL;
3828
dbenv = dbc->dbp->dbenv;
3829
if (dbenv == NULL || !RPC_ON(dbenv))
3830
return (__dbcl_noserver(NULL));
3832
cl = (CLIENT *)dbenv->cl_handle;
3837
msg.dbccl_id = dbc->cl_id;
3840
replyp = __db_dbc_del_4003(&msg, cl);
3841
if (replyp == NULL) {
3842
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3846
ret = replyp->status;
3849
xdr_free((xdrproc_t)xdr___dbc_del_reply, (void *)replyp);
3854
* PUBLIC: int __dbcl_dbc_dup __P((DBC *, DBC **, u_int32_t));
3857
__dbcl_dbc_dup(dbc, dbcp, flags)
3864
__dbc_dup_reply *replyp = NULL;
3869
dbenv = dbc->dbp->dbenv;
3870
if (dbenv == NULL || !RPC_ON(dbenv))
3871
return (__dbcl_noserver(NULL));
3873
cl = (CLIENT *)dbenv->cl_handle;
3878
msg.dbccl_id = dbc->cl_id;
3881
replyp = __db_dbc_dup_4003(&msg, cl);
3882
if (replyp == NULL) {
3883
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3887
ret = __dbcl_dbc_dup_ret(dbc, dbcp, flags, replyp);
3890
xdr_free((xdrproc_t)xdr___dbc_dup_reply, (void *)replyp);
3895
* PUBLIC: int __dbcl_dbc_get __P((DBC *, DBT *, DBT *, u_int32_t));
3898
__dbcl_dbc_get(dbc, key, data, flags)
3906
__dbc_get_reply *replyp = NULL;
3911
dbenv = dbc->dbp->dbenv;
3912
if (dbenv == NULL || !RPC_ON(dbenv))
3913
return (__dbcl_noserver(NULL));
3915
cl = (CLIENT *)dbenv->cl_handle;
3920
msg.dbccl_id = dbc->cl_id;
3921
msg.keydlen = key->dlen;
3922
msg.keydoff = key->doff;
3923
msg.keyulen = key->ulen;
3924
msg.keyflags = key->flags;
3925
msg.keydata.keydata_val = key->data;
3926
msg.keydata.keydata_len = key->size;
3927
msg.datadlen = data->dlen;
3928
msg.datadoff = data->doff;
3929
msg.dataulen = data->ulen;
3930
msg.dataflags = data->flags;
3931
msg.datadata.datadata_val = data->data;
3932
msg.datadata.datadata_len = data->size;
3935
replyp = __db_dbc_get_4003(&msg, cl);
3936
if (replyp == NULL) {
3937
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
3941
ret = __dbcl_dbc_get_ret(dbc, key, data, flags, replyp);
3944
xdr_free((xdrproc_t)xdr___dbc_get_reply, (void *)replyp);
3949
* PUBLIC: int __dbcl_dbc_pget __P((DBC *, DBT *, DBT *, DBT *, u_int32_t));
3952
__dbcl_dbc_pget(dbc, skey, pkey, data, flags)
3961
__dbc_pget_reply *replyp = NULL;
3966
dbenv = dbc->dbp->dbenv;
3967
if (dbenv == NULL || !RPC_ON(dbenv))
3968
return (__dbcl_noserver(NULL));
3970
cl = (CLIENT *)dbenv->cl_handle;
3975
msg.dbccl_id = dbc->cl_id;
3976
msg.skeydlen = skey->dlen;
3977
msg.skeydoff = skey->doff;
3978
msg.skeyulen = skey->ulen;
3979
msg.skeyflags = skey->flags;
3980
msg.skeydata.skeydata_val = skey->data;
3981
msg.skeydata.skeydata_len = skey->size;
3982
msg.pkeydlen = pkey->dlen;
3983
msg.pkeydoff = pkey->doff;
3984
msg.pkeyulen = pkey->ulen;
3985
msg.pkeyflags = pkey->flags;
3986
msg.pkeydata.pkeydata_val = pkey->data;
3987
msg.pkeydata.pkeydata_len = pkey->size;
3988
msg.datadlen = data->dlen;
3989
msg.datadoff = data->doff;
3990
msg.dataulen = data->ulen;
3991
msg.dataflags = data->flags;
3992
msg.datadata.datadata_val = data->data;
3993
msg.datadata.datadata_len = data->size;
3996
replyp = __db_dbc_pget_4003(&msg, cl);
3997
if (replyp == NULL) {
3998
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
4002
ret = __dbcl_dbc_pget_ret(dbc, skey, pkey, data, flags, replyp);
4005
xdr_free((xdrproc_t)xdr___dbc_pget_reply, (void *)replyp);
4010
* PUBLIC: int __dbcl_dbc_put __P((DBC *, DBT *, DBT *, u_int32_t));
4013
__dbcl_dbc_put(dbc, key, data, flags)
4021
__dbc_put_reply *replyp = NULL;
4026
dbenv = dbc->dbp->dbenv;
4027
if (dbenv == NULL || !RPC_ON(dbenv))
4028
return (__dbcl_noserver(NULL));
4030
cl = (CLIENT *)dbenv->cl_handle;
4035
msg.dbccl_id = dbc->cl_id;
4036
msg.keydlen = key->dlen;
4037
msg.keydoff = key->doff;
4038
msg.keyulen = key->ulen;
4039
msg.keyflags = key->flags;
4040
msg.keydata.keydata_val = key->data;
4041
msg.keydata.keydata_len = key->size;
4042
msg.datadlen = data->dlen;
4043
msg.datadoff = data->doff;
4044
msg.dataulen = data->ulen;
4045
msg.dataflags = data->flags;
4046
msg.datadata.datadata_val = data->data;
4047
msg.datadata.datadata_len = data->size;
4050
replyp = __db_dbc_put_4003(&msg, cl);
4051
if (replyp == NULL) {
4052
__db_err(dbenv, clnt_sperror(cl, "Berkeley DB"));
4056
ret = __dbcl_dbc_put_ret(dbc, key, data, flags, replyp);
4059
xdr_free((xdrproc_t)xdr___dbc_put_reply, (void *)replyp);
4064
* PUBLIC: int __dbcl_lock_detect __P((DB_ENV *, u_int32_t, u_int32_t, int *));
4067
__dbcl_lock_detect(dbenv, flags, atype, aborted)
4073
COMPQUIET(flags, 0);
4074
COMPQUIET(atype, 0);
4075
COMPQUIET(aborted, 0);
4076
return (__dbcl_rpc_illegal(dbenv, "lock_detect"));
4080
* PUBLIC: int __dbcl_lock_get __P((DB_ENV *, u_int32_t, u_int32_t,
4081
* PUBLIC: const DBT *, db_lockmode_t, DB_LOCK *));
4084
__dbcl_lock_get(dbenv, locker, flags, obj, mode, lock)
4092
COMPQUIET(locker, 0);
4093
COMPQUIET(flags, 0);
4094
COMPQUIET(obj, NULL);
4097
return (__dbcl_rpc_illegal(dbenv, "lock_get"));
4101
* PUBLIC: int __dbcl_lock_id __P((DB_ENV *, u_int32_t *));
4104
__dbcl_lock_id(dbenv, idp)
4109
return (__dbcl_rpc_illegal(dbenv, "lock_id"));
4113
* PUBLIC: int __dbcl_lock_id_free __P((DB_ENV *, u_int32_t));
4116
__dbcl_lock_id_free(dbenv, id)
4121
return (__dbcl_rpc_illegal(dbenv, "lock_id_free"));
4125
* PUBLIC: int __dbcl_lock_put __P((DB_ENV *, DB_LOCK *));
4128
__dbcl_lock_put(dbenv, lock)
4133
return (__dbcl_rpc_illegal(dbenv, "lock_put"));
4137
* PUBLIC: int __dbcl_lock_stat __P((DB_ENV *, DB_LOCK_STAT **, u_int32_t));
4140
__dbcl_lock_stat(dbenv, statp, flags)
4142
DB_LOCK_STAT ** statp;
4145
COMPQUIET(statp, 0);
4146
COMPQUIET(flags, 0);
4147
return (__dbcl_rpc_illegal(dbenv, "lock_stat"));
4151
* PUBLIC: int __dbcl_lock_vec __P((DB_ENV *, u_int32_t, u_int32_t,
4152
* PUBLIC: DB_LOCKREQ *, int, DB_LOCKREQ **));
4155
__dbcl_lock_vec(dbenv, locker, flags, list, nlist, elistp)
4161
DB_LOCKREQ ** elistp;
4163
COMPQUIET(locker, 0);
4164
COMPQUIET(flags, 0);
4166
COMPQUIET(nlist, 0);
4167
COMPQUIET(elistp, 0);
4168
return (__dbcl_rpc_illegal(dbenv, "lock_vec"));
4172
* PUBLIC: int __dbcl_log_archive __P((DB_ENV *, char ***, u_int32_t));
4175
__dbcl_log_archive(dbenv, listp, flags)
4180
COMPQUIET(listp, 0);
4181
COMPQUIET(flags, 0);
4182
return (__dbcl_rpc_illegal(dbenv, "log_archive"));
4186
* PUBLIC: int __dbcl_log_cursor __P((DB_ENV *, DB_LOGC **, u_int32_t));
4189
__dbcl_log_cursor(dbenv, logcp, flags)
4194
COMPQUIET(logcp, 0);
4195
COMPQUIET(flags, 0);
4196
return (__dbcl_rpc_illegal(dbenv, "log_cursor"));
4200
* PUBLIC: int __dbcl_log_file __P((DB_ENV *, const DB_LSN *, char *, size_t));
4203
__dbcl_log_file(dbenv, lsn, namep, len)
4209
COMPQUIET(lsn, NULL);
4210
COMPQUIET(namep, NULL);
4212
return (__dbcl_rpc_illegal(dbenv, "log_file"));
4216
* PUBLIC: int __dbcl_log_flush __P((DB_ENV *, const DB_LSN *));
4219
__dbcl_log_flush(dbenv, lsn)
4223
COMPQUIET(lsn, NULL);
4224
return (__dbcl_rpc_illegal(dbenv, "log_flush"));
4228
* PUBLIC: int __dbcl_log_put __P((DB_ENV *, DB_LSN *, const DBT *,
4229
* PUBLIC: u_int32_t));
4232
__dbcl_log_put(dbenv, lsn, data, flags)
4239
COMPQUIET(data, NULL);
4240
COMPQUIET(flags, 0);
4241
return (__dbcl_rpc_illegal(dbenv, "log_put"));
4245
* PUBLIC: int __dbcl_log_stat __P((DB_ENV *, DB_LOG_STAT **, u_int32_t));
4248
__dbcl_log_stat(dbenv, statp, flags)
4250
DB_LOG_STAT ** statp;
4253
COMPQUIET(statp, 0);
4254
COMPQUIET(flags, 0);
4255
return (__dbcl_rpc_illegal(dbenv, "log_stat"));
4259
* PUBLIC: int __dbcl_memp_register __P((DB_ENV *, int, int (*)(DB_ENV *,
4260
* PUBLIC: db_pgno_t, void *, DBT *), int (*)(DB_ENV *, db_pgno_t, void *, DBT *)));
4263
__dbcl_memp_register(dbenv, ftype, func0, func1)
4266
int (*func0) __P((DB_ENV *, db_pgno_t, void *, DBT *));
4267
int (*func1) __P((DB_ENV *, db_pgno_t, void *, DBT *));
4269
COMPQUIET(ftype, 0);
4270
COMPQUIET(func0, 0);
4271
COMPQUIET(func1, 0);
4272
return (__dbcl_rpc_illegal(dbenv, "memp_register"));
4276
* PUBLIC: int __dbcl_memp_stat __P((DB_ENV *, DB_MPOOL_STAT **,
4277
* PUBLIC: DB_MPOOL_FSTAT ***, u_int32_t));
4280
__dbcl_memp_stat(dbenv, gstatp, fstatp, flags)
4282
DB_MPOOL_STAT ** gstatp;
4283
DB_MPOOL_FSTAT *** fstatp;
4286
COMPQUIET(gstatp, 0);
4287
COMPQUIET(fstatp, 0);
4288
COMPQUIET(flags, 0);
4289
return (__dbcl_rpc_illegal(dbenv, "memp_stat"));
4293
* PUBLIC: int __dbcl_memp_sync __P((DB_ENV *, DB_LSN *));
4296
__dbcl_memp_sync(dbenv, lsn)
4301
return (__dbcl_rpc_illegal(dbenv, "memp_sync"));
4305
* PUBLIC: int __dbcl_memp_trickle __P((DB_ENV *, int, int *));
4308
__dbcl_memp_trickle(dbenv, pct, nwrotep)
4314
COMPQUIET(nwrotep, 0);
4315
return (__dbcl_rpc_illegal(dbenv, "memp_trickle"));
4319
* PUBLIC: int __dbcl_memp_fget __P((DB_MPOOLFILE *, u_int32_t *, u_int32_t,
4323
__dbcl_memp_fget(dbmfp, pgnoaddr, flags, addrp)
4324
DB_MPOOLFILE * dbmfp;
4325
u_int32_t * pgnoaddr;
4331
dbenv = dbmfp->dbenv;
4332
COMPQUIET(pgnoaddr, 0);
4333
COMPQUIET(flags, 0);
4334
COMPQUIET(addrp, 0);
4335
return (__dbcl_rpc_illegal(dbenv, "memp_fget"));
4339
* PUBLIC: int __dbcl_memp_fopen __P((DB_MPOOLFILE *, const char *, u_int32_t,
4340
* PUBLIC: int, size_t));
4343
__dbcl_memp_fopen(dbmfp, path, flags, mode, pagesize)
4344
DB_MPOOLFILE * dbmfp;
4352
dbenv = dbmfp->dbenv;
4354
COMPQUIET(flags, 0);
4356
COMPQUIET(pagesize, 0);
4357
return (__dbcl_rpc_illegal(dbenv, "memp_fopen"));
4361
* PUBLIC: int __dbcl_memp_fput __P((DB_MPOOLFILE *, void *, u_int32_t));
4364
__dbcl_memp_fput(dbmfp, pgaddr, flags)
4365
DB_MPOOLFILE * dbmfp;
4371
dbenv = dbmfp->dbenv;
4372
COMPQUIET(pgaddr, 0);
4373
COMPQUIET(flags, 0);
4374
return (__dbcl_rpc_illegal(dbenv, "memp_fput"));
4378
* PUBLIC: int __dbcl_memp_fset __P((DB_MPOOLFILE *, void *, u_int32_t));
4381
__dbcl_memp_fset(dbmfp, pgaddr, flags)
4382
DB_MPOOLFILE * dbmfp;
4388
dbenv = dbmfp->dbenv;
4389
COMPQUIET(pgaddr, 0);
4390
COMPQUIET(flags, 0);
4391
return (__dbcl_rpc_illegal(dbenv, "memp_fset"));
4395
* PUBLIC: int __dbcl_memp_get_clear_len __P((DB_MPOOLFILE *, u_int32_t *));
4398
__dbcl_memp_get_clear_len(dbmfp, clear_lenp)
4399
DB_MPOOLFILE * dbmfp;
4400
u_int32_t * clear_lenp;
4404
dbenv = dbmfp->dbenv;
4405
COMPQUIET(clear_lenp, 0);
4406
return (__dbcl_rpc_illegal(dbenv, "memp_get_clear_len"));
4410
* PUBLIC: int __dbcl_memp_set_clear_len __P((DB_MPOOLFILE *, u_int32_t));
4413
__dbcl_memp_set_clear_len(dbmfp, clear_len)
4414
DB_MPOOLFILE * dbmfp;
4415
u_int32_t clear_len;
4419
dbenv = dbmfp->dbenv;
4420
COMPQUIET(clear_len, 0);
4421
return (__dbcl_rpc_illegal(dbenv, "memp_set_clear_len"));
4425
* PUBLIC: int __dbcl_memp_get_fileid __P((DB_MPOOLFILE *, u_int8_t *));
4428
__dbcl_memp_get_fileid(dbmfp, fileid)
4429
DB_MPOOLFILE * dbmfp;
4434
dbenv = dbmfp->dbenv;
4435
COMPQUIET(fileid, 0);
4436
return (__dbcl_rpc_illegal(dbenv, "memp_get_fileid"));
4440
* PUBLIC: int __dbcl_memp_set_fileid __P((DB_MPOOLFILE *, u_int8_t *));
4443
__dbcl_memp_set_fileid(dbmfp, fileid)
4444
DB_MPOOLFILE * dbmfp;
4449
dbenv = dbmfp->dbenv;
4450
COMPQUIET(fileid, 0);
4451
return (__dbcl_rpc_illegal(dbenv, "memp_set_fileid"));
4455
* PUBLIC: int __dbcl_memp_get_flags __P((DB_MPOOLFILE *, u_int32_t *));
4458
__dbcl_memp_get_flags(dbmfp, flagsp)
4459
DB_MPOOLFILE * dbmfp;
4464
dbenv = dbmfp->dbenv;
4465
COMPQUIET(flagsp, 0);
4466
return (__dbcl_rpc_illegal(dbenv, "memp_get_flags"));
4470
* PUBLIC: int __dbcl_memp_set_flags __P((DB_MPOOLFILE *, u_int32_t, int));
4473
__dbcl_memp_set_flags(dbmfp, flags, onoff)
4474
DB_MPOOLFILE * dbmfp;
4480
dbenv = dbmfp->dbenv;
4481
COMPQUIET(flags, 0);
4482
COMPQUIET(onoff, 0);
4483
return (__dbcl_rpc_illegal(dbenv, "memp_set_flags"));
4487
* PUBLIC: int __dbcl_memp_get_ftype __P((DB_MPOOLFILE *, int *));
4490
__dbcl_memp_get_ftype(dbmfp, ftype)
4491
DB_MPOOLFILE * dbmfp;
4496
dbenv = dbmfp->dbenv;
4497
COMPQUIET(ftype, 0);
4498
return (__dbcl_rpc_illegal(dbenv, "memp_get_ftype"));
4502
* PUBLIC: int __dbcl_memp_set_ftype __P((DB_MPOOLFILE *, int));
4505
__dbcl_memp_set_ftype(dbmfp, ftype)
4506
DB_MPOOLFILE * dbmfp;
4511
dbenv = dbmfp->dbenv;
4512
COMPQUIET(ftype, 0);
4513
return (__dbcl_rpc_illegal(dbenv, "memp_set_ftype"));
4517
* PUBLIC: int __dbcl_memp_get_lsn_offset __P((DB_MPOOLFILE *, int32_t *));
4520
__dbcl_memp_get_lsn_offset(dbmfp, lsn_offsetp)
4521
DB_MPOOLFILE * dbmfp;
4522
int32_t * lsn_offsetp;
4526
dbenv = dbmfp->dbenv;
4527
COMPQUIET(lsn_offsetp, 0);
4528
return (__dbcl_rpc_illegal(dbenv, "memp_get_lsn_offset"));
4532
* PUBLIC: int __dbcl_memp_set_lsn_offset __P((DB_MPOOLFILE *, int32_t));
4535
__dbcl_memp_set_lsn_offset(dbmfp, lsn_offset)
4536
DB_MPOOLFILE * dbmfp;
4541
dbenv = dbmfp->dbenv;
4542
COMPQUIET(lsn_offset, 0);
4543
return (__dbcl_rpc_illegal(dbenv, "memp_set_lsn_offset"));
4547
* PUBLIC: int __dbcl_memp_get_maxsize __P((DB_MPOOLFILE *, u_int32_t *,
4548
* PUBLIC: u_int32_t *));
4551
__dbcl_memp_get_maxsize(dbmfp, gbytesp, bytesp)
4552
DB_MPOOLFILE * dbmfp;
4553
u_int32_t * gbytesp;
4558
dbenv = dbmfp->dbenv;
4559
COMPQUIET(gbytesp, 0);
4560
COMPQUIET(bytesp, 0);
4561
return (__dbcl_rpc_illegal(dbenv, "memp_get_maxsize"));
4565
* PUBLIC: int __dbcl_memp_set_maxsize __P((DB_MPOOLFILE *, u_int32_t,
4566
* PUBLIC: u_int32_t));
4569
__dbcl_memp_set_maxsize(dbmfp, gbytes, bytes)
4570
DB_MPOOLFILE * dbmfp;
4576
dbenv = dbmfp->dbenv;
4577
COMPQUIET(gbytes, 0);
4578
COMPQUIET(bytes, 0);
4579
return (__dbcl_rpc_illegal(dbenv, "memp_set_maxsize"));
4583
* PUBLIC: int __dbcl_memp_get_pgcookie __P((DB_MPOOLFILE *, DBT *));
4586
__dbcl_memp_get_pgcookie(dbmfp, pgcookie)
4587
DB_MPOOLFILE * dbmfp;
4592
dbenv = dbmfp->dbenv;
4593
COMPQUIET(pgcookie, 0);
4594
return (__dbcl_rpc_illegal(dbenv, "memp_get_pgcookie"));
4598
* PUBLIC: int __dbcl_memp_set_pgcookie __P((DB_MPOOLFILE *, DBT *));
4601
__dbcl_memp_set_pgcookie(dbmfp, pgcookie)
4602
DB_MPOOLFILE * dbmfp;
4607
dbenv = dbmfp->dbenv;
4608
COMPQUIET(pgcookie, 0);
4609
return (__dbcl_rpc_illegal(dbenv, "memp_set_pgcookie"));
4613
* PUBLIC: int __dbcl_memp_get_priority __P((DB_MPOOLFILE *,
4614
* PUBLIC: DB_CACHE_PRIORITY *));
4617
__dbcl_memp_get_priority(dbmfp, priorityp)
4618
DB_MPOOLFILE * dbmfp;
4619
DB_CACHE_PRIORITY * priorityp;
4623
dbenv = dbmfp->dbenv;
4624
COMPQUIET(priorityp, 0);
4625
return (__dbcl_rpc_illegal(dbenv, "memp_get_priority"));
4629
* PUBLIC: int __dbcl_memp_set_priority __P((DB_MPOOLFILE *,
4630
* PUBLIC: DB_CACHE_PRIORITY));
4633
__dbcl_memp_set_priority(dbmfp, priority)
4634
DB_MPOOLFILE * dbmfp;
4635
DB_CACHE_PRIORITY priority;
4639
dbenv = dbmfp->dbenv;
4640
COMPQUIET(priority, 0);
4641
return (__dbcl_rpc_illegal(dbenv, "memp_set_priority"));
4645
* PUBLIC: int __dbcl_memp_fsync __P((DB_MPOOLFILE *));
4648
__dbcl_memp_fsync(dbmfp)
4649
DB_MPOOLFILE * dbmfp;
4653
dbenv = dbmfp->dbenv;
4654
return (__dbcl_rpc_illegal(dbenv, "memp_fsync"));