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)