cde/lib/csa/cmxdr.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 /* $XConsortium: cmxdr.c /main/1 1996/04/21 19:22:14 drk $ */
  24 /*
  25  *  (c) Copyright 1993, 1994 Hewlett-Packard Company
  26  *  (c) Copyright 1993, 1994 International Business Machines Corp.
  27  *  (c) Copyright 1993, 1994 Novell, Inc.
  28  *  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
  29  */
  30
  31 /*
  32  * xdr routines for xapia csa data structures
  33  */
  34
  35 #include <EUSCompat.h>
  36 #include "cm.h"
  37 #include "csa.h"
  38 #include "cmxdr.h"
  39
  40 /* Functions generated by rtable4.x */
  41 /*
  42  * time_t is a typedef which is system dependent
  43  */
  44 bool_t
  45 xdr_time_t(register XDR *xdrs, time_t *objp)
  46 {
  47 #ifdef __osf__
  48         if (!xdr_int(xdrs, objp))
  49                 return (FALSE);
  50 #else
  51         if (!xdr_long(xdrs, objp))
  52                 return (FALSE);
  53 #endif
  54         return (TRUE);
  55 }
  56
  57
  58 /*
  59  * cms_name - a user name or calendar name which is
  60  *              variable length character string
  61  */
  62
  63 bool_t
  64 xdr_cms_name(register XDR *xdrs, cms_name *objp)
  65 {
  66
  67         register long *buf;
  68
  69         if (!xdr_string(xdrs, objp, ~0))
  70                 return (FALSE);
  71         return (TRUE);
  72 }
  73
  74 /*
  75  * cms_access_entry - data structure for the access list attribute
  76  */
  77
  78 bool_t
  79 xdr_cms_access_entry(register XDR *xdrs, cms_access_entry *objp)
  80 {
  81
  82         register long *buf;
  83
  84         if (!xdr_string(xdrs, &objp->user, ~0))
  85                 return (FALSE);
  86         if (!xdr_u_int(xdrs, &objp->rights))
  87                 return (FALSE);
  88         if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (cms_access_entry),
  89             (xdrproc_t) xdr_cms_access_entry))
  90                 return (FALSE);
  91         return (TRUE);
  92 }
  93
  94 /*
  95  * cms_key consists of the time and the unique
  96  * identifier of the entry.
  97  */
  98
  99 bool_t
 100 xdr_cms_key(register XDR *xdrs, cms_key *objp)
 101 {
 102
 103         register long *buf;
 104
 105         if (!xdr_time_t(xdrs, &objp->time))
 106                 return (FALSE);
 107         if (!xdr_long(xdrs, &objp->id))
 108                 return (FALSE);
 109         return (TRUE);
 110 }
 111
 112 bool_t
 113 xdr_CSA_opaque_data(register XDR *xdrs, CSA_opaque_data *objp)
 114 {
 115
 116         register long *buf;
 117
 118         if (!xdr_bytes(xdrs, (char **)&objp->data, (u_int *) &objp->size, ~0))
 119                 return (FALSE);
 120         return (TRUE);
 121 }
 122
 123 bool_t
 124 xdr_CSA_reminder(register XDR *xdrs, CSA_reminder *objp)
 125 {
 126
 127         register long *buf;
 128
 129         if (!xdr_string(xdrs, &objp->lead_time, ~0))
 130                 return (FALSE);
 131         if (!xdr_string(xdrs, &objp->snooze_time, ~0))
 132                 return (FALSE);
 133         if (!xdr_u_long(xdrs, &objp->repeat_count))
 134                 return (FALSE);
 135         if (!xdr_CSA_opaque_data(xdrs, &objp->reminder_data))
 136                 return (FALSE);
 137         return (TRUE);
 138 }
 139
 140 bool_t
 141 xdr_CSA_date_time_entry(register XDR *xdrs, CSA_date_time_entry *objp)
 142 {
 143
 144         register long *buf;
 145
 146         if (!xdr_string(xdrs, &objp->date_time, ~0))
 147                 return (FALSE);
 148         if (!xdr_pointer(xdrs, (char **)&objp->next,
 149             sizeof (CSA_date_time_entry), (xdrproc_t) xdr_CSA_date_time_entry))
 150                 return (FALSE);
 151         return (TRUE);
 152 }
 153
 154 bool_t
 155 xdr_cms_attribute_value(register XDR *xdrs, cms_attribute_value *objp)
 156 {
 157
 158         register long *buf;
 159
 160         if (!xdr_int(xdrs, &objp->type))
 161                 return (FALSE);
 162
 163         switch (objp->type) {
 164         case CSA_VALUE_SINT32:
 165         case CSA_VALUE_ENUMERATED:
 166                 if (!xdr_long(xdrs, &objp->item.sint32_value))
 167                         return (FALSE);
 168                 break;
 169         case CSA_VALUE_BOOLEAN:
 170         case CSA_VALUE_FLAGS:
 171         case CSA_VALUE_UINT32:
 172                 if (!xdr_u_long(xdrs, &objp->item.uint32_value))
 173                         return (FALSE);
 174                 break;
 175         case CSA_VALUE_STRING:
 176         case CSA_VALUE_CALENDAR_USER:
 177         case CSA_VALUE_DATE_TIME:
 178         case CSA_VALUE_DATE_TIME_RANGE:
 179         case CSA_VALUE_TIME_DURATION:
 180                 if (!xdr_string(xdrs, &objp->item.string_value, ~0))
 181                         return (FALSE);
 182                 break;
 183         case CSA_VALUE_ACCESS_LIST:
 184                 if (!xdr_pointer(xdrs, (char **)&objp->item.access_list_value,
 185                     sizeof (cms_access_entry),
 186                     (xdrproc_t) xdr_cms_access_entry))
 187                         return (FALSE);
 188                 break;
 189         case CSA_VALUE_DATE_TIME_LIST:
 190                 if (!xdr_pointer(xdrs,
 191                     (char **)&objp->item.date_time_list_value,
 192                     sizeof (CSA_date_time_entry),
 193                     (xdrproc_t) xdr_CSA_date_time_entry))
 194                         return (FALSE);
 195                 break;
 196         case CSA_VALUE_REMINDER:
 197                 if (!xdr_pointer(xdrs,
 198                     (char **)&objp->item.reminder_value,
 199                     sizeof (CSA_reminder), (xdrproc_t) xdr_CSA_reminder))
 200                         return (FALSE);
 201                 break;
 202         case CSA_VALUE_OPAQUE_DATA:
 203                 if (!xdr_pointer(xdrs, (char **)&objp->item.opaque_data_value,
 204                     sizeof (CSA_opaque_data), (xdrproc_t) xdr_CSA_opaque_data))
 205                         return (FALSE);
 206                 break;
 207         }
 208         return (TRUE);
 209 }
 210
 211 /*
 212  * num contains the hashed number for the associated name assigned
 213  * by the server.  Client should not change its value.
 214  * If it's zero, name is not hashed yet.
 215  */
 216
 217 bool_t
 218 xdr_cms_attr_name(register XDR *xdrs, cms_attr_name *objp)
 219 {
 220
 221         register long *buf;
 222
 223         if (!xdr_short(xdrs, &objp->num))
 224                 return (FALSE);
 225         if (!xdr_string(xdrs, &objp->name, ~0))
 226                 return (FALSE);
 227         return (TRUE);
 228 }
 229
 230 /*
 231  *
 232  */
 233
 234 bool_t
 235 xdr_cms_attribute(register XDR *xdrs, cms_attribute *objp)
 236 {
 237
 238         register long *buf;
 239
 240         if (!xdr_cms_attr_name(xdrs, &objp->name))
 241                 return (FALSE);
 242         if (!xdr_pointer(xdrs, (char **)&objp->value,
 243             sizeof (CSA_attribute_value), (xdrproc_t) xdr_cms_attribute_value))
 244                 return (FALSE);
 245         return (TRUE);
 246 }
 247
 248
 249 /*
 250  * An entry is identified by an identifier unique within the calendar
 251  * and has a variable number of attributes associated with it.
 252  */
 253
 254 bool_t
 255 xdr_cms_entry(register XDR *xdrs, cms_entry *objp)
 256 {
 257
 258         register long *buf;
 259
 260         if (!xdr_cms_key(xdrs, &objp->key))
 261                 return (FALSE);
 262         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 263             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 264                 return (FALSE);
 265         if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (cms_entry),
 266             (xdrproc_t) xdr_cms_entry))
 267                 return (FALSE);
 268         return (TRUE);
 269 }
 270
 271
 272 /*
 273  * cms_enumerate_calendar_attr_res
 274  *
 275  * If stat is CSA_SUCCESS, names contains an array of names.
 276  */
 277
 278 bool_t
 279 xdr_cms_enumerate_calendar_attr_res(register XDR *xdrs, cms_enumerate_calendar_attr_res *objp)
 280 {
 281
 282         register long *buf;
 283
 284         if (!xdr_u_long(xdrs, &objp->stat))
 285                 return (FALSE);
 286         if (!xdr_array(xdrs, (char **)&objp->names, (u_int *) &objp->num_names,
 287             ~0, sizeof (cms_attr_name), (xdrproc_t) xdr_cms_attr_name))
 288                 return (FALSE);
 289         return (TRUE);
 290 }
 291
 292
 293 /*
 294  * cms_list_calendars_res
 295  *
 296  * If stat is CSA_SUCCESS, names contains an array of names.
 297  */
 298
 299 bool_t
 300 xdr_cms_list_calendars_res(register XDR *xdrs, cms_list_calendars_res *objp)
 301 {
 302
 303         register long *buf;
 304
 305         if (!xdr_u_long(xdrs, &objp->stat))
 306                 return (FALSE);
 307         if (!xdr_array(xdrs, (char **)&objp->names, (u_int *) &objp->num_names,
 308             ~0, sizeof (cms_name), (xdrproc_t) xdr_cms_name))
 309                 return (FALSE);
 310         return (TRUE);
 311 }
 312
 313
 314 /*
 315  * cms_open_args - used by CMS_OPEN_CALENDAR
 316  */
 317
 318 bool_t
 319 xdr_cms_open_args(register XDR *xdrs, cms_open_args *objp)
 320 {
 321
 322         register long *buf;
 323
 324         if (!xdr_string(xdrs, &objp->cal, ~0))
 325                 return (FALSE);
 326         if (!xdr_int(xdrs, &objp->pid))
 327                 return (FALSE);
 328         return (TRUE);
 329 }
 330
 331
 332 /*
 333  * cms_open_res - returned by CMS_OPEN_CALENDAR
 334  *
 335  * If stat is DtCm_OK,
 336  *      svr_vers contains the version number of the server,
 337  *      file_vers contains the version number of the callog file,
 338  *      user_access is the calling user's access right to the calendar
 339  *      num_attrs indicates the size of the array pointed to by attrs,
 340  *      and attrs contains an array of calendar attributes.
 341  */
 342
 343 bool_t
 344 xdr_cms_open_res(register XDR *xdrs, cms_open_res *objp)
 345 {
 346
 347         register long *buf;
 348
 349         if (!xdr_u_long(xdrs, &objp->stat))
 350                 return (FALSE);
 351         if (!xdr_int(xdrs, &objp->svr_vers))
 352                 return (FALSE);
 353         if (!xdr_int(xdrs, &objp->file_vers))
 354                 return (FALSE);
 355         if (!xdr_u_int(xdrs, &objp->user_access))
 356                 return (FALSE);
 357         if (!xdr_array(xdrs, (char **)&objp->attrs, &objp->num_attrs,
 358             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 359                 return (FALSE);
 360         return (TRUE);
 361 }
 362
 363
 364 /*
 365  * cms_create_args - used by CMS_CREATE_CALENDAR
 366  */
 367
 368 bool_t
 369 xdr_cms_create_args(register XDR *xdrs, cms_create_args *objp)
 370 {
 371
 372         register long *buf;
 373
 374         if (!xdr_string(xdrs, &objp->cal, ~0))
 375                 return (FALSE);
 376         if (!xdr_string(xdrs, &objp->char_set, ~0))
 377                 return (FALSE);
 378         if (!xdr_int(xdrs, &objp->pid))
 379                 return (FALSE);
 380         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 381             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 382                 return (FALSE);
 383         return (TRUE);
 384 }
 385
 386
 387 /*
 388  * cms_remove_args - used by CMS_REMOVE_CALENDAR
 389  */
 390
 391 bool_t
 392 xdr_cms_remove_args(register XDR *xdrs, cms_remove_args *objp)
 393 {
 394
 395         register long *buf;
 396
 397         if (!xdr_string(xdrs, &objp->cal, ~0))
 398                 return (FALSE);
 399         if (!xdr_int(xdrs, &objp->pid))
 400                 return (FALSE);
 401         return (TRUE);
 402 }
 403
 404
 405 /*
 406  * cms_register_args - used by CMS_REGISTER and CMS_UNREGISTER
 407  */
 408
 409 bool_t
 410 xdr_cms_register_args(register XDR *xdrs, cms_register_args *objp)
 411 {
 412
 413         register long *buf;
 414
 415         if (!xdr_string(xdrs, &objp->cal, ~0))
 416                 return (FALSE);
 417         if (!xdr_u_int(xdrs, &objp->update_type))
 418                 return (FALSE);
 419         if (!xdr_u_long(xdrs, &objp->prognum))
 420                 return (FALSE);
 421         if (!xdr_u_long(xdrs, &objp->versnum))
 422                 return (FALSE);
 423         if (!xdr_u_long(xdrs, &objp->procnum))
 424                 return (FALSE);
 425         if (!xdr_int(xdrs, &objp->pid))
 426                 return (FALSE);
 427         return (TRUE);
 428 }
 429
 430
 431 /*
 432  * cms_get_cal_attr_res - used by CMS_GET_CALENDAR_ATTR
 433  *
 434  * If stat is CSA_SUCCESS, attrs contains an array of attributes.
 435  */
 436
 437 bool_t
 438 xdr_cms_get_cal_attr_res(register XDR *xdrs, cms_get_cal_attr_res *objp)
 439 {
 440
 441         register long *buf;
 442
 443         if (!xdr_u_long(xdrs, &objp->stat))
 444                 return (FALSE);
 445         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 446             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 447                 return (FALSE);
 448         return (TRUE);
 449 }
 450
 451
 452 /*
 453  * cms_get_cal_attr_args - used by CMS_GET_CALENDAR_ATTR
 454  */
 455
 456 bool_t
 457 xdr_cms_get_cal_attr_args(register XDR *xdrs, cms_get_cal_attr_args *objp)
 458 {
 459
 460         register long *buf;
 461
 462         if (!xdr_string(xdrs, &objp->cal, ~0))
 463                 return (FALSE);
 464         if (!xdr_array(xdrs, (char **)&objp->names, (u_int *) &objp->num_names,
 465             ~0, sizeof (cms_attr_name), (xdrproc_t) xdr_cms_attr_name))
 466                 return (FALSE);
 467         return (TRUE);
 468 }
 469
 470
 471 /*
 472  * cms_set_cal_attr_args - used by CMS_SET_CALENDAR_ATTR
 473  */
 474
 475 bool_t
 476 xdr_cms_set_cal_attr_args(register XDR *xdrs, cms_set_cal_attr_args *objp)
 477 {
 478
 479         register long *buf;
 480
 481         if (!xdr_string(xdrs, &objp->cal, ~0))
 482                 return (FALSE);
 483         if (!xdr_int(xdrs, &objp->pid))
 484                 return (FALSE);
 485         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 486             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 487                 return (FALSE);
 488         return (TRUE);
 489 }
 490
 491
 492 /*
 493  * cms_archive_res - used by CMS_ARCHIVE
 494  *
 495  * If stat is CSA_SUCCESS, data contains the data to be archived
 496  */
 497
 498 bool_t
 499 xdr_cms_archive_res(register XDR *xdrs, cms_archive_res *objp)
 500 {
 501
 502         register long *buf;
 503
 504         if (!xdr_u_long(xdrs, &objp->stat))
 505                 return (FALSE);
 506         if (!xdr_string(xdrs, &objp->data, ~0))
 507                 return (FALSE);
 508         return (TRUE);
 509 }
 510
 511
 512 /*
 513  * cms_archive_args - used by CMS_ARCHIVE
 514  */
 515
 516 bool_t
 517 xdr_cms_archive_args(register XDR *xdrs, cms_archive_args *objp)
 518 {
 519
 520         register long *buf;
 521
 522         if (!xdr_string(xdrs, &objp->cal, ~0))
 523                 return (FALSE);
 524         if (!xdr_bool(xdrs, &objp->delete))
 525                 return (FALSE);
 526         if (!xdr_string(xdrs, &objp->char_set, ~0))
 527                 return (FALSE);
 528         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 529             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 530                 return (FALSE);
 531         if (!xdr_array(xdrs, (char **)&objp->ops, (u_int *) &objp->num_attrs,
 532             ~0, sizeof (CSA_enum), (xdrproc_t) xdr_long))
 533                 return (FALSE);
 534         return (TRUE);
 535 }
 536
 537
 538 /*
 539  * cms_restore_args - used by CMS_RESTORE
 540  */
 541
 542 bool_t
 543 xdr_cms_restore_args(register XDR *xdrs, cms_restore_args *objp)
 544 {
 545
 546         register long *buf;
 547
 548         if (!xdr_string(xdrs, &objp->cal, ~0))
 549                 return (FALSE);
 550         if (!xdr_string(xdrs, &objp->data, ~0))
 551                 return (FALSE);
 552         if (!xdr_string(xdrs, &objp->char_set, ~0))
 553                 return (FALSE);
 554         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 555             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 556                 return (FALSE);
 557         if (!xdr_array(xdrs, (char **)&objp->ops, (u_int *) &objp->num_attrs,
 558             ~0, sizeof (CSA_enum), (xdrproc_t) xdr_long))
 559                 return (FALSE);
 560         return (TRUE);
 561 }
 562
 563
 564 /*
 565  * cms_reminder
 566  */
 567
 568 bool_t
 569 xdr_cms_reminder_ref(register XDR *xdrs, cms_reminder_ref *objp)
 570 {
 571
 572         register long *buf;
 573
 574         if (!xdr_string(xdrs, &objp->reminder_name, ~0))
 575                 return (FALSE);
 576         if (!xdr_string(xdrs, &objp->entryid, ~0))
 577                 return (FALSE);
 578         if (!xdr_cms_key(xdrs, &objp->key))
 579                 return (FALSE);
 580         if (!xdr_time_t(xdrs, &objp->runtime))
 581                 return (FALSE);
 582         if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (cms_reminder_ref),
 583             (xdrproc_t) xdr_cms_reminder_ref))
 584                 return (FALSE);
 585         return (TRUE);
 586 }
 587
 588
 589 /*
 590  * cms_reminder_res - used by CMS_LOOKUP_REMINDER
 591  *
 592  * If stat is CSA_SUCCESS, rems contains an array of reminders.
 593  */
 594
 595 bool_t
 596 xdr_cms_reminder_res(register XDR *xdrs, cms_reminder_res *objp)
 597 {
 598
 599         register long *buf;
 600
 601         if (!xdr_u_long(xdrs, &objp->stat))
 602                 return (FALSE);
 603         if (!xdr_pointer(xdrs, (char **)&objp->rems, sizeof (cms_reminder_ref),
 604             (xdrproc_t) xdr_cms_reminder_ref))
 605                 return (FALSE);
 606         return (TRUE);
 607 }
 608
 609
 610 /*
 611  * cms_reminder_args - used by CMS_LOOKUP_REMINDER
 612  */
 613
 614 bool_t
 615 xdr_cms_reminder_args(register XDR *xdrs, cms_reminder_args *objp)
 616 {
 617
 618         register long *buf;
 619
 620         if (!xdr_string(xdrs, &objp->cal, ~0))
 621                 return (FALSE);
 622         if (!xdr_time_t(xdrs, &objp->tick))
 623                 return (FALSE);
 624         if (!xdr_array(xdrs, (char **)&objp->names, (u_int *) &objp->num_names,
 625             ~0, sizeof (cms_attr_name), (xdrproc_t) xdr_cms_attr_name))
 626                 return (FALSE);
 627         return (TRUE);
 628 }
 629
 630
 631 /*
 632  * cms_entries_res
 633  *
 634  * If stat is CSA_SUCCESS, entries contains an array of entries.
 635  */
 636
 637 bool_t
 638 xdr_cms_entries_res(register XDR *xdrs, cms_entries_res *objp)
 639 {
 640
 641         register long *buf;
 642
 643         if (!xdr_u_long(xdrs, &objp->stat))
 644                 return (FALSE);
 645         if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof (cms_entry),
 646             (xdrproc_t) xdr_cms_entry))
 647                 return (FALSE);
 648         return (TRUE);
 649 }
 650
 651
 652 /*
 653  * cms_lookup_entries_args - used by CMS_LOOKUP_ENTRIES
 654  */
 655
 656 bool_t
 657 xdr_cms_lookup_entries_args(register XDR *xdrs, cms_lookup_entries_args *objp)
 658 {
 659
 660         register long *buf;
 661
 662         if (!xdr_string(xdrs, &objp->cal, ~0))
 663                 return (FALSE);
 664         if (!xdr_string(xdrs, &objp->char_set, ~0))
 665                 return (FALSE);
 666         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 667             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 668                 return (FALSE);
 669         if (!xdr_array(xdrs, (char **)&objp->ops, (u_int *) &objp->num_attrs,
 670             ~0, sizeof (CSA_enum), (xdrproc_t) xdr_long))
 671                 return (FALSE);
 672         return (TRUE);
 673 }
 674
 675
 676 /*
 677  * cms_enumerate_args - used by CMS_ENUERATE_SEQUENCE
 678  */
 679
 680 bool_t
 681 xdr_cms_enumerate_args(register XDR *xdrs, cms_enumerate_args *objp)
 682 {
 683
 684         register long *buf;
 685
 686         if (!xdr_string(xdrs, &objp->cal, ~0))
 687                 return (FALSE);
 688         if (!xdr_long(xdrs, &objp->id))
 689                 return (FALSE);
 690         if (!xdr_long(xdrs, &objp->start))
 691                 return (FALSE);
 692         if (!xdr_long(xdrs, &objp->end))
 693                 return (FALSE);
 694         return (TRUE);
 695 }
 696
 697 /*
 698  * If stat is CSA_SUCCESS, attrs contains an array of
 699  * attributes.
 700  */
 701
 702 bool_t
 703 xdr_cms_get_entry_attr_res_item(
 704         register XDR                    *xdrs,
 705         cms_get_entry_attr_res_item     *objp)
 706 {
 707
 708         register long *buf;
 709
 710         if (!xdr_u_long(xdrs, &objp->stat))
 711                 return (FALSE);
 712         if (!xdr_cms_key(xdrs, &objp->key))
 713                 return (FALSE);
 714         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 715             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 716                 return (FALSE);
 717         if (!xdr_pointer(xdrs, (char **)&objp->next,
 718             sizeof (cms_get_entry_attr_res_item),
 719             (xdrproc_t) xdr_cms_get_entry_attr_res_item))
 720                 return (FALSE);
 721         return (TRUE);
 722 }
 723
 724
 725 /*
 726  * cms_get_entry_attr_res - used by CMS_GET_ENTRY_ATTR
 727  *
 728  * If stat is CSA_SUCCESS, entries contains an array of
 729  * cms_get_entry_attr_res_item structures.
 730  */
 731
 732 bool_t
 733 xdr_cms_get_entry_attr_res(register XDR *xdrs, cms_get_entry_attr_res *objp)
 734 {
 735
 736         register long *buf;
 737
 738         if (!xdr_u_long(xdrs, &objp->stat))
 739                 return (FALSE);
 740         if (!xdr_pointer(xdrs, (char **)&objp->entries,
 741             sizeof (cms_get_entry_attr_res_item),
 742             (xdrproc_t) xdr_cms_get_entry_attr_res_item))
 743                 return (FALSE);
 744         return (TRUE);
 745 }
 746
 747
 748 /*
 749  * cms_get_entry_attr_args - used by CMS_GET_ENTRY_ATTR
 750  */
 751
 752 bool_t
 753 xdr_cms_get_entry_attr_args(register XDR *xdrs, cms_get_entry_attr_args *objp)
 754 {
 755
 756         register long *buf;
 757
 758         if (!xdr_string(xdrs, &objp->cal, ~0))
 759                 return (FALSE);
 760         if (!xdr_array(xdrs, (char **)&objp->keys, (u_int *) &objp->num_keys,
 761             ~0, sizeof (cms_key), (xdrproc_t) xdr_cms_key))
 762                 return (FALSE);
 763         if (!xdr_array(xdrs, (char **)&objp->names, (u_int *) &objp->num_names,
 764             ~0, sizeof (cms_attr_name), (xdrproc_t) xdr_cms_attr_name))
 765                 return (FALSE);
 766         return (TRUE);
 767 }
 768
 769
 770 /*
 771  * cms_entry_res
 772  *
 773  * If stat is CSA_SUCCESS, entry points to an entry.
 774  */
 775
 776 bool_t
 777 xdr_cms_entry_res(register XDR *xdrs, cms_entry_res *objp)
 778 {
 779
 780         register long *buf;
 781
 782         if (!xdr_u_long(xdrs, &objp->stat))
 783                 return (FALSE);
 784         if (!xdr_pointer(xdrs, (char **)&objp->entry, sizeof (cms_entry),
 785             (xdrproc_t) xdr_cms_entry))
 786                 return (FALSE);
 787         return (TRUE);
 788 }
 789
 790
 791 /*
 792  * cms_insert_args - used by CMS_INSERT_ENTRY
 793  */
 794
 795 bool_t
 796 xdr_cms_insert_args(register XDR *xdrs, cms_insert_args *objp)
 797 {
 798
 799         register long *buf;
 800
 801         if (!xdr_string(xdrs, &objp->cal, ~0))
 802                 return (FALSE);
 803         if (!xdr_int(xdrs, &objp->pid))
 804                 return (FALSE);
 805         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 806             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 807                 return (FALSE);
 808         return (TRUE);
 809 }
 810
 811
 812 /*
 813  * cms_update_args - used by CMS_UPDATE_ENTRY
 814  */
 815
 816 bool_t
 817 xdr_cms_update_args(register XDR *xdrs, cms_update_args *objp)
 818 {
 819
 820         register long *buf;
 821
 822         if (!xdr_string(xdrs, &objp->cal, ~0))
 823                 return (FALSE);
 824         if (!xdr_int(xdrs, &objp->pid))
 825                 return (FALSE);
 826         if (!xdr_cms_key(xdrs, &objp->entry))
 827                 return (FALSE);
 828         if (!xdr_int(xdrs, &objp->scope))
 829                 return (FALSE);
 830         if (!xdr_array(xdrs, (char **)&objp->attrs, (u_int *) &objp->num_attrs,
 831             ~0, sizeof (cms_attribute), (xdrproc_t) xdr_cms_attribute))
 832                 return (FALSE);
 833         return (TRUE);
 834 }
 835
 836
 837 /*
 838  * cms_delete_args - used by CMS_DELETE_ENTRY
 839  */
 840
 841 bool_t
 842 xdr_cms_delete_args(register XDR *xdrs, cms_delete_args *objp)
 843 {
 844
 845         register long *buf;
 846
 847         if (!xdr_string(xdrs, &objp->cal, ~0))
 848                 return (FALSE);
 849         if (!xdr_int(xdrs, &objp->pid))
 850                 return (FALSE);
 851         if (!xdr_cms_key(xdrs, &objp->entry))
 852                 return (FALSE);
 853         if (!xdr_int(xdrs, &objp->scope))
 854                 return (FALSE);
 855         return (TRUE);
 856 }