nis/nis_xdr.c

   1 /* Copyright (c) 1997, 1998, 2005, 2006, 2007 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <rpcsvc/nis.h>
  21 #include <rpcsvc/nis_callback.h> /* for "official" Solaris xdr functions */
  22
  23 /* This functions do exist without beginning "_" under Solaris 2.x, but
  24    we have no prototypes for them. To avoid the same problems as with the
  25    YP xdr functions, we don't make them public. */
  26 #include "nis_xdr.h"
  27
  28 static bool_t
  29 xdr_nis_attr (XDR *xdrs, nis_attr *objp)
  30 {
  31   bool_t res = xdr_string (xdrs, &objp->zattr_ndx, ~0);
  32   if (__builtin_expect (res, TRUE))
  33     res = xdr_bytes (xdrs, (char **) &objp->zattr_val.zattr_val_val,
  34                      &objp->zattr_val.zattr_val_len, ~0);
  35   return res;
  36 }
  37
  38 static __always_inline bool_t
  39 xdr_nis_name (XDR *xdrs, nis_name *objp)
  40 {
  41   return xdr_string (xdrs, objp, ~0);
  42 }
  43
  44 bool_t
  45 _xdr_nis_name (XDR *xdrs, nis_name *objp)
  46 {
  47   return xdr_nis_name (xdrs, objp);
  48 }
  49
  50 static __always_inline bool_t
  51 xdr_zotypes (XDR *xdrs, zotypes *objp)
  52 {
  53   return xdr_enum (xdrs, (enum_t *) objp);
  54 }
  55
  56 static __always_inline bool_t
  57 xdr_nstype (XDR *xdrs, nstype *objp)
  58 {
  59   return xdr_enum (xdrs, (enum_t *) objp);
  60 }
  61
  62 static bool_t
  63 xdr_oar_mask (XDR *xdrs, oar_mask *objp)
  64 {
  65   bool_t res = xdr_u_int (xdrs, &objp->oa_rights);
  66   if (__builtin_expect (res, TRUE))
  67     res = xdr_zotypes (xdrs, &objp->oa_otype);
  68   return res;
  69 }
  70
  71 static bool_t
  72 xdr_endpoint (XDR *xdrs, endpoint *objp)
  73 {
  74   bool_t res =  xdr_string (xdrs, &objp->uaddr, ~0);
  75   if (__builtin_expect (res, TRUE))
  76     {
  77       res = xdr_string (xdrs, &objp->family, ~0);
  78       if (__builtin_expect (res, 1))
  79         res = xdr_string (xdrs, &objp->proto, ~0);
  80     }
  81   return res;
  82 }
  83
  84 bool_t
  85 _xdr_nis_server (XDR *xdrs, nis_server *objp)
  86 {
  87   bool_t res = xdr_nis_name (xdrs, &objp->name);
  88   if (__builtin_expect (res, TRUE))
  89     {
  90       res = xdr_array (xdrs, (void *) &objp->ep.ep_val, &objp->ep.ep_len,
  91                        ~0, sizeof (endpoint), (xdrproc_t) xdr_endpoint);
  92       if (__builtin_expect (res, TRUE))
  93         {
  94           res = xdr_u_int (xdrs, &objp->key_type);
  95           if (__builtin_expect (res, TRUE))
  96             res = xdr_netobj (xdrs, &objp->pkey);
  97         }
  98     }
  99   return res;
 100 }
 101
 102 bool_t
 103 _xdr_directory_obj (XDR *xdrs, directory_obj *objp)
 104 {
 105   bool_t res = xdr_nis_name (xdrs, &objp->do_name);
 106   if (__builtin_expect (res, TRUE))
 107     {
 108       res = xdr_nstype (xdrs, &objp->do_type);
 109       if (__builtin_expect (res, TRUE))
 110         {
 111           res = xdr_array (xdrs, (void *) &objp->do_servers.do_servers_val,
 112                            &objp->do_servers.do_servers_len, ~0,
 113                            sizeof (nis_server), (xdrproc_t) _xdr_nis_server);
 114           if (__builtin_expect (res, TRUE))
 115             {
 116               res = xdr_uint32_t (xdrs, &objp->do_ttl);
 117               if (__builtin_expect (res, TRUE))
 118                 res = xdr_array (xdrs,
 119                                  (void *) &objp->do_armask.do_armask_val,
 120                                  &objp->do_armask.do_armask_len, ~0,
 121                                  sizeof (oar_mask), (xdrproc_t) xdr_oar_mask);
 122             }
 123         }
 124     }
 125   return res;
 126 }
 127
 128 static bool_t
 129 xdr_entry_col (XDR *xdrs, entry_col *objp)
 130 {
 131   bool_t res = xdr_u_int (xdrs, &objp->ec_flags);
 132   if (__builtin_expect (res, TRUE))
 133     res = xdr_bytes (xdrs, (char **) &objp->ec_value.ec_value_val,
 134                      &objp->ec_value.ec_value_len, ~0);
 135   return res;
 136 }
 137
 138 static bool_t
 139 xdr_entry_obj (XDR *xdrs, entry_obj *objp)
 140 {
 141   bool_t res = xdr_string (xdrs, &objp->en_type, ~0);
 142   if (__builtin_expect (res, TRUE))
 143     res = xdr_array (xdrs, (void *) &objp->en_cols.en_cols_val,
 144                      &objp->en_cols.en_cols_len, ~0,
 145                      sizeof (entry_col), (xdrproc_t) xdr_entry_col);
 146   return res;
 147 }
 148
 149 static bool_t
 150 xdr_group_obj (XDR *xdrs, group_obj *objp)
 151 {
 152   bool_t res = xdr_u_int (xdrs, &objp->gr_flags);
 153   if (__builtin_expect (res, TRUE))
 154     res = xdr_array (xdrs, (void *) &objp->gr_members.gr_members_val,
 155                      &objp->gr_members.gr_members_len, ~0,
 156                      sizeof (nis_name), (xdrproc_t) _xdr_nis_name);
 157   return res;
 158 }
 159
 160 static bool_t
 161 xdr_link_obj (XDR *xdrs, link_obj *objp)
 162 {
 163   bool_t res = xdr_zotypes (xdrs, &objp->li_rtype);
 164   if (__builtin_expect (res, TRUE))
 165     {
 166       res = xdr_array (xdrs, (void *) &objp->li_attrs.li_attrs_val,
 167                        &objp->li_attrs.li_attrs_len, ~0,
 168                        sizeof (nis_attr), (xdrproc_t) xdr_nis_attr);
 169       if (__builtin_expect (res, TRUE))
 170         res = xdr_nis_name (xdrs, &objp->li_name);
 171     }
 172   return res;
 173 }
 174
 175 static bool_t
 176 xdr_table_col (XDR *xdrs, table_col *objp)
 177 {
 178   bool_t res = xdr_string (xdrs, &objp->tc_name, 64);
 179   if (__builtin_expect (res, TRUE))
 180     {
 181       res = xdr_u_int (xdrs, &objp->tc_flags);
 182       if (__builtin_expect (res, TRUE))
 183         res = xdr_u_int (xdrs, &objp->tc_rights);
 184     }
 185   return res;
 186 }
 187
 188 static bool_t
 189 xdr_table_obj (XDR *xdrs, table_obj *objp)
 190 {
 191   bool_t res = xdr_string (xdrs, &objp->ta_type, 64);
 192   if (__builtin_expect (res, TRUE))
 193     {
 194       res = xdr_int (xdrs, &objp->ta_maxcol);
 195       if (__builtin_expect (res, TRUE))
 196         {
 197           res = xdr_u_char (xdrs, &objp->ta_sep);
 198           if (__builtin_expect (res, TRUE))
 199             {
 200               res = xdr_array (xdrs, (void *) &objp->ta_cols.ta_cols_val,
 201                                &objp->ta_cols.ta_cols_len, ~0,
 202                                sizeof (table_col), (xdrproc_t) xdr_table_col);
 203               if (__builtin_expect (res, TRUE))
 204                 res = xdr_string (xdrs, &objp->ta_path, ~0);
 205             }
 206         }
 207     }
 208   return res;
 209 }
 210
 211 static bool_t
 212 xdr_objdata (XDR *xdrs, objdata *objp)
 213 {
 214   bool_t res = xdr_zotypes (xdrs, &objp->zo_type);
 215   if (!__builtin_expect (res, TRUE))
 216     return res;
 217   switch (objp->zo_type)
 218     {
 219     case NIS_DIRECTORY_OBJ:
 220       return _xdr_directory_obj (xdrs, &objp->objdata_u.di_data);
 221     case NIS_GROUP_OBJ:
 222       return xdr_group_obj (xdrs, &objp->objdata_u.gr_data);
 223     case NIS_TABLE_OBJ:
 224       return xdr_table_obj (xdrs, &objp->objdata_u.ta_data);
 225     case NIS_ENTRY_OBJ:
 226       return xdr_entry_obj (xdrs, &objp->objdata_u.en_data);
 227     case NIS_LINK_OBJ:
 228       return xdr_link_obj (xdrs, &objp->objdata_u.li_data);
 229     case NIS_PRIVATE_OBJ:
 230       return xdr_bytes (xdrs, &objp->objdata_u.po_data.po_data_val,
 231                         &objp->objdata_u.po_data.po_data_len, ~0);
 232     case NIS_NO_OBJ:
 233     case NIS_BOGUS_OBJ:
 234     default:
 235       return TRUE;
 236     }
 237 }
 238
 239 static bool_t
 240 xdr_nis_oid (XDR *xdrs, nis_oid *objp)
 241 {
 242   bool_t res = xdr_uint32_t (xdrs, &objp->ctime);
 243   if  (__builtin_expect (res, TRUE))
 244     res = xdr_uint32_t (xdrs, &objp->mtime);
 245   return res;
 246 }
 247
 248 bool_t
 249 _xdr_nis_object (XDR *xdrs, nis_object *objp)
 250 {
 251   bool_t res = xdr_nis_oid (xdrs, &objp->zo_oid);
 252   if (__builtin_expect (res, TRUE))
 253     {
 254       res = xdr_nis_name (xdrs, &objp->zo_name);
 255       if (__builtin_expect (res, TRUE))
 256         {
 257           res = xdr_nis_name (xdrs, &objp->zo_owner);
 258           if (__builtin_expect (res, TRUE))
 259             {
 260               res = xdr_nis_name (xdrs, &objp->zo_group);
 261               if (__builtin_expect (res, TRUE))
 262                 {
 263                   res = xdr_nis_name (xdrs, &objp->zo_domain);
 264                   if (__builtin_expect (res, TRUE))
 265                     {
 266                       res = xdr_u_int (xdrs, &objp->zo_access);
 267                       if (__builtin_expect (res, TRUE))
 268                         {
 269                           res = xdr_uint32_t (xdrs, &objp->zo_ttl);
 270                           if (__builtin_expect (res, TRUE))
 271                             res = xdr_objdata (xdrs, &objp->zo_data);
 272                         }
 273                     }
 274                 }
 275             }
 276         }
 277     }
 278   return res;
 279 }
 280
 281 static __always_inline bool_t
 282 xdr_nis_error (XDR *xdrs, nis_error *objp)
 283 {
 284   return xdr_enum (xdrs, (enum_t *) objp);
 285 }
 286
 287 bool_t
 288 _xdr_nis_error (XDR *xdrs, nis_error *objp)
 289 {
 290   return xdr_nis_error (xdrs, objp);
 291 }
 292
 293 bool_t
 294 _xdr_nis_result (XDR *xdrs, nis_result *objp)
 295 {
 296   bool_t res = xdr_nis_error (xdrs, &objp->status);
 297   if (__builtin_expect (res, TRUE))
 298     {
 299       res = xdr_array (xdrs, (void *) &objp->objects.objects_val,
 300                        &objp->objects.objects_len, ~0,
 301                        sizeof (nis_object), (xdrproc_t) _xdr_nis_object);
 302       if (__builtin_expect (res, TRUE))
 303         {
 304           res = xdr_netobj (xdrs, &objp->cookie);
 305           if (__builtin_expect (res, TRUE))
 306             {
 307               res = xdr_uint32_t (xdrs, &objp->zticks);
 308               if (__builtin_expect (res, TRUE))
 309                 {
 310                   res = xdr_uint32_t (xdrs, &objp->dticks);
 311                   if (__builtin_expect (res, TRUE))
 312                     {
 313                       res = xdr_uint32_t (xdrs, &objp->aticks);
 314                       if (__builtin_expect (res, TRUE))
 315                         res = xdr_uint32_t (xdrs, &objp->cticks);
 316                     }
 317                 }
 318             }
 319         }
 320     }
 321   return res;
 322 }
 323 libnsl_hidden_def (_xdr_nis_result)
 324
 325 bool_t
 326 _xdr_ns_request (XDR *xdrs, ns_request *objp)
 327 {
 328   bool_t res = xdr_nis_name (xdrs, &objp->ns_name);
 329   if (__builtin_expect (res, TRUE))
 330     res = xdr_array (xdrs, (void *) &objp->ns_object.ns_object_val,
 331                      &objp->ns_object.ns_object_len, 1,
 332                      sizeof (nis_object), (xdrproc_t) _xdr_nis_object);
 333   return res;
 334 }
 335
 336 bool_t
 337 _xdr_ib_request (XDR *xdrs, ib_request *objp)
 338 {
 339   bool_t res = xdr_nis_name (xdrs, &objp->ibr_name);
 340   if (__builtin_expect (res, TRUE))
 341     {
 342       res = xdr_array (xdrs, (void *) &objp->ibr_srch.ibr_srch_val,
 343                        &objp->ibr_srch.ibr_srch_len, ~0,
 344                        sizeof (nis_attr), (xdrproc_t) xdr_nis_attr);
 345       if (__builtin_expect (res, TRUE))
 346         {
 347           res = xdr_u_int (xdrs, &objp->ibr_flags);
 348           if (__builtin_expect (res, TRUE))
 349             {
 350               res = xdr_array (xdrs, (void *) &objp->ibr_obj.ibr_obj_val,
 351                                &objp->ibr_obj.ibr_obj_len, 1,
 352                                sizeof (nis_object),
 353                                (xdrproc_t) _xdr_nis_object);
 354               if (__builtin_expect (res, TRUE))
 355                 {
 356                   res = xdr_array (xdrs,
 357                                    (void *) &objp->ibr_cbhost.ibr_cbhost_val,
 358                                    &objp->ibr_cbhost.ibr_cbhost_len, 1,
 359                                    sizeof (nis_server),
 360                                    (xdrproc_t) _xdr_nis_server);
 361                   if (__builtin_expect (res, TRUE))
 362                     {
 363                       res = xdr_u_int (xdrs, &objp->ibr_bufsize);
 364                       if (__builtin_expect (res, TRUE))
 365                         res =  xdr_netobj (xdrs, &objp->ibr_cookie);
 366                     }
 367                 }
 368             }
 369         }
 370     }
 371   return res;
 372 }
 373 libnsl_hidden_def (_xdr_ib_request)
 374
 375 bool_t
 376 _xdr_ping_args (XDR *xdrs, ping_args *objp)
 377 {
 378   bool_t res = xdr_nis_name (xdrs, &objp->dir);
 379   if (__builtin_expect (res, TRUE))
 380     res = xdr_uint32_t (xdrs, &objp->stamp);
 381   return res;
 382 }
 383
 384 bool_t
 385 _xdr_cp_result (XDR *xdrs, cp_result *objp)
 386 {
 387   bool_t res = xdr_nis_error (xdrs, &objp->cp_status);
 388   if (__builtin_expect (res, TRUE))
 389     {
 390       res = xdr_uint32_t (xdrs, &objp->cp_zticks);
 391       if (__builtin_expect (res, TRUE))
 392         res = xdr_uint32_t (xdrs, &objp->cp_dticks);
 393     }
 394   return res;
 395 }
 396
 397 bool_t
 398 _xdr_nis_tag (XDR *xdrs, nis_tag *objp)
 399 {
 400   bool_t res = xdr_u_int (xdrs, &objp->tag_type);
 401   if (__builtin_expect (res, TRUE))
 402     res = xdr_string (xdrs, &objp->tag_val, ~0);
 403   return res;
 404 }
 405
 406 bool_t
 407 _xdr_nis_taglist (XDR *xdrs, nis_taglist *objp)
 408 {
 409   return xdr_array (xdrs, (void *) &objp->tags.tags_val,
 410                     &objp->tags.tags_len, ~0, sizeof (nis_tag),
 411                     (xdrproc_t) _xdr_nis_tag);
 412 }
 413
 414 bool_t
 415 _xdr_fd_args (XDR *xdrs, fd_args *objp)
 416 {
 417   bool_t res = xdr_nis_name (xdrs, &objp->dir_name);
 418   if (__builtin_expect (res, TRUE))
 419     res = xdr_nis_name (xdrs, &objp->requester);
 420   return res;
 421 }
 422
 423 bool_t
 424 _xdr_fd_result (XDR *xdrs, fd_result *objp)
 425 {
 426   bool_t res = xdr_nis_error (xdrs, &objp->status);
 427   if (__builtin_expect (res, TRUE))
 428     {
 429       res = xdr_nis_name (xdrs, &objp->source);
 430       if (__builtin_expect (res, TRUE))
 431         {
 432           res = xdr_bytes (xdrs, (char **) &objp->dir_data.dir_data_val,
 433                            &objp->dir_data.dir_data_len, ~0);
 434           if (__builtin_expect (res, TRUE))
 435             res = xdr_bytes (xdrs, (char **) &objp->signature.signature_val,
 436                              &objp->signature.signature_len, ~0);
 437         }
 438     }
 439   return res;
 440 }
 441
 442 /* The following functions have prototypes in nis_callback.h.  So
 443    we make them public */
 444 bool_t
 445 xdr_obj_p (XDR *xdrs, obj_p *objp)
 446 {
 447   return xdr_pointer (xdrs, (char **)objp, sizeof (nis_object),
 448                       (xdrproc_t)_xdr_nis_object);
 449 }
 450 libnsl_hidden_def (xdr_obj_p)
 451
 452 bool_t
 453 xdr_cback_data (XDR *xdrs, cback_data *objp)
 454 {
 455   return xdr_array (xdrs, (void *) &objp->entries.entries_val,
 456                     &objp->entries.entries_len, ~0,
 457                     sizeof (obj_p), (xdrproc_t) xdr_obj_p);
 458 }
 459 libnsl_hidden_def (xdr_cback_data)