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