1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 23 /* 24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 29 /* All Rights Reserved */ 30 31 /* 32 * Portions of this source code were derived from Berkeley 33 * under license from the Regents of the University of 34 * California. 35 */ 36 37 #pragma ident "%Z%%M% %I% %E% SMI" 38 39 /* 40 * This contains ALL xdr routines used by the YP rpc interface. 41 */ 42 43 #include <unistd.h> 44 #include <stdlib.h> 45 #include <rpc/rpc.h> 46 #include "yp_b.h" 47 #include <rpcsvc/yp_prot.h> 48 #include <rpcsvc/ypclnt.h> 49 #include <sys/types.h> 50 #include <limits.h> 51 52 static bool xdr_ypmaplist(XDR *, struct ypmaplist **); 53 static bool xdr_ypmaplist_wrap_string(XDR *, char *); 54 55 typedef struct xdr_discrim XDR_DISCRIM; 56 extern bool xdr_ypreq_key(XDR *, struct ypreq_key *); 57 extern bool xdr_ypreq_nokey(XDR *, struct ypreq_nokey *); 58 extern bool xdr_ypresp_val(XDR *, struct ypresp_val *); 59 extern bool xdr_ypresp_key_val(XDR *, struct ypresp_key_val *); 60 extern bool xdr_ypmap_parms(XDR *, struct ypmap_parms *); 61 extern bool xdr_ypowner_wrap_string(XDR *, char **); 62 extern bool xdr_ypreq_newname_string(XDR *, char **); 63 64 65 /* 66 * Serializes/deserializes a dbm datum data structure. 67 */ 68 bool 69 xdr_datum(XDR *xdrs, datum *pdatum) 70 { 71 bool res; 72 uint_t dsize; 73 74 /* 75 * LP64 case : 76 * xdr_bytes() expects a uint_t for the 3rd argument. Since 77 * datum.dsize is a long, we need a new temporary to pass to 78 * xdr_bytes() 79 */ 80 if (xdrs->x_op == XDR_ENCODE) { 81 if (pdatum->dsize > UINT_MAX) 82 return (FALSE); 83 } 84 dsize = (uint_t)pdatum->dsize; 85 res = (bool)xdr_bytes(xdrs, (char **)&(pdatum->dptr), &dsize, 86 YPMAXRECORD); 87 if (xdrs->x_op == XDR_DECODE) { 88 pdatum->dsize = dsize; 89 } 90 91 return (res); 92 } 93 94 95 /* 96 * Serializes/deserializes a domain name string. This is a "wrapper" for 97 * xdr_string which knows about the maximum domain name size. 98 */ 99 bool 100 xdr_ypdomain_wrap_string(XDR *xdrs, char **ppstring) 101 { 102 return ((bool)xdr_string(xdrs, ppstring, YPMAXDOMAIN)); 103 } 104 105 /* 106 * Serializes/deserializes a map name string. This is a "wrapper" for 107 * xdr_string which knows about the maximum map name size. 108 */ 109 bool 110 xdr_ypmap_wrap_string(XDR *xdrs, char **ppstring) 111 { 112 return ((bool)xdr_string(xdrs, ppstring, YPMAXMAP)); 113 } 114 115 /* 116 * Serializes/deserializes a ypreq_key structure. 117 */ 118 bool 119 xdr_ypreq_key(XDR *xdrs, struct ypreq_key *ps) 120 { 121 return ((bool)(xdr_ypdomain_wrap_string(xdrs, &ps->domain) && 122 xdr_ypmap_wrap_string(xdrs, &ps->map) && 123 xdr_datum(xdrs, &ps->keydat))); 124 } 125 126 /* 127 * Serializes/deserializes a ypreq_nokey structure. 128 */ 129 bool 130 xdr_ypreq_nokey(XDR *xdrs, struct ypreq_nokey *ps) 131 { 132 return ((bool)(xdr_ypdomain_wrap_string(xdrs, &ps->domain) && 133 xdr_ypmap_wrap_string(xdrs, &ps->map))); 134 } 135 136 /* 137 * Serializes/deserializes a ypresp_val structure. 138 */ 139 bool 140 xdr_ypresp_val(XDR *xdrs, struct ypresp_val *ps) 141 { 142 return ((bool)(xdr_u_int(xdrs, &ps->status) && 143 xdr_datum(xdrs, &ps->valdat))); 144 } 145 146 /* 147 * Serializes/deserializes a ypresp_key_val structure. 148 */ 149 bool 150 xdr_ypresp_key_val(XDR *xdrs, struct ypresp_key_val *ps) 151 { 152 return ((bool)(xdr_u_int(xdrs, &ps->status) && 153 xdr_datum(xdrs, &ps->valdat) && 154 xdr_datum(xdrs, &ps->keydat))); 155 } 156 157 /* 158 * Serializes/deserializes a peer server's node name 159 */ 160 bool 161 xdr_ypowner_wrap_string(XDR *xdrs, char **ppstring) 162 { 163 return ((bool)xdr_string(xdrs, ppstring, YPMAXPEER)); 164 } 165 166 /* 167 * Serializes/deserializes a ypmap_parms structure. 168 */ 169 bool 170 xdr_ypmap_parms(XDR *xdrs, struct ypmap_parms *ps) 171 { 172 return ((bool)(xdr_ypdomain_wrap_string(xdrs, &ps->domain) && 173 xdr_ypmap_wrap_string(xdrs, &ps->map) && 174 xdr_u_int(xdrs, &ps->ordernum) && 175 xdr_ypowner_wrap_string(xdrs, &ps->owner))); 176 } 177 178 /* 179 * Serializes/deserializes a ypreq_newxfr name 180 */ 181 bool 182 xdr_ypreq_newname_string(XDR *xdrs, char **ppstring) 183 { 184 return ((bool)xdr_string(xdrs, ppstring, 256)); 185 } 186 187 /* 188 * Serializes/deserializes a ypresp_master structure. 189 */ 190 bool 191 xdr_ypresp_master(XDR *xdrs, struct ypresp_master *ps) 192 { 193 return ((bool)(xdr_u_int(xdrs, &ps->status) && 194 xdr_ypowner_wrap_string(xdrs, &ps->master))); 195 } 196 197 /* 198 * Serializes/deserializes a ypresp_order structure. 199 */ 200 bool 201 xdr_ypresp_order(XDR *xdrs, struct ypresp_order *ps) 202 { 203 return ((bool)(xdr_u_int(xdrs, &ps->status) && 204 xdr_u_int(xdrs, &ps->ordernum))); 205 } 206 207 /* 208 * This is like xdr_ypmap_wrap_string except that it serializes/deserializes 209 * an array, instead of a pointer, so xdr_reference can work on the structure 210 * containing the char array itself. 211 */ 212 static bool 213 xdr_ypmaplist_wrap_string(XDR *xdrs, char *pstring) 214 { 215 char *s; 216 217 s = pstring; 218 return ((bool)xdr_string(xdrs, &s, YPMAXMAP)); 219 } 220 221 /* 222 * Serializes/deserializes a ypmaplist. 223 */ 224 static bool 225 xdr_ypmaplist(XDR *xdrs, struct ypmaplist **lst) 226 { 227 bool_t more_elements; 228 int freeing = (xdrs->x_op == XDR_FREE); 229 struct ypmaplist **next; 230 231 for (;;) { 232 more_elements = (*lst != NULL); 233 234 if (!xdr_bool(xdrs, &more_elements)) 235 return (FALSE); 236 237 if (!more_elements) 238 return (TRUE); /* All done */ 239 240 if (freeing) 241 next = &((*lst)->ypml_next); 242 243 if (!xdr_reference(xdrs, (caddr_t *)lst, 244 (uint_t)sizeof (struct ypmaplist), 245 (xdrproc_t)xdr_ypmaplist_wrap_string)) 246 return (FALSE); 247 248 lst = (freeing) ? next : &((*lst)->ypml_next); 249 } 250 /*NOTREACHED*/ 251 } 252 253 /* 254 * Serializes/deserializes a ypresp_maplist. 255 */ 256 bool 257 xdr_ypresp_maplist(XDR *xdrs, struct ypresp_maplist *ps) 258 { 259 return ((bool)(xdr_u_int(xdrs, &ps->status) && 260 xdr_ypmaplist(xdrs, &ps->list))); 261 } 262 263 /* 264 * Serializes/deserializes a yppushresp_xfr structure. 265 */ 266 bool 267 xdr_yppushresp_xfr(XDR *xdrs, struct yppushresp_xfr *ps) 268 { 269 return ((bool)(xdr_u_int(xdrs, &ps->transid) && 270 xdr_u_int(xdrs, &ps->status))); 271 } 272 273 274 /* 275 * Serializes/deserializes a ypreq_xfr structure. 276 */ 277 bool 278 xdr_ypreq_newxfr(XDR *xdrs, struct ypreq_newxfr *ps) 279 { 280 return ((bool)(xdr_ypmap_parms(xdrs, &ps->map_parms) && 281 xdr_u_int(xdrs, &ps->transid) && 282 xdr_u_int(xdrs, &ps->proto) && 283 xdr_string(xdrs, &ps->name, 256))); 284 } 285 286 /* 287 * Serializes/deserializes a ypreq_xfr structure. 288 */ 289 bool 290 xdr_ypreq_xfr(XDR *xdrs, struct ypreq_xfr *ps) 291 { 292 return ((bool)(xdr_ypmap_parms(xdrs, &ps->map_parms) && 293 xdr_u_int(xdrs, &ps->transid) && 294 xdr_u_int(xdrs, &ps->proto) && 295 xdr_u_short(xdrs, &ps->port))); 296 } 297 298 299 /* 300 * Serializes/deserializes a stream of struct ypresp_key_val's. This is used 301 * only by the client side of the batch enumerate operation. 302 */ 303 bool 304 xdr_ypall(XDR *xdrs, struct ypall_callback *callback) 305 { 306 bool_t more; 307 struct ypresp_key_val kv; 308 char keybuf[YPMAXRECORD]; 309 char valbuf[YPMAXRECORD]; 310 311 if (xdrs->x_op == XDR_ENCODE) 312 return (FALSE); 313 314 if (xdrs->x_op == XDR_FREE) 315 return (TRUE); 316 317 kv.keydat.dptr = keybuf; 318 kv.valdat.dptr = valbuf; 319 kv.keydat.dsize = YPMAXRECORD; 320 kv.valdat.dsize = YPMAXRECORD; 321 322 for (;;) { 323 if (!xdr_bool(xdrs, &more)) 324 return (FALSE); 325 326 if (!more) 327 return (TRUE); 328 329 if (!xdr_ypresp_key_val(xdrs, &kv)) 330 return (FALSE); 331 if ((*callback->foreach)(kv.status, kv.keydat.dptr, 332 kv.keydat.dsize, kv.valdat.dptr, kv.valdat.dsize, 333 callback->data)) 334 return (TRUE); 335 } 336 } 337 338 bool_t 339 xdr_netconfig(XDR *xdrs, struct netconfig *objp) 340 { 341 if (!xdr_string(xdrs, &objp->nc_netid, ~0)) 342 return (FALSE); 343 if (!xdr_u_int(xdrs, &objp->nc_semantics)) 344 return (FALSE); 345 if (!xdr_u_int(xdrs, &objp->nc_flag)) 346 return (FALSE); 347 if (!xdr_string(xdrs, &objp->nc_protofmly, ~0)) 348 return (FALSE); 349 if (!xdr_string(xdrs, &objp->nc_proto, ~0)) 350 return (FALSE); 351 if (!xdr_string(xdrs, &objp->nc_device, ~0)) 352 return (FALSE); 353 if (!xdr_array(xdrs, (char **)&objp->nc_lookups, 354 (uint_t *)&objp->nc_nlookups, 100, sizeof (char *), 355 xdr_wrapstring)) 356 return (FALSE); 357 return ((bool)xdr_vector(xdrs, (char *)objp->nc_unused, 358 8, sizeof (uint_t), xdr_u_int)); 359 } 360