cde/lib/tt/lib/db/db_server_clnt.C

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 //%%  (c) Copyright 1993, 1994 Hewlett-Packard Company
  24 //%%  (c) Copyright 1993, 1994 International Business Machines Corp.
  25 //%%  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
  26 //%%  (c) Copyright 1993, 1994 Novell, Inc.
  27 //%%  $XConsortium: db_server_clnt.C /main/5 1995/11/28 19:25:18 cde-sun $
  28 /*
  29  * @(#)db_server_clnt.C 1.24 95/01/18
  30  *
  31  * Tool Talk Database Server - db_server_clnt.cc
  32  *
  33  * Copyright (c) 1992 by Sun Microsystems, Inc.
  34  *
  35  * This file contains the client side interface procedure for the db server.
  36  */
  37
  38 #include <rpc/rpc.h>
  39 #include <sys/time.h>
  40 #include <stdlib.h>
  41 #include <memory.h>
  42 #include "tt_options.h"
  43 #include "db/db_server.h"
  44 #include "db/tt_db_results.h"
  45
  46 // DM_ERROR is a fossil from the old v1.0 database server code.
  47 // As far as I can tell it just needs to not be zero (i.e. not TT_OK).
  48 // rfm 8/26/94
  49
  50 #define DM_ERROR 1
  51
  52 /* Default timeout can be changed using clnt_control() */
  53 static const struct timeval TIMEOUT = { 120, 0 };
  54 static _Tt_isam_results res;
  55 static clnt_stat rpc_result;
  56
  57 int *
  58 _tt_min_auth_level_1(char **argp, CLIENT *clnt, clnt_stat *result)
  59 {
  60         static int res;
  61
  62         memset((char *)&res, 0, sizeof(res));
  63         *result = clnt_call(clnt, _TT_MIN_AUTH_LEVEL,
  64                             (xdrproc_t)xdr_wrapstring, (caddr_t) argp,
  65                             (xdrproc_t)xdr_int, (caddr_t) &res,
  66                             TIMEOUT);
  67         switch (*result) {
  68               case RPC_SUCCESS:
  69                 return (&res);
  70               case RPC_TIMEDOUT:
  71                 // caller handles timeouts specially.
  72                 return (NULL);
  73               default:
  74 /*
  75  *              clnt_perror(clnt,"_tt_min_auth_level_1");
  76  */
  77                 return (NULL);
  78         }
  79 }
  80
  81 _Tt_isam_results *
  82 _tt_isaddindex_1(_Tt_isaddindex_args *argp, CLIENT *clnt)
  83 {
  84         memset((char *)&res, 0, sizeof(res));
  85         clnt_stat result = clnt_call(clnt, _TT_ISADDINDEX,
  86                                      (xdrproc_t)xdr_Tt_isaddindex_args,
  87                                      (caddr_t) argp,
  88                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
  89                                      TIMEOUT);
  90         switch (result) {
  91               case RPC_SUCCESS:
  92                 return (&res);
  93               default:
  94 /*
  95  *              clnt_perror(clnt,"_tt_isaddindex_1:");
  96  */
  97                 return (NULL);
  98         }
  99
 100 }
 101
 102 _Tt_isam_results *
 103 _tt_isbuild_1(_Tt_isbuild_args *argp, CLIENT *clnt)
 104 {
 105         memset((char *)&res, 0, sizeof(res));
 106         clnt_stat result = clnt_call(clnt, _TT_ISBUILD,
 107                                      (xdrproc_t)xdr_Tt_isbuild_args, (caddr_t) argp,
 108                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 109                                      TIMEOUT);
 110         switch (result) {
 111               case RPC_SUCCESS:
 112                 return (&res);
 113               default:
 114 /*
 115  *              clnt_perror(clnt,"_tt_isbuild_1:");
 116  */
 117                 return (NULL);
 118         }
 119
 120 }
 121
 122 _Tt_isam_results *
 123 _tt_isclose_1(int *argp, CLIENT *clnt)
 124 {
 125         memset((char *)&res, 0, sizeof(res));
 126         clnt_stat result = clnt_call(clnt, _TT_ISCLOSE,
 127                                      (xdrproc_t)xdr_int, (caddr_t) argp,
 128                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 129                                      TIMEOUT);
 130         switch (result) {
 131               case RPC_SUCCESS:
 132                 return (&res);
 133               default:
 134 /*
 135  *              clnt_perror(clnt,"_tt_isclose_1:");
 136  */
 137                 return (NULL);
 138         }
 139 }
 140
 141 _Tt_iscntl_results *
 142 _tt_iscntl_1(_Tt_iscntl_args *argp, CLIENT *clnt)
 143 {
 144         static _Tt_iscntl_results res;
 145
 146         memset((char *)&res, 0, sizeof(res));
 147         clnt_stat result = clnt_call(clnt, _TT_ISCNTL,
 148                                      (xdrproc_t)xdr_Tt_iscntl_args, (caddr_t) argp,
 149                                      (xdrproc_t)xdr_Tt_iscntl_results,
 150                                      (caddr_t) &res,
 151                                      TIMEOUT);
 152         switch (result) {
 153               case RPC_SUCCESS:
 154                 return (&res);
 155               default:
 156 /*
 157  *              clnt_perror(clnt,"_tt_iscntl_1:");
 158  */
 159                 return (NULL);
 160         }
 161 }
 162
 163 _Tt_isam_results *
 164 _tt_isdelrec_1(_Tt_isdelrec_args *argp, CLIENT *clnt)
 165 {
 166         memset((char *)&res, 0, sizeof(res));
 167         clnt_stat result = clnt_call(clnt, _TT_ISDELREC,
 168                                      (xdrproc_t)xdr_Tt_isdelrec_args,
 169                                      (caddr_t) argp,
 170                                      (xdrproc_t)xdr_Tt_isam_results,
 171                                      (caddr_t) &res,
 172                                      TIMEOUT);
 173         switch (result) {
 174               case RPC_SUCCESS:
 175                 return (&res);
 176               default:
 177 /*
 178  *              clnt_perror(clnt,"_tt_isdelrec_1:");
 179  */
 180                 return (NULL);
 181         }
 182 }
 183
 184 _Tt_isam_results *
 185 _tt_iserase_1(char **argp, CLIENT *clnt)
 186 {
 187         memset((char *)&res, 0, sizeof(res));
 188         clnt_stat result = clnt_call(clnt, _TT_ISERASE,
 189                                      (xdrproc_t)xdr_wrapstring, (caddr_t) argp,
 190                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 191                                      TIMEOUT);
 192         switch (result) {
 193               case RPC_SUCCESS:
 194                 return (&res);
 195               default:
 196 /*
 197  *              clnt_perror(clnt,"_tt_iserase_1:");
 198  */
 199                 return (NULL);
 200         }
 201 }
 202
 203 _Tt_isam_results *
 204 _tt_isopen_1(_Tt_isopen_args *argp, CLIENT *clnt)
 205 {
 206         memset((char *)&res, 0, sizeof(res));
 207         clnt_stat result = clnt_call(clnt, _TT_ISOPEN,
 208                                      (xdrproc_t)xdr_Tt_isopen_args, (caddr_t) argp,
 209                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 210                                      TIMEOUT);
 211         switch (result) {
 212               case RPC_SUCCESS:
 213                 return (&res);
 214               default:
 215 /*
 216  *              clnt_perror(clnt,"_tt_isopen_1:");
 217  */
 218                 return (NULL);
 219         }
 220 }
 221
 222
 223 _Tt_isread_results *
 224 _tt_isread_1(_Tt_isread_args *argp, CLIENT *clnt)
 225 {
 226         static _Tt_isread_results res;
 227
 228         memset((char *)&res, 0, sizeof(res));
 229         clnt_stat result = clnt_call(clnt, _TT_ISREAD,
 230                                      (xdrproc_t)xdr_Tt_isread_args,
 231                                      (caddr_t) argp,
 232                                      (xdrproc_t)xdr_Tt_isread_results,
 233                                      (caddr_t) &res,
 234                                      TIMEOUT);
 235         switch (result) {
 236               case RPC_SUCCESS:
 237                 return (&res);
 238               default:
 239 /*
 240  *              clnt_perror(clnt,"_tt_isread_1");
 241  */
 242                 return (NULL);
 243         }
 244 }
 245
 246 _Tt_isam_results *
 247 _tt_isrewrec_1(_Tt_isrewrec_args *argp, CLIENT *clnt)
 248 {
 249         memset((char *)&res, 0, sizeof(res));
 250         clnt_stat result = clnt_call(clnt, _TT_ISREWREC,
 251                                      (xdrproc_t)xdr_Tt_isrewrec_args,
 252                                      (caddr_t) argp,
 253                                      (xdrproc_t)xdr_Tt_isam_results,
 254                                      (caddr_t) &res,
 255                                      TIMEOUT);
 256         switch (result) {
 257               case RPC_SUCCESS:
 258                 return (&res);
 259               default:
 260 /*
 261  *              clnt_perror(clnt,"_tt_isrewrec_1");
 262  */
 263                 return (NULL);
 264         }
 265 }
 266
 267 _Tt_isam_results *
 268 _tt_isstart_1(_Tt_isstart_args *argp, CLIENT *clnt)
 269 {
 270         memset((char *)&res, 0, sizeof(res));
 271         clnt_stat result = clnt_call(clnt, _TT_ISSTART,
 272                                      (xdrproc_t)xdr_Tt_isstart_args, (caddr_t) argp,
 273                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 274                                      TIMEOUT);
 275         switch (result) {
 276               case RPC_SUCCESS:
 277                 return (&res);
 278               default:
 279 /*
 280  *              clnt_perror(clnt,"_tt_isstart_1");
 281  */
 282                 return (NULL);
 283         }
 284 }
 285
 286 _Tt_isam_results *
 287 _tt_iswrite_1(_Tt_iswrite_args *argp, CLIENT *clnt)
 288 {
 289         memset((char *)&res, 0, sizeof(res));
 290         clnt_stat result = clnt_call(clnt, _TT_ISWRITE,
 291                                      (xdrproc_t)xdr_Tt_iswrite_args, (caddr_t) argp,
 292                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 293                                      TIMEOUT);
 294         switch (result) {
 295               case RPC_SUCCESS:
 296                 return (&res);
 297               default:
 298 /*
 299  *              clnt_perror(clnt,"_tt_iswrite_1:");
 300  */
 301                 return (NULL);
 302         }
 303 }
 304
 305 _Tt_test_and_set_results *
 306 _tt_test_and_set_1(_Tt_test_and_set_args *argp, CLIENT *clnt)
 307 {
 308         static _Tt_test_and_set_results res;
 309
 310         memset((char *)&res, 0, sizeof(res));
 311         clnt_stat result = clnt_call(clnt, _TT_TEST_AND_SET,
 312                                      (xdrproc_t)xdr_Tt_test_and_set_args,
 313                                      (caddr_t) argp,
 314                                      (xdrproc_t)xdr_Tt_test_and_set_results,
 315                                      (caddr_t) &res, TIMEOUT);
 316         switch (result) {
 317               case RPC_SUCCESS:
 318                 return (&res);
 319               default:
 320 /*
 321  *              clnt_perror(clnt,"_tt_test_and_set_1:");
 322  */
 323                 return (NULL);
 324         }
 325
 326 }
 327
 328 _Tt_isam_results *
 329 _tt_transaction_1(_Tt_transaction_args *argp, CLIENT *clnt)
 330 {
 331         memset((char *)&res, 0, sizeof(res));
 332         clnt_stat result = clnt_call(clnt, _TT_TRANSACTION,
 333                                      (xdrproc_t)xdr_Tt_transaction_args,
 334                                      (caddr_t) argp,
 335                                      (xdrproc_t)xdr_Tt_isam_results,
 336                                      (caddr_t) &res,
 337                                      TIMEOUT);
 338         switch (result) {
 339               case RPC_SUCCESS:
 340                 return (&res);
 341               default:
 342 /*
 343  *              clnt_perror(clnt,"_tt_transaction_1:");
 344  */
 345                 return (NULL);
 346         }
 347 }
 348
 349
 350 /*
 351  * _tt_mfs_1()
 352  *      If the (char *) pointed at by the return value is non-null,
 353  *      the caller has to free it via
 354  *      xdr_free((xdrproc_t)xdr_wrapstring, *<return_val>).
 355  */
 356 char **
 357 _tt_mfs_1(char **argp,  CLIENT *clnt)
 358 {
 359         static char *res;
 360         res = 0;
 361         clnt_stat result = clnt_call(clnt, _TT_MFS,
 362                                      (xdrproc_t)xdr_wrapstring, (caddr_t) argp,
 363                                      (xdrproc_t)xdr_wrapstring, (caddr_t) &res,
 364                                      TIMEOUT);
 365         switch (result) {
 366               case RPC_SUCCESS:
 367                 return (&res);
 368               default:
 369 /*
 370  *              clnt_perror(clnt,"_tt_mfs_1:");
 371  */
 372                 return (NULL);
 373         }
 374 }
 375
 376 _Tt_oidaccess_results *
 377 _tt_getoidaccess_1(_Tt_oidaccess_args *argp, CLIENT *clnt)
 378 {
 379         static _Tt_oidaccess_results res;
 380
 381         memset((char *)&res, 0, sizeof(res));
 382         clnt_stat result = clnt_call(clnt, _TT_GETOIDACCESS,
 383                                      (xdrproc_t)xdr_Tt_oidaccess_args,
 384                                      (caddr_t) argp,
 385                                      (xdrproc_t)xdr_Tt_oidaccess_results,
 386                                      (caddr_t) &res,
 387                                      TIMEOUT);
 388         switch (result) {
 389               case RPC_SUCCESS:
 390                 return (&res);
 391               default:
 392 /*
 393  *              clnt_perror(clnt,"_tt_getoiduser:");
 394  */
 395                 res.result = DM_ERROR;
 396                 res.iserrno = 0;
 397                 res.uid = 65534; // nobody.  Can't find a system define..
 398                 return (&res);
 399         }
 400 }
 401
 402 _Tt_isam_results *
 403 _tt_setoiduser_1(_Tt_oidaccess_args *argp, CLIENT *clnt)
 404 {
 405         memset((char *)&res, 0, sizeof(res));
 406         clnt_stat result = clnt_call(clnt, _TT_SETOIDUSER,
 407                                      (xdrproc_t)xdr_Tt_oidaccess_args,
 408                                      (caddr_t) argp,
 409                                      (xdrproc_t)xdr_Tt_isam_results,
 410                                      (caddr_t) &res,
 411                                      TIMEOUT);
 412         switch (result) {
 413               case RPC_SUCCESS:
 414                 return (&res);
 415               default:
 416 /*
 417  *              clnt_perror(clnt,"_tt_setoiduser:");
 418  */
 419                 res.result = DM_ERROR;
 420                 res.iserrno = 0;
 421                 return (&res);
 422         }
 423 }
 424
 425 _Tt_isam_results *
 426 _tt_setoidgroup_1(_Tt_oidaccess_args *argp, CLIENT *clnt)
 427 {
 428         memset((char *)&res, 0, sizeof(res));
 429         clnt_stat result = clnt_call(clnt, _TT_SETOIDGROUP,
 430                                      (xdrproc_t)xdr_Tt_oidaccess_args,
 431                                      (caddr_t) argp,
 432                                      (xdrproc_t)xdr_Tt_isam_results,
 433                                      (caddr_t) &res,
 434                                      TIMEOUT);
 435         switch (result) {
 436               case RPC_SUCCESS:
 437                 return (&res);
 438               default:
 439 /*
 440  *              clnt_perror(clnt,"_tt_setoidgroup:");
 441  */
 442                 res.result = DM_ERROR;
 443                 res.iserrno = 0;
 444                 return (&res);
 445         }
 446 }
 447
 448 _Tt_isam_results *
 449 _tt_setoidmode_1(_Tt_oidaccess_args *argp, CLIENT *clnt)
 450 {
 451         memset((char *)&res, 0, sizeof(res));
 452         clnt_stat result = clnt_call(clnt, _TT_SETOIDMODE,
 453                                      (xdrproc_t)xdr_Tt_oidaccess_args,
 454                                      (caddr_t) argp,
 455                                      (xdrproc_t)xdr_Tt_isam_results,
 456                                      (caddr_t) &res,
 457                                      TIMEOUT);
 458         switch (result) {
 459               case RPC_SUCCESS:
 460                 return (&res);
 461               default:
 462 /*
 463  *              clnt_perror(clnt,"_tt_setoidmode:");
 464  */
 465                 res.result = DM_ERROR;
 466                 res.iserrno = 0;
 467                 return (&res);
 468         }
 469 }
 470
 471 _Tt_isam_results *
 472 _tt_addsession_1(_Tt_session_args *argp, CLIENT *clnt)
 473 {
 474         memset((char *)&res, 0, sizeof(res));
 475         clnt_stat result = clnt_call(clnt, _TT_ADDSESSION,
 476                                      (xdrproc_t)xdr_Tt_session_args, (caddr_t) argp,
 477                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 478                                      TIMEOUT);
 479         switch (result) {
 480               case RPC_SUCCESS:
 481                 return (&res);
 482               default:
 483 /*
 484  *              clnt_perror(clnt,"_tt_addsession:");
 485  */
 486                 res.result = DM_ERROR;
 487                 res.iserrno = 0;
 488                 return (&res);
 489         }
 490 }
 491
 492 _Tt_isam_results *
 493 _tt_delsession_1(_Tt_session_args *argp, CLIENT *clnt)
 494 {
 495         memset((char *)&res, 0, sizeof(res));
 496         clnt_stat result = clnt_call(clnt, _TT_DELSESSION,
 497                                      (xdrproc_t)xdr_Tt_session_args, (caddr_t) argp,
 498                                      (xdrproc_t)xdr_Tt_isam_results, (caddr_t) &res,
 499                                      TIMEOUT);
 500         switch (result) {
 501               case RPC_SUCCESS:
 502                 return (&res);
 503               default:
 504 /*
 505  *              clnt_perror(clnt,"_tt_delsession:");
 506  */
 507                 res.result = DM_ERROR;
 508                 res.iserrno = 0;
 509                 return (&res);
 510         }
 511 }
 512
 513
 514 _Tt_spec_props *
 515 _tt_gettype_1(_Tt_spec_props *argp, CLIENT *clnt)
 516 {
 517         static _Tt_spec_props res;
 518
 519         memset((char *)&res, 0, sizeof(res));
 520         clnt_stat result = clnt_call(clnt, _TT_GETTYPE,
 521                                      (xdrproc_t)xdr_Tt_spec_props, (caddr_t) argp,
 522                                      (xdrproc_t)xdr_Tt_spec_props, (caddr_t) &res,
 523                                      TIMEOUT);
 524         switch (result) {
 525               case RPC_SUCCESS:
 526                 return (&res);
 527               default:
 528 /*
 529  *              clnt_perror(clnt,"_tt_gettype:");
 530  */
 531                 res.result = DM_ERROR;
 532                 res.iserrno = 0;
 533                 return (&res);
 534         }
 535 }
 536
 537 clnt_stat _tt_get_rpc_result()
 538 {
 539         return rpc_result;
 540 }
 541
 542 _tt_auth_level_results *
 543 _tt_get_min_auth_level_1(void *argp, CLIENT *clnt)
 544 {
 545         static _tt_auth_level_results res;
 546
 547         memset((void *)&res, '\0', sizeof(res));
 548         clnt_stat result = clnt_call(clnt, TT_GET_MIN_AUTH_LEVEL,
 549                                      (xdrproc_t) xdr_void, (caddr_t) argp,
 550                                      (xdrproc_t) xdr_tt_auth_level_results,
 551                                      (caddr_t) &res, TIMEOUT);
 552         if (result != RPC_SUCCESS) {
 553                 rpc_result = result;
 554                 return (NULL);
 555         }
 556         return (&res);
 557 }
 558
 559 _tt_file_partition_results *
 560 _tt_get_file_partition_1(char **argp, CLIENT *clnt)
 561 {
 562         static _tt_file_partition_results res;
 563
 564         memset((void *)&res, '\0', sizeof(res));
 565         clnt_stat result = clnt_call(clnt, TT_GET_FILE_PARTITION,
 566                                      (xdrproc_t) xdr_wrapstring,
 567                                      (caddr_t) argp,
 568                                      (xdrproc_t) xdr_tt_file_partition_results,
 569                                      (caddr_t) &res, TIMEOUT);
 570         if (result != RPC_SUCCESS) {
 571                 return (NULL);
 572         }
 573         return (&res);
 574 }
 575
 576 _tt_db_cache_results *
 577 _tt_create_file_1(_tt_create_file_args *argp, CLIENT *clnt)
 578 {
 579         static _tt_db_cache_results res;
 580
 581         memset((void *)&res, '\0', sizeof(res));
 582         clnt_stat result = clnt_call(clnt, TT_CREATE_FILE,
 583                                      (xdrproc_t) xdr_tt_create_file_args,
 584                                      (caddr_t) argp,
 585                                      (xdrproc_t) xdr_tt_db_cache_results,
 586                                      (caddr_t) &res, TIMEOUT);
 587         if (result != RPC_SUCCESS) {
 588                 return (NULL);
 589         }
 590         return (&res);
 591 }
 592
 593 _tt_db_cache_results *
 594 _tt_create_obj_1(_tt_create_obj_args *argp, CLIENT *clnt)
 595 {
 596         static _tt_db_cache_results res;
 597
 598         memset((void *)&res, '\0', sizeof(res));
 599         clnt_stat result = clnt_call(clnt, TT_CREATE_OBJ,
 600                                      (xdrproc_t) xdr_tt_create_obj_args,
 601                                      (caddr_t) argp,
 602                                      (xdrproc_t) xdr_tt_db_cache_results,
 603                                      (caddr_t) &res, TIMEOUT);
 604         if (result != RPC_SUCCESS) {
 605                 return (NULL);
 606         }
 607         return (&res);
 608 }
 609
 610 _tt_db_results *
 611 _tt_remove_file_1(_tt_remove_file_args *argp, CLIENT *clnt)
 612 {
 613         static _tt_db_results res;
 614
 615         memset((void *)&res, '\0', sizeof(res));
 616         clnt_stat result = clnt_call(clnt, TT_REMOVE_FILE,
 617                                      (xdrproc_t) xdr_tt_remove_file_args,
 618                                      (caddr_t) argp,
 619                                      (xdrproc_t) xdr_tt_db_results,
 620                                      (caddr_t) &res, TIMEOUT);
 621         if (result != RPC_SUCCESS) {
 622                 return (NULL);
 623         }
 624         return (&res);
 625 }
 626
 627 _tt_db_results *
 628 _tt_remove_obj_1(_tt_remove_obj_args *argp, CLIENT *clnt)
 629 {
 630         static _tt_db_results res;
 631
 632         memset((void *)&res, '\0', sizeof(res));
 633         clnt_stat result = clnt_call(clnt, TT_REMOVE_OBJ,
 634                                      (xdrproc_t) xdr_tt_remove_obj_args,
 635                                      (caddr_t) argp,
 636                                      (xdrproc_t) xdr_tt_db_results,
 637                                      (caddr_t) &res, TIMEOUT);
 638         if (result != RPC_SUCCESS) {
 639                 return (NULL);
 640         }
 641         return (&res);
 642 }
 643
 644 _tt_db_results *
 645 _tt_move_file_1(_tt_move_file_args *argp, CLIENT *clnt)
 646 {
 647         static _tt_db_results res;
 648
 649         memset((void *)&res, '\0', sizeof(res));
 650         clnt_stat result = clnt_call(clnt, TT_REMOVE_FILE,
 651                                      (xdrproc_t) xdr_tt_move_file_args,
 652                                      (caddr_t) argp,
 653                                      (xdrproc_t) xdr_tt_db_results,
 654                                      (caddr_t) &res, TIMEOUT);
 655         if (result != RPC_SUCCESS) {
 656                 return (NULL);
 657         }
 658         return (&res);
 659 }
 660
 661 _tt_db_cache_results *
 662 _tt_set_file_props_1(_tt_set_file_props_args *argp, CLIENT *clnt)
 663 {
 664         static _tt_db_cache_results res;
 665
 666         memset((void *)&res, '\0', sizeof(res));
 667         clnt_stat result = clnt_call(clnt, TT_SET_FILE_PROPS,
 668                                      (xdrproc_t) xdr_tt_set_file_props_args,
 669                                      (caddr_t) argp,
 670                                      (xdrproc_t) xdr_tt_db_cache_results,
 671                                      (caddr_t) &res, TIMEOUT);
 672         if (result != RPC_SUCCESS) {
 673                 return (NULL);
 674         }
 675         return (&res);
 676 }
 677
 678 _tt_db_cache_results *
 679 _tt_set_file_prop_1(_tt_set_file_prop_args *argp, CLIENT *clnt)
 680 {
 681         static _tt_db_cache_results res;
 682
 683         memset((void *)&res, '\0', sizeof(res));
 684         clnt_stat result = clnt_call(clnt, TT_SET_FILE_PROP,
 685                                      (xdrproc_t) xdr_tt_set_file_prop_args,
 686                                      (caddr_t) argp,
 687                                      (xdrproc_t) xdr_tt_db_cache_results,
 688                                      (caddr_t) &res, TIMEOUT);
 689         if (result != RPC_SUCCESS) {
 690                 return (NULL);
 691         }
 692         return (&res);
 693 }
 694
 695 _tt_db_cache_results *
 696 _tt_add_file_prop_1(_tt_add_file_prop_args *argp, CLIENT *clnt)
 697 {
 698         static _tt_db_cache_results res;
 699
 700         memset((void *)&res, '\0', sizeof(res));
 701         clnt_stat result = clnt_call(clnt, TT_ADD_FILE_PROP,
 702                                      (xdrproc_t) xdr_tt_add_file_prop_args,
 703                                      (caddr_t) argp,
 704                                      (xdrproc_t) xdr_tt_db_cache_results,
 705                                      (caddr_t) &res, TIMEOUT);
 706         if (result != RPC_SUCCESS) {
 707                 return (NULL);
 708         }
 709         return (&res);
 710 }
 711
 712 _tt_db_cache_results *
 713 _tt_delete_file_prop_1(_tt_del_file_prop_args *argp, CLIENT *clnt)
 714 {
 715         static _tt_db_cache_results res;
 716
 717         memset((void *)&res, '\0', sizeof(res));
 718         clnt_stat result = clnt_call(clnt, TT_DELETE_FILE_PROP,
 719                                      (xdrproc_t) xdr_tt_del_file_prop_args,
 720                                      (caddr_t) argp,
 721                                      (xdrproc_t) xdr_tt_db_cache_results,
 722                                      (caddr_t) &res, TIMEOUT);
 723         if (result != RPC_SUCCESS) {
 724                 return (NULL);
 725         }
 726         return (&res);
 727 }
 728
 729 _tt_file_prop_results *
 730 _tt_get_file_prop_1(_tt_get_file_prop_args *argp, CLIENT *clnt)
 731 {
 732         static _tt_file_prop_results res;
 733
 734         memset((void *)&res, '\0', sizeof(res));
 735         clnt_stat result = clnt_call(clnt, TT_GET_FILE_PROP,
 736                                      (xdrproc_t) xdr_tt_get_file_prop_args,
 737                                      (caddr_t) argp,
 738                                      (xdrproc_t) xdr_tt_file_prop_results,
 739                                      (caddr_t) &res, TIMEOUT);
 740         if (result != RPC_SUCCESS) {
 741                 return (NULL);
 742         }
 743         return (&res);
 744 }
 745
 746 _tt_file_props_results *
 747 _tt_get_file_props_1(_tt_get_file_props_args *argp, CLIENT *clnt)
 748 {
 749         static _tt_file_props_results res;
 750
 751         memset((void *)&res, '\0', sizeof(res));
 752         clnt_stat result = clnt_call(clnt, TT_GET_FILE_PROPS,
 753                                      (xdrproc_t) xdr_tt_get_file_props_args,
 754                                      (caddr_t) argp,
 755                                      (xdrproc_t) xdr_tt_file_props_results,
 756                                      (caddr_t) &res, TIMEOUT);
 757         if (result != RPC_SUCCESS) {
 758                 return (NULL);
 759         }
 760         return (&res);
 761 }
 762
 763 _tt_file_objs_results *
 764 _tt_get_file_objs_1(_tt_get_file_objs_args *argp, CLIENT *clnt)
 765 {
 766         static _tt_file_objs_results res;
 767
 768         memset((void *)&res, '\0', sizeof(res));
 769         clnt_stat result = clnt_call(clnt, TT_GET_FILE_OBJS,
 770                                      (xdrproc_t) xdr_tt_get_file_objs_args,
 771                                      (caddr_t) argp,
 772                                      (xdrproc_t) xdr_tt_file_objs_results,
 773                                      (caddr_t) &res, TIMEOUT);
 774         if (result != RPC_SUCCESS) {
 775                 return (NULL);
 776         }
 777         return (&res);
 778 }
 779
 780 _tt_db_results *
 781 _tt_set_file_access_1(_tt_set_file_access_args *argp, CLIENT *clnt)
 782 {
 783         static _tt_db_results res;
 784
 785         memset((void *)&res, '\0', sizeof(res));
 786         clnt_stat result = clnt_call(clnt, TT_SET_FILE_ACCESS,
 787                                      (xdrproc_t) xdr_tt_set_file_access_args,
 788                                      (caddr_t) argp,
 789                                      (xdrproc_t) xdr_tt_db_results,
 790                                      (caddr_t) &res, TIMEOUT);
 791         if (result != RPC_SUCCESS) {
 792                 return (NULL);
 793         }
 794         return (&res);
 795 }
 796
 797 _tt_file_access_results *
 798 _tt_get_file_access_1(_tt_get_file_access_args *argp, CLIENT *clnt)
 799 {
 800         static _tt_file_access_results res;
 801
 802         memset((void *)&res, '\0', sizeof(res));
 803         clnt_stat result = clnt_call(clnt, TT_GET_FILE_ACCESS,
 804                                      (xdrproc_t) xdr_tt_get_file_access_args,
 805                                      (caddr_t) argp,
 806                                      (xdrproc_t) xdr_tt_file_access_results,
 807                                      (caddr_t) &res, TIMEOUT);
 808         if (result != RPC_SUCCESS) {
 809                 return (NULL);
 810         }
 811         return (&res);
 812 }
 813
 814 _tt_obj_props_results *
 815 _tt_set_obj_props_1(_tt_set_obj_props_args *argp, CLIENT *clnt)
 816 {
 817         static _tt_obj_props_results res;
 818
 819         memset((void *)&res, '\0', sizeof(res));
 820         clnt_stat result = clnt_call(clnt, TT_SET_OBJ_PROPS,
 821                                      (xdrproc_t) xdr_tt_set_obj_props_args,
 822                                      (caddr_t) argp,
 823                                      (xdrproc_t) xdr_tt_obj_props_results,
 824                                      (caddr_t) &res, TIMEOUT);
 825         if (result != RPC_SUCCESS) {
 826                 return (NULL);
 827         }
 828         return (&res);
 829 }
 830
 831 _tt_obj_props_results *
 832 _tt_set_obj_prop_1(_tt_set_obj_prop_args *argp, CLIENT *clnt)
 833 {
 834         static _tt_obj_props_results res;
 835
 836         memset((void *)&res, '\0', sizeof(res));
 837         clnt_stat result = clnt_call(clnt, TT_SET_OBJ_PROP,
 838                                      (xdrproc_t) xdr_tt_set_obj_prop_args,
 839                                      (caddr_t) argp,
 840                                      (xdrproc_t) xdr_tt_obj_props_results,
 841                                      (caddr_t) &res, TIMEOUT);
 842         if (result != RPC_SUCCESS) {
 843                 return (NULL);
 844         }
 845         return (&res);
 846 }
 847
 848 _tt_obj_props_results *
 849 _tt_add_obj_prop_1(_tt_add_obj_prop_args *argp, CLIENT *clnt)
 850 {
 851         static _tt_obj_props_results res;
 852
 853         memset((void *)&res, '\0', sizeof(res));
 854         clnt_stat result = clnt_call(clnt, TT_ADD_OBJ_PROP,
 855                                      (xdrproc_t) xdr_tt_add_obj_prop_args,
 856                                      (caddr_t) argp,
 857                                      (xdrproc_t) xdr_tt_obj_props_results,
 858                                      (caddr_t) &res, TIMEOUT);
 859         if (result != RPC_SUCCESS) {
 860                 return (NULL);
 861         }
 862         return (&res);
 863 }
 864
 865 _tt_obj_props_results *
 866 _tt_delete_obj_prop_1(_tt_del_obj_prop_args *argp, CLIENT *clnt)
 867 {
 868         static _tt_obj_props_results res;
 869
 870         memset((void *)&res, '\0', sizeof(res));
 871         clnt_stat result = clnt_call(clnt, TT_DELETE_OBJ_PROP,
 872                                      (xdrproc_t) xdr_tt_del_obj_prop_args,
 873                                      (caddr_t) argp,
 874                                      (xdrproc_t) xdr_tt_obj_props_results,
 875                                      (caddr_t) &res, TIMEOUT);
 876         if (result != RPC_SUCCESS) {
 877                 return (NULL);
 878         }
 879         return (&res);
 880 }
 881
 882 _tt_obj_prop_results *
 883 _tt_get_obj_prop_1(_tt_get_obj_prop_args *argp, CLIENT *clnt)
 884 {
 885         static _tt_obj_prop_results res;
 886
 887         memset((void *)&res, '\0', sizeof(res));
 888         clnt_stat result = clnt_call(clnt, TT_GET_OBJ_PROP,
 889                                      (xdrproc_t) xdr_tt_get_obj_prop_args,
 890                                      (caddr_t) argp,
 891                                      (xdrproc_t) xdr_tt_obj_prop_results,
 892                                      (caddr_t) &res, TIMEOUT);
 893         if (result != RPC_SUCCESS) {
 894                 return (NULL);
 895         }
 896         return (&res);
 897 }
 898
 899 _tt_obj_props_results *
 900 _tt_get_obj_props_1(_tt_get_obj_props_args *argp, CLIENT *clnt)
 901 {
 902         static _tt_obj_props_results res;
 903
 904         memset((void *)&res, '\0', sizeof(res));
 905         clnt_stat result = clnt_call(clnt, TT_GET_OBJ_PROPS,
 906                                      (xdrproc_t) xdr_tt_get_obj_props_args,
 907                                      (caddr_t) argp,
 908                                      (xdrproc_t) xdr_tt_obj_props_results,
 909                                      (caddr_t) &res, TIMEOUT);
 910         if (result != RPC_SUCCESS) {
 911                 return (NULL);
 912         }
 913         return (&res);
 914 }
 915
 916 _tt_db_results *
 917 _tt_set_obj_type_1(_tt_set_obj_type_args *argp, CLIENT *clnt)
 918 {
 919         static _tt_db_results res;
 920
 921         memset((void *)&res, '\0', sizeof(res));
 922         clnt_stat result = clnt_call(clnt, TT_SET_OBJ_TYPE,
 923                                      (xdrproc_t) xdr_tt_set_obj_type_args,
 924                                      (caddr_t) argp,
 925                                      (xdrproc_t) xdr_tt_db_results,
 926                                      (caddr_t) &res, TIMEOUT);
 927         if (result != RPC_SUCCESS) {
 928                 return (NULL);
 929         }
 930         return (&res);
 931 }
 932
 933 _tt_obj_type_results *
 934 _tt_get_obj_type_1(_tt_get_obj_type_args *argp, CLIENT *clnt)
 935 {
 936         static _tt_obj_type_results res;
 937
 938         memset((void *)&res, '\0', sizeof(res));
 939         clnt_stat result = clnt_call(clnt, TT_GET_OBJ_TYPE,
 940                                      (xdrproc_t) xdr_wrapstring,
 941                                      (caddr_t) argp,
 942                                      (xdrproc_t) xdr_tt_obj_type_results,
 943                                      (caddr_t) &res, TIMEOUT);
 944         if (result != RPC_SUCCESS) {
 945                 return (NULL);
 946         }
 947         return (&res);
 948 }
 949
 950 _tt_db_results *
 951 _tt_set_obj_file_1(_tt_set_obj_file_args *argp, CLIENT *clnt)
 952 {
 953         static _tt_db_results res;
 954
 955         memset((void *)&res, '\0', sizeof(res));
 956         clnt_stat result = clnt_call(clnt, TT_SET_OBJ_FILE,
 957                                      (xdrproc_t) xdr_tt_set_obj_file_args,
 958                                      (caddr_t) argp,
 959                                      (xdrproc_t) xdr_tt_db_results,
 960                                      (caddr_t) &res, TIMEOUT);
 961         if (result != RPC_SUCCESS) {
 962                 return (NULL);
 963         }
 964         return (&res);
 965 }
 966
 967 _tt_obj_file_results *
 968 _tt_get_obj_file_1(_tt_get_obj_file_args *argp, CLIENT *clnt)
 969 {
 970         static _tt_obj_file_results res;
 971
 972         memset((void *)&res, '\0', sizeof(res));
 973         clnt_stat result = clnt_call(clnt, TT_GET_OBJ_FILE,
 974                                      (xdrproc_t) xdr_tt_get_obj_file_args,
 975                                      (caddr_t) argp,
 976                                      (xdrproc_t) xdr_tt_obj_file_results,
 977                                      (caddr_t) &res, TIMEOUT);
 978         if (result != RPC_SUCCESS) {
 979                 return (NULL);
 980         }
 981         return (&res);
 982 }
 983
 984 _tt_db_results *
 985 _tt_set_obj_access_1(_tt_set_obj_access_args *argp, CLIENT *clnt)
 986 {
 987         static _tt_db_results res;
 988
 989         memset((void *)&res, '\0', sizeof(res));
 990         clnt_stat result = clnt_call(clnt, TT_SET_OBJ_ACCESS,
 991                                      (xdrproc_t) xdr_tt_set_obj_access_args,
 992                                      (caddr_t) argp,
 993                                      (xdrproc_t) xdr_tt_db_results,
 994                                      (caddr_t) &res, TIMEOUT);
 995         if (result != RPC_SUCCESS) {
 996                 return (NULL);
 997         }
 998         return (&res);
 999 }
1000
1001 _tt_obj_access_results *
1002 _tt_get_obj_access_1(_tt_get_obj_access_args *argp, CLIENT *clnt)
1003 {
1004         static _tt_obj_access_results res;
1005
1006         memset((void *)&res, '\0', sizeof(res));
1007         clnt_stat result = clnt_call(clnt, TT_GET_OBJ_ACCESS,
1008                                      (xdrproc_t) xdr_tt_get_obj_access_args,
1009                                      (caddr_t) argp,
1010                                      (xdrproc_t) xdr_tt_obj_access_results,
1011                                      (caddr_t) &res, TIMEOUT);
1012         if (result != RPC_SUCCESS) {
1013                 return (NULL);
1014         }
1015         return (&res);
1016 }
1017
1018 _tt_is_file_in_db_results *
1019 _tt_is_file_in_db_1(_tt_is_file_in_db_args *argp, CLIENT *clnt)
1020 {
1021         static _tt_is_file_in_db_results res;
1022
1023         memset((void *)&res, '\0', sizeof(res));
1024         clnt_stat result = clnt_call(clnt, TT_IS_FILE_IN_DB,
1025                                      (xdrproc_t) xdr_tt_is_file_in_db_args,
1026                                      (caddr_t) argp,
1027                                      (xdrproc_t) xdr_tt_is_file_in_db_results,
1028                                      (caddr_t) &res, TIMEOUT);
1029         if (result != RPC_SUCCESS) {
1030                 return (NULL);
1031         }
1032         return (&res);
1033 }
1034
1035 _tt_is_obj_in_db_results *
1036 _tt_is_obj_in_db_1(_tt_is_obj_in_db_args *argp, CLIENT *clnt)
1037 {
1038         static _tt_is_obj_in_db_results res;
1039
1040         memset((void *)&res, '\0', sizeof(res));
1041         clnt_stat result = clnt_call(clnt, TT_IS_OBJ_IN_DB,
1042                                      (xdrproc_t) xdr_tt_is_obj_in_db_args,
1043                                      (caddr_t) argp,
1044                                      (xdrproc_t) xdr_tt_is_obj_in_db_results,
1045                                      (caddr_t) &res, TIMEOUT);
1046         if (result != RPC_SUCCESS) {
1047                 return (NULL);
1048         }
1049         return (&res);
1050 }
1051
1052 _tt_db_results *
1053 _tt_queue_message_1(_tt_queue_msg_args *argp, CLIENT *clnt)
1054 {
1055         static _tt_db_results res;
1056
1057         memset((void *)&res, '\0', sizeof(res));
1058         clnt_stat result = clnt_call(clnt, TT_QUEUE_MESSAGE,
1059                                      (xdrproc_t) xdr_tt_queue_msg_args,
1060                                      (caddr_t) argp,
1061                                      (xdrproc_t) xdr_tt_db_results,
1062                                      (caddr_t) &res, TIMEOUT);
1063         if (result != RPC_SUCCESS) {
1064                 return (NULL);
1065         }
1066         return (&res);
1067 }
1068
1069 _tt_dequeue_msgs_results *
1070 _tt_dequeue_messages_1(_tt_dequeue_msgs_args *argp, CLIENT *clnt)
1071 {
1072         static _tt_dequeue_msgs_results res;
1073
1074         memset((void *)&res, '\0', sizeof(res));
1075         clnt_stat result = clnt_call(clnt, TT_DEQUEUE_MESSAGES,
1076                                      (xdrproc_t) xdr_tt_dequeue_msgs_args,
1077                                      (caddr_t) argp,
1078                                      (xdrproc_t) xdr_tt_dequeue_msgs_results,
1079                                      (caddr_t) &res, TIMEOUT);
1080         if (result != RPC_SUCCESS) {
1081                 return (NULL);
1082         }
1083         return (&res);
1084 }
1085
1086
1087 // used for API call tt_host_file_netfile()
1088 _tt_file_netfile_results *
1089 _tt_file_netfile_1(_tt_file_netfile_args *argp, CLIENT *clnt)
1090 {
1091         static _tt_file_netfile_results res;
1092
1093         memset((void *)&res, '\0', sizeof(res));
1094         clnt_stat result = clnt_call(clnt, TTDB_FILE_NETFILE,
1095                                      (xdrproc_t) xdr_tt_file_netfile_args,
1096                                      (caddr_t) argp,
1097                                      (xdrproc_t) xdr_tt_file_netfile_results,
1098                                      (caddr_t) &res,
1099                                      TIMEOUT);
1100         if (result == RPC_PROCUNAVAIL) {
1101                 res.results = TT_DB_ERR_RPC_UNIMP;
1102         } else {
1103                 if (result != RPC_SUCCESS) {
1104                         return (NULL);
1105                 }
1106         }
1107
1108         return (&res);
1109 }
1110
1111
1112 // used for API call tt_host_netfile_file()
1113 _tt_file_netfile_results *
1114 _tt_netfile_file_1(_tt_file_netfile_args *argp, CLIENT *clnt)
1115 {
1116         static _tt_file_netfile_results res;
1117
1118         memset((void *)&res, '\0', sizeof(res));
1119         clnt_stat result = clnt_call(clnt, TTDB_NETFILE_FILE,
1120                                      (xdrproc_t) xdr_tt_file_netfile_args,
1121                                      (caddr_t) argp,
1122                                      (xdrproc_t) xdr_tt_file_netfile_results,
1123                                      (caddr_t) &res,
1124                                      TIMEOUT);
1125         if (result == RPC_PROCUNAVAIL) {
1126                 res.results = TT_DB_ERR_RPC_UNIMP;
1127         } else {
1128                 if (result != RPC_SUCCESS) {
1129                         return (NULL);
1130                 }
1131         }
1132
1133         return (&res);
1134 }
1135
1136 _tt_get_all_sessions_results    *
1137 _tt_get_all_sessions_1(_tt_get_all_sessions_args *argp, CLIENT * clnt)
1138 {
1139     static _tt_get_all_sessions_results res;
1140
1141     clnt_call(clnt, TT_GET_ALL_SESSIONS,
1142                                  (xdrproc_t) xdr_tt_get_all_sessions_args,
1143                                  (caddr_t) argp,
1144                                  (xdrproc_t) xdr_tt_get_all_sessions_results,
1145                                  (caddr_t) &res,
1146                                  TIMEOUT);
1147
1148     return(&res);
1149 }
1150
1151 _tt_garbage_collect_results     *
1152 _tt_garbage_collect_1(void * /*NOTUSED*/, CLIENT *clnt)
1153 {
1154         static  _tt_garbage_collect_results     res;
1155
1156         clnt_call(clnt, TT_GARBAGE_COLLECT,
1157                                      (xdrproc_t) xdr_void, (caddr_t) NULL,
1158                                      (xdrproc_t) xdr_tt_garbage_collect_results,
1159                                      (caddr_t) &res,
1160                                      TIMEOUT);
1161
1162         return(&res);
1163 }
1164
1165 _tt_delete_session_results *
1166 _tt_delete_session_1(_tt_delete_session_args * args, CLIENT *clnt)
1167 {
1168         static  _tt_delete_session_results      res;
1169
1170         clnt_call(clnt, TT_DELETE_SESSION,
1171                                      (xdrproc_t) xdr_tt_delete_session_args,
1172                                      (caddr_t) args,
1173                                      (xdrproc_t) xdr_tt_delete_session_results,
1174                                      (caddr_t) &res,
1175                                      TIMEOUT);
1176
1177         return(&res);
1178 }
1179